2 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 * the C code (not assembly, mmx, ...) of this file can be used
21 * under the LGPL license too
25 supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR32_1, BGR24, BGR16, BGR15, RGB32, RGB32_1, RGB24, Y8/Y800, YVU9/IF09, PAL8
26 supported output formats: YV12, I420/IYUV, YUY2, UYVY, {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09
27 {BGR,RGB}{1,4,8,15,16} support dithering
29 unscaled special converters (YV12=I420=IYUV, Y800=Y8)
30 YV12 -> {BGR,RGB}{1,4,8,15,16,24,32}
35 BGR24 -> BGR32 & RGB24 -> RGB32
36 BGR32 -> BGR24 & RGB32 -> RGB24
41 tested special converters (most are tested actually, but I did not write it down ...)
48 untested special converters
49 YV12/I420 -> BGR15/BGR24/BGR32 (it is the yuv2rgb stuff, so it should be OK)
50 YV12/I420 -> YV12/I420
51 YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
52 BGR24 -> BGR32 & RGB24 -> RGB32
53 BGR32 -> BGR24 & RGB32 -> RGB24
64 #include "swscale_internal.h"
66 #include "libavutil/intreadwrite.h"
67 #include "libavutil/x86_cpu.h"
68 #include "libavutil/avutil.h"
69 #include "libavutil/bswap.h"
70 #include "libavutil/pixdesc.h"
76 //#define HAVE_AMD3DNOW
81 #define FAST_BGR2YV12 // use 7 bit coefficients instead of 15 bit
86 #define PI 3.14159265358979323846
89 #define isPacked(x) ( \
91 || (x)==PIX_FMT_YUYV422 \
92 || (x)==PIX_FMT_UYVY422 \
95 #define usePal(x) (av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL)
97 #define RGB2YUV_SHIFT 15
98 #define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
99 #define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
100 #define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
101 #define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
102 #define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
103 #define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
104 #define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
105 #define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
106 #define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))
108 static const double rgb2yuv_table
[8][9]={
109 {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5},
110 {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5},
111 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
112 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
113 {0.59 , 0.11 , 0.30 , -0.331, 0.5, -0.169, -0.421, -0.079, 0.5}, //FCC
114 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
115 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //SMPTE 170M
116 {0.701 , 0.087 , 0.212 , -0.384, 0.5 -0.116, -0.445, -0.055, 0.5}, //SMPTE 240M
121 Special versions: fast Y 1:1 scaling (no interpolation in y direction)
124 more intelligent misalignment avoidance for the horizontal scaler
125 write special vertical cubic upscale version
126 optimize C code (YV12 / minmax)
127 add support for packed pixel YUV input & output
128 add support for Y8 output
129 optimize BGR24 & BGR32
130 add BGR4 output support
131 write special BGR->BGR scaler
134 #if ARCH_X86 && CONFIG_GPL
135 DECLARE_ASM_CONST(8, uint64_t, bF8
)= 0xF8F8F8F8F8F8F8F8LL
;
136 DECLARE_ASM_CONST(8, uint64_t, bFC
)= 0xFCFCFCFCFCFCFCFCLL
;
137 DECLARE_ASM_CONST(8, uint64_t, w10
)= 0x0010001000100010LL
;
138 DECLARE_ASM_CONST(8, uint64_t, w02
)= 0x0002000200020002LL
;
139 DECLARE_ASM_CONST(8, uint64_t, bm00001111
)=0x00000000FFFFFFFFLL
;
140 DECLARE_ASM_CONST(8, uint64_t, bm00000111
)=0x0000000000FFFFFFLL
;
141 DECLARE_ASM_CONST(8, uint64_t, bm11111000
)=0xFFFFFFFFFF000000LL
;
142 DECLARE_ASM_CONST(8, uint64_t, bm01010101
)=0x00FF00FF00FF00FFLL
;
144 const DECLARE_ALIGNED(8, uint64_t, ff_dither4
)[2] = {
145 0x0103010301030103LL
,
146 0x0200020002000200LL
,};
148 const DECLARE_ALIGNED(8, uint64_t, ff_dither8
)[2] = {
149 0x0602060206020602LL
,
150 0x0004000400040004LL
,};
152 DECLARE_ASM_CONST(8, uint64_t, b16Mask
)= 0x001F001F001F001FLL
;
153 DECLARE_ASM_CONST(8, uint64_t, g16Mask
)= 0x07E007E007E007E0LL
;
154 DECLARE_ASM_CONST(8, uint64_t, r16Mask
)= 0xF800F800F800F800LL
;
155 DECLARE_ASM_CONST(8, uint64_t, b15Mask
)= 0x001F001F001F001FLL
;
156 DECLARE_ASM_CONST(8, uint64_t, g15Mask
)= 0x03E003E003E003E0LL
;
157 DECLARE_ASM_CONST(8, uint64_t, r15Mask
)= 0x7C007C007C007C00LL
;
159 DECLARE_ALIGNED(8, const uint64_t, ff_M24A
) = 0x00FF0000FF0000FFLL
;
160 DECLARE_ALIGNED(8, const uint64_t, ff_M24B
) = 0xFF0000FF0000FF00LL
;
161 DECLARE_ALIGNED(8, const uint64_t, ff_M24C
) = 0x0000FF0000FF0000LL
;
164 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YCoeff
) = 0x000000210041000DULL
;
165 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UCoeff
) = 0x0000FFEEFFDC0038ULL
;
166 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2VCoeff
) = 0x00000038FFD2FFF8ULL
;
168 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YCoeff
) = 0x000020E540830C8BULL
;
169 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UCoeff
) = 0x0000ED0FDAC23831ULL
;
170 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2VCoeff
) = 0x00003831D0E6F6EAULL
;
171 #endif /* FAST_BGR2YV12 */
172 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YOffset
) = 0x1010101010101010ULL
;
173 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UVOffset
) = 0x8080808080808080ULL
;
174 DECLARE_ALIGNED(8, const uint64_t, ff_w1111
) = 0x0001000100010001ULL
;
176 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toY1Coeff
) = 0x0C88000040870C88ULL
;
177 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toY2Coeff
) = 0x20DE4087000020DEULL
;
178 DECLARE_ASM_CONST(8, uint64_t, ff_rgb24toY1Coeff
) = 0x20DE0000408720DEULL
;
179 DECLARE_ASM_CONST(8, uint64_t, ff_rgb24toY2Coeff
) = 0x0C88408700000C88ULL
;
180 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toYOffset
) = 0x0008400000084000ULL
;
182 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toUV
)[2][4] = {
183 {0x38380000DAC83838ULL
, 0xECFFDAC80000ECFFULL
, 0xF6E40000D0E3F6E4ULL
, 0x3838D0E300003838ULL
},
184 {0xECFF0000DAC8ECFFULL
, 0x3838DAC800003838ULL
, 0x38380000D0E33838ULL
, 0xF6E4D0E30000F6E4ULL
},
187 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toUVOffset
)= 0x0040400000404000ULL
;
189 #endif /* ARCH_X86 && CONFIG_GPL */
191 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_4
)[2][8]={
192 { 1, 3, 1, 3, 1, 3, 1, 3, },
193 { 2, 0, 2, 0, 2, 0, 2, 0, },
196 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_8
)[2][8]={
197 { 6, 2, 6, 2, 6, 2, 6, 2, },
198 { 0, 4, 0, 4, 0, 4, 0, 4, },
201 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_32
)[8][8]={
202 { 17, 9, 23, 15, 16, 8, 22, 14, },
203 { 5, 29, 3, 27, 4, 28, 2, 26, },
204 { 21, 13, 19, 11, 20, 12, 18, 10, },
205 { 0, 24, 6, 30, 1, 25, 7, 31, },
206 { 16, 8, 22, 14, 17, 9, 23, 15, },
207 { 4, 28, 2, 26, 5, 29, 3, 27, },
208 { 20, 12, 18, 10, 21, 13, 19, 11, },
209 { 1, 25, 7, 31, 0, 24, 6, 30, },
212 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_73
)[8][8]={
213 { 0, 55, 14, 68, 3, 58, 17, 72, },
214 { 37, 18, 50, 32, 40, 22, 54, 35, },
215 { 9, 64, 5, 59, 13, 67, 8, 63, },
216 { 46, 27, 41, 23, 49, 31, 44, 26, },
217 { 2, 57, 16, 71, 1, 56, 15, 70, },
218 { 39, 21, 52, 34, 38, 19, 51, 33, },
219 { 11, 66, 7, 62, 10, 65, 6, 60, },
220 { 48, 30, 43, 25, 47, 29, 42, 24, },
224 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
225 {117, 62, 158, 103, 113, 58, 155, 100, },
226 { 34, 199, 21, 186, 31, 196, 17, 182, },
227 {144, 89, 131, 76, 141, 86, 127, 72, },
228 { 0, 165, 41, 206, 10, 175, 52, 217, },
229 {110, 55, 151, 96, 120, 65, 162, 107, },
230 { 28, 193, 14, 179, 38, 203, 24, 189, },
231 {138, 83, 124, 69, 148, 93, 134, 79, },
232 { 7, 172, 48, 213, 3, 168, 45, 210, },
235 // tries to correct a gamma of 1.5
236 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
237 { 0, 143, 18, 200, 2, 156, 25, 215, },
238 { 78, 28, 125, 64, 89, 36, 138, 74, },
239 { 10, 180, 3, 161, 16, 195, 8, 175, },
240 {109, 51, 93, 38, 121, 60, 105, 47, },
241 { 1, 152, 23, 210, 0, 147, 20, 205, },
242 { 85, 33, 134, 71, 81, 30, 130, 67, },
243 { 14, 190, 6, 171, 12, 185, 5, 166, },
244 {117, 57, 101, 44, 113, 54, 97, 41, },
247 // tries to correct a gamma of 2.0
248 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
249 { 0, 124, 8, 193, 0, 140, 12, 213, },
250 { 55, 14, 104, 42, 66, 19, 119, 52, },
251 { 3, 168, 1, 145, 6, 187, 3, 162, },
252 { 86, 31, 70, 21, 99, 39, 82, 28, },
253 { 0, 134, 11, 206, 0, 129, 9, 200, },
254 { 62, 17, 114, 48, 58, 16, 109, 45, },
255 { 5, 181, 2, 157, 4, 175, 1, 151, },
256 { 95, 36, 78, 26, 90, 34, 74, 24, },
259 // tries to correct a gamma of 2.5
260 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
261 { 0, 107, 3, 187, 0, 125, 6, 212, },
262 { 39, 7, 86, 28, 49, 11, 102, 36, },
263 { 1, 158, 0, 131, 3, 180, 1, 151, },
264 { 68, 19, 52, 12, 81, 25, 64, 17, },
265 { 0, 119, 5, 203, 0, 113, 4, 195, },
266 { 45, 9, 96, 33, 42, 8, 91, 30, },
267 { 2, 172, 1, 144, 2, 165, 0, 137, },
268 { 77, 23, 60, 15, 72, 21, 56, 14, },
272 static av_always_inline
void yuv2yuvX16inC_template(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
273 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
274 const int16_t **alpSrc
, uint16_t *dest
, uint16_t *uDest
, uint16_t *vDest
, uint16_t *aDest
,
275 int dstW
, int chrDstW
, int big_endian
)
277 //FIXME Optimize (just quickly written not optimized..)
280 for (i
= 0; i
< dstW
; i
++) {
284 for (j
= 0; j
< lumFilterSize
; j
++)
285 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
288 AV_WB16(&dest
[i
], av_clip_uint16(val
>> 11));
290 AV_WL16(&dest
[i
], av_clip_uint16(val
>> 11));
295 for (i
= 0; i
< chrDstW
; i
++) {
300 for (j
= 0; j
< chrFilterSize
; j
++) {
301 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
302 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
306 AV_WB16(&uDest
[i
], av_clip_uint16(u
>> 11));
307 AV_WB16(&vDest
[i
], av_clip_uint16(v
>> 11));
309 AV_WL16(&uDest
[i
], av_clip_uint16(u
>> 11));
310 AV_WL16(&vDest
[i
], av_clip_uint16(v
>> 11));
315 if (CONFIG_SWSCALE_ALPHA
&& aDest
) {
316 for (i
= 0; i
< dstW
; i
++) {
320 for (j
= 0; j
< lumFilterSize
; j
++)
321 val
+= alpSrc
[j
][i
] * lumFilter
[j
];
324 AV_WB16(&aDest
[i
], av_clip_uint16(val
>> 11));
326 AV_WL16(&aDest
[i
], av_clip_uint16(val
>> 11));
332 static inline void yuv2yuvX16inC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
333 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
334 const int16_t **alpSrc
, uint16_t *dest
, uint16_t *uDest
, uint16_t *vDest
, uint16_t *aDest
, int dstW
, int chrDstW
,
335 enum PixelFormat dstFormat
)
337 if (isBE(dstFormat
)) {
338 yuv2yuvX16inC_template(lumFilter
, lumSrc
, lumFilterSize
,
339 chrFilter
, chrSrc
, chrFilterSize
,
341 dest
, uDest
, vDest
, aDest
,
344 yuv2yuvX16inC_template(lumFilter
, lumSrc
, lumFilterSize
,
345 chrFilter
, chrSrc
, chrFilterSize
,
347 dest
, uDest
, vDest
, aDest
,
352 static inline void yuv2yuvXinC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
353 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
354 const int16_t **alpSrc
, uint8_t *dest
, uint8_t *uDest
, uint8_t *vDest
, uint8_t *aDest
, int dstW
, int chrDstW
)
356 //FIXME Optimize (just quickly written not optimized..)
358 for (i
=0; i
<dstW
; i
++) {
361 for (j
=0; j
<lumFilterSize
; j
++)
362 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
364 dest
[i
]= av_clip_uint8(val
>>19);
368 for (i
=0; i
<chrDstW
; i
++) {
372 for (j
=0; j
<chrFilterSize
; j
++) {
373 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
374 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
377 uDest
[i
]= av_clip_uint8(u
>>19);
378 vDest
[i
]= av_clip_uint8(v
>>19);
381 if (CONFIG_SWSCALE_ALPHA
&& aDest
)
382 for (i
=0; i
<dstW
; i
++) {
385 for (j
=0; j
<lumFilterSize
; j
++)
386 val
+= alpSrc
[j
][i
] * lumFilter
[j
];
388 aDest
[i
]= av_clip_uint8(val
>>19);
393 static inline void yuv2nv12XinC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
394 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
395 uint8_t *dest
, uint8_t *uDest
, int dstW
, int chrDstW
, int dstFormat
)
397 //FIXME Optimize (just quickly written not optimized..)
399 for (i
=0; i
<dstW
; i
++) {
402 for (j
=0; j
<lumFilterSize
; j
++)
403 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
405 dest
[i
]= av_clip_uint8(val
>>19);
411 if (dstFormat
== PIX_FMT_NV12
)
412 for (i
=0; i
<chrDstW
; i
++) {
416 for (j
=0; j
<chrFilterSize
; j
++) {
417 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
418 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
421 uDest
[2*i
]= av_clip_uint8(u
>>19);
422 uDest
[2*i
+1]= av_clip_uint8(v
>>19);
425 for (i
=0; i
<chrDstW
; i
++) {
429 for (j
=0; j
<chrFilterSize
; j
++) {
430 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
431 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
434 uDest
[2*i
]= av_clip_uint8(v
>>19);
435 uDest
[2*i
+1]= av_clip_uint8(u
>>19);
439 #define YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha) \
440 for (i=0; i<(dstW>>1); i++) {\
446 int av_unused A1, A2;\
447 type av_unused *r, *b, *g;\
450 for (j=0; j<lumFilterSize; j++) {\
451 Y1 += lumSrc[j][i2] * lumFilter[j];\
452 Y2 += lumSrc[j][i2+1] * lumFilter[j];\
454 for (j=0; j<chrFilterSize; j++) {\
455 U += chrSrc[j][i] * chrFilter[j];\
456 V += chrSrc[j][i+VOFW] * chrFilter[j];\
465 for (j=0; j<lumFilterSize; j++) {\
466 A1 += alpSrc[j][i2 ] * lumFilter[j];\
467 A2 += alpSrc[j][i2+1] * lumFilter[j];\
473 #define YSCALE_YUV_2_PACKEDX_C(type,alpha) \
474 YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha)\
475 if ((Y1|Y2|U|V)&256) {\
476 if (Y1>255) Y1=255; \
477 else if (Y1<0)Y1=0; \
478 if (Y2>255) Y2=255; \
479 else if (Y2<0)Y2=0; \
485 if (alpha && ((A1|A2)&256)) {\
486 A1=av_clip_uint8(A1);\
487 A2=av_clip_uint8(A2);\
490 #define YSCALE_YUV_2_PACKEDX_FULL_C(rnd,alpha) \
491 for (i=0; i<dstW; i++) {\
499 for (j=0; j<lumFilterSize; j++) {\
500 Y += lumSrc[j][i ] * lumFilter[j];\
502 for (j=0; j<chrFilterSize; j++) {\
503 U += chrSrc[j][i ] * chrFilter[j];\
504 V += chrSrc[j][i+VOFW] * chrFilter[j];\
511 for (j=0; j<lumFilterSize; j++)\
512 A += alpSrc[j][i ] * lumFilter[j];\
515 A = av_clip_uint8(A);\
518 #define YSCALE_YUV_2_RGBX_FULL_C(rnd,alpha) \
519 YSCALE_YUV_2_PACKEDX_FULL_C(rnd>>3,alpha)\
520 Y-= c->yuv2rgb_y_offset;\
521 Y*= c->yuv2rgb_y_coeff;\
523 R= Y + V*c->yuv2rgb_v2r_coeff;\
524 G= Y + V*c->yuv2rgb_v2g_coeff + U*c->yuv2rgb_u2g_coeff;\
525 B= Y + U*c->yuv2rgb_u2b_coeff;\
526 if ((R|G|B)&(0xC0000000)) {\
527 if (R>=(256<<22)) R=(256<<22)-1; \
529 if (G>=(256<<22)) G=(256<<22)-1; \
531 if (B>=(256<<22)) B=(256<<22)-1; \
535 #define YSCALE_YUV_2_GRAY16_C \
536 for (i=0; i<(dstW>>1); i++) {\
545 for (j=0; j<lumFilterSize; j++) {\
546 Y1 += lumSrc[j][i2] * lumFilter[j];\
547 Y2 += lumSrc[j][i2+1] * lumFilter[j];\
551 if ((Y1|Y2|U|V)&65536) {\
552 if (Y1>65535) Y1=65535; \
553 else if (Y1<0)Y1=0; \
554 if (Y2>65535) Y2=65535; \
555 else if (Y2<0)Y2=0; \
558 #define YSCALE_YUV_2_RGBX_C(type,alpha) \
559 YSCALE_YUV_2_PACKEDX_C(type,alpha) /* FIXME fix tables so that clipping is not needed and then use _NOCLIP*/\
560 r = (type *)c->table_rV[V]; \
561 g = (type *)(c->table_gU[U] + c->table_gV[V]); \
562 b = (type *)c->table_bU[U];
564 #define YSCALE_YUV_2_PACKED2_C(type,alpha) \
565 for (i=0; i<(dstW>>1); i++) { \
567 int Y1= (buf0[i2 ]*yalpha1+buf1[i2 ]*yalpha)>>19; \
568 int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>19; \
569 int U= (uvbuf0[i ]*uvalpha1+uvbuf1[i ]*uvalpha)>>19; \
570 int V= (uvbuf0[i+VOFW]*uvalpha1+uvbuf1[i+VOFW]*uvalpha)>>19; \
571 type av_unused *r, *b, *g; \
572 int av_unused A1, A2; \
574 A1= (abuf0[i2 ]*yalpha1+abuf1[i2 ]*yalpha)>>19; \
575 A2= (abuf0[i2+1]*yalpha1+abuf1[i2+1]*yalpha)>>19; \
578 #define YSCALE_YUV_2_GRAY16_2_C \
579 for (i=0; i<(dstW>>1); i++) { \
581 int Y1= (buf0[i2 ]*yalpha1+buf1[i2 ]*yalpha)>>11; \
582 int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>11;
584 #define YSCALE_YUV_2_RGB2_C(type,alpha) \
585 YSCALE_YUV_2_PACKED2_C(type,alpha)\
586 r = (type *)c->table_rV[V];\
587 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
588 b = (type *)c->table_bU[U];
590 #define YSCALE_YUV_2_PACKED1_C(type,alpha) \
591 for (i=0; i<(dstW>>1); i++) {\
593 int Y1= buf0[i2 ]>>7;\
594 int Y2= buf0[i2+1]>>7;\
595 int U= (uvbuf1[i ])>>7;\
596 int V= (uvbuf1[i+VOFW])>>7;\
597 type av_unused *r, *b, *g;\
598 int av_unused A1, A2;\
604 #define YSCALE_YUV_2_GRAY16_1_C \
605 for (i=0; i<(dstW>>1); i++) {\
607 int Y1= buf0[i2 ]<<1;\
608 int Y2= buf0[i2+1]<<1;
610 #define YSCALE_YUV_2_RGB1_C(type,alpha) \
611 YSCALE_YUV_2_PACKED1_C(type,alpha)\
612 r = (type *)c->table_rV[V];\
613 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
614 b = (type *)c->table_bU[U];
616 #define YSCALE_YUV_2_PACKED1B_C(type,alpha) \
617 for (i=0; i<(dstW>>1); i++) {\
619 int Y1= buf0[i2 ]>>7;\
620 int Y2= buf0[i2+1]>>7;\
621 int U= (uvbuf0[i ] + uvbuf1[i ])>>8;\
622 int V= (uvbuf0[i+VOFW] + uvbuf1[i+VOFW])>>8;\
623 type av_unused *r, *b, *g;\
624 int av_unused A1, A2;\
630 #define YSCALE_YUV_2_RGB1B_C(type,alpha) \
631 YSCALE_YUV_2_PACKED1B_C(type,alpha)\
632 r = (type *)c->table_rV[V];\
633 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
634 b = (type *)c->table_bU[U];
636 #define YSCALE_YUV_2_MONO2_C \
637 const uint8_t * const d128=dither_8x8_220[y&7];\
638 uint8_t *g= c->table_gU[128] + c->table_gV[128];\
639 for (i=0; i<dstW-7; i+=8) {\
641 acc = g[((buf0[i ]*yalpha1+buf1[i ]*yalpha)>>19) + d128[0]];\
642 acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];\
643 acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];\
644 acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];\
645 acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];\
646 acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];\
647 acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];\
648 acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];\
649 ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
653 #define YSCALE_YUV_2_MONOX_C \
654 const uint8_t * const d128=dither_8x8_220[y&7];\
655 uint8_t *g= c->table_gU[128] + c->table_gV[128];\
657 for (i=0; i<dstW-1; i+=2) {\
662 for (j=0; j<lumFilterSize; j++) {\
663 Y1 += lumSrc[j][i] * lumFilter[j];\
664 Y2 += lumSrc[j][i+1] * lumFilter[j];\
674 acc+= acc + g[Y1+d128[(i+0)&7]];\
675 acc+= acc + g[Y2+d128[(i+1)&7]];\
677 ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
682 #define YSCALE_YUV_2_ANYRGB_C(func, func2, func_g16, func_monoblack)\
683 switch(c->dstFormat) {\
684 case PIX_FMT_RGB48BE:\
685 case PIX_FMT_RGB48LE:\
687 ((uint8_t*)dest)[ 0]= r[Y1];\
688 ((uint8_t*)dest)[ 1]= r[Y1];\
689 ((uint8_t*)dest)[ 2]= g[Y1];\
690 ((uint8_t*)dest)[ 3]= g[Y1];\
691 ((uint8_t*)dest)[ 4]= b[Y1];\
692 ((uint8_t*)dest)[ 5]= b[Y1];\
693 ((uint8_t*)dest)[ 6]= r[Y2];\
694 ((uint8_t*)dest)[ 7]= r[Y2];\
695 ((uint8_t*)dest)[ 8]= g[Y2];\
696 ((uint8_t*)dest)[ 9]= g[Y2];\
697 ((uint8_t*)dest)[10]= b[Y2];\
698 ((uint8_t*)dest)[11]= b[Y2];\
705 int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
706 func(uint32_t,needAlpha)\
707 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? (A1<<24) : 0);\
708 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? (A2<<24) : 0);\
711 if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
713 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (A1<<24);\
714 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (A2<<24);\
718 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
719 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
727 int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
728 func(uint32_t,needAlpha)\
729 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? A1 : 0);\
730 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? A2 : 0);\
733 if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
735 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + A1;\
736 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + A2;\
740 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
741 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
748 ((uint8_t*)dest)[0]= r[Y1];\
749 ((uint8_t*)dest)[1]= g[Y1];\
750 ((uint8_t*)dest)[2]= b[Y1];\
751 ((uint8_t*)dest)[3]= r[Y2];\
752 ((uint8_t*)dest)[4]= g[Y2];\
753 ((uint8_t*)dest)[5]= b[Y2];\
759 ((uint8_t*)dest)[0]= b[Y1];\
760 ((uint8_t*)dest)[1]= g[Y1];\
761 ((uint8_t*)dest)[2]= r[Y1];\
762 ((uint8_t*)dest)[3]= b[Y2];\
763 ((uint8_t*)dest)[4]= g[Y2];\
764 ((uint8_t*)dest)[5]= r[Y2];\
768 case PIX_FMT_RGB565BE:\
769 case PIX_FMT_RGB565LE:\
770 case PIX_FMT_BGR565BE:\
771 case PIX_FMT_BGR565LE:\
773 const int dr1= dither_2x2_8[y&1 ][0];\
774 const int dg1= dither_2x2_4[y&1 ][0];\
775 const int db1= dither_2x2_8[(y&1)^1][0];\
776 const int dr2= dither_2x2_8[y&1 ][1];\
777 const int dg2= dither_2x2_4[y&1 ][1];\
778 const int db2= dither_2x2_8[(y&1)^1][1];\
780 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
781 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
785 case PIX_FMT_RGB555BE:\
786 case PIX_FMT_RGB555LE:\
787 case PIX_FMT_BGR555BE:\
788 case PIX_FMT_BGR555LE:\
790 const int dr1= dither_2x2_8[y&1 ][0];\
791 const int dg1= dither_2x2_8[y&1 ][1];\
792 const int db1= dither_2x2_8[(y&1)^1][0];\
793 const int dr2= dither_2x2_8[y&1 ][1];\
794 const int dg2= dither_2x2_8[y&1 ][0];\
795 const int db2= dither_2x2_8[(y&1)^1][1];\
797 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
798 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
805 const uint8_t * const d64= dither_8x8_73[y&7];\
806 const uint8_t * const d32= dither_8x8_32[y&7];\
808 ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];\
809 ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];\
816 const uint8_t * const d64= dither_8x8_73 [y&7];\
817 const uint8_t * const d128=dither_8x8_220[y&7];\
819 ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]\
820 + ((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);\
824 case PIX_FMT_RGB4_BYTE:\
825 case PIX_FMT_BGR4_BYTE:\
827 const uint8_t * const d64= dither_8x8_73 [y&7];\
828 const uint8_t * const d128=dither_8x8_220[y&7];\
830 ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];\
831 ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];\
835 case PIX_FMT_MONOBLACK:\
836 case PIX_FMT_MONOWHITE:\
841 case PIX_FMT_YUYV422:\
843 ((uint8_t*)dest)[2*i2+0]= Y1;\
844 ((uint8_t*)dest)[2*i2+1]= U;\
845 ((uint8_t*)dest)[2*i2+2]= Y2;\
846 ((uint8_t*)dest)[2*i2+3]= V;\
849 case PIX_FMT_UYVY422:\
851 ((uint8_t*)dest)[2*i2+0]= U;\
852 ((uint8_t*)dest)[2*i2+1]= Y1;\
853 ((uint8_t*)dest)[2*i2+2]= V;\
854 ((uint8_t*)dest)[2*i2+3]= Y2;\
857 case PIX_FMT_GRAY16BE:\
859 ((uint8_t*)dest)[2*i2+0]= Y1>>8;\
860 ((uint8_t*)dest)[2*i2+1]= Y1;\
861 ((uint8_t*)dest)[2*i2+2]= Y2>>8;\
862 ((uint8_t*)dest)[2*i2+3]= Y2;\
865 case PIX_FMT_GRAY16LE:\
867 ((uint8_t*)dest)[2*i2+0]= Y1;\
868 ((uint8_t*)dest)[2*i2+1]= Y1>>8;\
869 ((uint8_t*)dest)[2*i2+2]= Y2;\
870 ((uint8_t*)dest)[2*i2+3]= Y2>>8;\
875 static inline void yuv2packedXinC(SwsContext
*c
, const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
876 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
877 const int16_t **alpSrc
, uint8_t *dest
, int dstW
, int y
)
880 YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGBX_C
, YSCALE_YUV_2_PACKEDX_C(void,0), YSCALE_YUV_2_GRAY16_C
, YSCALE_YUV_2_MONOX_C
)
883 static inline void yuv2rgbXinC_full(SwsContext
*c
, const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
884 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
885 const int16_t **alpSrc
, uint8_t *dest
, int dstW
, int y
)
888 int step
= c
->dstFormatBpp
/8;
891 switch(c
->dstFormat
) {
899 int needAlpha
= CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
;
900 YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha
)
901 dest
[aidx
]= needAlpha
? A
: 255;
908 if (CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
) {
909 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
917 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
934 int needAlpha
= CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
;
935 YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha
)
936 dest
[aidx
]= needAlpha
? A
: 255;
943 if (CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
) {
944 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
952 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
967 static void fillPlane(uint8_t* plane
, int stride
, int width
, int height
, int y
, uint8_t val
)
970 uint8_t *ptr
= plane
+ stride
*y
;
971 for (i
=0; i
<height
; i
++) {
972 memset(ptr
, val
, width
);
977 static inline void rgb48ToY(uint8_t *dst
, const uint8_t *src
, int width
,
981 for (i
= 0; i
< width
; i
++) {
986 dst
[i
] = (RY
*r
+ GY
*g
+ BY
*b
+ (33<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
990 static inline void rgb48ToUV(uint8_t *dstU
, uint8_t *dstV
,
991 const uint8_t *src1
, const uint8_t *src2
,
992 int width
, uint32_t *unused
)
996 for (i
= 0; i
< width
; i
++) {
997 int r
= src1
[6*i
+ 0];
998 int g
= src1
[6*i
+ 2];
999 int b
= src1
[6*i
+ 4];
1001 dstU
[i
] = (RU
*r
+ GU
*g
+ BU
*b
+ (257<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
1002 dstV
[i
] = (RV
*r
+ GV
*g
+ BV
*b
+ (257<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
1006 static inline void rgb48ToUV_half(uint8_t *dstU
, uint8_t *dstV
,
1007 const uint8_t *src1
, const uint8_t *src2
,
1008 int width
, uint32_t *unused
)
1012 for (i
= 0; i
< width
; i
++) {
1013 int r
= src1
[12*i
+ 0] + src1
[12*i
+ 6];
1014 int g
= src1
[12*i
+ 2] + src1
[12*i
+ 8];
1015 int b
= src1
[12*i
+ 4] + src1
[12*i
+ 10];
1017 dstU
[i
]= (RU
*r
+ GU
*g
+ BU
*b
+ (257<<RGB2YUV_SHIFT
)) >> (RGB2YUV_SHIFT
+1);
1018 dstV
[i
]= (RV
*r
+ GV
*g
+ BV
*b
+ (257<<RGB2YUV_SHIFT
)) >> (RGB2YUV_SHIFT
+1);
1022 #define BGR2Y(type, name, shr, shg, shb, maskr, maskg, maskb, RY, GY, BY, S)\
1023 static inline void name(uint8_t *dst, const uint8_t *src, long width, uint32_t *unused)\
1026 for (i=0; i<width; i++) {\
1027 int b= (((const type*)src)[i]>>shb)&maskb;\
1028 int g= (((const type*)src)[i]>>shg)&maskg;\
1029 int r= (((const type*)src)[i]>>shr)&maskr;\
1031 dst[i]= (((RY)*r + (GY)*g + (BY)*b + (33<<((S)-1)))>>(S));\
1035 BGR2Y(uint32_t, bgr32ToY
,16, 0, 0, 0x00FF, 0xFF00, 0x00FF, RY
<< 8, GY
, BY
<< 8, RGB2YUV_SHIFT
+8)
1036 BGR2Y(uint32_t, rgb32ToY
, 0, 0,16, 0x00FF, 0xFF00, 0x00FF, RY
<< 8, GY
, BY
<< 8, RGB2YUV_SHIFT
+8)
1037 BGR2Y(uint16_t, bgr16ToY
, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RY
<<11, GY
<<5, BY
, RGB2YUV_SHIFT
+8)
1038 BGR2Y(uint16_t, bgr15ToY
, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RY
<<10, GY
<<5, BY
, RGB2YUV_SHIFT
+7)
1039 BGR2Y(uint16_t, rgb16ToY
, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RY
, GY
<<5, BY
<<11, RGB2YUV_SHIFT
+8)
1040 BGR2Y(uint16_t, rgb15ToY
, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RY
, GY
<<5, BY
<<10, RGB2YUV_SHIFT
+7)
1042 static inline void abgrToA(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1045 for (i
=0; i
<width
; i
++) {
1050 #define BGR2UV(type, name, shr, shg, shb, maska, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S)\
1051 static inline void name(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
1054 for (i=0; i<width; i++) {\
1055 int b= (((const type*)src)[i]&maskb)>>shb;\
1056 int g= (((const type*)src)[i]&maskg)>>shg;\
1057 int r= (((const type*)src)[i]&maskr)>>shr;\
1059 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<((S)-1)))>>(S);\
1060 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<((S)-1)))>>(S);\
1063 static inline void name ## _half(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
1066 for (i=0; i<width; i++) {\
1067 int pix0= ((const type*)src)[2*i+0];\
1068 int pix1= ((const type*)src)[2*i+1];\
1069 int g= (pix0&~(maskr|maskb))+(pix1&~(maskr|maskb));\
1070 int b= ((pix0+pix1-g)&(maskb|(2*maskb)))>>shb;\
1071 int r= ((pix0+pix1-g)&(maskr|(2*maskr)))>>shr;\
1072 g&= maskg|(2*maskg);\
1076 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<(S)))>>((S)+1);\
1077 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<(S)))>>((S)+1);\
1081 BGR2UV(uint32_t, bgr32ToUV
,16, 0, 0, 0xFF000000, 0xFF0000, 0xFF00, 0x00FF, RU
<< 8, GU
, BU
<< 8, RV
<< 8, GV
, BV
<< 8, RGB2YUV_SHIFT
+8)
1082 BGR2UV(uint32_t, rgb32ToUV
, 0, 0,16, 0xFF000000, 0x00FF, 0xFF00, 0xFF0000, RU
<< 8, GU
, BU
<< 8, RV
<< 8, GV
, BV
<< 8, RGB2YUV_SHIFT
+8)
1083 BGR2UV(uint16_t, bgr16ToUV
, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RU
<<11, GU
<<5, BU
, RV
<<11, GV
<<5, BV
, RGB2YUV_SHIFT
+8)
1084 BGR2UV(uint16_t, bgr15ToUV
, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RU
<<10, GU
<<5, BU
, RV
<<10, GV
<<5, BV
, RGB2YUV_SHIFT
+7)
1085 BGR2UV(uint16_t, rgb16ToUV
, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RU
, GU
<<5, BU
<<11, RV
, GV
<<5, BV
<<11, RGB2YUV_SHIFT
+8)
1086 BGR2UV(uint16_t, rgb15ToUV
, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RU
, GU
<<5, BU
<<10, RV
, GV
<<5, BV
<<10, RGB2YUV_SHIFT
+7)
1088 static inline void palToY(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *pal
)
1091 for (i
=0; i
<width
; i
++) {
1094 dst
[i
]= pal
[d
] & 0xFF;
1098 static inline void palToUV(uint8_t *dstU
, uint8_t *dstV
,
1099 const uint8_t *src1
, const uint8_t *src2
,
1100 long width
, uint32_t *pal
)
1103 assert(src1
== src2
);
1104 for (i
=0; i
<width
; i
++) {
1105 int p
= pal
[src1
[i
]];
1112 static inline void monowhite2Y(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1115 for (i
=0; i
<width
/8; i
++) {
1118 dst
[8*i
+j
]= ((d
>>(7-j
))&1)*255;
1122 static inline void monoblack2Y(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1125 for (i
=0; i
<width
/8; i
++) {
1128 dst
[8*i
+j
]= ((d
>>(7-j
))&1)*255;
1132 //Note: we have C, MMX, MMX2, 3DNOW versions, there is no 3DNOW+MMX2 one
1134 #if ((!HAVE_MMX || !CONFIG_GPL) && !HAVE_ALTIVEC) || CONFIG_RUNTIME_CPUDETECT
1139 #if HAVE_ALTIVEC || CONFIG_RUNTIME_CPUDETECT
1140 #define COMPILE_ALTIVEC
1146 #if ((HAVE_MMX && !HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT) && CONFIG_GPL
1150 #if (HAVE_MMX2 || CONFIG_RUNTIME_CPUDETECT) && CONFIG_GPL
1151 #define COMPILE_MMX2
1154 #if ((HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT) && CONFIG_GPL
1155 #define COMPILE_3DNOW
1159 #define COMPILE_TEMPLATE_MMX 0
1160 #define COMPILE_TEMPLATE_MMX2 0
1161 #define COMPILE_TEMPLATE_AMD3DNOW 0
1162 #define COMPILE_TEMPLATE_ALTIVEC 0
1165 #define RENAME(a) a ## _C
1166 #include "swscale_template.c"
1169 #ifdef COMPILE_ALTIVEC
1171 #undef COMPILE_TEMPLATE_ALTIVEC
1172 #define COMPILE_TEMPLATE_ALTIVEC 1
1173 #define RENAME(a) a ## _altivec
1174 #include "swscale_template.c"
1182 #undef COMPILE_TEMPLATE_MMX
1183 #undef COMPILE_TEMPLATE_MMX2
1184 #undef COMPILE_TEMPLATE_AMD3DNOW
1185 #define COMPILE_TEMPLATE_MMX 1
1186 #define COMPILE_TEMPLATE_MMX2 0
1187 #define COMPILE_TEMPLATE_AMD3DNOW 0
1188 #define RENAME(a) a ## _MMX
1189 #include "swscale_template.c"
1195 #undef COMPILE_TEMPLATE_MMX
1196 #undef COMPILE_TEMPLATE_MMX2
1197 #undef COMPILE_TEMPLATE_AMD3DNOW
1198 #define COMPILE_TEMPLATE_MMX 1
1199 #define COMPILE_TEMPLATE_MMX2 1
1200 #define COMPILE_TEMPLATE_AMD3DNOW 0
1201 #define RENAME(a) a ## _MMX2
1202 #include "swscale_template.c"
1206 #ifdef COMPILE_3DNOW
1208 #undef COMPILE_TEMPLATE_MMX
1209 #undef COMPILE_TEMPLATE_MMX2
1210 #undef COMPILE_TEMPLATE_AMD3DNOW
1211 #define COMPILE_TEMPLATE_MMX 1
1212 #define COMPILE_TEMPLATE_MMX2 0
1213 #define COMPILE_TEMPLATE_AMD3DNOW 1
1214 #define RENAME(a) a ## _3DNow
1215 #include "swscale_template.c"
1220 SwsFunc
ff_getSwsFunc(SwsContext
*c
)
1222 #if CONFIG_RUNTIME_CPUDETECT
1223 int flags
= c
->flags
;
1225 #if ARCH_X86 && CONFIG_GPL
1226 // ordered per speed fastest first
1227 if (flags
& SWS_CPU_CAPS_MMX2
) {
1228 sws_init_swScale_MMX2(c
);
1229 return swScale_MMX2
;
1230 } else if (flags
& SWS_CPU_CAPS_3DNOW
) {
1231 sws_init_swScale_3DNow(c
);
1232 return swScale_3DNow
;
1233 } else if (flags
& SWS_CPU_CAPS_MMX
) {
1234 sws_init_swScale_MMX(c
);
1237 sws_init_swScale_C(c
);
1243 if (flags
& SWS_CPU_CAPS_ALTIVEC
) {
1244 sws_init_swScale_altivec(c
);
1245 return swScale_altivec
;
1247 sws_init_swScale_C(c
);
1251 sws_init_swScale_C(c
);
1253 #endif /* ARCH_X86 && CONFIG_GPL */
1254 #else //CONFIG_RUNTIME_CPUDETECT
1255 #if COMPILE_TEMPLATE_MMX2
1256 sws_init_swScale_MMX2(c
);
1257 return swScale_MMX2
;
1258 #elif COMPILE_TEMPLATE_AMD3DNOW
1259 sws_init_swScale_3DNow(c
);
1260 return swScale_3DNow
;
1261 #elif COMPILE_TEMPLATE_MMX
1262 sws_init_swScale_MMX(c
);
1264 #elif COMPILE_TEMPLATE_ALTIVEC
1265 sws_init_swScale_altivec(c
);
1266 return swScale_altivec
;
1268 sws_init_swScale_C(c
);
1271 #endif //!CONFIG_RUNTIME_CPUDETECT
1274 static int planarToNv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1275 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1277 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1279 if (dstStride
[0]==srcStride
[0] && srcStride
[0] > 0)
1280 memcpy(dst
, src
[0], srcSliceH
*dstStride
[0]);
1283 const uint8_t *srcPtr
= src
[0];
1284 uint8_t *dstPtr
= dst
;
1285 for (i
=0; i
<srcSliceH
; i
++) {
1286 memcpy(dstPtr
, srcPtr
, c
->srcW
);
1287 srcPtr
+= srcStride
[0];
1288 dstPtr
+= dstStride
[0];
1291 dst
= dstParam
[1] + dstStride
[1]*srcSliceY
/2;
1292 if (c
->dstFormat
== PIX_FMT_NV12
)
1293 interleaveBytes(src
[1], src
[2], dst
, c
->srcW
/2, srcSliceH
/2, srcStride
[1], srcStride
[2], dstStride
[0]);
1295 interleaveBytes(src
[2], src
[1], dst
, c
->srcW
/2, srcSliceH
/2, srcStride
[2], srcStride
[1], dstStride
[0]);
1300 static int planarToYuy2Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1301 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1303 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1305 yv12toyuy2(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0], srcStride
[1], dstStride
[0]);
1310 static int planarToUyvyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1311 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1313 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1315 yv12touyvy(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0], srcStride
[1], dstStride
[0]);
1320 static int yuv422pToYuy2Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1321 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1323 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1325 yuv422ptoyuy2(src
[0],src
[1],src
[2],dst
,c
->srcW
,srcSliceH
,srcStride
[0],srcStride
[1],dstStride
[0]);
1330 static int yuv422pToUyvyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1331 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1333 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1335 yuv422ptouyvy(src
[0],src
[1],src
[2],dst
,c
->srcW
,srcSliceH
,srcStride
[0],srcStride
[1],dstStride
[0]);
1340 static int yuyvToYuv420Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1341 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1343 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1344 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
/2;
1345 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
/2;
1347 yuyvtoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1350 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1355 static int yuyvToYuv422Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1356 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1358 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1359 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
;
1360 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
;
1362 yuyvtoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1367 static int uyvyToYuv420Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1368 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1370 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1371 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
/2;
1372 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
/2;
1374 uyvytoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1377 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1382 static int uyvyToYuv422Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1383 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1385 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1386 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
;
1387 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
;
1389 uyvytoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1394 static int palToRgbWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1395 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1397 const enum PixelFormat srcFormat
= c
->srcFormat
;
1398 const enum PixelFormat dstFormat
= c
->dstFormat
;
1399 void (*conv
)(const uint8_t *src
, uint8_t *dst
, long num_pixels
,
1400 const uint8_t *palette
)=NULL
;
1402 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1403 const uint8_t *srcPtr
= src
[0];
1405 if (usePal(srcFormat
)) {
1406 switch (dstFormat
) {
1407 case PIX_FMT_RGB32
: conv
= palette8topacked32
; break;
1408 case PIX_FMT_BGR32
: conv
= palette8topacked32
; break;
1409 case PIX_FMT_BGR32_1
: conv
= palette8topacked32
; break;
1410 case PIX_FMT_RGB32_1
: conv
= palette8topacked32
; break;
1411 case PIX_FMT_RGB24
: conv
= palette8topacked24
; break;
1412 case PIX_FMT_BGR24
: conv
= palette8topacked24
; break;
1417 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
1418 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
1420 for (i
=0; i
<srcSliceH
; i
++) {
1421 conv(srcPtr
, dstPtr
, c
->srcW
, (uint8_t *) c
->pal_rgb
);
1422 srcPtr
+= srcStride
[0];
1423 dstPtr
+= dstStride
[0];
1430 #define isRGBA32(x) ( \
1431 (x) == PIX_FMT_ARGB \
1432 || (x) == PIX_FMT_RGBA \
1433 || (x) == PIX_FMT_BGRA \
1434 || (x) == PIX_FMT_ABGR \
1437 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1438 static int rgbToRgbWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1439 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1441 const enum PixelFormat srcFormat
= c
->srcFormat
;
1442 const enum PixelFormat dstFormat
= c
->dstFormat
;
1443 const int srcBpp
= (c
->srcFormatBpp
+ 7) >> 3;
1444 const int dstBpp
= (c
->dstFormatBpp
+ 7) >> 3;
1445 const int srcId
= c
->srcFormatBpp
>> 2; /* 1:0, 4:1, 8:2, 15:3, 16:4, 24:6, 32:8 */
1446 const int dstId
= c
->dstFormatBpp
>> 2;
1447 void (*conv
)(const uint8_t *src
, uint8_t *dst
, long src_size
)=NULL
;
1449 #define CONV_IS(src, dst) (srcFormat == PIX_FMT_##src && dstFormat == PIX_FMT_##dst)
1451 if (isRGBA32(srcFormat
) && isRGBA32(dstFormat
)) {
1452 if ( CONV_IS(ABGR
, RGBA
)
1453 || CONV_IS(ARGB
, BGRA
)
1454 || CONV_IS(BGRA
, ARGB
)
1455 || CONV_IS(RGBA
, ABGR
)) conv
= shuffle_bytes_3210
;
1456 else if (CONV_IS(ABGR
, ARGB
)
1457 || CONV_IS(ARGB
, ABGR
)) conv
= shuffle_bytes_0321
;
1458 else if (CONV_IS(ABGR
, BGRA
)
1459 || CONV_IS(ARGB
, RGBA
)) conv
= shuffle_bytes_1230
;
1460 else if (CONV_IS(BGRA
, RGBA
)
1461 || CONV_IS(RGBA
, BGRA
)) conv
= shuffle_bytes_2103
;
1462 else if (CONV_IS(BGRA
, ABGR
)
1463 || CONV_IS(RGBA
, ARGB
)) conv
= shuffle_bytes_3012
;
1466 if ( (isBGRinInt(srcFormat
) && isBGRinInt(dstFormat
))
1467 || (isRGBinInt(srcFormat
) && isRGBinInt(dstFormat
))) {
1468 switch(srcId
| (dstId
<<4)) {
1469 case 0x34: conv
= rgb16to15
; break;
1470 case 0x36: conv
= rgb24to15
; break;
1471 case 0x38: conv
= rgb32to15
; break;
1472 case 0x43: conv
= rgb15to16
; break;
1473 case 0x46: conv
= rgb24to16
; break;
1474 case 0x48: conv
= rgb32to16
; break;
1475 case 0x63: conv
= rgb15to24
; break;
1476 case 0x64: conv
= rgb16to24
; break;
1477 case 0x68: conv
= rgb32to24
; break;
1478 case 0x83: conv
= rgb15to32
; break;
1479 case 0x84: conv
= rgb16to32
; break;
1480 case 0x86: conv
= rgb24to32
; break;
1482 } else if ( (isBGRinInt(srcFormat
) && isRGBinInt(dstFormat
))
1483 || (isRGBinInt(srcFormat
) && isBGRinInt(dstFormat
))) {
1484 switch(srcId
| (dstId
<<4)) {
1485 case 0x33: conv
= rgb15tobgr15
; break;
1486 case 0x34: conv
= rgb16tobgr15
; break;
1487 case 0x36: conv
= rgb24tobgr15
; break;
1488 case 0x38: conv
= rgb32tobgr15
; break;
1489 case 0x43: conv
= rgb15tobgr16
; break;
1490 case 0x44: conv
= rgb16tobgr16
; break;
1491 case 0x46: conv
= rgb24tobgr16
; break;
1492 case 0x48: conv
= rgb32tobgr16
; break;
1493 case 0x63: conv
= rgb15tobgr24
; break;
1494 case 0x64: conv
= rgb16tobgr24
; break;
1495 case 0x66: conv
= rgb24tobgr24
; break;
1496 case 0x68: conv
= rgb32tobgr24
; break;
1497 case 0x83: conv
= rgb15tobgr32
; break;
1498 case 0x84: conv
= rgb16tobgr32
; break;
1499 case 0x86: conv
= rgb24tobgr32
; break;
1504 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
1505 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
1507 const uint8_t *srcPtr
= src
[0];
1508 uint8_t *dstPtr
= dst
[0];
1509 if ((srcFormat
== PIX_FMT_RGB32_1
|| srcFormat
== PIX_FMT_BGR32_1
) && !isRGBA32(dstFormat
))
1510 srcPtr
+= ALT32_CORR
;
1512 if ((dstFormat
== PIX_FMT_RGB32_1
|| dstFormat
== PIX_FMT_BGR32_1
) && !isRGBA32(srcFormat
))
1513 dstPtr
+= ALT32_CORR
;
1515 if (dstStride
[0]*srcBpp
== srcStride
[0]*dstBpp
&& srcStride
[0] > 0)
1516 conv(srcPtr
, dstPtr
+ dstStride
[0]*srcSliceY
, srcSliceH
*srcStride
[0]);
1519 dstPtr
+= dstStride
[0]*srcSliceY
;
1521 for (i
=0; i
<srcSliceH
; i
++) {
1522 conv(srcPtr
, dstPtr
, c
->srcW
*srcBpp
);
1523 srcPtr
+= srcStride
[0];
1524 dstPtr
+= dstStride
[0];
1531 static int bgr24ToYv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1532 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1536 dst
[0]+ srcSliceY
*dstStride
[0],
1537 dst
[1]+(srcSliceY
>>1)*dstStride
[1],
1538 dst
[2]+(srcSliceY
>>1)*dstStride
[2],
1540 dstStride
[0], dstStride
[1], srcStride
[0]);
1542 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1546 static int yvu9ToYv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1547 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1552 if (srcStride
[0]==dstStride
[0] && srcStride
[0] > 0)
1553 memcpy(dst
[0]+ srcSliceY
*dstStride
[0], src
[0], srcStride
[0]*srcSliceH
);
1555 const uint8_t *srcPtr
= src
[0];
1556 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1558 for (i
=0; i
<srcSliceH
; i
++) {
1559 memcpy(dstPtr
, srcPtr
, c
->srcW
);
1560 srcPtr
+= srcStride
[0];
1561 dstPtr
+= dstStride
[0];
1565 if (c
->dstFormat
==PIX_FMT_YUV420P
|| c
->dstFormat
==PIX_FMT_YUVA420P
) {
1566 planar2x(src
[1], dst
[1] + dstStride
[1]*(srcSliceY
>> 1), c
->chrSrcW
,
1567 srcSliceH
>> 2, srcStride
[1], dstStride
[1]);
1568 planar2x(src
[2], dst
[2] + dstStride
[2]*(srcSliceY
>> 1), c
->chrSrcW
,
1569 srcSliceH
>> 2, srcStride
[2], dstStride
[2]);
1571 planar2x(src
[1], dst
[2] + dstStride
[2]*(srcSliceY
>> 1), c
->chrSrcW
,
1572 srcSliceH
>> 2, srcStride
[1], dstStride
[2]);
1573 planar2x(src
[2], dst
[1] + dstStride
[1]*(srcSliceY
>> 1), c
->chrSrcW
,
1574 srcSliceH
>> 2, srcStride
[2], dstStride
[1]);
1577 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1581 /* unscaled copy like stuff (assumes nearly identical formats) */
1582 static int packedCopyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1583 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1585 if (dstStride
[0]==srcStride
[0] && srcStride
[0] > 0)
1586 memcpy(dst
[0] + dstStride
[0]*srcSliceY
, src
[0], srcSliceH
*dstStride
[0]);
1589 const uint8_t *srcPtr
= src
[0];
1590 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1593 /* universal length finder */
1594 while(length
+c
->srcW
<= FFABS(dstStride
[0])
1595 && length
+c
->srcW
<= FFABS(srcStride
[0])) length
+= c
->srcW
;
1598 for (i
=0; i
<srcSliceH
; i
++) {
1599 memcpy(dstPtr
, srcPtr
, length
);
1600 srcPtr
+= srcStride
[0];
1601 dstPtr
+= dstStride
[0];
1607 static int planarCopyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1608 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1611 for (plane
=0; plane
<4; plane
++) {
1612 int length
= (plane
==0 || plane
==3) ? c
->srcW
: -((-c
->srcW
)>>c
->chrDstHSubSample
);
1613 int y
= (plane
==0 || plane
==3) ? srcSliceY
: -((-srcSliceY
)>>c
->chrDstVSubSample
);
1614 int height
= (plane
==0 || plane
==3) ? srcSliceH
: -((-srcSliceH
)>>c
->chrDstVSubSample
);
1615 const uint8_t *srcPtr
= src
[plane
];
1616 uint8_t *dstPtr
= dst
[plane
] + dstStride
[plane
]*y
;
1618 if (!dst
[plane
]) continue;
1619 // ignore palette for GRAY8
1620 if (plane
== 1 && !dst
[2]) continue;
1621 if (!src
[plane
] || (plane
== 1 && !src
[2])) {
1622 if(is16BPS(c
->dstFormat
))
1624 fillPlane(dst
[plane
], dstStride
[plane
], length
, height
, y
, (plane
==3) ? 255 : 128);
1626 if(is16BPS(c
->srcFormat
) && !is16BPS(c
->dstFormat
)) {
1627 if (!isBE(c
->srcFormat
)) srcPtr
++;
1628 for (i
=0; i
<height
; i
++) {
1629 for (j
=0; j
<length
; j
++) dstPtr
[j
] = srcPtr
[j
<<1];
1630 srcPtr
+= srcStride
[plane
];
1631 dstPtr
+= dstStride
[plane
];
1633 } else if(!is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
)) {
1634 for (i
=0; i
<height
; i
++) {
1635 for (j
=0; j
<length
; j
++) {
1636 dstPtr
[ j
<<1 ] = srcPtr
[j
];
1637 dstPtr
[(j
<<1)+1] = srcPtr
[j
];
1639 srcPtr
+= srcStride
[plane
];
1640 dstPtr
+= dstStride
[plane
];
1642 } else if(is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
)
1643 && isBE(c
->srcFormat
) != isBE(c
->dstFormat
)) {
1645 for (i
=0; i
<height
; i
++) {
1646 for (j
=0; j
<length
; j
++)
1647 ((uint16_t*)dstPtr
)[j
] = bswap_16(((const uint16_t*)srcPtr
)[j
]);
1648 srcPtr
+= srcStride
[plane
];
1649 dstPtr
+= dstStride
[plane
];
1651 } else if (dstStride
[plane
]==srcStride
[plane
] && srcStride
[plane
] > 0)
1652 memcpy(dst
[plane
] + dstStride
[plane
]*y
, src
[plane
], height
*dstStride
[plane
]);
1654 if(is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
))
1656 for (i
=0; i
<height
; i
++) {
1657 memcpy(dstPtr
, srcPtr
, length
);
1658 srcPtr
+= srcStride
[plane
];
1659 dstPtr
+= dstStride
[plane
];
1667 int ff_hardcodedcpuflags(void)
1670 #if COMPILE_TEMPLATE_MMX2
1671 flags
|= SWS_CPU_CAPS_MMX
|SWS_CPU_CAPS_MMX2
;
1672 #elif COMPILE_TEMPLATE_AMD3DNOW
1673 flags
|= SWS_CPU_CAPS_MMX
|SWS_CPU_CAPS_3DNOW
;
1674 #elif COMPILE_TEMPLATE_MMX
1675 flags
|= SWS_CPU_CAPS_MMX
;
1676 #elif COMPILE_TEMPLATE_ALTIVEC
1677 flags
|= SWS_CPU_CAPS_ALTIVEC
;
1679 flags
|= SWS_CPU_CAPS_BFIN
;
1684 void ff_get_unscaled_swscale(SwsContext
*c
)
1686 const enum PixelFormat srcFormat
= c
->srcFormat
;
1687 const enum PixelFormat dstFormat
= c
->dstFormat
;
1688 const int flags
= c
->flags
;
1689 const int dstH
= c
->dstH
;
1692 needsDither
= isAnyRGB(dstFormat
)
1693 && c
->dstFormatBpp
< 24
1694 && (c
->dstFormatBpp
< c
->srcFormatBpp
|| (!isAnyRGB(srcFormat
)));
1697 if ((srcFormat
== PIX_FMT_YUV420P
|| srcFormat
== PIX_FMT_YUVA420P
) && (dstFormat
== PIX_FMT_NV12
|| dstFormat
== PIX_FMT_NV21
)) {
1698 c
->swScale
= planarToNv12Wrapper
;
1701 if ((srcFormat
==PIX_FMT_YUV420P
|| srcFormat
==PIX_FMT_YUV422P
|| srcFormat
==PIX_FMT_YUVA420P
) && isAnyRGB(dstFormat
)
1702 && !(flags
& SWS_ACCURATE_RND
) && !(dstH
&1)) {
1703 c
->swScale
= ff_yuv2rgb_get_func_ptr(c
);
1706 if (srcFormat
==PIX_FMT_YUV410P
&& (dstFormat
==PIX_FMT_YUV420P
|| dstFormat
==PIX_FMT_YUVA420P
) && !(flags
& SWS_BITEXACT
)) {
1707 c
->swScale
= yvu9ToYv12Wrapper
;
1711 if (srcFormat
==PIX_FMT_BGR24
&& (dstFormat
==PIX_FMT_YUV420P
|| dstFormat
==PIX_FMT_YUVA420P
) && !(flags
& SWS_ACCURATE_RND
))
1712 c
->swScale
= bgr24ToYv12Wrapper
;
1714 /* RGB/BGR -> RGB/BGR (no dither needed forms) */
1715 if ( isAnyRGB(srcFormat
)
1716 && isAnyRGB(dstFormat
)
1717 && srcFormat
!= PIX_FMT_BGR8
&& dstFormat
!= PIX_FMT_BGR8
1718 && srcFormat
!= PIX_FMT_RGB8
&& dstFormat
!= PIX_FMT_RGB8
1719 && srcFormat
!= PIX_FMT_BGR4
&& dstFormat
!= PIX_FMT_BGR4
1720 && srcFormat
!= PIX_FMT_RGB4
&& dstFormat
!= PIX_FMT_RGB4
1721 && srcFormat
!= PIX_FMT_BGR4_BYTE
&& dstFormat
!= PIX_FMT_BGR4_BYTE
1722 && srcFormat
!= PIX_FMT_RGB4_BYTE
&& dstFormat
!= PIX_FMT_RGB4_BYTE
1723 && srcFormat
!= PIX_FMT_MONOBLACK
&& dstFormat
!= PIX_FMT_MONOBLACK
1724 && srcFormat
!= PIX_FMT_MONOWHITE
&& dstFormat
!= PIX_FMT_MONOWHITE
1725 && srcFormat
!= PIX_FMT_RGB48LE
&& dstFormat
!= PIX_FMT_RGB48LE
1726 && srcFormat
!= PIX_FMT_RGB48BE
&& dstFormat
!= PIX_FMT_RGB48BE
1727 && (!needsDither
|| (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
))))
1728 c
->swScale
= rgbToRgbWrapper
;
1730 if ((usePal(srcFormat
) && (
1731 dstFormat
== PIX_FMT_RGB32
||
1732 dstFormat
== PIX_FMT_RGB32_1
||
1733 dstFormat
== PIX_FMT_RGB24
||
1734 dstFormat
== PIX_FMT_BGR32
||
1735 dstFormat
== PIX_FMT_BGR32_1
||
1736 dstFormat
== PIX_FMT_BGR24
)))
1737 c
->swScale
= palToRgbWrapper
;
1739 if (srcFormat
== PIX_FMT_YUV422P
) {
1740 if (dstFormat
== PIX_FMT_YUYV422
)
1741 c
->swScale
= yuv422pToYuy2Wrapper
;
1742 else if (dstFormat
== PIX_FMT_UYVY422
)
1743 c
->swScale
= yuv422pToUyvyWrapper
;
1746 /* LQ converters if -sws 0 or -sws 4*/
1747 if (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
)) {
1749 if (srcFormat
== PIX_FMT_YUV420P
|| srcFormat
== PIX_FMT_YUVA420P
) {
1750 if (dstFormat
== PIX_FMT_YUYV422
)
1751 c
->swScale
= planarToYuy2Wrapper
;
1752 else if (dstFormat
== PIX_FMT_UYVY422
)
1753 c
->swScale
= planarToUyvyWrapper
;
1756 if(srcFormat
== PIX_FMT_YUYV422
&& (dstFormat
== PIX_FMT_YUV420P
|| dstFormat
== PIX_FMT_YUVA420P
))
1757 c
->swScale
= yuyvToYuv420Wrapper
;
1758 if(srcFormat
== PIX_FMT_UYVY422
&& (dstFormat
== PIX_FMT_YUV420P
|| dstFormat
== PIX_FMT_YUVA420P
))
1759 c
->swScale
= uyvyToYuv420Wrapper
;
1760 if(srcFormat
== PIX_FMT_YUYV422
&& dstFormat
== PIX_FMT_YUV422P
)
1761 c
->swScale
= yuyvToYuv422Wrapper
;
1762 if(srcFormat
== PIX_FMT_UYVY422
&& dstFormat
== PIX_FMT_YUV422P
)
1763 c
->swScale
= uyvyToYuv422Wrapper
;
1765 #ifdef COMPILE_ALTIVEC
1766 if ((c
->flags
& SWS_CPU_CAPS_ALTIVEC
) &&
1767 !(c
->flags
& SWS_BITEXACT
) &&
1768 srcFormat
== PIX_FMT_YUV420P
) {
1769 // unscaled YV12 -> packed YUV, we want speed
1770 if (dstFormat
== PIX_FMT_YUYV422
)
1771 c
->swScale
= yv12toyuy2_unscaled_altivec
;
1772 else if (dstFormat
== PIX_FMT_UYVY422
)
1773 c
->swScale
= yv12touyvy_unscaled_altivec
;
1778 if ( srcFormat
== dstFormat
1779 || (srcFormat
== PIX_FMT_YUVA420P
&& dstFormat
== PIX_FMT_YUV420P
)
1780 || (srcFormat
== PIX_FMT_YUV420P
&& dstFormat
== PIX_FMT_YUVA420P
)
1781 || (isPlanarYUV(srcFormat
) && isGray(dstFormat
))
1782 || (isPlanarYUV(dstFormat
) && isGray(srcFormat
))
1783 || (isGray(dstFormat
) && isGray(srcFormat
))
1784 || (isPlanarYUV(srcFormat
) && isPlanarYUV(dstFormat
)
1785 && c
->chrDstHSubSample
== c
->chrSrcHSubSample
1786 && c
->chrDstVSubSample
== c
->chrSrcVSubSample
1787 && dstFormat
!= PIX_FMT_NV12
&& dstFormat
!= PIX_FMT_NV21
1788 && srcFormat
!= PIX_FMT_NV12
&& srcFormat
!= PIX_FMT_NV21
))
1790 if (isPacked(c
->srcFormat
))
1791 c
->swScale
= packedCopyWrapper
;
1792 else /* Planar YUV or gray */
1793 c
->swScale
= planarCopyWrapper
;
1796 if (flags
& SWS_CPU_CAPS_BFIN
)
1797 ff_bfin_get_unscaled_swscale (c
);
1801 static void reset_ptr(const uint8_t* src
[], int format
)
1803 if(!isALPHA(format
))
1805 if(!isPlanarYUV(format
)) {
1808 if (!usePal(format
))
1814 * swscale wrapper, so we don't need to export the SwsContext.
1815 * Assumes planar YUV to be in YUV order instead of YVU.
1817 int sws_scale(SwsContext
*c
, const uint8_t* const src
[], const int srcStride
[], int srcSliceY
,
1818 int srcSliceH
, uint8_t* const dst
[], const int dstStride
[])
1821 const uint8_t* src2
[4]= {src
[0], src
[1], src
[2], src
[3]};
1822 uint8_t* dst2
[4]= {dst
[0], dst
[1], dst
[2], dst
[3]};
1824 // do not mess up sliceDir if we have a "trailing" 0-size slice
1828 if (c
->sliceDir
== 0 && srcSliceY
!= 0 && srcSliceY
+ srcSliceH
!= c
->srcH
) {
1829 av_log(c
, AV_LOG_ERROR
, "Slices start in the middle!\n");
1832 if (c
->sliceDir
== 0) {
1833 if (srcSliceY
== 0) c
->sliceDir
= 1; else c
->sliceDir
= -1;
1836 if (usePal(c
->srcFormat
)) {
1837 for (i
=0; i
<256; i
++) {
1838 int p
, r
, g
, b
,y
,u
,v
;
1839 if(c
->srcFormat
== PIX_FMT_PAL8
) {
1840 p
=((const uint32_t*)(src
[1]))[i
];
1844 } else if(c
->srcFormat
== PIX_FMT_RGB8
) {
1848 } else if(c
->srcFormat
== PIX_FMT_BGR8
) {
1852 } else if(c
->srcFormat
== PIX_FMT_RGB4_BYTE
) {
1856 } else if(c
->srcFormat
== PIX_FMT_GRAY8
) {
1859 assert(c
->srcFormat
== PIX_FMT_BGR4_BYTE
);
1864 y
= av_clip_uint8((RY
*r
+ GY
*g
+ BY
*b
+ ( 33<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1865 u
= av_clip_uint8((RU
*r
+ GU
*g
+ BU
*b
+ (257<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1866 v
= av_clip_uint8((RV
*r
+ GV
*g
+ BV
*b
+ (257<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1867 c
->pal_yuv
[i
]= y
+ (u
<<8) + (v
<<16);
1869 switch(c
->dstFormat
) {
1874 c
->pal_rgb
[i
]= r
+ (g
<<8) + (b
<<16);
1876 case PIX_FMT_BGR32_1
:
1880 c
->pal_rgb
[i
]= (r
+ (g
<<8) + (b
<<16)) << 8;
1882 case PIX_FMT_RGB32_1
:
1886 c
->pal_rgb
[i
]= (b
+ (g
<<8) + (r
<<16)) << 8;
1893 c
->pal_rgb
[i
]= b
+ (g
<<8) + (r
<<16);
1898 // copy strides, so they can safely be modified
1899 if (c
->sliceDir
== 1) {
1900 // slices go from top to bottom
1901 int srcStride2
[4]= {srcStride
[0], srcStride
[1], srcStride
[2], srcStride
[3]};
1902 int dstStride2
[4]= {dstStride
[0], dstStride
[1], dstStride
[2], dstStride
[3]};
1904 reset_ptr(src2
, c
->srcFormat
);
1905 reset_ptr((const uint8_t**)dst2
, c
->dstFormat
);
1907 /* reset slice direction at end of frame */
1908 if (srcSliceY
+ srcSliceH
== c
->srcH
)
1911 return c
->swScale(c
, src2
, srcStride2
, srcSliceY
, srcSliceH
, dst2
, dstStride2
);
1913 // slices go from bottom to top => we flip the image internally
1914 int srcStride2
[4]= {-srcStride
[0], -srcStride
[1], -srcStride
[2], -srcStride
[3]};
1915 int dstStride2
[4]= {-dstStride
[0], -dstStride
[1], -dstStride
[2], -dstStride
[3]};
1917 src2
[0] += (srcSliceH
-1)*srcStride
[0];
1918 if (!usePal(c
->srcFormat
))
1919 src2
[1] += ((srcSliceH
>>c
->chrSrcVSubSample
)-1)*srcStride
[1];
1920 src2
[2] += ((srcSliceH
>>c
->chrSrcVSubSample
)-1)*srcStride
[2];
1921 src2
[3] += (srcSliceH
-1)*srcStride
[3];
1922 dst2
[0] += ( c
->dstH
-1)*dstStride
[0];
1923 dst2
[1] += ((c
->dstH
>>c
->chrDstVSubSample
)-1)*dstStride
[1];
1924 dst2
[2] += ((c
->dstH
>>c
->chrDstVSubSample
)-1)*dstStride
[2];
1925 dst2
[3] += ( c
->dstH
-1)*dstStride
[3];
1927 reset_ptr(src2
, c
->srcFormat
);
1928 reset_ptr((const uint8_t**)dst2
, c
->dstFormat
);
1930 /* reset slice direction at end of frame */
1934 return c
->swScale(c
, src2
, srcStride2
, c
->srcH
-srcSliceY
-srcSliceH
, srcSliceH
, dst2
, dstStride2
);
1938 #if LIBSWSCALE_VERSION_MAJOR < 1
1939 int sws_scale_ordered(SwsContext
*c
, const uint8_t* const src
[], int srcStride
[], int srcSliceY
,
1940 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1942 return sws_scale(c
, src
, srcStride
, srcSliceY
, srcSliceH
, dst
, dstStride
);