annotate postproc/swscale.c @ 5255:34166dede1d4

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