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
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (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 GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR32_1, BGR24, BGR16, BGR15, RGB32, RGB32_1, RGB24, Y8/Y800, YVU9/IF09, PAL8
23 supported output formats: YV12, I420/IYUV, YUY2, UYVY, {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09
24 {BGR,RGB}{1,4,8,15,16} support dithering
26 unscaled special converters (YV12=I420=IYUV, Y800=Y8)
27 YV12 -> {BGR,RGB}{1,4,8,12,15,16,24,32}
32 BGR24 -> BGR32 & RGB24 -> RGB32
33 BGR32 -> BGR24 & RGB32 -> RGB24
38 tested special converters (most are tested actually, but I did not write it down ...)
45 untested special converters
46 YV12/I420 -> BGR15/BGR24/BGR32 (it is the yuv2rgb stuff, so it should be OK)
47 YV12/I420 -> YV12/I420
48 YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
49 BGR24 -> BGR32 & RGB24 -> RGB32
50 BGR32 -> BGR24 & RGB32 -> RGB24
61 #include "swscale_internal.h"
63 #include "libavutil/intreadwrite.h"
64 #include "libavutil/x86_cpu.h"
65 #include "libavutil/avutil.h"
66 #include "libavutil/mathematics.h"
67 #include "libavutil/bswap.h"
68 #include "libavutil/pixdesc.h"
74 //#define HAVE_AMD3DNOW
79 #define FAST_BGR2YV12 // use 7 bit coefficients instead of 15 bit
81 #define isPacked(x) ( \
83 || (x)==PIX_FMT_YUYV422 \
84 || (x)==PIX_FMT_UYVY422 \
88 #define RGB2YUV_SHIFT 15
89 #define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
90 #define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
91 #define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
92 #define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
93 #define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
94 #define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
95 #define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
96 #define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
97 #define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))
99 static const double rgb2yuv_table
[8][9]={
100 {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5}, //ITU709
101 {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5}, //ITU709
102 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
103 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
104 {0.59 , 0.11 , 0.30 , -0.331, 0.5, -0.169, -0.421, -0.079, 0.5}, //FCC
105 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
106 {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
107 {0.701 , 0.087 , 0.212 , -0.384, 0.5, -0.116, -0.445, -0.055, 0.5}, //SMPTE 240M
112 Special versions: fast Y 1:1 scaling (no interpolation in y direction)
115 more intelligent misalignment avoidance for the horizontal scaler
116 write special vertical cubic upscale version
117 optimize C code (YV12 / minmax)
118 add support for packed pixel YUV input & output
119 add support for Y8 output
120 optimize BGR24 & BGR32
121 add BGR4 output support
122 write special BGR->BGR scaler
126 DECLARE_ASM_CONST(8, uint64_t, bF8
)= 0xF8F8F8F8F8F8F8F8LL
;
127 DECLARE_ASM_CONST(8, uint64_t, bFC
)= 0xFCFCFCFCFCFCFCFCLL
;
128 DECLARE_ASM_CONST(8, uint64_t, w10
)= 0x0010001000100010LL
;
129 DECLARE_ASM_CONST(8, uint64_t, w02
)= 0x0002000200020002LL
;
130 DECLARE_ASM_CONST(8, uint64_t, bm00001111
)=0x00000000FFFFFFFFLL
;
131 DECLARE_ASM_CONST(8, uint64_t, bm00000111
)=0x0000000000FFFFFFLL
;
132 DECLARE_ASM_CONST(8, uint64_t, bm11111000
)=0xFFFFFFFFFF000000LL
;
133 DECLARE_ASM_CONST(8, uint64_t, bm01010101
)=0x00FF00FF00FF00FFLL
;
135 const DECLARE_ALIGNED(8, uint64_t, ff_dither4
)[2] = {
136 0x0103010301030103LL
,
137 0x0200020002000200LL
,};
139 const DECLARE_ALIGNED(8, uint64_t, ff_dither8
)[2] = {
140 0x0602060206020602LL
,
141 0x0004000400040004LL
,};
143 DECLARE_ASM_CONST(8, uint64_t, b16Mask
)= 0x001F001F001F001FLL
;
144 DECLARE_ASM_CONST(8, uint64_t, g16Mask
)= 0x07E007E007E007E0LL
;
145 DECLARE_ASM_CONST(8, uint64_t, r16Mask
)= 0xF800F800F800F800LL
;
146 DECLARE_ASM_CONST(8, uint64_t, b15Mask
)= 0x001F001F001F001FLL
;
147 DECLARE_ASM_CONST(8, uint64_t, g15Mask
)= 0x03E003E003E003E0LL
;
148 DECLARE_ASM_CONST(8, uint64_t, r15Mask
)= 0x7C007C007C007C00LL
;
150 DECLARE_ALIGNED(8, const uint64_t, ff_M24A
) = 0x00FF0000FF0000FFLL
;
151 DECLARE_ALIGNED(8, const uint64_t, ff_M24B
) = 0xFF0000FF0000FF00LL
;
152 DECLARE_ALIGNED(8, const uint64_t, ff_M24C
) = 0x0000FF0000FF0000LL
;
155 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YCoeff
) = 0x000000210041000DULL
;
156 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UCoeff
) = 0x0000FFEEFFDC0038ULL
;
157 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2VCoeff
) = 0x00000038FFD2FFF8ULL
;
159 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YCoeff
) = 0x000020E540830C8BULL
;
160 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UCoeff
) = 0x0000ED0FDAC23831ULL
;
161 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2VCoeff
) = 0x00003831D0E6F6EAULL
;
162 #endif /* FAST_BGR2YV12 */
163 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YOffset
) = 0x1010101010101010ULL
;
164 DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UVOffset
) = 0x8080808080808080ULL
;
165 DECLARE_ALIGNED(8, const uint64_t, ff_w1111
) = 0x0001000100010001ULL
;
167 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toY1Coeff
) = 0x0C88000040870C88ULL
;
168 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toY2Coeff
) = 0x20DE4087000020DEULL
;
169 DECLARE_ASM_CONST(8, uint64_t, ff_rgb24toY1Coeff
) = 0x20DE0000408720DEULL
;
170 DECLARE_ASM_CONST(8, uint64_t, ff_rgb24toY2Coeff
) = 0x0C88408700000C88ULL
;
171 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toYOffset
) = 0x0008400000084000ULL
;
173 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toUV
)[2][4] = {
174 {0x38380000DAC83838ULL
, 0xECFFDAC80000ECFFULL
, 0xF6E40000D0E3F6E4ULL
, 0x3838D0E300003838ULL
},
175 {0xECFF0000DAC8ECFFULL
, 0x3838DAC800003838ULL
, 0x38380000D0E33838ULL
, 0xF6E4D0E30000F6E4ULL
},
178 DECLARE_ASM_CONST(8, uint64_t, ff_bgr24toUVOffset
)= 0x0040400000404000ULL
;
180 #endif /* ARCH_X86 */
182 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_4
)[2][8]={
183 { 1, 3, 1, 3, 1, 3, 1, 3, },
184 { 2, 0, 2, 0, 2, 0, 2, 0, },
187 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_8
)[2][8]={
188 { 6, 2, 6, 2, 6, 2, 6, 2, },
189 { 0, 4, 0, 4, 0, 4, 0, 4, },
192 DECLARE_ALIGNED(8, const uint8_t, dither_4x4_16
)[4][8]={
193 { 8, 4, 11, 7, 8, 4, 11, 7, },
194 { 2, 14, 1, 13, 2, 14, 1, 13, },
195 { 10, 6, 9, 5, 10, 6, 9, 5, },
196 { 0, 12, 3, 15, 0, 12, 3, 15, },
199 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_32
)[8][8]={
200 { 17, 9, 23, 15, 16, 8, 22, 14, },
201 { 5, 29, 3, 27, 4, 28, 2, 26, },
202 { 21, 13, 19, 11, 20, 12, 18, 10, },
203 { 0, 24, 6, 30, 1, 25, 7, 31, },
204 { 16, 8, 22, 14, 17, 9, 23, 15, },
205 { 4, 28, 2, 26, 5, 29, 3, 27, },
206 { 20, 12, 18, 10, 21, 13, 19, 11, },
207 { 1, 25, 7, 31, 0, 24, 6, 30, },
210 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_73
)[8][8]={
211 { 0, 55, 14, 68, 3, 58, 17, 72, },
212 { 37, 18, 50, 32, 40, 22, 54, 35, },
213 { 9, 64, 5, 59, 13, 67, 8, 63, },
214 { 46, 27, 41, 23, 49, 31, 44, 26, },
215 { 2, 57, 16, 71, 1, 56, 15, 70, },
216 { 39, 21, 52, 34, 38, 19, 51, 33, },
217 { 11, 66, 7, 62, 10, 65, 6, 60, },
218 { 48, 30, 43, 25, 47, 29, 42, 24, },
222 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
223 {117, 62, 158, 103, 113, 58, 155, 100, },
224 { 34, 199, 21, 186, 31, 196, 17, 182, },
225 {144, 89, 131, 76, 141, 86, 127, 72, },
226 { 0, 165, 41, 206, 10, 175, 52, 217, },
227 {110, 55, 151, 96, 120, 65, 162, 107, },
228 { 28, 193, 14, 179, 38, 203, 24, 189, },
229 {138, 83, 124, 69, 148, 93, 134, 79, },
230 { 7, 172, 48, 213, 3, 168, 45, 210, },
233 // tries to correct a gamma of 1.5
234 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
235 { 0, 143, 18, 200, 2, 156, 25, 215, },
236 { 78, 28, 125, 64, 89, 36, 138, 74, },
237 { 10, 180, 3, 161, 16, 195, 8, 175, },
238 {109, 51, 93, 38, 121, 60, 105, 47, },
239 { 1, 152, 23, 210, 0, 147, 20, 205, },
240 { 85, 33, 134, 71, 81, 30, 130, 67, },
241 { 14, 190, 6, 171, 12, 185, 5, 166, },
242 {117, 57, 101, 44, 113, 54, 97, 41, },
245 // tries to correct a gamma of 2.0
246 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
247 { 0, 124, 8, 193, 0, 140, 12, 213, },
248 { 55, 14, 104, 42, 66, 19, 119, 52, },
249 { 3, 168, 1, 145, 6, 187, 3, 162, },
250 { 86, 31, 70, 21, 99, 39, 82, 28, },
251 { 0, 134, 11, 206, 0, 129, 9, 200, },
252 { 62, 17, 114, 48, 58, 16, 109, 45, },
253 { 5, 181, 2, 157, 4, 175, 1, 151, },
254 { 95, 36, 78, 26, 90, 34, 74, 24, },
257 // tries to correct a gamma of 2.5
258 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220
)[8][8]={
259 { 0, 107, 3, 187, 0, 125, 6, 212, },
260 { 39, 7, 86, 28, 49, 11, 102, 36, },
261 { 1, 158, 0, 131, 3, 180, 1, 151, },
262 { 68, 19, 52, 12, 81, 25, 64, 17, },
263 { 0, 119, 5, 203, 0, 113, 4, 195, },
264 { 45, 9, 96, 33, 42, 8, 91, 30, },
265 { 2, 172, 1, 144, 2, 165, 0, 137, },
266 { 77, 23, 60, 15, 72, 21, 56, 14, },
270 static av_always_inline
void yuv2yuvX16inC_template(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
271 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
272 const int16_t **alpSrc
, uint16_t *dest
, uint16_t *uDest
, uint16_t *vDest
, uint16_t *aDest
,
273 int dstW
, int chrDstW
, int big_endian
)
275 //FIXME Optimize (just quickly written not optimized..)
278 for (i
= 0; i
< dstW
; i
++) {
282 for (j
= 0; j
< lumFilterSize
; j
++)
283 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
286 AV_WB16(&dest
[i
], av_clip_uint16(val
>> 11));
288 AV_WL16(&dest
[i
], av_clip_uint16(val
>> 11));
293 for (i
= 0; i
< chrDstW
; i
++) {
298 for (j
= 0; j
< chrFilterSize
; j
++) {
299 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
300 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
304 AV_WB16(&uDest
[i
], av_clip_uint16(u
>> 11));
305 AV_WB16(&vDest
[i
], av_clip_uint16(v
>> 11));
307 AV_WL16(&uDest
[i
], av_clip_uint16(u
>> 11));
308 AV_WL16(&vDest
[i
], av_clip_uint16(v
>> 11));
313 if (CONFIG_SWSCALE_ALPHA
&& aDest
) {
314 for (i
= 0; i
< dstW
; i
++) {
318 for (j
= 0; j
< lumFilterSize
; j
++)
319 val
+= alpSrc
[j
][i
] * lumFilter
[j
];
322 AV_WB16(&aDest
[i
], av_clip_uint16(val
>> 11));
324 AV_WL16(&aDest
[i
], av_clip_uint16(val
>> 11));
330 static inline void yuv2yuvX16inC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
331 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
332 const int16_t **alpSrc
, uint16_t *dest
, uint16_t *uDest
, uint16_t *vDest
, uint16_t *aDest
, int dstW
, int chrDstW
,
333 enum PixelFormat dstFormat
)
335 if (isBE(dstFormat
)) {
336 yuv2yuvX16inC_template(lumFilter
, lumSrc
, lumFilterSize
,
337 chrFilter
, chrSrc
, chrFilterSize
,
339 dest
, uDest
, vDest
, aDest
,
342 yuv2yuvX16inC_template(lumFilter
, lumSrc
, lumFilterSize
,
343 chrFilter
, chrSrc
, chrFilterSize
,
345 dest
, uDest
, vDest
, aDest
,
350 static inline void yuv2yuvXinC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
351 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
352 const int16_t **alpSrc
, uint8_t *dest
, uint8_t *uDest
, uint8_t *vDest
, uint8_t *aDest
, int dstW
, int chrDstW
)
354 //FIXME Optimize (just quickly written not optimized..)
356 for (i
=0; i
<dstW
; i
++) {
359 for (j
=0; j
<lumFilterSize
; j
++)
360 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
362 dest
[i
]= av_clip_uint8(val
>>19);
366 for (i
=0; i
<chrDstW
; i
++) {
370 for (j
=0; j
<chrFilterSize
; j
++) {
371 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
372 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
375 uDest
[i
]= av_clip_uint8(u
>>19);
376 vDest
[i
]= av_clip_uint8(v
>>19);
379 if (CONFIG_SWSCALE_ALPHA
&& aDest
)
380 for (i
=0; i
<dstW
; i
++) {
383 for (j
=0; j
<lumFilterSize
; j
++)
384 val
+= alpSrc
[j
][i
] * lumFilter
[j
];
386 aDest
[i
]= av_clip_uint8(val
>>19);
391 static inline void yuv2nv12XinC(const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
392 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
393 uint8_t *dest
, uint8_t *uDest
, int dstW
, int chrDstW
, int dstFormat
)
395 //FIXME Optimize (just quickly written not optimized..)
397 for (i
=0; i
<dstW
; i
++) {
400 for (j
=0; j
<lumFilterSize
; j
++)
401 val
+= lumSrc
[j
][i
] * lumFilter
[j
];
403 dest
[i
]= av_clip_uint8(val
>>19);
409 if (dstFormat
== PIX_FMT_NV12
)
410 for (i
=0; i
<chrDstW
; i
++) {
414 for (j
=0; j
<chrFilterSize
; j
++) {
415 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
416 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
419 uDest
[2*i
]= av_clip_uint8(u
>>19);
420 uDest
[2*i
+1]= av_clip_uint8(v
>>19);
423 for (i
=0; i
<chrDstW
; i
++) {
427 for (j
=0; j
<chrFilterSize
; j
++) {
428 u
+= chrSrc
[j
][i
] * chrFilter
[j
];
429 v
+= chrSrc
[j
][i
+ VOFW
] * chrFilter
[j
];
432 uDest
[2*i
]= av_clip_uint8(v
>>19);
433 uDest
[2*i
+1]= av_clip_uint8(u
>>19);
437 #define YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha) \
438 for (i=0; i<(dstW>>1); i++) {\
444 int av_unused A1, A2;\
445 type av_unused *r, *b, *g;\
448 for (j=0; j<lumFilterSize; j++) {\
449 Y1 += lumSrc[j][i2] * lumFilter[j];\
450 Y2 += lumSrc[j][i2+1] * lumFilter[j];\
452 for (j=0; j<chrFilterSize; j++) {\
453 U += chrSrc[j][i] * chrFilter[j];\
454 V += chrSrc[j][i+VOFW] * chrFilter[j];\
463 for (j=0; j<lumFilterSize; j++) {\
464 A1 += alpSrc[j][i2 ] * lumFilter[j];\
465 A2 += alpSrc[j][i2+1] * lumFilter[j];\
471 #define YSCALE_YUV_2_PACKEDX_C(type,alpha) \
472 YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha)\
473 if ((Y1|Y2|U|V)&256) {\
474 if (Y1>255) Y1=255; \
475 else if (Y1<0)Y1=0; \
476 if (Y2>255) Y2=255; \
477 else if (Y2<0)Y2=0; \
483 if (alpha && ((A1|A2)&256)) {\
484 A1=av_clip_uint8(A1);\
485 A2=av_clip_uint8(A2);\
488 #define YSCALE_YUV_2_PACKEDX_FULL_C(rnd,alpha) \
489 for (i=0; i<dstW; i++) {\
497 for (j=0; j<lumFilterSize; j++) {\
498 Y += lumSrc[j][i ] * lumFilter[j];\
500 for (j=0; j<chrFilterSize; j++) {\
501 U += chrSrc[j][i ] * chrFilter[j];\
502 V += chrSrc[j][i+VOFW] * chrFilter[j];\
509 for (j=0; j<lumFilterSize; j++)\
510 A += alpSrc[j][i ] * lumFilter[j];\
513 A = av_clip_uint8(A);\
516 #define YSCALE_YUV_2_RGBX_FULL_C(rnd,alpha) \
517 YSCALE_YUV_2_PACKEDX_FULL_C(rnd>>3,alpha)\
518 Y-= c->yuv2rgb_y_offset;\
519 Y*= c->yuv2rgb_y_coeff;\
521 R= Y + V*c->yuv2rgb_v2r_coeff;\
522 G= Y + V*c->yuv2rgb_v2g_coeff + U*c->yuv2rgb_u2g_coeff;\
523 B= Y + U*c->yuv2rgb_u2b_coeff;\
524 if ((R|G|B)&(0xC0000000)) {\
525 if (R>=(256<<22)) R=(256<<22)-1; \
527 if (G>=(256<<22)) G=(256<<22)-1; \
529 if (B>=(256<<22)) B=(256<<22)-1; \
533 #define YSCALE_YUV_2_GRAY16_C \
534 for (i=0; i<(dstW>>1); i++) {\
543 for (j=0; j<lumFilterSize; j++) {\
544 Y1 += lumSrc[j][i2] * lumFilter[j];\
545 Y2 += lumSrc[j][i2+1] * lumFilter[j];\
549 if ((Y1|Y2|U|V)&65536) {\
550 if (Y1>65535) Y1=65535; \
551 else if (Y1<0)Y1=0; \
552 if (Y2>65535) Y2=65535; \
553 else if (Y2<0)Y2=0; \
556 #define YSCALE_YUV_2_RGBX_C(type,alpha) \
557 YSCALE_YUV_2_PACKEDX_C(type,alpha) /* FIXME fix tables so that clipping is not needed and then use _NOCLIP*/\
558 r = (type *)c->table_rV[V]; \
559 g = (type *)(c->table_gU[U] + c->table_gV[V]); \
560 b = (type *)c->table_bU[U];
562 #define YSCALE_YUV_2_PACKED2_C(type,alpha) \
563 for (i=0; i<(dstW>>1); i++) { \
565 int Y1= (buf0[i2 ]*yalpha1+buf1[i2 ]*yalpha)>>19; \
566 int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>19; \
567 int U= (uvbuf0[i ]*uvalpha1+uvbuf1[i ]*uvalpha)>>19; \
568 int V= (uvbuf0[i+VOFW]*uvalpha1+uvbuf1[i+VOFW]*uvalpha)>>19; \
569 type av_unused *r, *b, *g; \
570 int av_unused A1, A2; \
572 A1= (abuf0[i2 ]*yalpha1+abuf1[i2 ]*yalpha)>>19; \
573 A2= (abuf0[i2+1]*yalpha1+abuf1[i2+1]*yalpha)>>19; \
576 #define YSCALE_YUV_2_GRAY16_2_C \
577 for (i=0; i<(dstW>>1); i++) { \
579 int Y1= (buf0[i2 ]*yalpha1+buf1[i2 ]*yalpha)>>11; \
580 int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>11;
582 #define YSCALE_YUV_2_RGB2_C(type,alpha) \
583 YSCALE_YUV_2_PACKED2_C(type,alpha)\
584 r = (type *)c->table_rV[V];\
585 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
586 b = (type *)c->table_bU[U];
588 #define YSCALE_YUV_2_PACKED1_C(type,alpha) \
589 for (i=0; i<(dstW>>1); i++) {\
591 int Y1= buf0[i2 ]>>7;\
592 int Y2= buf0[i2+1]>>7;\
593 int U= (uvbuf1[i ])>>7;\
594 int V= (uvbuf1[i+VOFW])>>7;\
595 type av_unused *r, *b, *g;\
596 int av_unused A1, A2;\
602 #define YSCALE_YUV_2_GRAY16_1_C \
603 for (i=0; i<(dstW>>1); i++) {\
605 int Y1= buf0[i2 ]<<1;\
606 int Y2= buf0[i2+1]<<1;
608 #define YSCALE_YUV_2_RGB1_C(type,alpha) \
609 YSCALE_YUV_2_PACKED1_C(type,alpha)\
610 r = (type *)c->table_rV[V];\
611 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
612 b = (type *)c->table_bU[U];
614 #define YSCALE_YUV_2_PACKED1B_C(type,alpha) \
615 for (i=0; i<(dstW>>1); i++) {\
617 int Y1= buf0[i2 ]>>7;\
618 int Y2= buf0[i2+1]>>7;\
619 int U= (uvbuf0[i ] + uvbuf1[i ])>>8;\
620 int V= (uvbuf0[i+VOFW] + uvbuf1[i+VOFW])>>8;\
621 type av_unused *r, *b, *g;\
622 int av_unused A1, A2;\
628 #define YSCALE_YUV_2_RGB1B_C(type,alpha) \
629 YSCALE_YUV_2_PACKED1B_C(type,alpha)\
630 r = (type *)c->table_rV[V];\
631 g = (type *)(c->table_gU[U] + c->table_gV[V]);\
632 b = (type *)c->table_bU[U];
634 #define YSCALE_YUV_2_MONO2_C \
635 const uint8_t * const d128=dither_8x8_220[y&7];\
636 uint8_t *g= c->table_gU[128] + c->table_gV[128];\
637 for (i=0; i<dstW-7; i+=8) {\
639 acc = g[((buf0[i ]*yalpha1+buf1[i ]*yalpha)>>19) + d128[0]];\
640 acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];\
641 acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];\
642 acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];\
643 acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];\
644 acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];\
645 acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];\
646 acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];\
647 ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
651 #define YSCALE_YUV_2_MONOX_C \
652 const uint8_t * const d128=dither_8x8_220[y&7];\
653 uint8_t *g= c->table_gU[128] + c->table_gV[128];\
655 for (i=0; i<dstW-1; i+=2) {\
660 for (j=0; j<lumFilterSize; j++) {\
661 Y1 += lumSrc[j][i] * lumFilter[j];\
662 Y2 += lumSrc[j][i+1] * lumFilter[j];\
672 acc+= acc + g[Y1+d128[(i+0)&7]];\
673 acc+= acc + g[Y2+d128[(i+1)&7]];\
675 ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
680 #define YSCALE_YUV_2_ANYRGB_C(func, func2, func_g16, func_monoblack)\
681 switch(c->dstFormat) {\
682 case PIX_FMT_RGB48BE:\
683 case PIX_FMT_RGB48LE:\
685 ((uint8_t*)dest)[ 0]= r[Y1];\
686 ((uint8_t*)dest)[ 1]= r[Y1];\
687 ((uint8_t*)dest)[ 2]= g[Y1];\
688 ((uint8_t*)dest)[ 3]= g[Y1];\
689 ((uint8_t*)dest)[ 4]= b[Y1];\
690 ((uint8_t*)dest)[ 5]= b[Y1];\
691 ((uint8_t*)dest)[ 6]= r[Y2];\
692 ((uint8_t*)dest)[ 7]= r[Y2];\
693 ((uint8_t*)dest)[ 8]= g[Y2];\
694 ((uint8_t*)dest)[ 9]= g[Y2];\
695 ((uint8_t*)dest)[10]= b[Y2];\
696 ((uint8_t*)dest)[11]= b[Y2];\
703 int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
704 func(uint32_t,needAlpha)\
705 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? (A1<<24) : 0);\
706 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? (A2<<24) : 0);\
709 if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
711 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (A1<<24);\
712 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (A2<<24);\
716 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
717 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
725 int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
726 func(uint32_t,needAlpha)\
727 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? A1 : 0);\
728 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? A2 : 0);\
731 if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
733 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + A1;\
734 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + A2;\
738 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
739 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
746 ((uint8_t*)dest)[0]= r[Y1];\
747 ((uint8_t*)dest)[1]= g[Y1];\
748 ((uint8_t*)dest)[2]= b[Y1];\
749 ((uint8_t*)dest)[3]= r[Y2];\
750 ((uint8_t*)dest)[4]= g[Y2];\
751 ((uint8_t*)dest)[5]= b[Y2];\
757 ((uint8_t*)dest)[0]= b[Y1];\
758 ((uint8_t*)dest)[1]= g[Y1];\
759 ((uint8_t*)dest)[2]= r[Y1];\
760 ((uint8_t*)dest)[3]= b[Y2];\
761 ((uint8_t*)dest)[4]= g[Y2];\
762 ((uint8_t*)dest)[5]= r[Y2];\
766 case PIX_FMT_RGB565BE:\
767 case PIX_FMT_RGB565LE:\
768 case PIX_FMT_BGR565BE:\
769 case PIX_FMT_BGR565LE:\
771 const int dr1= dither_2x2_8[y&1 ][0];\
772 const int dg1= dither_2x2_4[y&1 ][0];\
773 const int db1= dither_2x2_8[(y&1)^1][0];\
774 const int dr2= dither_2x2_8[y&1 ][1];\
775 const int dg2= dither_2x2_4[y&1 ][1];\
776 const int db2= dither_2x2_8[(y&1)^1][1];\
778 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
779 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
783 case PIX_FMT_RGB555BE:\
784 case PIX_FMT_RGB555LE:\
785 case PIX_FMT_BGR555BE:\
786 case PIX_FMT_BGR555LE:\
788 const int dr1= dither_2x2_8[y&1 ][0];\
789 const int dg1= dither_2x2_8[y&1 ][1];\
790 const int db1= dither_2x2_8[(y&1)^1][0];\
791 const int dr2= dither_2x2_8[y&1 ][1];\
792 const int dg2= dither_2x2_8[y&1 ][0];\
793 const int db2= dither_2x2_8[(y&1)^1][1];\
795 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
796 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
800 case PIX_FMT_RGB444BE:\
801 case PIX_FMT_RGB444LE:\
802 case PIX_FMT_BGR444BE:\
803 case PIX_FMT_BGR444LE:\
805 const int dr1= dither_4x4_16[y&3 ][0];\
806 const int dg1= dither_4x4_16[y&3 ][1];\
807 const int db1= dither_4x4_16[(y&3)^3][0];\
808 const int dr2= dither_4x4_16[y&3 ][1];\
809 const int dg2= dither_4x4_16[y&3 ][0];\
810 const int db2= dither_4x4_16[(y&3)^3][1];\
812 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
813 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
820 const uint8_t * const d64= dither_8x8_73[y&7];\
821 const uint8_t * const d32= dither_8x8_32[y&7];\
823 ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];\
824 ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];\
831 const uint8_t * const d64= dither_8x8_73 [y&7];\
832 const uint8_t * const d128=dither_8x8_220[y&7];\
834 ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]\
835 + ((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);\
839 case PIX_FMT_RGB4_BYTE:\
840 case PIX_FMT_BGR4_BYTE:\
842 const uint8_t * const d64= dither_8x8_73 [y&7];\
843 const uint8_t * const d128=dither_8x8_220[y&7];\
845 ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];\
846 ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];\
850 case PIX_FMT_MONOBLACK:\
851 case PIX_FMT_MONOWHITE:\
856 case PIX_FMT_YUYV422:\
858 ((uint8_t*)dest)[2*i2+0]= Y1;\
859 ((uint8_t*)dest)[2*i2+1]= U;\
860 ((uint8_t*)dest)[2*i2+2]= Y2;\
861 ((uint8_t*)dest)[2*i2+3]= V;\
864 case PIX_FMT_UYVY422:\
866 ((uint8_t*)dest)[2*i2+0]= U;\
867 ((uint8_t*)dest)[2*i2+1]= Y1;\
868 ((uint8_t*)dest)[2*i2+2]= V;\
869 ((uint8_t*)dest)[2*i2+3]= Y2;\
872 case PIX_FMT_GRAY16BE:\
874 ((uint8_t*)dest)[2*i2+0]= Y1>>8;\
875 ((uint8_t*)dest)[2*i2+1]= Y1;\
876 ((uint8_t*)dest)[2*i2+2]= Y2>>8;\
877 ((uint8_t*)dest)[2*i2+3]= Y2;\
880 case PIX_FMT_GRAY16LE:\
882 ((uint8_t*)dest)[2*i2+0]= Y1;\
883 ((uint8_t*)dest)[2*i2+1]= Y1>>8;\
884 ((uint8_t*)dest)[2*i2+2]= Y2;\
885 ((uint8_t*)dest)[2*i2+3]= Y2>>8;\
890 static inline void yuv2packedXinC(SwsContext
*c
, const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
891 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
892 const int16_t **alpSrc
, uint8_t *dest
, int dstW
, int y
)
895 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
)
898 static inline void yuv2rgbXinC_full(SwsContext
*c
, const int16_t *lumFilter
, const int16_t **lumSrc
, int lumFilterSize
,
899 const int16_t *chrFilter
, const int16_t **chrSrc
, int chrFilterSize
,
900 const int16_t **alpSrc
, uint8_t *dest
, int dstW
, int y
)
903 int step
= c
->dstFormatBpp
/8;
906 switch(c
->dstFormat
) {
914 int needAlpha
= CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
;
915 YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha
)
916 dest
[aidx
]= needAlpha
? A
: 255;
923 if (CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
) {
924 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
932 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
949 int needAlpha
= CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
;
950 YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha
)
951 dest
[aidx
]= needAlpha
? A
: 255;
958 if (CONFIG_SWSCALE_ALPHA
&& c
->alpPixBuf
) {
959 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
967 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
982 static void fillPlane(uint8_t* plane
, int stride
, int width
, int height
, int y
, uint8_t val
)
985 uint8_t *ptr
= plane
+ stride
*y
;
986 for (i
=0; i
<height
; i
++) {
987 memset(ptr
, val
, width
);
992 static inline void rgb48ToY(uint8_t *dst
, const uint8_t *src
, long width
,
996 for (i
= 0; i
< width
; i
++) {
1001 dst
[i
] = (RY
*r
+ GY
*g
+ BY
*b
+ (33<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
1005 static inline void rgb48ToUV(uint8_t *dstU
, uint8_t *dstV
,
1006 const uint8_t *src1
, const uint8_t *src2
,
1007 long width
, uint32_t *unused
)
1011 for (i
= 0; i
< width
; i
++) {
1012 int r
= src1
[6*i
+ 0];
1013 int g
= src1
[6*i
+ 2];
1014 int b
= src1
[6*i
+ 4];
1016 dstU
[i
] = (RU
*r
+ GU
*g
+ BU
*b
+ (257<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
1017 dstV
[i
] = (RV
*r
+ GV
*g
+ BV
*b
+ (257<<(RGB2YUV_SHIFT
-1))) >> RGB2YUV_SHIFT
;
1021 static inline void rgb48ToUV_half(uint8_t *dstU
, uint8_t *dstV
,
1022 const uint8_t *src1
, const uint8_t *src2
,
1023 long width
, uint32_t *unused
)
1027 for (i
= 0; i
< width
; i
++) {
1028 int r
= src1
[12*i
+ 0] + src1
[12*i
+ 6];
1029 int g
= src1
[12*i
+ 2] + src1
[12*i
+ 8];
1030 int b
= src1
[12*i
+ 4] + src1
[12*i
+ 10];
1032 dstU
[i
]= (RU
*r
+ GU
*g
+ BU
*b
+ (257<<RGB2YUV_SHIFT
)) >> (RGB2YUV_SHIFT
+1);
1033 dstV
[i
]= (RV
*r
+ GV
*g
+ BV
*b
+ (257<<RGB2YUV_SHIFT
)) >> (RGB2YUV_SHIFT
+1);
1037 #define BGR2Y(type, name, shr, shg, shb, maskr, maskg, maskb, RY, GY, BY, S)\
1038 static inline void name(uint8_t *dst, const uint8_t *src, long width, uint32_t *unused)\
1041 for (i=0; i<width; i++) {\
1042 int b= (((const type*)src)[i]>>shb)&maskb;\
1043 int g= (((const type*)src)[i]>>shg)&maskg;\
1044 int r= (((const type*)src)[i]>>shr)&maskr;\
1046 dst[i]= (((RY)*r + (GY)*g + (BY)*b + (33<<((S)-1)))>>(S));\
1050 BGR2Y(uint32_t, bgr32ToY
,16, 0, 0, 0x00FF, 0xFF00, 0x00FF, RY
<< 8, GY
, BY
<< 8, RGB2YUV_SHIFT
+8)
1051 BGR2Y(uint32_t, rgb32ToY
, 0, 0,16, 0x00FF, 0xFF00, 0x00FF, RY
<< 8, GY
, BY
<< 8, RGB2YUV_SHIFT
+8)
1052 BGR2Y(uint16_t, bgr16ToY
, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RY
<<11, GY
<<5, BY
, RGB2YUV_SHIFT
+8)
1053 BGR2Y(uint16_t, bgr15ToY
, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RY
<<10, GY
<<5, BY
, RGB2YUV_SHIFT
+7)
1054 BGR2Y(uint16_t, rgb16ToY
, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RY
, GY
<<5, BY
<<11, RGB2YUV_SHIFT
+8)
1055 BGR2Y(uint16_t, rgb15ToY
, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RY
, GY
<<5, BY
<<10, RGB2YUV_SHIFT
+7)
1057 static inline void abgrToA(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1060 for (i
=0; i
<width
; i
++) {
1065 #define BGR2UV(type, name, shr, shg, shb, maska, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S)\
1066 static inline void name(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
1069 for (i=0; i<width; i++) {\
1070 int b= (((const type*)src)[i]&maskb)>>shb;\
1071 int g= (((const type*)src)[i]&maskg)>>shg;\
1072 int r= (((const type*)src)[i]&maskr)>>shr;\
1074 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<((S)-1)))>>(S);\
1075 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<((S)-1)))>>(S);\
1078 static inline void name ## _half(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
1081 for (i=0; i<width; i++) {\
1082 int pix0= ((const type*)src)[2*i+0];\
1083 int pix1= ((const type*)src)[2*i+1];\
1084 int g= (pix0&~(maskr|maskb))+(pix1&~(maskr|maskb));\
1085 int b= ((pix0+pix1-g)&(maskb|(2*maskb)))>>shb;\
1086 int r= ((pix0+pix1-g)&(maskr|(2*maskr)))>>shr;\
1087 g&= maskg|(2*maskg);\
1091 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<(S)))>>((S)+1);\
1092 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<(S)))>>((S)+1);\
1096 BGR2UV(uint32_t, bgr32ToUV
,16, 0, 0, 0xFF000000, 0xFF0000, 0xFF00, 0x00FF, RU
<< 8, GU
, BU
<< 8, RV
<< 8, GV
, BV
<< 8, RGB2YUV_SHIFT
+8)
1097 BGR2UV(uint32_t, rgb32ToUV
, 0, 0,16, 0xFF000000, 0x00FF, 0xFF00, 0xFF0000, RU
<< 8, GU
, BU
<< 8, RV
<< 8, GV
, BV
<< 8, RGB2YUV_SHIFT
+8)
1098 BGR2UV(uint16_t, bgr16ToUV
, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RU
<<11, GU
<<5, BU
, RV
<<11, GV
<<5, BV
, RGB2YUV_SHIFT
+8)
1099 BGR2UV(uint16_t, bgr15ToUV
, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RU
<<10, GU
<<5, BU
, RV
<<10, GV
<<5, BV
, RGB2YUV_SHIFT
+7)
1100 BGR2UV(uint16_t, rgb16ToUV
, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RU
, GU
<<5, BU
<<11, RV
, GV
<<5, BV
<<11, RGB2YUV_SHIFT
+8)
1101 BGR2UV(uint16_t, rgb15ToUV
, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RU
, GU
<<5, BU
<<10, RV
, GV
<<5, BV
<<10, RGB2YUV_SHIFT
+7)
1103 static inline void palToY(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *pal
)
1106 for (i
=0; i
<width
; i
++) {
1109 dst
[i
]= pal
[d
] & 0xFF;
1113 static inline void palToUV(uint8_t *dstU
, uint8_t *dstV
,
1114 const uint8_t *src1
, const uint8_t *src2
,
1115 long width
, uint32_t *pal
)
1118 assert(src1
== src2
);
1119 for (i
=0; i
<width
; i
++) {
1120 int p
= pal
[src1
[i
]];
1127 static inline void monowhite2Y(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1130 for (i
=0; i
<width
/8; i
++) {
1133 dst
[8*i
+j
]= ((d
>>(7-j
))&1)*255;
1137 static inline void monoblack2Y(uint8_t *dst
, const uint8_t *src
, long width
, uint32_t *unused
)
1140 for (i
=0; i
<width
/8; i
++) {
1143 dst
[8*i
+j
]= ((d
>>(7-j
))&1)*255;
1147 //Note: we have C, MMX, MMX2, 3DNOW versions, there is no 3DNOW+MMX2 one
1149 #if (!HAVE_MMX && !HAVE_ALTIVEC) || CONFIG_RUNTIME_CPUDETECT
1155 #define COMPILE_ALTIVEC
1161 #if (HAVE_MMX && !HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT
1165 #if HAVE_MMX2 || CONFIG_RUNTIME_CPUDETECT
1166 #define COMPILE_MMX2
1169 #if (HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT
1170 #define COMPILE_3DNOW
1174 #define COMPILE_TEMPLATE_MMX 0
1175 #define COMPILE_TEMPLATE_MMX2 0
1176 #define COMPILE_TEMPLATE_AMD3DNOW 0
1177 #define COMPILE_TEMPLATE_ALTIVEC 0
1180 #define RENAME(a) a ## _C
1181 #include "swscale_template.c"
1184 #ifdef COMPILE_ALTIVEC
1186 #undef COMPILE_TEMPLATE_ALTIVEC
1187 #define COMPILE_TEMPLATE_ALTIVEC 1
1188 #define RENAME(a) a ## _altivec
1189 #include "swscale_template.c"
1197 #undef COMPILE_TEMPLATE_MMX
1198 #undef COMPILE_TEMPLATE_MMX2
1199 #undef COMPILE_TEMPLATE_AMD3DNOW
1200 #define COMPILE_TEMPLATE_MMX 1
1201 #define COMPILE_TEMPLATE_MMX2 0
1202 #define COMPILE_TEMPLATE_AMD3DNOW 0
1203 #define RENAME(a) a ## _MMX
1204 #include "swscale_template.c"
1210 #undef COMPILE_TEMPLATE_MMX
1211 #undef COMPILE_TEMPLATE_MMX2
1212 #undef COMPILE_TEMPLATE_AMD3DNOW
1213 #define COMPILE_TEMPLATE_MMX 1
1214 #define COMPILE_TEMPLATE_MMX2 1
1215 #define COMPILE_TEMPLATE_AMD3DNOW 0
1216 #define RENAME(a) a ## _MMX2
1217 #include "swscale_template.c"
1221 #ifdef COMPILE_3DNOW
1223 #undef COMPILE_TEMPLATE_MMX
1224 #undef COMPILE_TEMPLATE_MMX2
1225 #undef COMPILE_TEMPLATE_AMD3DNOW
1226 #define COMPILE_TEMPLATE_MMX 1
1227 #define COMPILE_TEMPLATE_MMX2 0
1228 #define COMPILE_TEMPLATE_AMD3DNOW 1
1229 #define RENAME(a) a ## _3DNow
1230 #include "swscale_template.c"
1235 SwsFunc
ff_getSwsFunc(SwsContext
*c
)
1237 #if CONFIG_RUNTIME_CPUDETECT
1238 int flags
= c
->flags
;
1241 // ordered per speed fastest first
1242 if (flags
& SWS_CPU_CAPS_MMX2
) {
1243 sws_init_swScale_MMX2(c
);
1244 return swScale_MMX2
;
1245 } else if (flags
& SWS_CPU_CAPS_3DNOW
) {
1246 sws_init_swScale_3DNow(c
);
1247 return swScale_3DNow
;
1248 } else if (flags
& SWS_CPU_CAPS_MMX
) {
1249 sws_init_swScale_MMX(c
);
1252 sws_init_swScale_C(c
);
1257 #ifdef COMPILE_ALTIVEC
1258 if (flags
& SWS_CPU_CAPS_ALTIVEC
) {
1259 sws_init_swScale_altivec(c
);
1260 return swScale_altivec
;
1262 sws_init_swScale_C(c
);
1266 sws_init_swScale_C(c
);
1268 #endif /* ARCH_X86 */
1269 #else //CONFIG_RUNTIME_CPUDETECT
1270 #if COMPILE_TEMPLATE_MMX2
1271 sws_init_swScale_MMX2(c
);
1272 return swScale_MMX2
;
1273 #elif COMPILE_TEMPLATE_AMD3DNOW
1274 sws_init_swScale_3DNow(c
);
1275 return swScale_3DNow
;
1276 #elif COMPILE_TEMPLATE_MMX
1277 sws_init_swScale_MMX(c
);
1279 #elif COMPILE_TEMPLATE_ALTIVEC
1280 sws_init_swScale_altivec(c
);
1281 return swScale_altivec
;
1283 sws_init_swScale_C(c
);
1286 #endif //!CONFIG_RUNTIME_CPUDETECT
1289 static int planarToNv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1290 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1292 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1294 if (dstStride
[0]==srcStride
[0] && srcStride
[0] > 0)
1295 memcpy(dst
, src
[0], srcSliceH
*dstStride
[0]);
1298 const uint8_t *srcPtr
= src
[0];
1299 uint8_t *dstPtr
= dst
;
1300 for (i
=0; i
<srcSliceH
; i
++) {
1301 memcpy(dstPtr
, srcPtr
, c
->srcW
);
1302 srcPtr
+= srcStride
[0];
1303 dstPtr
+= dstStride
[0];
1306 dst
= dstParam
[1] + dstStride
[1]*srcSliceY
/2;
1307 if (c
->dstFormat
== PIX_FMT_NV12
)
1308 interleaveBytes(src
[1], src
[2], dst
, c
->srcW
/2, srcSliceH
/2, srcStride
[1], srcStride
[2], dstStride
[0]);
1310 interleaveBytes(src
[2], src
[1], dst
, c
->srcW
/2, srcSliceH
/2, srcStride
[2], srcStride
[1], dstStride
[0]);
1315 static int planarToYuy2Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1316 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1318 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1320 yv12toyuy2(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0], srcStride
[1], dstStride
[0]);
1325 static int planarToUyvyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1326 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1328 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1330 yv12touyvy(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0], srcStride
[1], dstStride
[0]);
1335 static int yuv422pToYuy2Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1336 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1338 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1340 yuv422ptoyuy2(src
[0],src
[1],src
[2],dst
,c
->srcW
,srcSliceH
,srcStride
[0],srcStride
[1],dstStride
[0]);
1345 static int yuv422pToUyvyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1346 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1348 uint8_t *dst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1350 yuv422ptouyvy(src
[0],src
[1],src
[2],dst
,c
->srcW
,srcSliceH
,srcStride
[0],srcStride
[1],dstStride
[0]);
1355 static int yuyvToYuv420Wrapper(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
/2;
1360 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
/2;
1362 yuyvtoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1365 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1370 static int yuyvToYuv422Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1371 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1373 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1374 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
;
1375 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
;
1377 yuyvtoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1382 static int uyvyToYuv420Wrapper(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
/2;
1387 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
/2;
1389 uyvytoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1392 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1397 static int uyvyToYuv422Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1398 int srcSliceH
, uint8_t* dstParam
[], int dstStride
[])
1400 uint8_t *ydst
=dstParam
[0] + dstStride
[0]*srcSliceY
;
1401 uint8_t *udst
=dstParam
[1] + dstStride
[1]*srcSliceY
;
1402 uint8_t *vdst
=dstParam
[2] + dstStride
[2]*srcSliceY
;
1404 uyvytoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0], dstStride
[1], srcStride
[0]);
1409 static int palToRgbWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1410 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1412 const enum PixelFormat srcFormat
= c
->srcFormat
;
1413 const enum PixelFormat dstFormat
= c
->dstFormat
;
1414 void (*conv
)(const uint8_t *src
, uint8_t *dst
, long num_pixels
,
1415 const uint8_t *palette
)=NULL
;
1417 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1418 const uint8_t *srcPtr
= src
[0];
1420 if (usePal(srcFormat
)) {
1421 switch (dstFormat
) {
1422 case PIX_FMT_RGB32
: conv
= sws_convertPalette8ToPacked32
; break;
1423 case PIX_FMT_BGR32
: conv
= sws_convertPalette8ToPacked32
; break;
1424 case PIX_FMT_BGR32_1
: conv
= sws_convertPalette8ToPacked32
; break;
1425 case PIX_FMT_RGB32_1
: conv
= sws_convertPalette8ToPacked32
; break;
1426 case PIX_FMT_RGB24
: conv
= sws_convertPalette8ToPacked24
; break;
1427 case PIX_FMT_BGR24
: conv
= sws_convertPalette8ToPacked24
; break;
1432 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
1433 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
1435 for (i
=0; i
<srcSliceH
; i
++) {
1436 conv(srcPtr
, dstPtr
, c
->srcW
, (uint8_t *) c
->pal_rgb
);
1437 srcPtr
+= srcStride
[0];
1438 dstPtr
+= dstStride
[0];
1445 #define isRGBA32(x) ( \
1446 (x) == PIX_FMT_ARGB \
1447 || (x) == PIX_FMT_RGBA \
1448 || (x) == PIX_FMT_BGRA \
1449 || (x) == PIX_FMT_ABGR \
1452 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1453 static int rgbToRgbWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1454 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1456 const enum PixelFormat srcFormat
= c
->srcFormat
;
1457 const enum PixelFormat dstFormat
= c
->dstFormat
;
1458 const int srcBpp
= (c
->srcFormatBpp
+ 7) >> 3;
1459 const int dstBpp
= (c
->dstFormatBpp
+ 7) >> 3;
1460 const int srcId
= c
->srcFormatBpp
>> 2; /* 1:0, 4:1, 8:2, 15:3, 16:4, 24:6, 32:8 */
1461 const int dstId
= c
->dstFormatBpp
>> 2;
1462 void (*conv
)(const uint8_t *src
, uint8_t *dst
, long src_size
)=NULL
;
1464 #define CONV_IS(src, dst) (srcFormat == PIX_FMT_##src && dstFormat == PIX_FMT_##dst)
1466 if (isRGBA32(srcFormat
) && isRGBA32(dstFormat
)) {
1467 if ( CONV_IS(ABGR
, RGBA
)
1468 || CONV_IS(ARGB
, BGRA
)
1469 || CONV_IS(BGRA
, ARGB
)
1470 || CONV_IS(RGBA
, ABGR
)) conv
= shuffle_bytes_3210
;
1471 else if (CONV_IS(ABGR
, ARGB
)
1472 || CONV_IS(ARGB
, ABGR
)) conv
= shuffle_bytes_0321
;
1473 else if (CONV_IS(ABGR
, BGRA
)
1474 || CONV_IS(ARGB
, RGBA
)) conv
= shuffle_bytes_1230
;
1475 else if (CONV_IS(BGRA
, RGBA
)
1476 || CONV_IS(RGBA
, BGRA
)) conv
= shuffle_bytes_2103
;
1477 else if (CONV_IS(BGRA
, ABGR
)
1478 || CONV_IS(RGBA
, ARGB
)) conv
= shuffle_bytes_3012
;
1481 if ( (isBGRinInt(srcFormat
) && isBGRinInt(dstFormat
))
1482 || (isRGBinInt(srcFormat
) && isRGBinInt(dstFormat
))) {
1483 switch(srcId
| (dstId
<<4)) {
1484 case 0x34: conv
= rgb16to15
; break;
1485 case 0x36: conv
= rgb24to15
; break;
1486 case 0x38: conv
= rgb32to15
; break;
1487 case 0x43: conv
= rgb15to16
; break;
1488 case 0x46: conv
= rgb24to16
; break;
1489 case 0x48: conv
= rgb32to16
; break;
1490 case 0x63: conv
= rgb15to24
; break;
1491 case 0x64: conv
= rgb16to24
; break;
1492 case 0x68: conv
= rgb32to24
; break;
1493 case 0x83: conv
= rgb15to32
; break;
1494 case 0x84: conv
= rgb16to32
; break;
1495 case 0x86: conv
= rgb24to32
; break;
1497 } else if ( (isBGRinInt(srcFormat
) && isRGBinInt(dstFormat
))
1498 || (isRGBinInt(srcFormat
) && isBGRinInt(dstFormat
))) {
1499 switch(srcId
| (dstId
<<4)) {
1500 case 0x33: conv
= rgb15tobgr15
; break;
1501 case 0x34: conv
= rgb16tobgr15
; break;
1502 case 0x36: conv
= rgb24tobgr15
; break;
1503 case 0x38: conv
= rgb32tobgr15
; break;
1504 case 0x43: conv
= rgb15tobgr16
; break;
1505 case 0x44: conv
= rgb16tobgr16
; break;
1506 case 0x46: conv
= rgb24tobgr16
; break;
1507 case 0x48: conv
= rgb32tobgr16
; break;
1508 case 0x63: conv
= rgb15tobgr24
; break;
1509 case 0x64: conv
= rgb16tobgr24
; break;
1510 case 0x66: conv
= rgb24tobgr24
; break;
1511 case 0x68: conv
= rgb32tobgr24
; break;
1512 case 0x83: conv
= rgb15tobgr32
; break;
1513 case 0x84: conv
= rgb16tobgr32
; break;
1514 case 0x86: conv
= rgb24tobgr32
; break;
1519 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
1520 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
1522 const uint8_t *srcPtr
= src
[0];
1523 uint8_t *dstPtr
= dst
[0];
1524 if ((srcFormat
== PIX_FMT_RGB32_1
|| srcFormat
== PIX_FMT_BGR32_1
) && !isRGBA32(dstFormat
))
1525 srcPtr
+= ALT32_CORR
;
1527 if ((dstFormat
== PIX_FMT_RGB32_1
|| dstFormat
== PIX_FMT_BGR32_1
) && !isRGBA32(srcFormat
))
1528 dstPtr
+= ALT32_CORR
;
1530 if (dstStride
[0]*srcBpp
== srcStride
[0]*dstBpp
&& srcStride
[0] > 0)
1531 conv(srcPtr
, dstPtr
+ dstStride
[0]*srcSliceY
, srcSliceH
*srcStride
[0]);
1534 dstPtr
+= dstStride
[0]*srcSliceY
;
1536 for (i
=0; i
<srcSliceH
; i
++) {
1537 conv(srcPtr
, dstPtr
, c
->srcW
*srcBpp
);
1538 srcPtr
+= srcStride
[0];
1539 dstPtr
+= dstStride
[0];
1546 static int bgr24ToYv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1547 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1551 dst
[0]+ srcSliceY
*dstStride
[0],
1552 dst
[1]+(srcSliceY
>>1)*dstStride
[1],
1553 dst
[2]+(srcSliceY
>>1)*dstStride
[2],
1555 dstStride
[0], dstStride
[1], srcStride
[0]);
1557 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1561 static int yvu9ToYv12Wrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1562 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1567 if (srcStride
[0]==dstStride
[0] && srcStride
[0] > 0)
1568 memcpy(dst
[0]+ srcSliceY
*dstStride
[0], src
[0], srcStride
[0]*srcSliceH
);
1570 const uint8_t *srcPtr
= src
[0];
1571 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1573 for (i
=0; i
<srcSliceH
; i
++) {
1574 memcpy(dstPtr
, srcPtr
, c
->srcW
);
1575 srcPtr
+= srcStride
[0];
1576 dstPtr
+= dstStride
[0];
1580 if (c
->dstFormat
==PIX_FMT_YUV420P
|| c
->dstFormat
==PIX_FMT_YUVA420P
) {
1581 planar2x(src
[1], dst
[1] + dstStride
[1]*(srcSliceY
>> 1), c
->chrSrcW
,
1582 srcSliceH
>> 2, srcStride
[1], dstStride
[1]);
1583 planar2x(src
[2], dst
[2] + dstStride
[2]*(srcSliceY
>> 1), c
->chrSrcW
,
1584 srcSliceH
>> 2, srcStride
[2], dstStride
[2]);
1586 planar2x(src
[1], dst
[2] + dstStride
[2]*(srcSliceY
>> 1), c
->chrSrcW
,
1587 srcSliceH
>> 2, srcStride
[1], dstStride
[2]);
1588 planar2x(src
[2], dst
[1] + dstStride
[1]*(srcSliceY
>> 1), c
->chrSrcW
,
1589 srcSliceH
>> 2, srcStride
[2], dstStride
[1]);
1592 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
1596 /* unscaled copy like stuff (assumes nearly identical formats) */
1597 static int packedCopyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1598 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1600 if (dstStride
[0]==srcStride
[0] && srcStride
[0] > 0)
1601 memcpy(dst
[0] + dstStride
[0]*srcSliceY
, src
[0], srcSliceH
*dstStride
[0]);
1604 const uint8_t *srcPtr
= src
[0];
1605 uint8_t *dstPtr
= dst
[0] + dstStride
[0]*srcSliceY
;
1608 /* universal length finder */
1609 while(length
+c
->srcW
<= FFABS(dstStride
[0])
1610 && length
+c
->srcW
<= FFABS(srcStride
[0])) length
+= c
->srcW
;
1613 for (i
=0; i
<srcSliceH
; i
++) {
1614 memcpy(dstPtr
, srcPtr
, length
);
1615 srcPtr
+= srcStride
[0];
1616 dstPtr
+= dstStride
[0];
1622 static int planarCopyWrapper(SwsContext
*c
, const uint8_t* src
[], int srcStride
[], int srcSliceY
,
1623 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1626 for (plane
=0; plane
<4; plane
++) {
1627 int length
= (plane
==0 || plane
==3) ? c
->srcW
: -((-c
->srcW
)>>c
->chrDstHSubSample
);
1628 int y
= (plane
==0 || plane
==3) ? srcSliceY
: -((-srcSliceY
)>>c
->chrDstVSubSample
);
1629 int height
= (plane
==0 || plane
==3) ? srcSliceH
: -((-srcSliceH
)>>c
->chrDstVSubSample
);
1630 const uint8_t *srcPtr
= src
[plane
];
1631 uint8_t *dstPtr
= dst
[plane
] + dstStride
[plane
]*y
;
1633 if (!dst
[plane
]) continue;
1634 // ignore palette for GRAY8
1635 if (plane
== 1 && !dst
[2]) continue;
1636 if (!src
[plane
] || (plane
== 1 && !src
[2])) {
1637 if(is16BPS(c
->dstFormat
))
1639 fillPlane(dst
[plane
], dstStride
[plane
], length
, height
, y
, (plane
==3) ? 255 : 128);
1641 if(is16BPS(c
->srcFormat
) && !is16BPS(c
->dstFormat
)) {
1642 if (!isBE(c
->srcFormat
)) srcPtr
++;
1643 for (i
=0; i
<height
; i
++) {
1644 for (j
=0; j
<length
; j
++) dstPtr
[j
] = srcPtr
[j
<<1];
1645 srcPtr
+= srcStride
[plane
];
1646 dstPtr
+= dstStride
[plane
];
1648 } else if(!is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
)) {
1649 for (i
=0; i
<height
; i
++) {
1650 for (j
=0; j
<length
; j
++) {
1651 dstPtr
[ j
<<1 ] = srcPtr
[j
];
1652 dstPtr
[(j
<<1)+1] = srcPtr
[j
];
1654 srcPtr
+= srcStride
[plane
];
1655 dstPtr
+= dstStride
[plane
];
1657 } else if(is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
)
1658 && isBE(c
->srcFormat
) != isBE(c
->dstFormat
)) {
1660 for (i
=0; i
<height
; i
++) {
1661 for (j
=0; j
<length
; j
++)
1662 ((uint16_t*)dstPtr
)[j
] = av_bswap16(((const uint16_t*)srcPtr
)[j
]);
1663 srcPtr
+= srcStride
[plane
];
1664 dstPtr
+= dstStride
[plane
];
1666 } else if (dstStride
[plane
] == srcStride
[plane
] &&
1667 srcStride
[plane
] > 0 && srcStride
[plane
] == length
) {
1668 memcpy(dst
[plane
] + dstStride
[plane
]*y
, src
[plane
],
1669 height
*dstStride
[plane
]);
1671 if(is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
))
1673 for (i
=0; i
<height
; i
++) {
1674 memcpy(dstPtr
, srcPtr
, length
);
1675 srcPtr
+= srcStride
[plane
];
1676 dstPtr
+= dstStride
[plane
];
1684 int ff_hardcodedcpuflags(void)
1687 #if COMPILE_TEMPLATE_MMX2
1688 flags
|= SWS_CPU_CAPS_MMX
|SWS_CPU_CAPS_MMX2
;
1689 #elif COMPILE_TEMPLATE_AMD3DNOW
1690 flags
|= SWS_CPU_CAPS_MMX
|SWS_CPU_CAPS_3DNOW
;
1691 #elif COMPILE_TEMPLATE_MMX
1692 flags
|= SWS_CPU_CAPS_MMX
;
1693 #elif COMPILE_TEMPLATE_ALTIVEC
1694 flags
|= SWS_CPU_CAPS_ALTIVEC
;
1696 flags
|= SWS_CPU_CAPS_BFIN
;
1701 void ff_get_unscaled_swscale(SwsContext
*c
)
1703 const enum PixelFormat srcFormat
= c
->srcFormat
;
1704 const enum PixelFormat dstFormat
= c
->dstFormat
;
1705 const int flags
= c
->flags
;
1706 const int dstH
= c
->dstH
;
1709 needsDither
= isAnyRGB(dstFormat
)
1710 && c
->dstFormatBpp
< 24
1711 && (c
->dstFormatBpp
< c
->srcFormatBpp
|| (!isAnyRGB(srcFormat
)));
1714 if ((srcFormat
== PIX_FMT_YUV420P
|| srcFormat
== PIX_FMT_YUVA420P
) && (dstFormat
== PIX_FMT_NV12
|| dstFormat
== PIX_FMT_NV21
)) {
1715 c
->swScale
= planarToNv12Wrapper
;
1718 if ((srcFormat
==PIX_FMT_YUV420P
|| srcFormat
==PIX_FMT_YUV422P
|| srcFormat
==PIX_FMT_YUVA420P
) && isAnyRGB(dstFormat
)
1719 && !(flags
& SWS_ACCURATE_RND
) && !(dstH
&1)) {
1720 c
->swScale
= ff_yuv2rgb_get_func_ptr(c
);
1723 if (srcFormat
==PIX_FMT_YUV410P
&& (dstFormat
==PIX_FMT_YUV420P
|| dstFormat
==PIX_FMT_YUVA420P
) && !(flags
& SWS_BITEXACT
)) {
1724 c
->swScale
= yvu9ToYv12Wrapper
;
1728 if (srcFormat
==PIX_FMT_BGR24
&& (dstFormat
==PIX_FMT_YUV420P
|| dstFormat
==PIX_FMT_YUVA420P
) && !(flags
& SWS_ACCURATE_RND
))
1729 c
->swScale
= bgr24ToYv12Wrapper
;
1731 /* RGB/BGR -> RGB/BGR (no dither needed forms) */
1732 if ( isAnyRGB(srcFormat
)
1733 && isAnyRGB(dstFormat
)
1734 && srcFormat
!= PIX_FMT_BGR8
&& dstFormat
!= PIX_FMT_BGR8
1735 && srcFormat
!= PIX_FMT_RGB8
&& dstFormat
!= PIX_FMT_RGB8
1736 && srcFormat
!= PIX_FMT_BGR4
&& dstFormat
!= PIX_FMT_BGR4
1737 && srcFormat
!= PIX_FMT_RGB4
&& dstFormat
!= PIX_FMT_RGB4
1738 && srcFormat
!= PIX_FMT_BGR4_BYTE
&& dstFormat
!= PIX_FMT_BGR4_BYTE
1739 && srcFormat
!= PIX_FMT_RGB4_BYTE
&& dstFormat
!= PIX_FMT_RGB4_BYTE
1740 && srcFormat
!= PIX_FMT_MONOBLACK
&& dstFormat
!= PIX_FMT_MONOBLACK
1741 && srcFormat
!= PIX_FMT_MONOWHITE
&& dstFormat
!= PIX_FMT_MONOWHITE
1742 && srcFormat
!= PIX_FMT_RGB48LE
&& dstFormat
!= PIX_FMT_RGB48LE
1743 && srcFormat
!= PIX_FMT_RGB48BE
&& dstFormat
!= PIX_FMT_RGB48BE
1744 && (!needsDither
|| (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
))))
1745 c
->swScale
= rgbToRgbWrapper
;
1747 if ((usePal(srcFormat
) && (
1748 dstFormat
== PIX_FMT_RGB32
||
1749 dstFormat
== PIX_FMT_RGB32_1
||
1750 dstFormat
== PIX_FMT_RGB24
||
1751 dstFormat
== PIX_FMT_BGR32
||
1752 dstFormat
== PIX_FMT_BGR32_1
||
1753 dstFormat
== PIX_FMT_BGR24
)))
1754 c
->swScale
= palToRgbWrapper
;
1756 if (srcFormat
== PIX_FMT_YUV422P
) {
1757 if (dstFormat
== PIX_FMT_YUYV422
)
1758 c
->swScale
= yuv422pToYuy2Wrapper
;
1759 else if (dstFormat
== PIX_FMT_UYVY422
)
1760 c
->swScale
= yuv422pToUyvyWrapper
;
1763 /* LQ converters if -sws 0 or -sws 4*/
1764 if (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
)) {
1766 if (srcFormat
== PIX_FMT_YUV420P
|| srcFormat
== PIX_FMT_YUVA420P
) {
1767 if (dstFormat
== PIX_FMT_YUYV422
)
1768 c
->swScale
= planarToYuy2Wrapper
;
1769 else if (dstFormat
== PIX_FMT_UYVY422
)
1770 c
->swScale
= planarToUyvyWrapper
;
1773 if(srcFormat
== PIX_FMT_YUYV422
&& (dstFormat
== PIX_FMT_YUV420P
|| dstFormat
== PIX_FMT_YUVA420P
))
1774 c
->swScale
= yuyvToYuv420Wrapper
;
1775 if(srcFormat
== PIX_FMT_UYVY422
&& (dstFormat
== PIX_FMT_YUV420P
|| dstFormat
== PIX_FMT_YUVA420P
))
1776 c
->swScale
= uyvyToYuv420Wrapper
;
1777 if(srcFormat
== PIX_FMT_YUYV422
&& dstFormat
== PIX_FMT_YUV422P
)
1778 c
->swScale
= yuyvToYuv422Wrapper
;
1779 if(srcFormat
== PIX_FMT_UYVY422
&& dstFormat
== PIX_FMT_YUV422P
)
1780 c
->swScale
= uyvyToYuv422Wrapper
;
1782 #ifdef COMPILE_ALTIVEC
1783 if ((c
->flags
& SWS_CPU_CAPS_ALTIVEC
) &&
1784 !(c
->flags
& SWS_BITEXACT
) &&
1785 srcFormat
== PIX_FMT_YUV420P
) {
1786 // unscaled YV12 -> packed YUV, we want speed
1787 if (dstFormat
== PIX_FMT_YUYV422
)
1788 c
->swScale
= yv12toyuy2_unscaled_altivec
;
1789 else if (dstFormat
== PIX_FMT_UYVY422
)
1790 c
->swScale
= yv12touyvy_unscaled_altivec
;
1795 if ( srcFormat
== dstFormat
1796 || (srcFormat
== PIX_FMT_YUVA420P
&& dstFormat
== PIX_FMT_YUV420P
)
1797 || (srcFormat
== PIX_FMT_YUV420P
&& dstFormat
== PIX_FMT_YUVA420P
)
1798 || (isPlanarYUV(srcFormat
) && isGray(dstFormat
))
1799 || (isPlanarYUV(dstFormat
) && isGray(srcFormat
))
1800 || (isGray(dstFormat
) && isGray(srcFormat
))
1801 || (isPlanarYUV(srcFormat
) && isPlanarYUV(dstFormat
)
1802 && c
->chrDstHSubSample
== c
->chrSrcHSubSample
1803 && c
->chrDstVSubSample
== c
->chrSrcVSubSample
1804 && dstFormat
!= PIX_FMT_NV12
&& dstFormat
!= PIX_FMT_NV21
1805 && srcFormat
!= PIX_FMT_NV12
&& srcFormat
!= PIX_FMT_NV21
))
1807 if (isPacked(c
->srcFormat
))
1808 c
->swScale
= packedCopyWrapper
;
1809 else /* Planar YUV or gray */
1810 c
->swScale
= planarCopyWrapper
;
1813 if (flags
& SWS_CPU_CAPS_BFIN
)
1814 ff_bfin_get_unscaled_swscale (c
);
1818 static void reset_ptr(const uint8_t* src
[], int format
)
1820 if(!isALPHA(format
))
1822 if(!isPlanarYUV(format
)) {
1825 if (!usePal(format
))
1831 * swscale wrapper, so we don't need to export the SwsContext.
1832 * Assumes planar YUV to be in YUV order instead of YVU.
1834 int sws_scale(SwsContext
*c
, const uint8_t* const src
[], const int srcStride
[], int srcSliceY
,
1835 int srcSliceH
, uint8_t* const dst
[], const int dstStride
[])
1838 const uint8_t* src2
[4]= {src
[0], src
[1], src
[2], src
[3]};
1839 uint8_t* dst2
[4]= {dst
[0], dst
[1], dst
[2], dst
[3]};
1841 // do not mess up sliceDir if we have a "trailing" 0-size slice
1845 if (c
->sliceDir
== 0 && srcSliceY
!= 0 && srcSliceY
+ srcSliceH
!= c
->srcH
) {
1846 av_log(c
, AV_LOG_ERROR
, "Slices start in the middle!\n");
1849 if (c
->sliceDir
== 0) {
1850 if (srcSliceY
== 0) c
->sliceDir
= 1; else c
->sliceDir
= -1;
1853 if (usePal(c
->srcFormat
)) {
1854 for (i
=0; i
<256; i
++) {
1855 int p
, r
, g
, b
,y
,u
,v
;
1856 if(c
->srcFormat
== PIX_FMT_PAL8
) {
1857 p
=((const uint32_t*)(src
[1]))[i
];
1861 } else if(c
->srcFormat
== PIX_FMT_RGB8
) {
1865 } else if(c
->srcFormat
== PIX_FMT_BGR8
) {
1869 } else if(c
->srcFormat
== PIX_FMT_RGB4_BYTE
) {
1873 } else if(c
->srcFormat
== PIX_FMT_GRAY8
) {
1876 assert(c
->srcFormat
== PIX_FMT_BGR4_BYTE
);
1881 y
= av_clip_uint8((RY
*r
+ GY
*g
+ BY
*b
+ ( 33<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1882 u
= av_clip_uint8((RU
*r
+ GU
*g
+ BU
*b
+ (257<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1883 v
= av_clip_uint8((RV
*r
+ GV
*g
+ BV
*b
+ (257<<(RGB2YUV_SHIFT
-1)))>>RGB2YUV_SHIFT
);
1884 c
->pal_yuv
[i
]= y
+ (u
<<8) + (v
<<16);
1886 switch(c
->dstFormat
) {
1891 c
->pal_rgb
[i
]= r
+ (g
<<8) + (b
<<16);
1893 case PIX_FMT_BGR32_1
:
1897 c
->pal_rgb
[i
]= (r
+ (g
<<8) + (b
<<16)) << 8;
1899 case PIX_FMT_RGB32_1
:
1903 c
->pal_rgb
[i
]= (b
+ (g
<<8) + (r
<<16)) << 8;
1910 c
->pal_rgb
[i
]= b
+ (g
<<8) + (r
<<16);
1915 // copy strides, so they can safely be modified
1916 if (c
->sliceDir
== 1) {
1917 // slices go from top to bottom
1918 int srcStride2
[4]= {srcStride
[0], srcStride
[1], srcStride
[2], srcStride
[3]};
1919 int dstStride2
[4]= {dstStride
[0], dstStride
[1], dstStride
[2], dstStride
[3]};
1921 reset_ptr(src2
, c
->srcFormat
);
1922 reset_ptr((const uint8_t**)dst2
, c
->dstFormat
);
1924 /* reset slice direction at end of frame */
1925 if (srcSliceY
+ srcSliceH
== c
->srcH
)
1928 return c
->swScale(c
, src2
, srcStride2
, srcSliceY
, srcSliceH
, dst2
, dstStride2
);
1930 // slices go from bottom to top => we flip the image internally
1931 int srcStride2
[4]= {-srcStride
[0], -srcStride
[1], -srcStride
[2], -srcStride
[3]};
1932 int dstStride2
[4]= {-dstStride
[0], -dstStride
[1], -dstStride
[2], -dstStride
[3]};
1934 src2
[0] += (srcSliceH
-1)*srcStride
[0];
1935 if (!usePal(c
->srcFormat
))
1936 src2
[1] += ((srcSliceH
>>c
->chrSrcVSubSample
)-1)*srcStride
[1];
1937 src2
[2] += ((srcSliceH
>>c
->chrSrcVSubSample
)-1)*srcStride
[2];
1938 src2
[3] += (srcSliceH
-1)*srcStride
[3];
1939 dst2
[0] += ( c
->dstH
-1)*dstStride
[0];
1940 dst2
[1] += ((c
->dstH
>>c
->chrDstVSubSample
)-1)*dstStride
[1];
1941 dst2
[2] += ((c
->dstH
>>c
->chrDstVSubSample
)-1)*dstStride
[2];
1942 dst2
[3] += ( c
->dstH
-1)*dstStride
[3];
1944 reset_ptr(src2
, c
->srcFormat
);
1945 reset_ptr((const uint8_t**)dst2
, c
->dstFormat
);
1947 /* reset slice direction at end of frame */
1951 return c
->swScale(c
, src2
, srcStride2
, c
->srcH
-srcSliceY
-srcSliceH
, srcSliceH
, dst2
, dstStride2
);
1955 #if LIBSWSCALE_VERSION_MAJOR < 1
1956 int sws_scale_ordered(SwsContext
*c
, const uint8_t* const src
[], int srcStride
[], int srcSliceY
,
1957 int srcSliceH
, uint8_t* dst
[], int dstStride
[])
1959 return sws_scale(c
, src
, srcStride
, srcSliceY
, srcSliceH
, dst
, dstStride
);
1963 /* Convert the palette to the same packed 32-bit format as the palette */
1964 void sws_convertPalette8ToPacked32(const uint8_t *src
, uint8_t *dst
, long num_pixels
, const uint8_t *palette
)
1968 for (i
=0; i
<num_pixels
; i
++)
1969 ((uint32_t *) dst
)[i
] = ((const uint32_t *) palette
)[src
[i
]];
1972 /* Palette format: ABCD -> dst format: ABC */
1973 void sws_convertPalette8ToPacked24(const uint8_t *src
, uint8_t *dst
, long num_pixels
, const uint8_t *palette
)
1977 for (i
=0; i
<num_pixels
; i
++) {
1979 dst
[0]= palette
[src
[i
]*4+0];
1980 dst
[1]= palette
[src
[i
]*4+1];
1981 dst
[2]= palette
[src
[i
]*4+2];