annotate postproc/swscale.c @ 6241:34b3bdd52d01

corrections, sync
author jonas
date Thu, 30 May 2002 14:45:13 +0000
parents 523014df7d32
children e7635c03910f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
4295
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
1 /*
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
2 Copyright (C) 2001-2002 Michael Niedermayer <michaelni@gmx.at>
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
3
4295
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
4 This program is free software; you can redistribute it and/or modify
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
5 it under the terms of the GNU General Public License as published by
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
6 the Free Software Foundation; either version 2 of the License, or
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
7 (at your option) any later version.
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
8
4295
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
9 This program is distributed in the hope that it will be useful,
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
12 GNU General Public License for more details.
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
13
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
14 You should have received a copy of the GNU General Public License
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
15 along with this program; if not, write to the Free Software
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
67c56df76a44 copyright(swscaler) = GPL
michael
parents: 4294
diff changeset
17 */
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
18
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
19 /*
4580
f01ed4dfa868 bgr15 input support
michael
parents: 4578
diff changeset
20 supported Input formats: YV12, I420, IYUV, YUY2, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8, Y800
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
21 supported output formats: YV12, I420, IYUV, BGR15, BGR16, BGR24, BGR32 (grayscale soon too)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
22 BGR15/16 support dithering
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
23
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
24 unscaled special converters
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
25 YV12/I420/IYUV -> BGR15/BGR16/BGR24/BGR32
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
26 YV12/I420/IYUV -> YV12/I420/IYUV
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
27 YUY2/BGR15/BGR16/BGR24/BGR32/RGB24/RGB32 -> same format
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
28 BGR24 -> BGR32 & RGB24 -> RGB32
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
29 BGR32 -> BGR24 & RGB32 -> RGB24
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
30 BGR15 -> BGR16
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
31 */
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
32
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
33 /*
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
34 tested special converters
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
35 YV12/I420 -> BGR16
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
36 YV12 -> YV12
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
37 BGR15 -> BGR16
4791
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
38 BGR16 -> BGR16
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
39
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
40 untested special converters
4791
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
41 YV12/I420 -> BGR15/BGR24/BGR32 (its the yuv2rgb stuff, so it should be ok)
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
42 YV12/I420 -> YV12/I420
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
43 YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
44 BGR24 -> BGR32 & RGB24 -> RGB32
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
45 BGR32 -> BGR24 & RGB32 -> RGB24
4623
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
46 BGR24 -> YV12
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
47 */
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
48
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
49 #include <inttypes.h>
2476
a6c5a537f30a a few warning fixes (missing #include's)
pl
parents: 2469
diff changeset
50 #include <string.h>
3272
7e4399d1eb65 horizontal up/downscale linear & cubic
michael
parents: 3209
diff changeset
51 #include <math.h>
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
52 #include <stdio.h>
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
53 #include "../config.h"
4248
3cdb86beebce mangle for win32 in postproc
atmos4
parents: 3641
diff changeset
54 #include "../mangle.h"
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
55 #include <assert.h>
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
56 #ifdef HAVE_MALLOC_H
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
57 #include <malloc.h>
6057
31e465fda59c various openbsd and general warning fixes - patch by Bj«Órn Sandell <biorn@dce.chalmers.se>
arpi
parents: 5937
diff changeset
58 #else
31e465fda59c various openbsd and general warning fixes - patch by Bj«Órn Sandell <biorn@dce.chalmers.se>
arpi
parents: 5937
diff changeset
59 #include <stdlib.h>
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
60 #endif
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
61 #include "swscale.h"
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
62 #include "../cpudetect.h"
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
63 #include "../bswap.h"
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
64 #include "../libvo/img_format.h"
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
65 #include "rgb2rgb.h"
4586
ee28f294cc48 fastmemcpy
michael
parents: 4581
diff changeset
66 #include "../libvo/fastmemcpy.h"
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
67 #include "../mp_msg.h"
2540
f2e70944d02a fixed a warning
michael
parents: 2534
diff changeset
68 #undef MOVNTQ
2680
e8a534509557 green line fix for dstw%8!=0
michael
parents: 2671
diff changeset
69 #undef PAVGB
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
70
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
71 //#undef HAVE_MMX2
4281
michael
parents: 4276
diff changeset
72 //#define HAVE_3DNOW
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
73 //#undef HAVE_MMX
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
74 //#undef ARCH_X86
4794
michael
parents: 4793
diff changeset
75 //#define WORDS_BIGENDIAN
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
76 #define DITHER1XBPP
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
77
4612
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
78 #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
79
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
80 #define RET 0xC3 //near return opcode for X86
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
81
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
82 #ifdef MP_DEBUG
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
83 #define ASSERT(x) assert(x);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
84 #else
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
85 #define ASSERT(x) ;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
86 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
87
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
88 #ifdef M_PI
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
89 #define PI M_PI
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
90 #else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
91 #define PI 3.14159265358979323846
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
92 #endif
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
93
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
94 //FIXME replace this with something faster
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
95 #define isPlanarYUV(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
96 #define isYUV(x) ((x)==IMGFMT_YUY2 || isPlanarYUV(x))
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
97 #define isHalfChrV(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
98 #define isHalfChrH(x) ((x)==IMGFMT_YUY2 || (x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
99 #define isPacked(x) ((x)==IMGFMT_YUY2 || ((x)&IMGFMT_BGR_MASK)==IMGFMT_BGR || ((x)&IMGFMT_RGB_MASK)==IMGFMT_RGB)
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
100 #define isGray(x) ((x)==IMGFMT_Y800)
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
101 #define isSupportedIn(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420 || (x)==IMGFMT_YUY2 \
4580
f01ed4dfa868 bgr15 input support
michael
parents: 4578
diff changeset
102 || (x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15\
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
103 || (x)==IMGFMT_RGB32|| (x)==IMGFMT_RGB24\
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
104 || (x)==IMGFMT_Y800)
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
105 #define isSupportedOut(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420 \
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
106 || (x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15)
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
107 #define isBGR(x) ((x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15)
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
108
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
109 #define RGB2YUV_SHIFT 16
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
110 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
111 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
112 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
113 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
114 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
115 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
116 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
117 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
118 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
119
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
120 extern int verbose; // defined in mplayer.c
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
121 /*
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
122 NOTES
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
123 Special versions: fast Y 1:1 scaling (no interpolation in y direction)
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
124
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
125 TODO
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
126 more intelligent missalignment avoidance for the horizontal scaler
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
127 write special vertical cubic upscale version
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
128 Optimize C code (yv12 / minmax)
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
129 add support for packed pixel yuv input & output
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
130 add support for Y8 output
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
131 optimize bgr24 & bgr32
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
132 add BGR4 output support
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
133 write special BGR->BGR scaler
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
134 deglobalize yuv2rgb*.c
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
135 */
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
136
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
137 #define ABS(a) ((a) > 0 ? (a) : (-(a)))
2469
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
138 #define MIN(a,b) ((a) > (b) ? (b) : (a))
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
139 #define MAX(a,b) ((a) < (b) ? (b) : (a))
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
140
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
141 #ifdef ARCH_X86
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
142 #define CAN_COMPILE_X86_ASM
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
143 #endif
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
144
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
145 #ifdef CAN_COMPILE_X86_ASM
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
146 static uint64_t __attribute__((aligned(8))) yCoeff= 0x2568256825682568LL;
2503
d21d8d5f2e23 yuv2rgb bugfix
michael
parents: 2476
diff changeset
147 static uint64_t __attribute__((aligned(8))) vrCoeff= 0x3343334333433343LL;
d21d8d5f2e23 yuv2rgb bugfix
michael
parents: 2476
diff changeset
148 static uint64_t __attribute__((aligned(8))) ubCoeff= 0x40cf40cf40cf40cfLL;
d21d8d5f2e23 yuv2rgb bugfix
michael
parents: 2476
diff changeset
149 static uint64_t __attribute__((aligned(8))) vgCoeff= 0xE5E2E5E2E5E2E5E2LL;
d21d8d5f2e23 yuv2rgb bugfix
michael
parents: 2476
diff changeset
150 static uint64_t __attribute__((aligned(8))) ugCoeff= 0xF36EF36EF36EF36ELL;
2669
476b9b3b91be faster bgr15/16
michael
parents: 2638
diff changeset
151 static uint64_t __attribute__((aligned(8))) bF8= 0xF8F8F8F8F8F8F8F8LL;
476b9b3b91be faster bgr15/16
michael
parents: 2638
diff changeset
152 static uint64_t __attribute__((aligned(8))) bFC= 0xFCFCFCFCFCFCFCFCLL;
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
153 static uint64_t __attribute__((aligned(8))) w400= 0x0400040004000400LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
154 static uint64_t __attribute__((aligned(8))) w80= 0x0080008000800080LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
155 static uint64_t __attribute__((aligned(8))) w10= 0x0010001000100010LL;
3272
7e4399d1eb65 horizontal up/downscale linear & cubic
michael
parents: 3209
diff changeset
156 static uint64_t __attribute__((aligned(8))) w02= 0x0002000200020002LL;
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
157 static uint64_t __attribute__((aligned(8))) bm00001111=0x00000000FFFFFFFFLL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
158 static uint64_t __attribute__((aligned(8))) bm00000111=0x0000000000FFFFFFLL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
159 static uint64_t __attribute__((aligned(8))) bm11111000=0xFFFFFFFFFF000000LL;
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
160 static uint64_t __attribute__((aligned(8))) bm01010101=0x00FF00FF00FF00FFLL;
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
161
2750
9ef09e232505 gcc does optimize writes to non volatile variables away if it didnt know that they were read in between
michael
parents: 2748
diff changeset
162 static volatile uint64_t __attribute__((aligned(8))) b5Dither;
9ef09e232505 gcc does optimize writes to non volatile variables away if it didnt know that they were read in between
michael
parents: 2748
diff changeset
163 static volatile uint64_t __attribute__((aligned(8))) g5Dither;
9ef09e232505 gcc does optimize writes to non volatile variables away if it didnt know that they were read in between
michael
parents: 2748
diff changeset
164 static volatile uint64_t __attribute__((aligned(8))) g6Dither;
9ef09e232505 gcc does optimize writes to non volatile variables away if it didnt know that they were read in between
michael
parents: 2748
diff changeset
165 static volatile uint64_t __attribute__((aligned(8))) r5Dither;
2748
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
166
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
167 static uint64_t __attribute__((aligned(8))) dither4[2]={
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
168 0x0103010301030103LL,
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
169 0x0200020002000200LL,};
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
170
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
171 static uint64_t __attribute__((aligned(8))) dither8[2]={
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
172 0x0602060206020602LL,
01dbf100b4f8 better dithering
michael
parents: 2730
diff changeset
173 0x0004000400040004LL,};
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
174
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
175 static uint64_t __attribute__((aligned(8))) b16Mask= 0x001F001F001F001FLL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
176 static uint64_t __attribute__((aligned(8))) g16Mask= 0x07E007E007E007E0LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
177 static uint64_t __attribute__((aligned(8))) r16Mask= 0xF800F800F800F800LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
178 static uint64_t __attribute__((aligned(8))) b15Mask= 0x001F001F001F001FLL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
179 static uint64_t __attribute__((aligned(8))) g15Mask= 0x03E003E003E003E0LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
180 static uint64_t __attribute__((aligned(8))) r15Mask= 0x7C007C007C007C00LL;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
181
2730
c483fc9bf0c4 faster bgr24 output
michael
parents: 2728
diff changeset
182 static uint64_t __attribute__((aligned(8))) M24A= 0x00FF0000FF0000FFLL;
c483fc9bf0c4 faster bgr24 output
michael
parents: 2728
diff changeset
183 static uint64_t __attribute__((aligned(8))) M24B= 0xFF0000FF0000FF00LL;
c483fc9bf0c4 faster bgr24 output
michael
parents: 2728
diff changeset
184 static uint64_t __attribute__((aligned(8))) M24C= 0x0000FF0000FF0000LL;
c483fc9bf0c4 faster bgr24 output
michael
parents: 2728
diff changeset
185
4612
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
186 #ifdef FAST_BGR2YV12
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
187 static const uint64_t bgr2YCoeff __attribute__((aligned(8))) = 0x000000210041000DULL;
4619
ef213d64e20a bgr24toUV in MMX
michael
parents: 4612
diff changeset
188 static const uint64_t bgr2UCoeff __attribute__((aligned(8))) = 0x0000FFEEFFDC0038ULL;
ef213d64e20a bgr24toUV in MMX
michael
parents: 4612
diff changeset
189 static const uint64_t bgr2VCoeff __attribute__((aligned(8))) = 0x00000038FFD2FFF8ULL;
4612
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
190 #else
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
191 static const uint64_t bgr2YCoeff __attribute__((aligned(8))) = 0x000020E540830C8BULL;
4619
ef213d64e20a bgr24toUV in MMX
michael
parents: 4612
diff changeset
192 static const uint64_t bgr2UCoeff __attribute__((aligned(8))) = 0x0000ED0FDAC23831ULL;
ef213d64e20a bgr24toUV in MMX
michael
parents: 4612
diff changeset
193 static const uint64_t bgr2VCoeff __attribute__((aligned(8))) = 0x00003831D0E6F6EAULL;
4612
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
194 #endif
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
195 static const uint64_t bgr2YOffset __attribute__((aligned(8))) = 0x1010101010101010ULL;
4619
ef213d64e20a bgr24toUV in MMX
michael
parents: 4612
diff changeset
196 static const uint64_t bgr2UVOffset __attribute__((aligned(8)))= 0x8080808080808080ULL;
4612
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
197 static const uint64_t w1111 __attribute__((aligned(8))) = 0x0001000100010001ULL;
4edfdec1dc12 bgr24toY in MMX
michael
parents: 4586
diff changeset
198
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
199 // FIXME remove
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
200 static uint64_t __attribute__((aligned(8))) asm_yalpha1;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
201 static uint64_t __attribute__((aligned(8))) asm_uvalpha1;
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
202 #endif
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
203
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
204 // clipping helper table for C implementations:
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
205 static unsigned char clip_table[768];
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
206
2584
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
207 static unsigned short clip_table16b[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
208 static unsigned short clip_table16g[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
209 static unsigned short clip_table16r[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
210 static unsigned short clip_table15b[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
211 static unsigned short clip_table15g[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
212 static unsigned short clip_table15r[768];
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
213
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
214 // yuv->rgb conversion tables:
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
215 static int yuvtab_2568[256];
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
216 static int yuvtab_3343[256];
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
217 static int yuvtab_0c92[256];
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
218 static int yuvtab_1a1e[256];
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
219 static int yuvtab_40cf[256];
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
220 // Needed for cubic scaler to catch overflows
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
221 static int clip_yuvtab_2568[768];
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
222 static int clip_yuvtab_3343[768];
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
223 static int clip_yuvtab_0c92[768];
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
224 static int clip_yuvtab_1a1e[768];
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
225 static int clip_yuvtab_40cf[768];
2264
7851375ea156 increased precission of s_xinc s_xinc2 (needed for the mmx2 bugfix)
michael
parents: 2237
diff changeset
226
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
227 //global sws_flags from the command line
4421
5dd78b21afbc -sws 2 is default now
michael
parents: 4419
diff changeset
228 int sws_flags=2;
3272
7e4399d1eb65 horizontal up/downscale linear & cubic
michael
parents: 3209
diff changeset
229
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
230 //global srcFilter
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
231 SwsFilter src_filter= {NULL, NULL, NULL, NULL};
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
232
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
233 float sws_lum_gblur= 0.0;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
234 float sws_chr_gblur= 0.0;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
235 int sws_chr_vshift= 0;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
236 int sws_chr_hshift= 0;
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
237 float sws_chr_sharpen= 0.0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
238 float sws_lum_sharpen= 0.0;
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
239
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
240 /* cpuCaps combined from cpudetect and whats actually compiled in
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
241 (if there is no support for something compiled in it wont appear here) */
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
242 static CpuCaps cpuCaps;
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
243
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
244 void (*swScale)(SwsContext *context, uint8_t* src[], int srcStride[], int srcSliceY,
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
245 int srcSliceH, uint8_t* dst[], int dstStride[])=NULL;
2469
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
246
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
247 static SwsVector *getConvVec(SwsVector *a, SwsVector *b);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
248
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
249 #ifdef CAN_COMPILE_X86_ASM
2671
555cb027c7a7 fixed warnings
michael
parents: 2669
diff changeset
250 void in_asm_used_var_warning_killer()
555cb027c7a7 fixed warnings
michael
parents: 2669
diff changeset
251 {
3272
7e4399d1eb65 horizontal up/downscale linear & cubic
michael
parents: 3209
diff changeset
252 volatile int i= yCoeff+vrCoeff+ubCoeff+vgCoeff+ugCoeff+bF8+bFC+w400+w80+w10+
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
253 bm00001111+bm00000111+bm11111000+b16Mask+g16Mask+r16Mask+b15Mask+g15Mask+r15Mask+asm_yalpha1+ asm_uvalpha1+
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
254 M24A+M24B+M24C+w02 + b5Dither+g5Dither+r5Dither+g6Dither+dither4[0]+dither8[0]+bm01010101;
2671
555cb027c7a7 fixed warnings
michael
parents: 2669
diff changeset
255 if(i) i=0;
555cb027c7a7 fixed warnings
michael
parents: 2669
diff changeset
256 }
555cb027c7a7 fixed warnings
michael
parents: 2669
diff changeset
257 #endif
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
258
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
259 static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
260 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
261 uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
262 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
263 //FIXME Optimize (just quickly writen not opti..)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
264 int i;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
265 for(i=0; i<dstW; i++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
266 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
267 int val=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
268 int j;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
269 for(j=0; j<lumFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
270 val += lumSrc[j][i] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
271
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
272 dest[i]= MIN(MAX(val>>19, 0), 255);
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
273 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
274
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
275 if(uDest != NULL)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
276 for(i=0; i<(dstW>>1); i++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
277 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
278 int u=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
279 int v=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
280 int j;
3641
33c560ffd3dc minor bugfixes (noone noticed them)
michael
parents: 3352
diff changeset
281 for(j=0; j<chrFilterSize; j++)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
282 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
283 u += chrSrc[j][i] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
284 v += chrSrc[j][i + 2048] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
285 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
286
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
287 uDest[i]= MIN(MAX(u>>19, 0), 255);
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
288 vDest[i]= MIN(MAX(v>>19, 0), 255);
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
289 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
290 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
291
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
292 static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
293 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
294 uint8_t *dest, int dstW, int dstFormat)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
295 {
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
296 if(dstFormat==IMGFMT_BGR32)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
297 {
4794
michael
parents: 4793
diff changeset
298 int i;
4793
68e7ed0c22be fixing bgr32 output on big-endian systems
michael
parents: 4791
diff changeset
299 #ifdef WORDS_BIGENDIAN
68e7ed0c22be fixing bgr32 output on big-endian systems
michael
parents: 4791
diff changeset
300 dest++;
68e7ed0c22be fixing bgr32 output on big-endian systems
michael
parents: 4791
diff changeset
301 #endif
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
302 for(i=0; i<(dstW>>1); i++){
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
303 int j;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
304 int Y1=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
305 int Y2=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
306 int U=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
307 int V=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
308 int Cb, Cr, Cg;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
309 for(j=0; j<lumFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
310 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
311 Y1 += lumSrc[j][2*i] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
312 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
313 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
314 for(j=0; j<chrFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
315 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
316 U += chrSrc[j][i] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
317 V += chrSrc[j][i+2048] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
318 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
319 Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
320 Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
321 U >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
322 V >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
323
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
324 Cb= clip_yuvtab_40cf[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
325 Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
326 Cr= clip_yuvtab_3343[V+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
327
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
328 dest[8*i+0]=clip_table[((Y1 + Cb) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
329 dest[8*i+1]=clip_table[((Y1 + Cg) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
330 dest[8*i+2]=clip_table[((Y1 + Cr) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
331
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
332 dest[8*i+4]=clip_table[((Y2 + Cb) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
333 dest[8*i+5]=clip_table[((Y2 + Cg) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
334 dest[8*i+6]=clip_table[((Y2 + Cr) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
335 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
336 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
337 else if(dstFormat==IMGFMT_BGR24)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
338 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
339 int i;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
340 for(i=0; i<(dstW>>1); i++){
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
341 int j;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
342 int Y1=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
343 int Y2=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
344 int U=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
345 int V=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
346 int Cb, Cr, Cg;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
347 for(j=0; j<lumFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
348 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
349 Y1 += lumSrc[j][2*i] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
350 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
351 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
352 for(j=0; j<chrFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
353 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
354 U += chrSrc[j][i] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
355 V += chrSrc[j][i+2048] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
356 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
357 Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
358 Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
359 U >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
360 V >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
361
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
362 Cb= clip_yuvtab_40cf[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
363 Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
364 Cr= clip_yuvtab_3343[V+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
365
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
366 dest[0]=clip_table[((Y1 + Cb) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
367 dest[1]=clip_table[((Y1 + Cg) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
368 dest[2]=clip_table[((Y1 + Cr) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
369
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
370 dest[3]=clip_table[((Y2 + Cb) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
371 dest[4]=clip_table[((Y2 + Cg) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
372 dest[5]=clip_table[((Y2 + Cr) >>13)];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
373 dest+=6;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
374 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
375 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
376 else if(dstFormat==IMGFMT_BGR16)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
377 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
378 int i;
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
379 #ifdef DITHER1XBPP
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
380 static int ditherb1=1<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
381 static int ditherg1=1<<13;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
382 static int ditherr1=2<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
383 static int ditherb2=3<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
384 static int ditherg2=3<<13;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
385 static int ditherr2=0<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
386
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
387 ditherb1 ^= (1^2)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
388 ditherg1 ^= (1^2)<<13;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
389 ditherr1 ^= (1^2)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
390 ditherb2 ^= (3^0)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
391 ditherg2 ^= (3^0)<<13;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
392 ditherr2 ^= (3^0)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
393 #else
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
394 const int ditherb1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
395 const int ditherg1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
396 const int ditherr1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
397 const int ditherb2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
398 const int ditherg2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
399 const int ditherr2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
400 #endif
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
401 for(i=0; i<(dstW>>1); i++){
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
402 int j;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
403 int Y1=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
404 int Y2=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
405 int U=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
406 int V=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
407 int Cb, Cr, Cg;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
408 for(j=0; j<lumFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
409 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
410 Y1 += lumSrc[j][2*i] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
411 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
412 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
413 for(j=0; j<chrFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
414 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
415 U += chrSrc[j][i] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
416 V += chrSrc[j][i+2048] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
417 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
418 Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
419 Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
420 U >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
421 V >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
422
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
423 Cb= clip_yuvtab_40cf[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
424 Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
425 Cr= clip_yuvtab_3343[V+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
426
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
427 ((uint16_t*)dest)[2*i] =
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
428 clip_table16b[(Y1 + Cb + ditherb1) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
429 clip_table16g[(Y1 + Cg + ditherg1) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
430 clip_table16r[(Y1 + Cr + ditherr1) >>13];
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
431
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
432 ((uint16_t*)dest)[2*i+1] =
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
433 clip_table16b[(Y2 + Cb + ditherb2) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
434 clip_table16g[(Y2 + Cg + ditherg2) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
435 clip_table16r[(Y2 + Cr + ditherr2) >>13];
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
436 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
437 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
438 else if(dstFormat==IMGFMT_BGR15)
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
439 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
440 int i;
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
441 #ifdef DITHER1XBPP
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
442 static int ditherb1=1<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
443 static int ditherg1=1<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
444 static int ditherr1=2<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
445 static int ditherb2=3<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
446 static int ditherg2=3<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
447 static int ditherr2=0<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
448
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
449 ditherb1 ^= (1^2)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
450 ditherg1 ^= (1^2)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
451 ditherr1 ^= (1^2)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
452 ditherb2 ^= (3^0)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
453 ditherg2 ^= (3^0)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
454 ditherr2 ^= (3^0)<<14;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
455 #else
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
456 const int ditherb1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
457 const int ditherg1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
458 const int ditherr1=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
459 const int ditherb2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
460 const int ditherg2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
461 const int ditherr2=0;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
462 #endif
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
463 for(i=0; i<(dstW>>1); i++){
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
464 int j;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
465 int Y1=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
466 int Y2=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
467 int U=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
468 int V=0;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
469 int Cb, Cr, Cg;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
470 for(j=0; j<lumFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
471 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
472 Y1 += lumSrc[j][2*i] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
473 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
474 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
475 for(j=0; j<chrFilterSize; j++)
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
476 {
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
477 U += chrSrc[j][i] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
478 V += chrSrc[j][i+2048] * chrFilter[j];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
479 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
480 Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
481 Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
482 U >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
483 V >>= 19;
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
484
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
485 Cb= clip_yuvtab_40cf[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
486 Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
487 Cr= clip_yuvtab_3343[V+ 256];
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
488
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
489 ((uint16_t*)dest)[2*i] =
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
490 clip_table15b[(Y1 + Cb + ditherb1) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
491 clip_table15g[(Y1 + Cg + ditherg1) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
492 clip_table15r[(Y1 + Cr + ditherr1) >>13];
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
493
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
494 ((uint16_t*)dest)[2*i+1] =
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
495 clip_table15b[(Y2 + Cb + ditherb2) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
496 clip_table15g[(Y2 + Cg + ditherg2) >>13] |
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
497 clip_table15r[(Y2 + Cr + ditherr2) >>13];
3352
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
498 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
499 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
500 }
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
501
64121e8a43f5 print more info if -v
michael
parents: 3344
diff changeset
502
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
503 //Note: we have C, X86, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
504 //Plain C versions
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
505 #if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT)
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
506 #define COMPILE_C
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
507 #endif
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
508
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
509 #ifdef CAN_COMPILE_X86_ASM
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
510
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
511 #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
512 #define COMPILE_MMX
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
513 #endif
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
514
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
515 #if defined (HAVE_MMX2) || defined (RUNTIME_CPUDETECT)
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
516 #define COMPILE_MMX2
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
517 #endif
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
518
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
519 #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
520 #define COMPILE_3DNOW
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
521 #endif
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
522 #endif //CAN_COMPILE_X86_ASM
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
523
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
524 #undef HAVE_MMX
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
525 #undef HAVE_MMX2
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
526 #undef HAVE_3DNOW
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
527
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
528 #ifdef COMPILE_C
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
529 #undef HAVE_MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
530 #undef HAVE_MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
531 #undef HAVE_3DNOW
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
532 #define RENAME(a) a ## _C
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
533 #include "swscale_template.c"
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
534 #endif
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
535
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
536 #ifdef CAN_COMPILE_X86_ASM
2576
437ed06579d8 c optimizations
michael
parents: 2575
diff changeset
537
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
538 //X86 versions
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
539 /*
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
540 #undef RENAME
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
541 #undef HAVE_MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
542 #undef HAVE_MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
543 #undef HAVE_3DNOW
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
544 #define ARCH_X86
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
545 #define RENAME(a) a ## _X86
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
546 #include "swscale_template.c"
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
547 */
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
548 //MMX versions
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
549 #ifdef COMPILE_MMX
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
550 #undef RENAME
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
551 #define HAVE_MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
552 #undef HAVE_MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
553 #undef HAVE_3DNOW
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
554 #define RENAME(a) a ## _MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
555 #include "swscale_template.c"
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
556 #endif
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
557
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
558 //MMX2 versions
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
559 #ifdef COMPILE_MMX2
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
560 #undef RENAME
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
561 #define HAVE_MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
562 #define HAVE_MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
563 #undef HAVE_3DNOW
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
564 #define RENAME(a) a ## _MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
565 #include "swscale_template.c"
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
566 #endif
2469
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
567
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
568 //3DNOW versions
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
569 #ifdef COMPILE_3DNOW
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
570 #undef RENAME
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
571 #define HAVE_MMX
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
572 #undef HAVE_MMX2
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
573 #define HAVE_3DNOW
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
574 #define RENAME(a) a ## _3DNow
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
575 #include "swscale_template.c"
3152
54710806be56 runtime cpu detection optional (compiles faster)
michael
parents: 3136
diff changeset
576 #endif
2469
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
577
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
578 #endif //CAN_COMPILE_X86_ASM
2469
03abc2743ed6 downscale
michael
parents: 2326
diff changeset
579
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
580 // minor note: the HAVE_xyz is messed up after that line so dont use it
2316
bcb229557e9b fixed alignment (static variables where sometimes not 8-byte aligned)
michael
parents: 2297
diff changeset
581
2232
65996b3467d7 MMX & MMX2 optimizations (MMX2 is buggy and commented out)
michael
parents: 2230
diff changeset
582
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
583 // old global scaler, dont use for new code
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
584 // will use sws_flags from the command line
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
585 void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
586 int srcSliceH, uint8_t* dst[], int dstStride, int dstbpp,
3209
0b172eb639f1 swscaler cleanup
michael
parents: 3152
diff changeset
587 int srcW, int srcH, int dstW, int dstH){
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
588
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
589 static SwsContext *context=NULL;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
590 int dstFormat;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
591 int dstStride3[3]= {dstStride, dstStride>>1, dstStride>>1};
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
592
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
593 switch(dstbpp)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
594 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
595 case 8 : dstFormat= IMGFMT_Y8; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
596 case 12: dstFormat= IMGFMT_YV12; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
597 case 15: dstFormat= IMGFMT_BGR15; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
598 case 16: dstFormat= IMGFMT_BGR16; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
599 case 24: dstFormat= IMGFMT_BGR24; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
600 case 32: dstFormat= IMGFMT_BGR32; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
601 default: return;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
602 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
603
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
604 if(!context) context=getSwsContextFromCmdLine(srcW, srcH, IMGFMT_YV12, dstW, dstH, dstFormat);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
605
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
606 context->swScale(context, src, srcStride, srcSliceY, srcSliceH, dst, dstStride3);
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
607 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
608
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
609 // will use sws_flags & src_filter (from cmd line)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
610 SwsContext *getSwsContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
611 {
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
612 int flags=0;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
613 static int firstTime=1;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
614
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
615 #ifdef ARCH_X86
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
616 if(gCpuCaps.hasMMX)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
617 asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
618 #endif
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
619 if(firstTime)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
620 {
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
621 firstTime=0;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
622 flags= SWS_PRINT_INFO;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
623 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
624 else if(verbose>1) flags= SWS_PRINT_INFO;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
625
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
626 if(src_filter.lumH) freeVec(src_filter.lumH);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
627 if(src_filter.lumV) freeVec(src_filter.lumV);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
628 if(src_filter.chrH) freeVec(src_filter.chrH);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
629 if(src_filter.chrV) freeVec(src_filter.chrV);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
630
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
631 if(sws_lum_gblur!=0.0){
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
632 src_filter.lumH= getGaussianVec(sws_lum_gblur, 3.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
633 src_filter.lumV= getGaussianVec(sws_lum_gblur, 3.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
634 }else{
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
635 src_filter.lumH= getIdentityVec();
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
636 src_filter.lumV= getIdentityVec();
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
637 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
638
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
639 if(sws_chr_gblur!=0.0){
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
640 src_filter.chrH= getGaussianVec(sws_chr_gblur, 3.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
641 src_filter.chrV= getGaussianVec(sws_chr_gblur, 3.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
642 }else{
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
643 src_filter.chrH= getIdentityVec();
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
644 src_filter.chrV= getIdentityVec();
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
645 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
646
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
647 if(sws_chr_sharpen!=0.0){
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
648 SwsVector *g= getConstVec(-1.0, 3);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
649 SwsVector *id= getConstVec(10.0/sws_chr_sharpen, 1);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
650 g->coeff[1]=2.0;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
651 addVec(id, g);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
652 convVec(src_filter.chrH, id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
653 convVec(src_filter.chrV, id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
654 freeVec(g);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
655 freeVec(id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
656 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
657
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
658 if(sws_lum_sharpen!=0.0){
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
659 SwsVector *g= getConstVec(-1.0, 3);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
660 SwsVector *id= getConstVec(10.0/sws_lum_sharpen, 1);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
661 g->coeff[1]=2.0;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
662 addVec(id, g);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
663 convVec(src_filter.lumH, id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
664 convVec(src_filter.lumV, id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
665 freeVec(g);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
666 freeVec(id);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
667 }
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
668
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
669 if(sws_chr_hshift)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
670 shiftVec(src_filter.chrH, sws_chr_hshift);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
671
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
672 if(sws_chr_vshift)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
673 shiftVec(src_filter.chrV, sws_chr_vshift);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
674
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
675 normalizeVec(src_filter.chrH, 1.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
676 normalizeVec(src_filter.chrV, 1.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
677 normalizeVec(src_filter.lumH, 1.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
678 normalizeVec(src_filter.lumV, 1.0);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
679
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
680 if(verbose > 1) printVec(src_filter.chrH);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
681 if(verbose > 1) printVec(src_filter.lumH);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
682
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
683 switch(sws_flags)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
684 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
685 case 0: flags|= SWS_FAST_BILINEAR; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
686 case 1: flags|= SWS_BILINEAR; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
687 case 2: flags|= SWS_BICUBIC; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
688 case 3: flags|= SWS_X; break;
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
689 case 4: flags|= SWS_POINT; break;
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
690 case 5: flags|= SWS_AREA; break;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
691 default:flags|= SWS_BILINEAR; break;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
692 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
693
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
694 return getSwsContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, &src_filter, NULL);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
695 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
696
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
697
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
698 static inline void initFilter(int16_t **outFilter, int16_t **filterPos, int *outFilterSize, int xInc,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
699 int srcW, int dstW, int filterAlign, int one, int flags,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
700 SwsVector *srcFilter, SwsVector *dstFilter)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
701 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
702 int i;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
703 int filterSize;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
704 int filter2Size;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
705 int minFilterSize;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
706 double *filter=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
707 double *filter2=NULL;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
708 #ifdef ARCH_X86
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
709 if(gCpuCaps.hasMMX)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
710 asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
711 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
712
4563
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
713 // Note the +1 is for the MMXscaler which reads over the end
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
714 *filterPos = (int16_t*)memalign(8, (dstW+1)*sizeof(int16_t));
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
715
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
716 if(ABS(xInc - 0x10000) <10) // unscaled
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
717 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
718 int i;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
719 filterSize= 1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
720 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
721 for(i=0; i<dstW*filterSize; i++) filter[i]=0;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
722
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
723 for(i=0; i<dstW; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
724 {
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
725 filter[i*filterSize]=1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
726 (*filterPos)[i]=i;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
727 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
728
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
729 }
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
730 else if(flags&SWS_POINT) // lame looking point sampling mode
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
731 {
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
732 int i;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
733 int xDstInSrc;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
734 filterSize= 1;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
735 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
736
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
737 xDstInSrc= xInc/2 - 0x8000;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
738 for(i=0; i<dstW; i++)
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
739 {
4492
8303419cc60f filterPos bugfix (only nearest neighbor scaling was affected)
michael
parents: 4481
diff changeset
740 int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
741
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
742 (*filterPos)[i]= xx;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
743 filter[i]= 1.0;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
744 xDstInSrc+= xInc;
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
745 }
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
746 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
747 else if(xInc <= (1<<16) || (flags&SWS_FAST_BILINEAR)) // upscale
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
748 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
749 int i;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
750 int xDstInSrc;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
751 if (flags&SWS_BICUBIC) filterSize= 4;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
752 else if(flags&SWS_X ) filterSize= 4;
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
753 else filterSize= 2; // SWS_BILINEAR / SWS_AREA
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
754 // printf("%d %d %d\n", filterSize, srcW, dstW);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
755 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
756
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
757 xDstInSrc= xInc/2 - 0x8000;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
758 for(i=0; i<dstW; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
759 {
4492
8303419cc60f filterPos bugfix (only nearest neighbor scaling was affected)
michael
parents: 4481
diff changeset
760 int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
761 int j;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
762
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
763 (*filterPos)[i]= xx;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
764 if((flags & SWS_BICUBIC) || (flags & SWS_X))
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
765 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
766 double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
767 double y1,y2,y3,y4;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
768 double A= -0.6;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
769 if(flags & SWS_BICUBIC){
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
770 // Equation is from VirtualDub
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
771 y1 = ( + A*d - 2.0*A*d*d + A*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
772 y2 = (+ 1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
773 y3 = ( - A*d + (2.0*A+3.0)*d*d - (A+2.0)*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
774 y4 = ( + A*d*d - A*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
775 }else{
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
776 // cubic interpolation (derived it myself)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
777 y1 = ( -2.0*d + 3.0*d*d - 1.0*d*d*d)/6.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
778 y2 = (6.0 -3.0*d - 6.0*d*d + 3.0*d*d*d)/6.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
779 y3 = ( +6.0*d + 3.0*d*d - 3.0*d*d*d)/6.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
780 y4 = ( -1.0*d + 1.0*d*d*d)/6.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
781 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
782
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
783 // printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
784 filter[i*filterSize + 0]= y1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
785 filter[i*filterSize + 1]= y2;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
786 filter[i*filterSize + 2]= y3;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
787 filter[i*filterSize + 3]= y4;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
788 // printf("%1.3f %1.3f %1.3f %1.3f %1.3f\n",d , y1, y2, y3, y4);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
789 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
790 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
791 {
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
792 //Bilinear upscale / linear interpolate / Area averaging
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
793 for(j=0; j<filterSize; j++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
794 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
795 double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
796 double coeff= 1.0 - d;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
797 if(coeff<0) coeff=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
798 // printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
799 filter[i*filterSize + j]= coeff;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
800 xx++;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
801 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
802 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
803 xDstInSrc+= xInc;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
804 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
805 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
806 else // downscale
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
807 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
808 int xDstInSrc;
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
809 ASSERT(dstW <= srcW)
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
810
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
811 if(flags&SWS_BICUBIC) filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
812 else if(flags&SWS_X) filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
813 else if(flags&SWS_AREA) filterSize= (int)ceil(1 + 1.0*srcW / (double)dstW);
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
814 else /* BILINEAR */ filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
815 // printf("%d %d %d\n", *filterSize, srcW, dstW);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
816 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
817
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
818 xDstInSrc= xInc/2 - 0x8000;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
819 for(i=0; i<dstW; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
820 {
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
821 int xx= (int)((double)xDstInSrc/(double)(1<<16) - (filterSize-1)*0.5 + 0.5);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
822 int j;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
823 (*filterPos)[i]= xx;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
824 for(j=0; j<filterSize; j++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
825 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
826 double d= ABS((xx<<16) - xDstInSrc)/(double)xInc;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
827 double coeff;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
828 if((flags & SWS_BICUBIC) || (flags & SWS_X))
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
829 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
830 double A= -0.75;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
831 // d*=2;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
832 // Equation is from VirtualDub
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
833 if(d<1.0)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
834 coeff = (1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
835 else if(d<2.0)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
836 coeff = (-4.0*A + 8.0*A*d - 5.0*A*d*d + A*d*d*d);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
837 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
838 coeff=0.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
839 }
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
840 else if(flags & SWS_AREA)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
841 {
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
842 double srcPixelSize= (1<<16)/(double)xInc;
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
843 if(d + srcPixelSize/2 < 0.5) coeff= 1.0;
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
844 else if(d - srcPixelSize/2 < 0.5) coeff= (0.5-d)/srcPixelSize + 0.5;
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
845 else coeff=0.0;
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
846 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
847 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
848 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
849 coeff= 1.0 - d;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
850 if(coeff<0) coeff=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
851 }
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
852 // printf("%1.3f %2.3f %d \n", coeff, d, xDstInSrc);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
853 filter[i*filterSize + j]= coeff;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
854 xx++;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
855 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
856 xDstInSrc+= xInc;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
857 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
858 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
859
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
860 /* apply src & dst Filter to filter -> filter2
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
861 free(filter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
862 */
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
863 ASSERT(filterSize>0)
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
864 filter2Size= filterSize;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
865 if(srcFilter) filter2Size+= srcFilter->length - 1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
866 if(dstFilter) filter2Size+= dstFilter->length - 1;
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
867 ASSERT(filter2Size>0)
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
868 filter2= (double*)memalign(8, filter2Size*dstW*sizeof(double));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
869
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
870 for(i=0; i<dstW; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
871 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
872 int j;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
873 SwsVector scaleFilter;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
874 SwsVector *outVec;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
875
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
876 scaleFilter.coeff= filter + i*filterSize;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
877 scaleFilter.length= filterSize;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
878
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
879 if(srcFilter) outVec= getConvVec(srcFilter, &scaleFilter);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
880 else outVec= &scaleFilter;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
881
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
882 ASSERT(outVec->length == filter2Size)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
883 //FIXME dstFilter
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
884
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
885 for(j=0; j<outVec->length; j++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
886 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
887 filter2[i*filter2Size + j]= outVec->coeff[j];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
888 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
889
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
890 (*filterPos)[i]+= (filterSize-1)/2 - (filter2Size-1)/2;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
891
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
892 if(outVec != &scaleFilter) freeVec(outVec);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
893 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
894 free(filter); filter=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
895
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
896 /* try to reduce the filter-size (step1 find size and shift left) */
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
897 // Assume its near normalized (*0.5 or *2.0 is ok but * 0.001 is not)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
898 minFilterSize= 0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
899 for(i=dstW-1; i>=0; i--)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
900 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
901 int min= filter2Size;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
902 int j;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
903 double cutOff=0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
904
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
905 /* get rid off near zero elements on the left by shifting left */
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
906 for(j=0; j<filter2Size; j++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
907 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
908 int k;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
909 cutOff += ABS(filter2[i*filter2Size]);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
910
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
911 if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
912
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
913 /* preserve Monotonicity because the core cant handle the filter otherwise */
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
914 if(i<dstW-1 && (*filterPos)[i] >= (*filterPos)[i+1]) break;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
915
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
916 // Move filter coeffs left
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
917 for(k=1; k<filter2Size; k++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
918 filter2[i*filter2Size + k - 1]= filter2[i*filter2Size + k];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
919 filter2[i*filter2Size + k - 1]= 0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
920 (*filterPos)[i]++;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
921 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
922
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
923 cutOff=0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
924 /* count near zeros on the right */
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
925 for(j=filter2Size-1; j>0; j--)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
926 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
927 cutOff += ABS(filter2[i*filter2Size + j]);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
928
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
929 if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
930 min--;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
931 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
932
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
933 if(min>minFilterSize) minFilterSize= min;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
934 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
935
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
936 ASSERT(minFilterSize > 0)
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
937 filterSize= (minFilterSize +(filterAlign-1)) & (~(filterAlign-1));
4806
a14eff26f66a use assert.h
michael
parents: 4794
diff changeset
938 ASSERT(filterSize > 0)
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
939 filter= (double*)memalign(8, filterSize*dstW*sizeof(double));
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
940 *outFilterSize= filterSize;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
941
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
942 if(flags&SWS_PRINT_INFO)
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
943 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: reducing / aligning filtersize %d -> %d\n", filter2Size, filterSize);
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
944 /* try to reduce the filter-size (step2 reduce it) */
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
945 for(i=0; i<dstW; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
946 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
947 int j;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
948
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
949 for(j=0; j<filterSize; j++)
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
950 {
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
951 if(j>=filter2Size) filter[i*filterSize + j]= 0.0;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
952 else filter[i*filterSize + j]= filter2[i*filter2Size + j];
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
953 }
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
954 }
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
955 free(filter2); filter2=NULL;
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
956
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
957
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
958 //FIXME try to align filterpos if possible
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
959
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
960 //fix borders
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
961 for(i=0; i<dstW; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
962 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
963 int j;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
964 if((*filterPos)[i] < 0)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
965 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
966 // Move filter coeffs left to compensate for filterPos
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
967 for(j=1; j<filterSize; j++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
968 {
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
969 int left= MAX(j + (*filterPos)[i], 0);
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
970 filter[i*filterSize + left] += filter[i*filterSize + j];
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
971 filter[i*filterSize + j]=0;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
972 }
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
973 (*filterPos)[i]= 0;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
974 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
975
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
976 if((*filterPos)[i] + filterSize > srcW)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
977 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
978 int shift= (*filterPos)[i] + filterSize - srcW;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
979 // Move filter coeffs right to compensate for filterPos
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
980 for(j=filterSize-2; j>=0; j--)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
981 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
982 int right= MIN(j + shift, filterSize-1);
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
983 filter[i*filterSize +right] += filter[i*filterSize +j];
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
984 filter[i*filterSize +j]=0;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
985 }
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
986 (*filterPos)[i]= srcW - filterSize;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
987 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
988 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
989
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
990 // Note the +1 is for the MMXscaler which reads over the end
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
991 *outFilter= (int16_t*)memalign(8, *outFilterSize*(dstW+1)*sizeof(int16_t));
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
992 memset(*outFilter, 0, *outFilterSize*(dstW+1)*sizeof(int16_t));
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
993
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
994 /* Normalize & Store in outFilter */
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
995 for(i=0; i<dstW; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
996 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
997 int j;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
998 double sum=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
999 double scale= one;
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1000 for(j=0; j<filterSize; j++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1001 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1002 sum+= filter[i*filterSize + j];
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1003 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1004 scale/= sum;
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1005 for(j=0; j<filterSize; j++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1006 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1007 (*outFilter)[i*(*outFilterSize) + j]= (int)(filter[i*filterSize + j]*scale);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1008 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1009 }
4563
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1010
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1011 (*filterPos)[dstW]= (*filterPos)[dstW-1]; // the MMX scaler will read over the end
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1012 for(i=0; i<*outFilterSize; i++)
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1013 {
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1014 int j= dstW*(*outFilterSize);
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1015 (*outFilter)[j + i]= (*outFilter)[j + i - (*outFilterSize)];
835d4fce67d5 fixing green line at right side bug (reported by Nick Kurshev <nickols_k@mail.ru>)
michael
parents: 4558
diff changeset
1016 }
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1017
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1018 free(filter);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1019 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1020
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1021 #ifdef ARCH_X86
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1022 static void initMMX2HScaler(int dstW, int xInc, uint8_t *funnyCode, int16_t *filter, int32_t *filterPos, int numSplits)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1023 {
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1024 uint8_t *fragmentA;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1025 int imm8OfPShufW1A;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1026 int imm8OfPShufW2A;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1027 int fragmentLengthA;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1028 uint8_t *fragmentB;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1029 int imm8OfPShufW1B;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1030 int imm8OfPShufW2B;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1031 int fragmentLengthB;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1032 int fragmentPos;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1033
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1034 int xpos, i;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1035
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1036 // create an optimized horizontal scaling routine
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1037
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1038 //code fragment
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1039
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1040 asm volatile(
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1041 "jmp 9f \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1042 // Begin
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1043 "0: \n\t"
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1044 "movq (%%edx, %%eax), %%mm3 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1045 "movd (%%ecx, %%esi), %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1046 "movd 1(%%ecx, %%esi), %%mm1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1047 "punpcklbw %%mm7, %%mm1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1048 "punpcklbw %%mm7, %%mm0 \n\t"
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1049 "pshufw $0xFF, %%mm1, %%mm1 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1050 "1: \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1051 "pshufw $0xFF, %%mm0, %%mm0 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1052 "2: \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1053 "psubw %%mm1, %%mm0 \n\t"
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1054 "movl 8(%%ebx, %%eax), %%esi \n\t"
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1055 "pmullw %%mm3, %%mm0 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1056 "psllw $7, %%mm1 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1057 "paddw %%mm1, %%mm0 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1058
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1059 "movq %%mm0, (%%edi, %%eax) \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1060
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1061 "addl $8, %%eax \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1062 // End
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1063 "9: \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1064 // "int $3\n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1065 "leal 0b, %0 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1066 "leal 1b, %1 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1067 "leal 2b, %2 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1068 "decl %1 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1069 "decl %2 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1070 "subl %0, %1 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1071 "subl %0, %2 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1072 "leal 9b, %3 \n\t"
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1073 "subl %0, %3 \n\t"
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1074
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1075
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1076 :"=r" (fragmentA), "=r" (imm8OfPShufW1A), "=r" (imm8OfPShufW2A),
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1077 "=r" (fragmentLengthA)
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1078 );
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1079
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1080 asm volatile(
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1081 "jmp 9f \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1082 // Begin
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1083 "0: \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1084 "movq (%%edx, %%eax), %%mm3 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1085 "movd (%%ecx, %%esi), %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1086 "punpcklbw %%mm7, %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1087 "pshufw $0xFF, %%mm0, %%mm1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1088 "1: \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1089 "pshufw $0xFF, %%mm0, %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1090 "2: \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1091 "psubw %%mm1, %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1092 "movl 8(%%ebx, %%eax), %%esi \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1093 "pmullw %%mm3, %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1094 "psllw $7, %%mm1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1095 "paddw %%mm1, %%mm0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1096
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1097 "movq %%mm0, (%%edi, %%eax) \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1098
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1099 "addl $8, %%eax \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1100 // End
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1101 "9: \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1102 // "int $3\n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1103 "leal 0b, %0 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1104 "leal 1b, %1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1105 "leal 2b, %2 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1106 "decl %1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1107 "decl %2 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1108 "subl %0, %1 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1109 "subl %0, %2 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1110 "leal 9b, %3 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1111 "subl %0, %3 \n\t"
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1112
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1113
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1114 :"=r" (fragmentB), "=r" (imm8OfPShufW1B), "=r" (imm8OfPShufW2B),
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1115 "=r" (fragmentLengthB)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1116 );
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1117
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1118 xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1119 fragmentPos=0;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1120
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1121 for(i=0; i<dstW/numSplits; i++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1122 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1123 int xx=xpos>>16;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1124
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1125 if((i&3) == 0)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1126 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1127 int a=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1128 int b=((xpos+xInc)>>16) - xx;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1129 int c=((xpos+xInc*2)>>16) - xx;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1130 int d=((xpos+xInc*3)>>16) - xx;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1131
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1132 filter[i ] = (( xpos & 0xFFFF) ^ 0xFFFF)>>9;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1133 filter[i+1] = (((xpos+xInc ) & 0xFFFF) ^ 0xFFFF)>>9;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1134 filter[i+2] = (((xpos+xInc*2) & 0xFFFF) ^ 0xFFFF)>>9;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1135 filter[i+3] = (((xpos+xInc*3) & 0xFFFF) ^ 0xFFFF)>>9;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1136 filterPos[i/2]= xx;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1137
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1138 if(d+1<4)
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1139 {
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1140 int maxShift= 3-(d+1);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1141 int shift=0;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1142
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1143 memcpy(funnyCode + fragmentPos, fragmentB, fragmentLengthB);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1144
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1145 funnyCode[fragmentPos + imm8OfPShufW1B]=
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1146 (a+1) | ((b+1)<<2) | ((c+1)<<4) | ((d+1)<<6);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1147 funnyCode[fragmentPos + imm8OfPShufW2B]=
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1148 a | (b<<2) | (c<<4) | (d<<6);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1149
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1150 if(i+3>=dstW) shift=maxShift; //avoid overread
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1151 else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //Align
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1152
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1153 if(shift && i>=shift)
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1154 {
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1155 funnyCode[fragmentPos + imm8OfPShufW1B]+= 0x55*shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1156 funnyCode[fragmentPos + imm8OfPShufW2B]+= 0x55*shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1157 filterPos[i/2]-=shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1158 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1159
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1160 fragmentPos+= fragmentLengthB;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1161 }
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1162 else
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1163 {
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1164 int maxShift= 3-d;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1165 int shift=0;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1166
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1167 memcpy(funnyCode + fragmentPos, fragmentA, fragmentLengthA);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1168
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1169 funnyCode[fragmentPos + imm8OfPShufW1A]=
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1170 funnyCode[fragmentPos + imm8OfPShufW2A]=
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1171 a | (b<<2) | (c<<4) | (d<<6);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1172
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1173 if(i+4>=dstW) shift=maxShift; //avoid overread
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1174 else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //partial align
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1175
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1176 if(shift && i>=shift)
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1177 {
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1178 funnyCode[fragmentPos + imm8OfPShufW1A]+= 0x55*shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1179 funnyCode[fragmentPos + imm8OfPShufW2A]+= 0x55*shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1180 filterPos[i/2]-=shift;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1181 }
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1182
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1183 fragmentPos+= fragmentLengthA;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1184 }
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1185
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1186 funnyCode[fragmentPos]= RET;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1187 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1188 xpos+=xInc;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1189 }
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1190 filterPos[i/2]= xpos>>16; // needed to jump to the next part
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1191 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1192 #endif // ARCH_X86
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1193
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1194 //FIXME remove
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
1195 void SwScale_Init(){
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1196 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1197
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1198 static void globalInit(){
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
1199 // generating tables:
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
1200 int i;
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1201 for(i=0; i<768; i++){
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1202 int c= MIN(MAX(i-256, 0), 255);
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1203 clip_table[i]=c;
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1204 yuvtab_2568[c]= clip_yuvtab_2568[i]=(0x2568*(c-16))+(256<<13);
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1205 yuvtab_3343[c]= clip_yuvtab_3343[i]=0x3343*(c-128);
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1206 yuvtab_0c92[c]= clip_yuvtab_0c92[i]=-0x0c92*(c-128);
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1207 yuvtab_1a1e[c]= clip_yuvtab_1a1e[i]=-0x1a1e*(c-128);
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1208 yuvtab_40cf[c]= clip_yuvtab_40cf[i]=0x40cf*(c-128);
2216
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
1209 }
9da2a0515184 software yv12->rgb scaler - separated from fsdga
arpi
parents:
diff changeset
1210
2584
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
1211 for(i=0; i<768; i++)
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
1212 {
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1213 int v= clip_table[i];
5246
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1214 clip_table16b[i]= v>>3;
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1215 clip_table16g[i]= (v<<3)&0x07E0;
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1216 clip_table16r[i]= (v<<8)&0xF800;
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1217 clip_table15b[i]= v>>3;
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1218 clip_table15g[i]= (v<<2)&0x03E0;
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1219 clip_table15r[i]= (v<<7)&0x7C00;
2584
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
1220 }
3344
e87c59969d17 vertical cubic/linear scaling
michael
parents: 3272
diff changeset
1221
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1222 cpuCaps= gCpuCaps;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1223
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1224 #ifdef RUNTIME_CPUDETECT
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1225 #ifdef CAN_COMPILE_X86_ASM
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1226 // ordered per speed fasterst first
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1227 if(gCpuCaps.hasMMX2)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1228 swScale= swScale_MMX2;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1229 else if(gCpuCaps.has3DNow)
4281
michael
parents: 4276
diff changeset
1230 swScale= swScale_3DNow;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1231 else if(gCpuCaps.hasMMX)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1232 swScale= swScale_MMX;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1233 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1234 swScale= swScale_C;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1235
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1236 #else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1237 swScale= swScale_C;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1238 cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1239 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1240 #else //RUNTIME_CPUDETECT
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1241 #ifdef HAVE_MMX2
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1242 swScale= swScale_MMX2;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1243 cpuCaps.has3DNow = 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1244 #elif defined (HAVE_3DNOW)
4281
michael
parents: 4276
diff changeset
1245 swScale= swScale_3DNow;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1246 cpuCaps.hasMMX2 = 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1247 #elif defined (HAVE_MMX)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1248 swScale= swScale_MMX;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1249 cpuCaps.hasMMX2 = cpuCaps.has3DNow = 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1250 #else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1251 swScale= swScale_C;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1252 cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1253 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1254 #endif //!RUNTIME_CPUDETECT
3126
e71ae0213431 runtime cpu detection
michael
parents: 2800
diff changeset
1255 }
2584
6d20d5d5829f 15/16bit in C speedup
michael
parents: 2576
diff changeset
1256
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1257 /* Warper functions for yuv2bgr */
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1258 static void planarYuvToBgr(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1259 int srcSliceH, uint8_t* dstParam[], int dstStride[]){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1260 uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1261
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1262 if(c->srcFormat==IMGFMT_YV12)
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1263 yuv2rgb( dst,src[0],src[1],src[2],c->srcW,srcSliceH,dstStride[0],srcStride[0],srcStride[1] );
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1264 else /* I420 & IYUV */
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1265 yuv2rgb( dst,src[0],src[2],src[1],c->srcW,srcSliceH,dstStride[0],srcStride[0],srcStride[1] );
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1266 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1267
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1268 static void bgr24to32Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1269 int srcSliceH, uint8_t* dst[], int dstStride[]){
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1270
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1271 if(dstStride[0]*3==srcStride[0]*4)
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1272 rgb24to32(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1273 else
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1274 {
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1275 int i;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1276 uint8_t *srcPtr= src[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1277 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1278
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1279 for(i=0; i<srcSliceH; i++)
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1280 {
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1281 rgb24to32(srcPtr, dstPtr, c->srcW*3);
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1282 srcPtr+= srcStride[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1283 dstPtr+= dstStride[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1284 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1285 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1286 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1287
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1288 static void bgr32to24Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1289 int srcSliceH, uint8_t* dst[], int dstStride[]){
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1290
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1291 if(dstStride[0]*4==srcStride[0]*3)
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1292 rgb32to24(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1293 else
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1294 {
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1295 int i;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1296 uint8_t *srcPtr= src[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1297 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1298
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1299 for(i=0; i<srcSliceH; i++)
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1300 {
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1301 rgb32to24(srcPtr, dstPtr, c->srcW<<2);
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1302 srcPtr+= srcStride[0];
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1303 dstPtr+= dstStride[0];
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1304 }
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1305 }
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1306 }
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1307
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1308 static void bgr15to16Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1309 int srcSliceH, uint8_t* dst[], int dstStride[]){
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1310
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1311 if(dstStride[0]==srcStride[0])
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1312 rgb15to16(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1313 else
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1314 {
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1315 int i;
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1316 uint8_t *srcPtr= src[0];
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1317 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1318
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1319 for(i=0; i<srcSliceH; i++)
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1320 {
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1321 rgb15to16(srcPtr, dstPtr, c->srcW<<1);
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1322 srcPtr+= srcStride[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1323 dstPtr+= dstStride[0];
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1324 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1325 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1326 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1327
4623
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1328 static void bgr24toyv12Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1329 int srcSliceH, uint8_t* dst[], int dstStride[]){
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1330
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1331 rgb24toyv12(
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1332 src[0],
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1333 dst[0]+ srcSliceY *dstStride[0],
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1334 dst[1]+(srcSliceY>>1)*dstStride[1],
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1335 dst[2]+(srcSliceY>>1)*dstStride[2],
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1336 c->srcW, srcSliceH,
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1337 dstStride[0], dstStride[1], srcStride[0]);
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1338 }
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1339
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1340
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1341 /* unscaled copy like stuff (assumes nearly identical formats) */
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1342 static void simpleCopy(SwsContext *c, uint8_t* srcParam[], int srcStrideParam[], int srcSliceY,
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1343 int srcSliceH, uint8_t* dstParam[], int dstStride[]){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1344
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1345 int srcStride[3];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1346 uint8_t *src[3];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1347 uint8_t *dst[3];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1348
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1349 if(c->srcFormat == IMGFMT_I420){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1350 src[0]= srcParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1351 src[1]= srcParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1352 src[2]= srcParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1353 srcStride[0]= srcStrideParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1354 srcStride[1]= srcStrideParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1355 srcStride[2]= srcStrideParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1356 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1357 else if(c->srcFormat==IMGFMT_YV12){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1358 src[0]= srcParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1359 src[1]= srcParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1360 src[2]= srcParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1361 srcStride[0]= srcStrideParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1362 srcStride[1]= srcStrideParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1363 srcStride[2]= srcStrideParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1364 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1365 else if(isPacked(c->srcFormat) || isGray(c->srcFormat)){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1366 src[0]= srcParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1367 src[1]=
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1368 src[2]= NULL;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1369 srcStride[0]= srcStrideParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1370 srcStride[1]=
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1371 srcStride[2]= 0;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1372 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1373
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1374 if(c->dstFormat == IMGFMT_I420){
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1375 dst[0]= dstParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1376 dst[1]= dstParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1377 dst[2]= dstParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1378
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1379 }else{
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1380 dst[0]= dstParam[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1381 dst[1]= dstParam[1];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1382 dst[2]= dstParam[2];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1383 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1384
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1385 if(isPacked(c->srcFormat))
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1386 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1387 if(dstStride[0]==srcStride[0])
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1388 memcpy(dst[0] + dstStride[0]*srcSliceY, src[0], srcSliceH*dstStride[0]);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1389 else
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1390 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1391 int i;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1392 uint8_t *srcPtr= src[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1393 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
1394 int length=0;
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
1395
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
1396 /* universal length finder */
4649
e0661cd256fd unscaled memcpy variant bugfix (negative strides)
michael
parents: 4623
diff changeset
1397 while(length+c->srcW <= ABS(dstStride[0])
e0661cd256fd unscaled memcpy variant bugfix (negative strides)
michael
parents: 4623
diff changeset
1398 && length+c->srcW <= ABS(srcStride[0])) length+= c->srcW;
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
1399 ASSERT(length!=0);
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1400
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1401 for(i=0; i<srcSliceH; i++)
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1402 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1403 memcpy(dstPtr, srcPtr, length);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1404 srcPtr+= srcStride[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1405 dstPtr+= dstStride[0];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1406 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1407 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1408 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1409 else
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1410 { /* Planar YUV */
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1411 int plane;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1412 for(plane=0; plane<3; plane++)
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1413 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1414 int length= plane==0 ? c->srcW : ((c->srcW+1)>>1);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1415 int y= plane==0 ? srcSliceY: ((srcSliceY+1)>>1);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1416 int height= plane==0 ? srcSliceH: ((srcSliceH+1)>>1);
4558
aac57ef92bab rgb32 & rgb24 input support
michael
parents: 4555
diff changeset
1417
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1418 if(dstStride[plane]==srcStride[plane])
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1419 memcpy(dst[plane] + dstStride[plane]*y, src[plane], height*dstStride[plane]);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1420 else
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1421 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1422 int i;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1423 uint8_t *srcPtr= src[plane];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1424 uint8_t *dstPtr= dst[plane] + dstStride[plane]*y;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1425 for(i=0; i<height; i++)
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1426 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1427 memcpy(dstPtr, srcPtr, length);
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1428 srcPtr+= srcStride[plane];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1429 dstPtr+= dstStride[plane];
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1430 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1431 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1432 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1433 }
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1434 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1435
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1436 SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1437 SwsFilter *srcFilter, SwsFilter *dstFilter){
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1438
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1439 SwsContext *c;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1440 int i;
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1441 int usesFilter;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1442 SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1443
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1444 #ifdef ARCH_X86
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1445 if(gCpuCaps.hasMMX)
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1446 asm volatile("emms\n\t"::: "memory");
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1447 #endif
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1448
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1449 if(swScale==NULL) globalInit();
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1450
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
1451 /* avoid dupplicate Formats, so we dont need to check to much */
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
1452 if(srcFormat==IMGFMT_IYUV) srcFormat=IMGFMT_I420;
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
1453 if(srcFormat==IMGFMT_Y8) srcFormat=IMGFMT_Y800;
4492
8303419cc60f filterPos bugfix (only nearest neighbor scaling was affected)
michael
parents: 4481
diff changeset
1454 if(dstFormat==IMGFMT_Y8) dstFormat=IMGFMT_Y800;
8303419cc60f filterPos bugfix (only nearest neighbor scaling was affected)
michael
parents: 4481
diff changeset
1455
4529
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1456 if(!isSupportedIn(srcFormat))
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1457 {
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1458 mp_msg(MSGT_SWS,MSGL_ERR,"swScaler: %s is not supported as input format\n", vo_format_name(srcFormat));
4529
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1459 return NULL;
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1460 }
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1461 if(!isSupportedOut(dstFormat))
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1462 {
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1463 mp_msg(MSGT_SWS,MSGL_ERR,"swScaler: %s is not supported as output format\n", vo_format_name(dstFormat));
4529
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1464 return NULL;
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1465 }
4481
b8ec9cc1b2c5 MMX(2) optimized YUY2 input
michael
parents: 4468
diff changeset
1466
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1467 /* sanity check */
4529
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1468 if(srcW<4 || srcH<1 || dstW<8 || dstH<1) //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1469 {
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1470 mp_msg(MSGT_SWS,MSGL_ERR,"swScaler: %dx%d -> %dx%d is invalid scaling dimension\n",
4529
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1471 srcW, srcH, dstW, dstH);
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1472 return NULL;
8f982d17c479 printing error messages if something is wrong instead of just return NULL;
michael
parents: 4492
diff changeset
1473 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1474
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1475 if(!dstFilter) dstFilter= &dummyFilter;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1476 if(!srcFilter) srcFilter= &dummyFilter;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1477
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1478 c= memalign(64, sizeof(SwsContext));
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1479 memset(c, 0, sizeof(SwsContext));
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1480
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1481 c->srcW= srcW;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1482 c->srcH= srcH;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1483 c->dstW= dstW;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1484 c->dstH= dstH;
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1485 c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1486 c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1487 c->flags= flags;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1488 c->dstFormat= dstFormat;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1489 c->srcFormat= srcFormat;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1490
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1491 usesFilter=0;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1492 if(dstFilter->lumV!=NULL && dstFilter->lumV->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1493 if(dstFilter->lumH!=NULL && dstFilter->lumH->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1494 if(dstFilter->chrV!=NULL && dstFilter->chrV->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1495 if(dstFilter->chrH!=NULL && dstFilter->chrH->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1496 if(srcFilter->lumV!=NULL && srcFilter->lumV->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1497 if(srcFilter->lumH!=NULL && srcFilter->lumH->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1498 if(srcFilter->chrV!=NULL && srcFilter->chrV->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1499 if(srcFilter->chrH!=NULL && srcFilter->chrH->length>1) usesFilter=1;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1500
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1501 /* unscaled special Cases */
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1502 if(srcW==dstW && srcH==dstH && !usesFilter)
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1503 {
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1504 /* yuv2bgr */
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1505 if(isPlanarYUV(srcFormat) && isBGR(dstFormat))
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1506 {
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1507 // FIXME multiple yuv2rgb converters wont work that way cuz that thing is full of globals&statics
4791
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
1508 #ifdef WORDS_BIGENDIAN
5246
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1509 if(dstFormat==IMGFMT_BGR32)
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1510 yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_BGR);
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1511 else
4cfa6366e551 fixing bgr15&16 on big_endian
michael
parents: 4806
diff changeset
1512 yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_RGB);
4791
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
1513 #else
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1514 yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_RGB);
4791
7fcffc537252 unscaled yuv2rgb fix for big-endian systems
michael
parents: 4649
diff changeset
1515 #endif
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1516 c->swScale= planarYuvToBgr;
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1517
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1518 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1519 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4555
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1520 vo_format_name(srcFormat), vo_format_name(dstFormat));
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1521 return c;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1522 }
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1523
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1524 /* simple copy */
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1525 if(srcFormat == dstFormat || (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat)))
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1526 {
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1527 c->swScale= simpleCopy;
44fed00fce13 101 (yuv2rgb with mpeg1,...) ;)
michael
parents: 4554
diff changeset
1528
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1529 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1530 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1531 vo_format_name(srcFormat), vo_format_name(dstFormat));
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1532 return c;
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1533 }
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1534
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1535 /* bgr32to24 & rgb32to24*/
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1536 if((srcFormat==IMGFMT_BGR32 && dstFormat==IMGFMT_BGR24)
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1537 ||(srcFormat==IMGFMT_RGB32 && dstFormat==IMGFMT_RGB24))
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1538 {
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1539 c->swScale= bgr32to24Wrapper;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1540
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1541 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1542 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1543 vo_format_name(srcFormat), vo_format_name(dstFormat));
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1544 return c;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1545 }
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1546
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1547 /* bgr24to32 & rgb24to32*/
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1548 if((srcFormat==IMGFMT_BGR24 && dstFormat==IMGFMT_BGR32)
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1549 ||(srcFormat==IMGFMT_RGB24 && dstFormat==IMGFMT_RGB32))
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1550 {
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1551 c->swScale= bgr24to32Wrapper;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1552
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1553 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1554 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4567
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1555 vo_format_name(srcFormat), vo_format_name(dstFormat));
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1556 return c;
a7f2c58a9ab1 unscaled converters
michael
parents: 4563
diff changeset
1557 }
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1558
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1559 /* bgr15to16 */
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1560 if(srcFormat==IMGFMT_BGR15 && dstFormat==IMGFMT_BGR16)
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1561 {
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1562 c->swScale= bgr15to16Wrapper;
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1563
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1564 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1565 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4581
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1566 vo_format_name(srcFormat), vo_format_name(dstFormat));
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1567 return c;
7f4d58df90ac unscaled BGR15->BGR16
michael
parents: 4580
diff changeset
1568 }
4623
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1569
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1570 /* bgr24toYV12 */
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1571 if(srcFormat==IMGFMT_BGR24 && dstFormat==IMGFMT_YV12)
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1572 {
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1573 c->swScale= bgr24toyv12Wrapper;
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1574
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1575 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1576 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using unscaled %s -> %s special converter\n",
4623
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1577 vo_format_name(srcFormat), vo_format_name(dstFormat));
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1578 return c;
513f4e2a2153 unscaled BGR24 -> YV12
michael
parents: 4619
diff changeset
1579 }
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1580 }
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1581
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1582 if(cpuCaps.hasMMX2)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1583 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1584 c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1585 if(!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR))
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1586 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1587 if(flags&SWS_PRINT_INFO)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1588 mp_msg(MSGT_SWS,MSGL_WARN,"SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1589 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1590 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1591 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1592 c->canMMX2BeUsed=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1593
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1594
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1595 /* dont use full vertical UV input/internaly if the source doesnt even have it */
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1596 if(isHalfChrV(srcFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_V);
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1597 /* dont use full horizontal UV input if the source doesnt even have it */
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1598 if(isHalfChrH(srcFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_H_INP);
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1599 /* dont use full horizontal UV internally if the destination doesnt even have it */
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1600 if(isHalfChrH(dstFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_H_INT);
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1601
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1602 if(flags&SWS_FULL_CHR_H_INP) c->chrSrcW= srcW;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1603 else c->chrSrcW= (srcW+1)>>1;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1604
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1605 if(flags&SWS_FULL_CHR_H_INT) c->chrDstW= dstW;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1606 else c->chrDstW= (dstW+1)>>1;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1607
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1608 if(flags&SWS_FULL_CHR_V) c->chrSrcH= srcH;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1609 else c->chrSrcH= (srcH+1)>>1;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1610
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1611 if(isHalfChrV(dstFormat)) c->chrDstH= (dstH+1)>>1;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1612 else c->chrDstH= dstH;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1613
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1614 c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1615 c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1616
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1617
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1618 // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1619 // but only for the FAST_BILINEAR mode otherwise do correct scaling
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1620 // n-2 is the last chrominance sample available
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1621 // this is not perfect, but noone shuld notice the difference, the more correct variant
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1622 // would be like the vertical one, but that would require some special code for the
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1623 // first and last pixel
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1624 if(flags&SWS_FAST_BILINEAR)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1625 {
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1626 if(c->canMMX2BeUsed)
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1627 {
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1628 c->lumXInc+= 20;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1629 c->chrXInc+= 20;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1630 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1631 //we dont use the x86asm scaler if mmx is available
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1632 else if(cpuCaps.hasMMX)
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1633 {
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1634 c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1635 c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1636 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1637 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1638
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1639 /* precalculate horizontal scaler filter coefficients */
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1640 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1641 const int filterAlign= cpuCaps.hasMMX ? 4 : 1;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1642
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1643 initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1644 srcW , dstW, filterAlign, 1<<14, flags,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1645 srcFilter->lumH, dstFilter->lumH);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1646 initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1647 (srcW+1)>>1, c->chrDstW, filterAlign, 1<<14, flags,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1648 srcFilter->chrH, dstFilter->chrH);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1649
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1650 #ifdef ARCH_X86
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1651 // cant downscale !!!
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1652 if(c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR))
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1653 {
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1654 c->lumMmx2Filter = (int16_t*)memalign(8, (dstW /8+8)*sizeof(int16_t));
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1655 c->chrMmx2Filter = (int16_t*)memalign(8, (c->chrDstW /4+8)*sizeof(int16_t));
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1656 c->lumMmx2FilterPos= (int32_t*)memalign(8, (dstW /2/8+8)*sizeof(int32_t));
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1657 c->chrMmx2FilterPos= (int32_t*)memalign(8, (c->chrDstW/2/4+8)*sizeof(int32_t));
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1658
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1659 initMMX2HScaler( dstW, c->lumXInc, c->funnyYCode , c->lumMmx2Filter, c->lumMmx2FilterPos, 8);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
1660 initMMX2HScaler(c->chrDstW, c->chrXInc, c->funnyUVCode, c->chrMmx2Filter, c->chrMmx2FilterPos, 4);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1661 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1662 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1663 } // Init Horizontal stuff
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1664
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1665
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1666
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1667 /* precalculate vertical scaler filter coefficients */
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1668 initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1669 srcH , dstH, 1, (1<<12)-4, flags,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1670 srcFilter->lumV, dstFilter->lumV);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1671 initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1672 (srcH+1)>>1, c->chrDstH, 1, (1<<12)-4, flags,
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1673 srcFilter->chrV, dstFilter->chrV);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1674
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1675 // Calculate Buffer Sizes so that they wont run out while handling these damn slices
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1676 c->vLumBufSize= c->vLumFilterSize;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1677 c->vChrBufSize= c->vChrFilterSize;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1678 for(i=0; i<dstH; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1679 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1680 int chrI= i*c->chrDstH / dstH;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1681 int nextSlice= MAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1682 ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<1));
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1683 nextSlice&= ~1; // Slices start at even boundaries
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1684 if(c->vLumFilterPos[i ] + c->vLumBufSize < nextSlice)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1685 c->vLumBufSize= nextSlice - c->vLumFilterPos[i ];
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1686 if(c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>1))
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1687 c->vChrBufSize= (nextSlice>>1) - c->vChrFilterPos[chrI];
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1688 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1689
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1690 // allocate pixbufs (we use dynamic allocation because otherwise we would need to
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1691 c->lumPixBuf= (int16_t**)memalign(4, c->vLumBufSize*2*sizeof(int16_t*));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1692 c->chrPixBuf= (int16_t**)memalign(4, c->vChrBufSize*2*sizeof(int16_t*));
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1693 //Note we need at least one pixel more at the end because of the mmx code (just in case someone wanna replace the 4000/8000)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1694 for(i=0; i<c->vLumBufSize; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1695 c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= (uint16_t*)memalign(8, 4000);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1696 for(i=0; i<c->vChrBufSize; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1697 c->chrPixBuf[i]= c->chrPixBuf[i+c->vChrBufSize]= (uint16_t*)memalign(8, 8000);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1698
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1699 //try to avoid drawing green stuff between the right end and the stride end
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1700 for(i=0; i<c->vLumBufSize; i++) memset(c->lumPixBuf[i], 0, 4000);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1701 for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1702
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1703 ASSERT(c->chrDstH <= dstH)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1704
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1705 // pack filter data for mmx code
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1706 if(cpuCaps.hasMMX)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1707 {
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1708 c->lumMmxFilter= (int16_t*)memalign(8, c->vLumFilterSize* dstH*4*sizeof(int16_t));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1709 c->chrMmxFilter= (int16_t*)memalign(8, c->vChrFilterSize*c->chrDstH*4*sizeof(int16_t));
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1710 for(i=0; i<c->vLumFilterSize*dstH; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1711 c->lumMmxFilter[4*i]=c->lumMmxFilter[4*i+1]=c->lumMmxFilter[4*i+2]=c->lumMmxFilter[4*i+3]=
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1712 c->vLumFilter[i];
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1713 for(i=0; i<c->vChrFilterSize*c->chrDstH; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1714 c->chrMmxFilter[4*i]=c->chrMmxFilter[4*i+1]=c->chrMmxFilter[4*i+2]=c->chrMmxFilter[4*i+3]=
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1715 c->vChrFilter[i];
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1716 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1717
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1718 if(flags&SWS_PRINT_INFO)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1719 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1720 #ifdef DITHER1XBPP
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1721 char *dither= " dithered";
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1722 #else
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1723 char *dither= "";
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1724 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1725 if(flags&SWS_FAST_BILINEAR)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1726 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: FAST_BILINEAR scaler, ");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1727 else if(flags&SWS_BILINEAR)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1728 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: BILINEAR scaler, ");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1729 else if(flags&SWS_BICUBIC)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1730 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: BICUBIC scaler, ");
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1731 else if(flags&SWS_X)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1732 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: Experimental scaler, ");
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
1733 else if(flags&SWS_POINT)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1734 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: Nearest Neighbor / POINT scaler, ");
4402
67abbf501b02 area averageing scaling support (-sws 5) (is identical to bilinear for upscale)
michael
parents: 4401
diff changeset
1735 else if(flags&SWS_AREA)
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1736 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: Area Averageing scaler, ");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1737 else
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1738 mp_msg(MSGT_SWS,MSGL_INFO,"SwScaler: ehh flags invalid?! ");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1739
6138
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1740 mp_msg(MSGT_SWS,MSGL_INFO,"%dx%d %s -> %dx%d%s %s ",
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1741 srcW,srcH, vo_format_name(srcFormat), dstW,dstH,
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1742 (dstFormat==IMGFMT_BGR15 || dstFormat==IMGFMT_BGR16) ?
523014df7d32 big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents: 6057
diff changeset
1743 dither : "", vo_format_name(dstFormat));
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1744
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1745 if(cpuCaps.hasMMX2)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1746 mp_msg(MSGT_SWS,MSGL_INFO,"using MMX2\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1747 else if(cpuCaps.has3DNow)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1748 mp_msg(MSGT_SWS,MSGL_INFO,"using 3DNOW\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1749 else if(cpuCaps.hasMMX)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1750 mp_msg(MSGT_SWS,MSGL_INFO,"using MMX\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1751 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1752 mp_msg(MSGT_SWS,MSGL_INFO,"using C\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1753 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1754
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1755 if((flags & SWS_PRINT_INFO) && verbose)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1756 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1757 if(cpuCaps.hasMMX)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1758 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1759 if(c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1760 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1761 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1762 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1763 if(c->hLumFilterSize==4)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1764 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 4-tap MMX scaler for horizontal luminance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1765 else if(c->hLumFilterSize==8)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1766 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 8-tap MMX scaler for horizontal luminance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1767 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1768 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using n-tap MMX scaler for horizontal luminance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1769
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1770 if(c->hChrFilterSize==4)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1771 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 4-tap MMX scaler for horizontal chrominance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1772 else if(c->hChrFilterSize==8)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1773 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 8-tap MMX scaler for horizontal chrominance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1774 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1775 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using n-tap MMX scaler for horizontal chrominance scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1776 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1777 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1778 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1779 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1780 #ifdef ARCH_X86
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1781 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using X86-Asm scaler for horizontal scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1782 #else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1783 if(flags & SWS_FAST_BILINEAR)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1784 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using FAST_BILINEAR C scaler for horizontal scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1785 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1786 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using C scaler for horizontal scaling\n");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1787 #endif
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1788 }
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
1789 if(isPlanarYUV(dstFormat))
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1790 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1791 if(c->vLumFilterSize==1)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1792 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n", cpuCaps.hasMMX ? "MMX" : "C");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1793 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1794 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using n-tap %s scaler for vertical scaling (YV12 like)\n", cpuCaps.hasMMX ? "MMX" : "C");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1795 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1796 else
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1797 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1798 if(c->vLumFilterSize==1 && c->vChrFilterSize==2)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1799 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1800 "SwScaler: 2-tap scaler for vertical chrominance scaling (BGR)\n",cpuCaps.hasMMX ? "MMX" : "C");
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1801 else if(c->vLumFilterSize==2 && c->vChrFilterSize==2)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1802 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1803 else
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1804 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using n-tap %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1805 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1806
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1807 if(dstFormat==IMGFMT_BGR24)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1808 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using %s YV12->BGR24 Converter\n",
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1809 cpuCaps.hasMMX2 ? "MMX2" : (cpuCaps.hasMMX ? "MMX" : "C"));
4304
329ecbb6309b minor bugfix in the -v output
michael
parents: 4297
diff changeset
1810 else if(dstFormat==IMGFMT_BGR32)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1811 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using %s YV12->BGR32 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
4304
329ecbb6309b minor bugfix in the -v output
michael
parents: 4297
diff changeset
1812 else if(dstFormat==IMGFMT_BGR16)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1813 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using %s YV12->BGR16 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
4304
329ecbb6309b minor bugfix in the -v output
michael
parents: 4297
diff changeset
1814 else if(dstFormat==IMGFMT_BGR15)
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1815 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: using %s YV12->BGR15 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1816
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1817 mp_msg(MSGT_SWS,MSGL_V,"SwScaler: %dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1818 }
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1819 if((flags & SWS_PRINT_INFO) && verbose>1)
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1820 {
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1821 mp_msg(MSGT_SWS,MSGL_DBG2,"SwScaler:Lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1822 c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
5937
4b18bf35f153 printf to mp_msg
albeu
parents: 5452
diff changeset
1823 mp_msg(MSGT_SWS,MSGL_DBG2,"SwScaler:Chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
4467
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1824 c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
9512d6832b38 YUY2, BGR24, BGR32 input support (no mmx yet)
michael
parents: 4421
diff changeset
1825 }
4554
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1826
16fdb694cf13 swScale internally uses yuv2rgb now if possible
michael
parents: 4529
diff changeset
1827 c->swScale= swScale;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1828 return c;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1829 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1830
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1831 /**
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1832 * returns a normalized gaussian curve used to filter stuff
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1833 * quality=3 is high quality, lowwer is lowwer quality
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1834 */
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1835
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1836 SwsVector *getGaussianVec(double variance, double quality){
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1837 const int length= (int)(variance*quality + 0.5) | 1;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1838 int i;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1839 double *coeff= memalign(sizeof(double), length*sizeof(double));
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1840 double middle= (length-1)*0.5;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1841 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1842
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1843 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1844 vec->length= length;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1845
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1846 for(i=0; i<length; i++)
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1847 {
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1848 double dist= i-middle;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1849 coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1850 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1851
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1852 normalizeVec(vec, 1.0);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1853
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1854 return vec;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1855 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1856
4297
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1857 SwsVector *getConstVec(double c, int length){
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1858 int i;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1859 double *coeff= memalign(sizeof(double), length*sizeof(double));
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1860 SwsVector *vec= malloc(sizeof(SwsVector));
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1861
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1862 vec->coeff= coeff;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1863 vec->length= length;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1864
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1865 for(i=0; i<length; i++)
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1866 coeff[i]= c;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1867
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1868 return vec;
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1869 }
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1870
29fef3982238 15/16 bit dithering in C (5% slower, can be disabled by comenting #define DITHER1XBPP out)
michael
parents: 4295
diff changeset
1871
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1872 SwsVector *getIdentityVec(void){
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1873 double *coeff= memalign(sizeof(double), sizeof(double));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1874 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1875 coeff[0]= 1.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1876
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1877 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1878 vec->length= 1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1879
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1880 return vec;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1881 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1882
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1883 void normalizeVec(SwsVector *a, double height){
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1884 int i;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1885 double sum=0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1886 double inv;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1887
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1888 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1889 sum+= a->coeff[i];
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1890
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1891 inv= height/sum;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1892
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1893 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1894 a->coeff[i]*= height;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1895 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1896
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1897 void scaleVec(SwsVector *a, double scalar){
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1898 int i;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1899
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1900 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1901 a->coeff[i]*= scalar;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1902 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1903
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1904 static SwsVector *getConvVec(SwsVector *a, SwsVector *b){
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1905 int length= a->length + b->length - 1;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1906 double *coeff= memalign(sizeof(double), length*sizeof(double));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1907 int i, j;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1908 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1909
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1910 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1911 vec->length= length;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1912
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1913 for(i=0; i<length; i++) coeff[i]= 0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1914
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1915 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1916 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1917 for(j=0; j<b->length; j++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1918 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1919 coeff[i+j]+= a->coeff[i]*b->coeff[j];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1920 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1921 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1922
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1923 return vec;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1924 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1925
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1926 static SwsVector *sumVec(SwsVector *a, SwsVector *b){
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1927 int length= MAX(a->length, b->length);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1928 double *coeff= memalign(sizeof(double), length*sizeof(double));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1929 int i;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1930 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1931
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1932 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1933 vec->length= length;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1934
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1935 for(i=0; i<length; i++) coeff[i]= 0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1936
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1937 for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1938 for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]+= b->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1939
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1940 return vec;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1941 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1942
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1943 static SwsVector *diffVec(SwsVector *a, SwsVector *b){
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1944 int length= MAX(a->length, b->length);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1945 double *coeff= memalign(sizeof(double), length*sizeof(double));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1946 int i;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1947 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1948
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1949 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1950 vec->length= length;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1951
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1952 for(i=0; i<length; i++) coeff[i]= 0.0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1953
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1954 for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1955 for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]-= b->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1956
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1957 return vec;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1958 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1959
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1960 /* shift left / or right if "shift" is negative */
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1961 static SwsVector *getShiftedVec(SwsVector *a, int shift){
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1962 int length= a->length + ABS(shift)*2;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1963 double *coeff= memalign(sizeof(double), length*sizeof(double));
4401
8d00348d0d6b nearest neighbor / sdl emulation ;) scaling (-sws 4)
michael
parents: 4304
diff changeset
1964 int i;
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1965 SwsVector *vec= malloc(sizeof(SwsVector));
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1966
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1967 vec->coeff= coeff;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1968 vec->length= length;
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1969
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1970 for(i=0; i<length; i++) coeff[i]= 0.0;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1971
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1972 for(i=0; i<a->length; i++)
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1973 {
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1974 coeff[i + (length-1)/2 - (a->length-1)/2 - shift]= a->coeff[i];
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1975 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
1976
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1977 return vec;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1978 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
1979
4294
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1980 void shiftVec(SwsVector *a, int shift){
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1981 SwsVector *shifted= getShiftedVec(a, shift);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1982 free(a->coeff);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1983 a->coeff= shifted->coeff;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1984 a->length= shifted->length;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1985 free(shifted);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1986 }
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1987
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1988 void addVec(SwsVector *a, SwsVector *b){
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1989 SwsVector *sum= sumVec(a, b);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1990 free(a->coeff);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1991 a->coeff= sum->coeff;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1992 a->length= sum->length;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1993 free(sum);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1994 }
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1995
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1996 void subVec(SwsVector *a, SwsVector *b){
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1997 SwsVector *diff= diffVec(a, b);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1998 free(a->coeff);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
1999 a->coeff= diff->coeff;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2000 a->length= diff->length;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2001 free(diff);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2002 }
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2003
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2004 void convVec(SwsVector *a, SwsVector *b){
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2005 SwsVector *conv= getConvVec(a, b);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2006 free(a->coeff);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2007 a->coeff= conv->coeff;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2008 a->length= conv->length;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2009 free(conv);
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2010 }
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2011
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2012 SwsVector *cloneVec(SwsVector *a){
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2013 double *coeff= memalign(sizeof(double), a->length*sizeof(double));
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2014 int i;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2015 SwsVector *vec= malloc(sizeof(SwsVector));
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2016
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2017 vec->coeff= coeff;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2018 vec->length= a->length;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2019
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2020 for(i=0; i<a->length; i++) coeff[i]= a->coeff[i];
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2021
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2022 return vec;
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2023 }
21dbbbbd5479 a few filters (should be removed/merged when arpis videofilter stuff is finished)
michael
parents: 4290
diff changeset
2024
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2025 void printVec(SwsVector *a){
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2026 int i;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2027 double max=0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2028 double min=0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2029 double range;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2030
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2031 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2032 if(a->coeff[i]>max) max= a->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2033
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2034 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2035 if(a->coeff[i]<min) min= a->coeff[i];
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2036
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2037 range= max - min;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2038
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2039 for(i=0; i<a->length; i++)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2040 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2041 int x= (int)((a->coeff[i]-min)*60.0/range +0.5);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2042 printf("%1.3f ", a->coeff[i]);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2043 for(;x>0; x--) printf(" ");
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2044 printf("|\n");
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2045 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2046 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2047
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2048 void freeVec(SwsVector *a){
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2049 if(!a) return;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2050 if(a->coeff) free(a->coeff);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2051 a->coeff=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2052 a->length=0;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2053 free(a);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2054 }
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2055
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2056 void freeSwsContext(SwsContext *c){
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2057 int i;
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2058
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2059 if(!c) return;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2060
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2061 if(c->lumPixBuf)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2062 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
2063 for(i=0; i<c->vLumBufSize; i++)
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2064 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2065 if(c->lumPixBuf[i]) free(c->lumPixBuf[i]);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2066 c->lumPixBuf[i]=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2067 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2068 free(c->lumPixBuf);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2069 c->lumPixBuf=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2070 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2071
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2072 if(c->chrPixBuf)
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2073 {
4419
f002407e298d YV12 like formats support (I420/IYUV)
michael
parents: 4402
diff changeset
2074 for(i=0; i<c->vChrBufSize; i++)
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2075 {
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2076 if(c->chrPixBuf[i]) free(c->chrPixBuf[i]);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2077 c->chrPixBuf[i]=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2078 }
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2079 free(c->chrPixBuf);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2080 c->chrPixBuf=NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2081 }
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2082
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2083 if(c->vLumFilter) free(c->vLumFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2084 c->vLumFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2085 if(c->vChrFilter) free(c->vChrFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2086 c->vChrFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2087 if(c->hLumFilter) free(c->hLumFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2088 c->hLumFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2089 if(c->hChrFilter) free(c->hChrFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2090 c->hChrFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2091
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2092 if(c->vLumFilterPos) free(c->vLumFilterPos);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2093 c->vLumFilterPos = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2094 if(c->vChrFilterPos) free(c->vChrFilterPos);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2095 c->vChrFilterPos = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2096 if(c->hLumFilterPos) free(c->hLumFilterPos);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2097 c->hLumFilterPos = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2098 if(c->hChrFilterPos) free(c->hChrFilterPos);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2099 c->hChrFilterPos = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2100
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2101 if(c->lumMmxFilter) free(c->lumMmxFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2102 c->lumMmxFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2103 if(c->chrMmxFilter) free(c->chrMmxFilter);
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2104 c->chrMmxFilter = NULL;
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2105
5452
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2106 if(c->lumMmx2Filter) free(c->lumMmx2Filter);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2107 c->lumMmx2Filter=NULL;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2108 if(c->chrMmx2Filter) free(c->chrMmx2Filter);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2109 c->chrMmx2Filter=NULL;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2110 if(c->lumMmx2FilterPos) free(c->lumMmx2FilterPos);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2111 c->lumMmx2FilterPos=NULL;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2112 if(c->chrMmx2FilterPos) free(c->chrMmx2FilterPos);
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2113 c->chrMmx2FilterPos=NULL;
eb87391a5292 overread in the mmx2 horizontal scaler fixed
michael
parents: 5246
diff changeset
2114
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2115 free(c);
4276
9199d15cb4e0 removed global vars so that multiple swscalers can be used
michael
parents: 4248
diff changeset
2116 }
4281
michael
parents: 4276
diff changeset
2117
4290
1f8ceb12284d general convolution filtering of the source picture
michael
parents: 4281
diff changeset
2118