2 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
4 * This file is part of Libav.
6 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #include "swscale_internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/cpu.h"
32 #include "libavutil/avutil.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/bswap.h"
35 #include "libavutil/pixdesc.h"
37 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_1
)[8][8] = {
38 { 0, 1, 0, 1, 0, 1, 0, 1,},
39 { 1, 0, 1, 0, 1, 0, 1, 0,},
40 { 0, 1, 0, 1, 0, 1, 0, 1,},
41 { 1, 0, 1, 0, 1, 0, 1, 0,},
42 { 0, 1, 0, 1, 0, 1, 0, 1,},
43 { 1, 0, 1, 0, 1, 0, 1, 0,},
44 { 0, 1, 0, 1, 0, 1, 0, 1,},
45 { 1, 0, 1, 0, 1, 0, 1, 0,},
47 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_3
)[8][8] = {
48 { 1, 2, 1, 2, 1, 2, 1, 2,},
49 { 3, 0, 3, 0, 3, 0, 3, 0,},
50 { 1, 2, 1, 2, 1, 2, 1, 2,},
51 { 3, 0, 3, 0, 3, 0, 3, 0,},
52 { 1, 2, 1, 2, 1, 2, 1, 2,},
53 { 3, 0, 3, 0, 3, 0, 3, 0,},
54 { 1, 2, 1, 2, 1, 2, 1, 2,},
55 { 3, 0, 3, 0, 3, 0, 3, 0,},
57 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_64
)[8][8] = {
58 { 18, 34, 30, 46, 17, 33, 29, 45,},
59 { 50, 2, 62, 14, 49, 1, 61, 13,},
60 { 26, 42, 22, 38, 25, 41, 21, 37,},
61 { 58, 10, 54, 6, 57, 9, 53, 5,},
62 { 16, 32, 28, 44, 19, 35, 31, 47,},
63 { 48, 0, 60, 12, 51, 3, 63, 15,},
64 { 24, 40, 20, 36, 27, 43, 23, 39,},
65 { 56, 8, 52, 4, 59, 11, 55, 7,},
67 extern const uint8_t dither_8x8_128
[8][8];
68 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_256
)[8][8] = {
69 { 72, 136, 120, 184, 68, 132, 116, 180,},
70 { 200, 8, 248, 56, 196, 4, 244, 52,},
71 { 104, 168, 88, 152, 100, 164, 84, 148,},
72 { 232, 40, 216, 24, 228, 36, 212, 20,},
73 { 64, 128, 102, 176, 76, 140, 124, 188,},
74 { 192, 0, 240, 48, 204, 12, 252, 60,},
75 { 96, 160, 80, 144, 108, 172, 92, 156,},
76 { 224, 32, 208, 16, 236, 44, 220, 28,},
79 #define RGB2YUV_SHIFT 15
80 #define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
81 #define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
82 #define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
83 #define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
84 #define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
85 #define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
86 #define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
87 #define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
88 #define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
90 static void fillPlane(uint8_t *plane
, int stride
, int width
, int height
, int y
,
94 uint8_t *ptr
= plane
+ stride
* y
;
95 for (i
= 0; i
< height
; i
++) {
96 memset(ptr
, val
, width
);
101 static void fill_plane9or10(uint8_t *plane
, int stride
, int width
,
102 int height
, int y
, uint8_t val
,
103 const int dst_depth
, const int big_endian
)
106 uint16_t *dst
= (uint16_t *) (plane
+ stride
* y
);
107 #define FILL8TO9_OR_10(wfunc) \
108 for (i = 0; i < height; i++) { \
109 for (j = 0; j < width; j++) { \
110 wfunc(&dst[j], (val << (dst_depth - 8)) | \
111 (val >> (16 - dst_depth))); \
116 FILL8TO9_OR_10(AV_WB16
);
118 FILL8TO9_OR_10(AV_WL16
);
122 static void copyPlane(const uint8_t *src
, int srcStride
,
123 int srcSliceY
, int srcSliceH
, int width
,
124 uint8_t *dst
, int dstStride
)
126 dst
+= dstStride
* srcSliceY
;
127 if (dstStride
== srcStride
&& srcStride
> 0) {
128 memcpy(dst
, src
, srcSliceH
* dstStride
);
131 for (i
= 0; i
< srcSliceH
; i
++) {
132 memcpy(dst
, src
, width
);
139 static int planarToNv12Wrapper(SwsContext
*c
, const uint8_t *src
[],
140 int srcStride
[], int srcSliceY
,
141 int srcSliceH
, uint8_t *dstParam
[],
144 uint8_t *dst
= dstParam
[1] + dstStride
[1] * srcSliceY
/ 2;
146 copyPlane(src
[0], srcStride
[0], srcSliceY
, srcSliceH
, c
->srcW
,
147 dstParam
[0], dstStride
[0]);
149 if (c
->dstFormat
== AV_PIX_FMT_NV12
)
150 interleaveBytes(src
[1], src
[2], dst
, c
->srcW
/ 2, srcSliceH
/ 2,
151 srcStride
[1], srcStride
[2], dstStride
[0]);
153 interleaveBytes(src
[2], src
[1], dst
, c
->srcW
/ 2, srcSliceH
/ 2,
154 srcStride
[2], srcStride
[1], dstStride
[0]);
159 static int planarToYuy2Wrapper(SwsContext
*c
, const uint8_t *src
[],
160 int srcStride
[], int srcSliceY
, int srcSliceH
,
161 uint8_t *dstParam
[], int dstStride
[])
163 uint8_t *dst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
165 yv12toyuy2(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0],
166 srcStride
[1], dstStride
[0]);
171 static int planarToUyvyWrapper(SwsContext
*c
, const uint8_t *src
[],
172 int srcStride
[], int srcSliceY
, int srcSliceH
,
173 uint8_t *dstParam
[], int dstStride
[])
175 uint8_t *dst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
177 yv12touyvy(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0],
178 srcStride
[1], dstStride
[0]);
183 static int yuv422pToYuy2Wrapper(SwsContext
*c
, const uint8_t *src
[],
184 int srcStride
[], int srcSliceY
, int srcSliceH
,
185 uint8_t *dstParam
[], int dstStride
[])
187 uint8_t *dst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
189 yuv422ptoyuy2(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0],
190 srcStride
[1], dstStride
[0]);
195 static int yuv422pToUyvyWrapper(SwsContext
*c
, const uint8_t *src
[],
196 int srcStride
[], int srcSliceY
, int srcSliceH
,
197 uint8_t *dstParam
[], int dstStride
[])
199 uint8_t *dst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
201 yuv422ptouyvy(src
[0], src
[1], src
[2], dst
, c
->srcW
, srcSliceH
, srcStride
[0],
202 srcStride
[1], dstStride
[0]);
207 static int yuyvToYuv420Wrapper(SwsContext
*c
, const uint8_t *src
[],
208 int srcStride
[], int srcSliceY
, int srcSliceH
,
209 uint8_t *dstParam
[], int dstStride
[])
211 uint8_t *ydst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
212 uint8_t *udst
= dstParam
[1] + dstStride
[1] * srcSliceY
/ 2;
213 uint8_t *vdst
= dstParam
[2] + dstStride
[2] * srcSliceY
/ 2;
215 yuyvtoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0],
216 dstStride
[1], srcStride
[0]);
219 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
224 static int yuyvToYuv422Wrapper(SwsContext
*c
, const uint8_t *src
[],
225 int srcStride
[], int srcSliceY
, int srcSliceH
,
226 uint8_t *dstParam
[], int dstStride
[])
228 uint8_t *ydst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
229 uint8_t *udst
= dstParam
[1] + dstStride
[1] * srcSliceY
;
230 uint8_t *vdst
= dstParam
[2] + dstStride
[2] * srcSliceY
;
232 yuyvtoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0],
233 dstStride
[1], srcStride
[0]);
238 static int uyvyToYuv420Wrapper(SwsContext
*c
, const uint8_t *src
[],
239 int srcStride
[], int srcSliceY
, int srcSliceH
,
240 uint8_t *dstParam
[], int dstStride
[])
242 uint8_t *ydst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
243 uint8_t *udst
= dstParam
[1] + dstStride
[1] * srcSliceY
/ 2;
244 uint8_t *vdst
= dstParam
[2] + dstStride
[2] * srcSliceY
/ 2;
246 uyvytoyuv420(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0],
247 dstStride
[1], srcStride
[0]);
250 fillPlane(dstParam
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
255 static int uyvyToYuv422Wrapper(SwsContext
*c
, const uint8_t *src
[],
256 int srcStride
[], int srcSliceY
, int srcSliceH
,
257 uint8_t *dstParam
[], int dstStride
[])
259 uint8_t *ydst
= dstParam
[0] + dstStride
[0] * srcSliceY
;
260 uint8_t *udst
= dstParam
[1] + dstStride
[1] * srcSliceY
;
261 uint8_t *vdst
= dstParam
[2] + dstStride
[2] * srcSliceY
;
263 uyvytoyuv422(ydst
, udst
, vdst
, src
[0], c
->srcW
, srcSliceH
, dstStride
[0],
264 dstStride
[1], srcStride
[0]);
269 static void gray8aToPacked32(const uint8_t *src
, uint8_t *dst
, int num_pixels
,
270 const uint8_t *palette
)
273 for (i
= 0; i
< num_pixels
; i
++)
274 ((uint32_t *) dst
)[i
] = ((const uint32_t *) palette
)[src
[i
<< 1]] | (src
[(i
<< 1) + 1] << 24);
277 static void gray8aToPacked32_1(const uint8_t *src
, uint8_t *dst
, int num_pixels
,
278 const uint8_t *palette
)
282 for (i
= 0; i
< num_pixels
; i
++)
283 ((uint32_t *) dst
)[i
] = ((const uint32_t *) palette
)[src
[i
<< 1]] | src
[(i
<< 1) + 1];
286 static void gray8aToPacked24(const uint8_t *src
, uint8_t *dst
, int num_pixels
,
287 const uint8_t *palette
)
291 for (i
= 0; i
< num_pixels
; i
++) {
293 dst
[0] = palette
[src
[i
<< 1] * 4 + 0];
294 dst
[1] = palette
[src
[i
<< 1] * 4 + 1];
295 dst
[2] = palette
[src
[i
<< 1] * 4 + 2];
300 static int packed_16bpc_bswap(SwsContext
*c
, const uint8_t *src
[],
301 int srcStride
[], int srcSliceY
, int srcSliceH
,
302 uint8_t *dst
[], int dstStride
[])
305 int srcstr
= srcStride
[0] >> 1;
306 int dststr
= dstStride
[0] >> 1;
307 uint16_t *dstPtr
= (uint16_t *) dst
[0];
308 const uint16_t *srcPtr
= (const uint16_t *) src
[0];
309 int min_stride
= FFMIN(srcstr
, dststr
);
311 for (i
= 0; i
< srcSliceH
; i
++) {
312 for (j
= 0; j
< min_stride
; j
++) {
313 dstPtr
[j
] = av_bswap16(srcPtr
[j
]);
322 static int palToRgbWrapper(SwsContext
*c
, const uint8_t *src
[], int srcStride
[],
323 int srcSliceY
, int srcSliceH
, uint8_t *dst
[],
326 const enum AVPixelFormat srcFormat
= c
->srcFormat
;
327 const enum AVPixelFormat dstFormat
= c
->dstFormat
;
328 void (*conv
)(const uint8_t *src
, uint8_t *dst
, int num_pixels
,
329 const uint8_t *palette
) = NULL
;
331 uint8_t *dstPtr
= dst
[0] + dstStride
[0] * srcSliceY
;
332 const uint8_t *srcPtr
= src
[0];
334 if (srcFormat
== AV_PIX_FMT_Y400A
) {
336 case AV_PIX_FMT_RGB32
: conv
= gray8aToPacked32
; break;
337 case AV_PIX_FMT_BGR32
: conv
= gray8aToPacked32
; break;
338 case AV_PIX_FMT_BGR32_1
: conv
= gray8aToPacked32_1
; break;
339 case AV_PIX_FMT_RGB32_1
: conv
= gray8aToPacked32_1
; break;
340 case AV_PIX_FMT_RGB24
: conv
= gray8aToPacked24
; break;
341 case AV_PIX_FMT_BGR24
: conv
= gray8aToPacked24
; break;
343 } else if (usePal(srcFormat
)) {
345 case AV_PIX_FMT_RGB32
: conv
= sws_convertPalette8ToPacked32
; break;
346 case AV_PIX_FMT_BGR32
: conv
= sws_convertPalette8ToPacked32
; break;
347 case AV_PIX_FMT_BGR32_1
: conv
= sws_convertPalette8ToPacked32
; break;
348 case AV_PIX_FMT_RGB32_1
: conv
= sws_convertPalette8ToPacked32
; break;
349 case AV_PIX_FMT_RGB24
: conv
= sws_convertPalette8ToPacked24
; break;
350 case AV_PIX_FMT_BGR24
: conv
= sws_convertPalette8ToPacked24
; break;
355 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
356 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
358 for (i
= 0; i
< srcSliceH
; i
++) {
359 conv(srcPtr
, dstPtr
, c
->srcW
, (uint8_t *) c
->pal_rgb
);
360 srcPtr
+= srcStride
[0];
361 dstPtr
+= dstStride
[0];
368 static void gbr24ptopacked24(const uint8_t *src
[], int srcStride
[],
369 uint8_t *dst
, int dstStride
, int srcSliceH
,
373 for (h
= 0; h
< srcSliceH
; h
++) {
374 uint8_t *dest
= dst
+ dstStride
* h
;
375 for (x
= 0; x
< width
; x
++) {
381 for (i
= 0; i
< 3; i
++)
382 src
[i
] += srcStride
[i
];
386 static void gbr24ptopacked32(const uint8_t *src
[], int srcStride
[],
387 uint8_t *dst
, int dstStride
, int srcSliceH
,
388 int alpha_first
, int width
)
391 for (h
= 0; h
< srcSliceH
; h
++) {
392 uint8_t *dest
= dst
+ dstStride
* h
;
395 for (x
= 0; x
< width
; x
++) {
402 for (x
= 0; x
< width
; x
++) {
410 for (i
= 0; i
< 3; i
++)
411 src
[i
] += srcStride
[i
];
415 static int planarRgbToRgbWrapper(SwsContext
*c
, const uint8_t *src
[],
416 int srcStride
[], int srcSliceY
, int srcSliceH
,
417 uint8_t *dst
[], int dstStride
[])
420 const uint8_t *src102
[] = { src
[1], src
[0], src
[2] };
421 const uint8_t *src201
[] = { src
[2], src
[0], src
[1] };
422 int stride102
[] = { srcStride
[1], srcStride
[0], srcStride
[2] };
423 int stride201
[] = { srcStride
[2], srcStride
[0], srcStride
[1] };
425 if (c
->srcFormat
!= AV_PIX_FMT_GBRP
) {
426 av_log(c
, AV_LOG_ERROR
, "unsupported planar RGB conversion %s -> %s\n",
427 av_get_pix_fmt_name(c
->srcFormat
),
428 av_get_pix_fmt_name(c
->dstFormat
));
432 switch (c
->dstFormat
) {
433 case AV_PIX_FMT_BGR24
:
434 gbr24ptopacked24(src102
, stride102
,
435 dst
[0] + srcSliceY
* dstStride
[0], dstStride
[0],
439 case AV_PIX_FMT_RGB24
:
440 gbr24ptopacked24(src201
, stride201
,
441 dst
[0] + srcSliceY
* dstStride
[0], dstStride
[0],
445 case AV_PIX_FMT_ARGB
:
447 case AV_PIX_FMT_RGBA
:
448 gbr24ptopacked32(src201
, stride201
,
449 dst
[0] + srcSliceY
* dstStride
[0], dstStride
[0],
450 srcSliceH
, alpha_first
, c
->srcW
);
453 case AV_PIX_FMT_ABGR
:
455 case AV_PIX_FMT_BGRA
:
456 gbr24ptopacked32(src102
, stride102
,
457 dst
[0] + srcSliceY
* dstStride
[0], dstStride
[0],
458 srcSliceH
, alpha_first
, c
->srcW
);
462 av_log(c
, AV_LOG_ERROR
,
463 "unsupported planar RGB conversion %s -> %s\n",
464 av_get_pix_fmt_name(c
->srcFormat
),
465 av_get_pix_fmt_name(c
->dstFormat
));
471 static void packedtogbr24p(const uint8_t *src
, int srcStride
,
472 uint8_t *dst
[], int dstStride
[], int srcSliceH
,
473 int alpha_first
, int inc_size
, int width
)
485 for (h
= 0; h
< srcSliceH
; h
++) {
486 for (x
= 0; x
< width
; x
++) {
493 src
+= srcStride
- width
* inc_size
;
494 dest
[0] += dstStride
[0];
495 dest
[1] += dstStride
[1];
496 dest
[2] += dstStride
[2];
500 static int rgbToPlanarRgbWrapper(SwsContext
*c
, const uint8_t *src
[],
501 int srcStride
[], int srcSliceY
, int srcSliceH
,
502 uint8_t *dst
[], int dstStride
[])
505 int stride102
[] = { dstStride
[1], dstStride
[0], dstStride
[2] };
506 int stride201
[] = { dstStride
[2], dstStride
[0], dstStride
[1] };
507 uint8_t *dst102
[] = { dst
[1] + srcSliceY
* dstStride
[1],
508 dst
[0] + srcSliceY
* dstStride
[0],
509 dst
[2] + srcSliceY
* dstStride
[2] };
510 uint8_t *dst201
[] = { dst
[2] + srcSliceY
* dstStride
[2],
511 dst
[0] + srcSliceY
* dstStride
[0],
512 dst
[1] + srcSliceY
* dstStride
[1] };
514 switch (c
->srcFormat
) {
516 packedtogbr24p((const uint8_t *) src
[0], srcStride
[0], dst201
,
517 stride201
, srcSliceH
, alpha_first
, 3, c
->srcW
);
520 packedtogbr24p((const uint8_t *) src
[0], srcStride
[0], dst102
,
521 stride102
, srcSliceH
, alpha_first
, 3, c
->srcW
);
526 packedtogbr24p((const uint8_t *) src
[0], srcStride
[0], dst201
,
527 stride201
, srcSliceH
, alpha_first
, 4, c
->srcW
);
532 packedtogbr24p((const uint8_t *) src
[0], srcStride
[0], dst102
,
533 stride102
, srcSliceH
, alpha_first
, 4, c
->srcW
);
536 av_log(c
, AV_LOG_ERROR
,
537 "unsupported planar RGB conversion %s -> %s\n",
538 av_get_pix_fmt_name(c
->srcFormat
),
539 av_get_pix_fmt_name(c
->dstFormat
));
545 #define isRGBA32(x) ( \
546 (x) == AV_PIX_FMT_ARGB \
547 || (x) == AV_PIX_FMT_RGBA \
548 || (x) == AV_PIX_FMT_BGRA \
549 || (x) == AV_PIX_FMT_ABGR \
552 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
553 typedef void (* rgbConvFn
) (const uint8_t *, uint8_t *, int);
554 static rgbConvFn
findRgbConvFn(SwsContext
*c
)
556 const enum AVPixelFormat srcFormat
= c
->srcFormat
;
557 const enum AVPixelFormat dstFormat
= c
->dstFormat
;
558 const int srcId
= c
->srcFormatBpp
;
559 const int dstId
= c
->dstFormatBpp
;
560 rgbConvFn conv
= NULL
;
561 const AVPixFmtDescriptor
*desc_src
= av_pix_fmt_desc_get(srcFormat
);
562 const AVPixFmtDescriptor
*desc_dst
= av_pix_fmt_desc_get(dstFormat
);
564 #define IS_NOT_NE(bpp, desc) \
565 (((bpp + 7) >> 3) == 2 && \
566 (!(desc->flags & PIX_FMT_BE) != !HAVE_BIGENDIAN))
568 /* if this is non-native rgb444/555/565, don't handle it here. */
569 if (IS_NOT_NE(srcId
, desc_src
) || IS_NOT_NE(dstId
, desc_dst
))
572 #define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
574 if (isRGBA32(srcFormat
) && isRGBA32(dstFormat
)) {
575 if ( CONV_IS(ABGR
, RGBA
)
576 || CONV_IS(ARGB
, BGRA
)
577 || CONV_IS(BGRA
, ARGB
)
578 || CONV_IS(RGBA
, ABGR
)) conv
= shuffle_bytes_3210
;
579 else if (CONV_IS(ABGR
, ARGB
)
580 || CONV_IS(ARGB
, ABGR
)) conv
= shuffle_bytes_0321
;
581 else if (CONV_IS(ABGR
, BGRA
)
582 || CONV_IS(ARGB
, RGBA
)) conv
= shuffle_bytes_1230
;
583 else if (CONV_IS(BGRA
, RGBA
)
584 || CONV_IS(RGBA
, BGRA
)) conv
= shuffle_bytes_2103
;
585 else if (CONV_IS(BGRA
, ABGR
)
586 || CONV_IS(RGBA
, ARGB
)) conv
= shuffle_bytes_3012
;
589 if ((isBGRinInt(srcFormat
) && isBGRinInt(dstFormat
)) ||
590 (isRGBinInt(srcFormat
) && isRGBinInt(dstFormat
))) {
591 switch (srcId
| (dstId
<< 16)) {
592 case 0x000F000C: conv
= rgb12to15
; break;
593 case 0x000F0010: conv
= rgb16to15
; break;
594 case 0x000F0018: conv
= rgb24to15
; break;
595 case 0x000F0020: conv
= rgb32to15
; break;
596 case 0x0010000F: conv
= rgb15to16
; break;
597 case 0x00100018: conv
= rgb24to16
; break;
598 case 0x00100020: conv
= rgb32to16
; break;
599 case 0x0018000F: conv
= rgb15to24
; break;
600 case 0x00180010: conv
= rgb16to24
; break;
601 case 0x00180020: conv
= rgb32to24
; break;
602 case 0x0020000F: conv
= rgb15to32
; break;
603 case 0x00200010: conv
= rgb16to32
; break;
604 case 0x00200018: conv
= rgb24to32
; break;
606 } else if ((isBGRinInt(srcFormat
) && isRGBinInt(dstFormat
)) ||
607 (isRGBinInt(srcFormat
) && isBGRinInt(dstFormat
))) {
608 switch (srcId
| (dstId
<< 16)) {
609 case 0x000C000C: conv
= rgb12tobgr12
; break;
610 case 0x000F000F: conv
= rgb15tobgr15
; break;
611 case 0x000F0010: conv
= rgb16tobgr15
; break;
612 case 0x000F0018: conv
= rgb24tobgr15
; break;
613 case 0x000F0020: conv
= rgb32tobgr15
; break;
614 case 0x0010000F: conv
= rgb15tobgr16
; break;
615 case 0x00100010: conv
= rgb16tobgr16
; break;
616 case 0x00100018: conv
= rgb24tobgr16
; break;
617 case 0x00100020: conv
= rgb32tobgr16
; break;
618 case 0x0018000F: conv
= rgb15tobgr24
; break;
619 case 0x00180010: conv
= rgb16tobgr24
; break;
620 case 0x00180018: conv
= rgb24tobgr24
; break;
621 case 0x00180020: conv
= rgb32tobgr24
; break;
622 case 0x0020000F: conv
= rgb15tobgr32
; break;
623 case 0x00200010: conv
= rgb16tobgr32
; break;
624 case 0x00200018: conv
= rgb24tobgr32
; break;
631 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
632 static int rgbToRgbWrapper(SwsContext
*c
, const uint8_t *src
[], int srcStride
[],
633 int srcSliceY
, int srcSliceH
, uint8_t *dst
[],
637 const enum AVPixelFormat srcFormat
= c
->srcFormat
;
638 const enum AVPixelFormat dstFormat
= c
->dstFormat
;
639 const int srcBpp
= (c
->srcFormatBpp
+ 7) >> 3;
640 const int dstBpp
= (c
->dstFormatBpp
+ 7) >> 3;
641 rgbConvFn conv
= findRgbConvFn(c
);
644 av_log(c
, AV_LOG_ERROR
, "internal error %s -> %s converter\n",
645 sws_format_name(srcFormat
), sws_format_name(dstFormat
));
647 const uint8_t *srcPtr
= src
[0];
648 uint8_t *dstPtr
= dst
[0];
649 if ((srcFormat
== AV_PIX_FMT_RGB32_1
|| srcFormat
== AV_PIX_FMT_BGR32_1
) &&
650 !isRGBA32(dstFormat
))
651 srcPtr
+= ALT32_CORR
;
653 if ((dstFormat
== AV_PIX_FMT_RGB32_1
|| dstFormat
== AV_PIX_FMT_BGR32_1
) &&
654 !isRGBA32(srcFormat
))
655 dstPtr
+= ALT32_CORR
;
657 if (dstStride
[0] * srcBpp
== srcStride
[0] * dstBpp
&& srcStride
[0] > 0 &&
658 !(srcStride
[0] % srcBpp
))
659 conv(srcPtr
, dstPtr
+ dstStride
[0] * srcSliceY
,
660 srcSliceH
* srcStride
[0]);
663 dstPtr
+= dstStride
[0] * srcSliceY
;
665 for (i
= 0; i
< srcSliceH
; i
++) {
666 conv(srcPtr
, dstPtr
, c
->srcW
* srcBpp
);
667 srcPtr
+= srcStride
[0];
668 dstPtr
+= dstStride
[0];
675 static int bgr24ToYv12Wrapper(SwsContext
*c
, const uint8_t *src
[],
676 int srcStride
[], int srcSliceY
, int srcSliceH
,
677 uint8_t *dst
[], int dstStride
[])
681 dst
[0] + srcSliceY
* dstStride
[0],
682 dst
[1] + (srcSliceY
>> 1) * dstStride
[1],
683 dst
[2] + (srcSliceY
>> 1) * dstStride
[2],
685 dstStride
[0], dstStride
[1], srcStride
[0]);
687 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
691 static int yvu9ToYv12Wrapper(SwsContext
*c
, const uint8_t *src
[],
692 int srcStride
[], int srcSliceY
, int srcSliceH
,
693 uint8_t *dst
[], int dstStride
[])
695 copyPlane(src
[0], srcStride
[0], srcSliceY
, srcSliceH
, c
->srcW
,
696 dst
[0], dstStride
[0]);
698 planar2x(src
[1], dst
[1] + dstStride
[1] * (srcSliceY
>> 1), c
->chrSrcW
,
699 srcSliceH
>> 2, srcStride
[1], dstStride
[1]);
700 planar2x(src
[2], dst
[2] + dstStride
[2] * (srcSliceY
>> 1), c
->chrSrcW
,
701 srcSliceH
>> 2, srcStride
[2], dstStride
[2]);
703 fillPlane(dst
[3], dstStride
[3], c
->srcW
, srcSliceH
, srcSliceY
, 255);
707 /* unscaled copy like stuff (assumes nearly identical formats) */
708 static int packedCopyWrapper(SwsContext
*c
, const uint8_t *src
[],
709 int srcStride
[], int srcSliceY
, int srcSliceH
,
710 uint8_t *dst
[], int dstStride
[])
712 if (dstStride
[0] == srcStride
[0] && srcStride
[0] > 0)
713 memcpy(dst
[0] + dstStride
[0] * srcSliceY
, src
[0], srcSliceH
* dstStride
[0]);
716 const uint8_t *srcPtr
= src
[0];
717 uint8_t *dstPtr
= dst
[0] + dstStride
[0] * srcSliceY
;
720 /* universal length finder */
721 while (length
+ c
->srcW
<= FFABS(dstStride
[0]) &&
722 length
+ c
->srcW
<= FFABS(srcStride
[0]))
726 for (i
= 0; i
< srcSliceH
; i
++) {
727 memcpy(dstPtr
, srcPtr
, length
);
728 srcPtr
+= srcStride
[0];
729 dstPtr
+= dstStride
[0];
735 #define clip9(x) av_clip_uintp2(x, 9)
736 #define clip10(x) av_clip_uintp2(x, 10)
737 #define DITHER_COPY(dst, dstStride, wfunc, src, srcStride, rfunc, dithers, shift, clip) \
738 for (i = 0; i < height; i++) { \
739 const uint8_t *dither = dithers[i & 7]; \
740 for (j = 0; j < length - 7; j += 8) { \
741 wfunc(&dst[j + 0], clip((rfunc(&src[j + 0]) + dither[0]) >> shift)); \
742 wfunc(&dst[j + 1], clip((rfunc(&src[j + 1]) + dither[1]) >> shift)); \
743 wfunc(&dst[j + 2], clip((rfunc(&src[j + 2]) + dither[2]) >> shift)); \
744 wfunc(&dst[j + 3], clip((rfunc(&src[j + 3]) + dither[3]) >> shift)); \
745 wfunc(&dst[j + 4], clip((rfunc(&src[j + 4]) + dither[4]) >> shift)); \
746 wfunc(&dst[j + 5], clip((rfunc(&src[j + 5]) + dither[5]) >> shift)); \
747 wfunc(&dst[j + 6], clip((rfunc(&src[j + 6]) + dither[6]) >> shift)); \
748 wfunc(&dst[j + 7], clip((rfunc(&src[j + 7]) + dither[7]) >> shift)); \
750 for (; j < length; j++) \
751 wfunc(&dst[j], (rfunc(&src[j]) + dither[j & 7]) >> shift); \
756 static int planarCopyWrapper(SwsContext
*c
, const uint8_t *src
[],
757 int srcStride
[], int srcSliceY
, int srcSliceH
,
758 uint8_t *dst
[], int dstStride
[])
760 const AVPixFmtDescriptor
*desc_src
= av_pix_fmt_desc_get(c
->srcFormat
);
761 const AVPixFmtDescriptor
*desc_dst
= av_pix_fmt_desc_get(c
->dstFormat
);
763 for (plane
= 0; plane
< 4; plane
++) {
764 int length
= (plane
== 0 || plane
== 3) ? c
->srcW
: -((-c
->srcW
) >> c
->chrDstHSubSample
);
765 int y
= (plane
== 0 || plane
== 3) ? srcSliceY
: -((-srcSliceY
) >> c
->chrDstVSubSample
);
766 int height
= (plane
== 0 || plane
== 3) ? srcSliceH
: -((-srcSliceH
) >> c
->chrDstVSubSample
);
767 const uint8_t *srcPtr
= src
[plane
];
768 uint8_t *dstPtr
= dst
[plane
] + dstStride
[plane
] * y
;
772 // ignore palette for GRAY8
773 if (plane
== 1 && !dst
[2]) continue;
774 if (!src
[plane
] || (plane
== 1 && !src
[2])) {
775 int val
= (plane
== 3) ? 255 : 128;
776 if (is16BPS(c
->dstFormat
))
778 if (is9_OR_10BPS(c
->dstFormat
)) {
779 fill_plane9or10(dst
[plane
], dstStride
[plane
],
780 length
, height
, y
, val
,
781 desc_dst
->comp
[plane
].depth_minus1
+ 1,
784 fillPlane(dst
[plane
], dstStride
[plane
], length
, height
, y
,
787 if (is9_OR_10BPS(c
->srcFormat
)) {
788 const int src_depth
= desc_src
->comp
[plane
].depth_minus1
+ 1;
789 const int dst_depth
= desc_dst
->comp
[plane
].depth_minus1
+ 1;
790 const uint16_t *srcPtr2
= (const uint16_t *) srcPtr
;
792 if (is16BPS(c
->dstFormat
)) {
793 uint16_t *dstPtr2
= (uint16_t *) dstPtr
;
794 #define COPY9_OR_10TO16(rfunc, wfunc) \
795 for (i = 0; i < height; i++) { \
796 for (j = 0; j < length; j++) { \
797 int srcpx = rfunc(&srcPtr2[j]); \
798 wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
800 dstPtr2 += dstStride[plane] / 2; \
801 srcPtr2 += srcStride[plane] / 2; \
803 if (isBE(c
->dstFormat
)) {
804 if (isBE(c
->srcFormat
)) {
805 COPY9_OR_10TO16(AV_RB16
, AV_WB16
);
807 COPY9_OR_10TO16(AV_RL16
, AV_WB16
);
810 if (isBE(c
->srcFormat
)) {
811 COPY9_OR_10TO16(AV_RB16
, AV_WL16
);
813 COPY9_OR_10TO16(AV_RL16
, AV_WL16
);
816 } else if (is9_OR_10BPS(c
->dstFormat
)) {
817 uint16_t *dstPtr2
= (uint16_t *) dstPtr
;
818 #define COPY9_OR_10TO9_OR_10(loop) \
819 for (i = 0; i < height; i++) { \
820 for (j = 0; j < length; j++) { \
823 dstPtr2 += dstStride[plane] / 2; \
824 srcPtr2 += srcStride[plane] / 2; \
826 #define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
827 if (dst_depth > src_depth) { \
828 COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
829 wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
830 } else if (dst_depth < src_depth) { \
831 DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
832 srcPtr2, srcStride[plane] / 2, rfunc, \
833 dither_8x8_1, 1, clip9); \
835 COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
837 if (isBE(c
->dstFormat
)) {
838 if (isBE(c
->srcFormat
)) {
839 COPY9_OR_10TO9_OR_10_2(AV_RB16
, AV_WB16
);
841 COPY9_OR_10TO9_OR_10_2(AV_RL16
, AV_WB16
);
844 if (isBE(c
->srcFormat
)) {
845 COPY9_OR_10TO9_OR_10_2(AV_RB16
, AV_WL16
);
847 COPY9_OR_10TO9_OR_10_2(AV_RL16
, AV_WL16
);
851 #define W8(a, b) { *(a) = (b); }
852 #define COPY9_OR_10TO8(rfunc) \
853 if (src_depth == 9) { \
854 DITHER_COPY(dstPtr, dstStride[plane], W8, \
855 srcPtr2, srcStride[plane] / 2, rfunc, \
856 dither_8x8_1, 1, av_clip_uint8); \
858 DITHER_COPY(dstPtr, dstStride[plane], W8, \
859 srcPtr2, srcStride[plane] / 2, rfunc, \
860 dither_8x8_3, 2, av_clip_uint8); \
862 if (isBE(c
->srcFormat
)) {
863 COPY9_OR_10TO8(AV_RB16
);
865 COPY9_OR_10TO8(AV_RL16
);
868 } else if (is9_OR_10BPS(c
->dstFormat
)) {
869 const int dst_depth
= desc_dst
->comp
[plane
].depth_minus1
+ 1;
870 uint16_t *dstPtr2
= (uint16_t *) dstPtr
;
872 if (is16BPS(c
->srcFormat
)) {
873 const uint16_t *srcPtr2
= (const uint16_t *) srcPtr
;
874 #define COPY16TO9_OR_10(rfunc, wfunc) \
875 if (dst_depth == 9) { \
876 DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
877 srcPtr2, srcStride[plane] / 2, rfunc, \
878 dither_8x8_128, 7, clip9); \
880 DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
881 srcPtr2, srcStride[plane] / 2, rfunc, \
882 dither_8x8_64, 6, clip10); \
884 if (isBE(c
->dstFormat
)) {
885 if (isBE(c
->srcFormat
)) {
886 COPY16TO9_OR_10(AV_RB16
, AV_WB16
);
888 COPY16TO9_OR_10(AV_RL16
, AV_WB16
);
891 if (isBE(c
->srcFormat
)) {
892 COPY16TO9_OR_10(AV_RB16
, AV_WL16
);
894 COPY16TO9_OR_10(AV_RL16
, AV_WL16
);
898 #define COPY8TO9_OR_10(wfunc) \
899 for (i = 0; i < height; i++) { \
900 for (j = 0; j < length; j++) { \
901 const int srcpx = srcPtr[j]; \
902 wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
904 dstPtr2 += dstStride[plane] / 2; \
905 srcPtr += srcStride[plane]; \
907 if (isBE(c
->dstFormat
)) {
908 COPY8TO9_OR_10(AV_WB16
);
910 COPY8TO9_OR_10(AV_WL16
);
913 } else if (is16BPS(c
->srcFormat
) && !is16BPS(c
->dstFormat
)) {
914 const uint16_t *srcPtr2
= (const uint16_t *) srcPtr
;
915 #define COPY16TO8(rfunc) \
916 DITHER_COPY(dstPtr, dstStride[plane], W8, \
917 srcPtr2, srcStride[plane] / 2, rfunc, \
918 dither_8x8_256, 8, av_clip_uint8);
919 if (isBE(c
->srcFormat
)) {
924 } else if (!is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
)) {
925 for (i
= 0; i
< height
; i
++) {
926 for (j
= 0; j
< length
; j
++) {
927 dstPtr
[ j
<< 1 ] = srcPtr
[j
];
928 dstPtr
[(j
<< 1) + 1] = srcPtr
[j
];
930 srcPtr
+= srcStride
[plane
];
931 dstPtr
+= dstStride
[plane
];
933 } else if (is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
) &&
934 isBE(c
->srcFormat
) != isBE(c
->dstFormat
)) {
936 for (i
= 0; i
< height
; i
++) {
937 for (j
= 0; j
< length
; j
++)
938 ((uint16_t *) dstPtr
)[j
] = av_bswap16(((const uint16_t *) srcPtr
)[j
]);
939 srcPtr
+= srcStride
[plane
];
940 dstPtr
+= dstStride
[plane
];
942 } else if (dstStride
[plane
] == srcStride
[plane
] &&
943 srcStride
[plane
] > 0 && srcStride
[plane
] == length
) {
944 memcpy(dst
[plane
] + dstStride
[plane
] * y
, src
[plane
],
945 height
* dstStride
[plane
]);
947 if (is16BPS(c
->srcFormat
) && is16BPS(c
->dstFormat
))
949 else if (!desc_src
->comp
[0].depth_minus1
)
950 length
>>= 3; // monowhite/black
951 for (i
= 0; i
< height
; i
++) {
952 memcpy(dstPtr
, srcPtr
, length
);
953 srcPtr
+= srcStride
[plane
];
954 dstPtr
+= dstStride
[plane
];
963 #define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt) \
964 ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) || \
965 (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))
968 void ff_get_unscaled_swscale(SwsContext
*c
)
970 const enum AVPixelFormat srcFormat
= c
->srcFormat
;
971 const enum AVPixelFormat dstFormat
= c
->dstFormat
;
972 const int flags
= c
->flags
;
973 const int dstH
= c
->dstH
;
976 needsDither
= isAnyRGB(dstFormat
) &&
977 c
->dstFormatBpp
< 24 &&
978 (c
->dstFormatBpp
< c
->srcFormatBpp
|| (!isAnyRGB(srcFormat
)));
981 if ((srcFormat
== AV_PIX_FMT_YUV420P
|| srcFormat
== AV_PIX_FMT_YUVA420P
) &&
982 (dstFormat
== AV_PIX_FMT_NV12
|| dstFormat
== AV_PIX_FMT_NV21
)) {
983 c
->swScale
= planarToNv12Wrapper
;
986 if ((srcFormat
== AV_PIX_FMT_YUV420P
|| srcFormat
== AV_PIX_FMT_YUV422P
||
987 srcFormat
== AV_PIX_FMT_YUVA420P
) && isAnyRGB(dstFormat
) &&
988 !(flags
& SWS_ACCURATE_RND
) && !(dstH
& 1)) {
989 c
->swScale
= ff_yuv2rgb_get_func_ptr(c
);
992 if (srcFormat
== AV_PIX_FMT_YUV410P
&&
993 (dstFormat
== AV_PIX_FMT_YUV420P
|| dstFormat
== AV_PIX_FMT_YUVA420P
) &&
994 !(flags
& SWS_BITEXACT
)) {
995 c
->swScale
= yvu9ToYv12Wrapper
;
999 if (srcFormat
== AV_PIX_FMT_BGR24
&&
1000 (dstFormat
== AV_PIX_FMT_YUV420P
|| dstFormat
== AV_PIX_FMT_YUVA420P
) &&
1001 !(flags
& SWS_ACCURATE_RND
))
1002 c
->swScale
= bgr24ToYv12Wrapper
;
1004 /* RGB/BGR -> RGB/BGR (no dither needed forms) */
1005 if (isAnyRGB(srcFormat
) && isAnyRGB(dstFormat
) && findRgbConvFn(c
)
1006 && (!needsDither
|| (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
))))
1007 c
->swScale
= rgbToRgbWrapper
;
1009 #define isByteRGB(f) ( \
1010 f == AV_PIX_FMT_RGB32 || \
1011 f == AV_PIX_FMT_RGB32_1 || \
1012 f == AV_PIX_FMT_RGB24 || \
1013 f == AV_PIX_FMT_BGR32 || \
1014 f == AV_PIX_FMT_BGR32_1 || \
1015 f == AV_PIX_FMT_BGR24)
1017 if (srcFormat
== AV_PIX_FMT_GBRP
&& isPlanar(srcFormat
) && isByteRGB(dstFormat
))
1018 c
->swScale
= planarRgbToRgbWrapper
;
1020 if (av_pix_fmt_desc_get(srcFormat
)->comp
[0].depth_minus1
== 7 &&
1021 isPackedRGB(srcFormat
) && dstFormat
== AV_PIX_FMT_GBRP
)
1022 c
->swScale
= rgbToPlanarRgbWrapper
;
1024 /* bswap 16 bits per pixel/component packed formats */
1025 if (IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_BGR444
) ||
1026 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_BGR48
) ||
1027 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_BGR555
) ||
1028 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_BGR565
) ||
1029 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_GRAY16
) ||
1030 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_RGB444
) ||
1031 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_RGB48
) ||
1032 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_RGB555
) ||
1033 IS_DIFFERENT_ENDIANESS(srcFormat
, dstFormat
, AV_PIX_FMT_RGB565
))
1034 c
->swScale
= packed_16bpc_bswap
;
1036 if ((usePal(srcFormat
) && (
1037 dstFormat
== AV_PIX_FMT_RGB32
||
1038 dstFormat
== AV_PIX_FMT_RGB32_1
||
1039 dstFormat
== AV_PIX_FMT_RGB24
||
1040 dstFormat
== AV_PIX_FMT_BGR32
||
1041 dstFormat
== AV_PIX_FMT_BGR32_1
||
1042 dstFormat
== AV_PIX_FMT_BGR24
)))
1043 c
->swScale
= palToRgbWrapper
;
1045 if (srcFormat
== AV_PIX_FMT_YUV422P
) {
1046 if (dstFormat
== AV_PIX_FMT_YUYV422
)
1047 c
->swScale
= yuv422pToYuy2Wrapper
;
1048 else if (dstFormat
== AV_PIX_FMT_UYVY422
)
1049 c
->swScale
= yuv422pToUyvyWrapper
;
1052 /* LQ converters if -sws 0 or -sws 4*/
1053 if (c
->flags
&(SWS_FAST_BILINEAR
|SWS_POINT
)) {
1055 if (srcFormat
== AV_PIX_FMT_YUV420P
|| srcFormat
== AV_PIX_FMT_YUVA420P
) {
1056 if (dstFormat
== AV_PIX_FMT_YUYV422
)
1057 c
->swScale
= planarToYuy2Wrapper
;
1058 else if (dstFormat
== AV_PIX_FMT_UYVY422
)
1059 c
->swScale
= planarToUyvyWrapper
;
1062 if (srcFormat
== AV_PIX_FMT_YUYV422
&&
1063 (dstFormat
== AV_PIX_FMT_YUV420P
|| dstFormat
== AV_PIX_FMT_YUVA420P
))
1064 c
->swScale
= yuyvToYuv420Wrapper
;
1065 if (srcFormat
== AV_PIX_FMT_UYVY422
&&
1066 (dstFormat
== AV_PIX_FMT_YUV420P
|| dstFormat
== AV_PIX_FMT_YUVA420P
))
1067 c
->swScale
= uyvyToYuv420Wrapper
;
1068 if (srcFormat
== AV_PIX_FMT_YUYV422
&& dstFormat
== AV_PIX_FMT_YUV422P
)
1069 c
->swScale
= yuyvToYuv422Wrapper
;
1070 if (srcFormat
== AV_PIX_FMT_UYVY422
&& dstFormat
== AV_PIX_FMT_YUV422P
)
1071 c
->swScale
= uyvyToYuv422Wrapper
;
1074 if ( srcFormat
== dstFormat
||
1075 (srcFormat
== AV_PIX_FMT_YUVA420P
&& dstFormat
== AV_PIX_FMT_YUV420P
) ||
1076 (srcFormat
== AV_PIX_FMT_YUV420P
&& dstFormat
== AV_PIX_FMT_YUVA420P
) ||
1077 (isPlanarYUV(srcFormat
) && isGray(dstFormat
)) ||
1078 (isPlanarYUV(dstFormat
) && isGray(srcFormat
)) ||
1079 (isGray(dstFormat
) && isGray(srcFormat
)) ||
1080 (isPlanarYUV(srcFormat
) && isPlanarYUV(dstFormat
) &&
1081 c
->chrDstHSubSample
== c
->chrSrcHSubSample
&&
1082 c
->chrDstVSubSample
== c
->chrSrcVSubSample
&&
1083 dstFormat
!= AV_PIX_FMT_NV12
&& dstFormat
!= AV_PIX_FMT_NV21
&&
1084 srcFormat
!= AV_PIX_FMT_NV12
&& srcFormat
!= AV_PIX_FMT_NV21
))
1086 if (isPacked(c
->srcFormat
))
1087 c
->swScale
= packedCopyWrapper
;
1088 else /* Planar YUV or gray */
1089 c
->swScale
= planarCopyWrapper
;
1093 ff_bfin_get_unscaled_swscale(c
);
1095 ff_swscale_get_unscaled_altivec(c
);
1098 static void reset_ptr(const uint8_t *src
[], int format
)
1100 if (!isALPHA(format
))
1102 if (!isPlanar(format
)) {
1103 src
[3] = src
[2] = NULL
;
1105 if (!usePal(format
))
1110 static int check_image_pointers(uint8_t *data
[4], enum AVPixelFormat pix_fmt
,
1111 const int linesizes
[4])
1113 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(pix_fmt
);
1116 for (i
= 0; i
< 4; i
++) {
1117 int plane
= desc
->comp
[i
].plane
;
1118 if (!data
[plane
] || !linesizes
[plane
])
1126 * swscale wrapper, so we don't need to export the SwsContext.
1127 * Assumes planar YUV to be in YUV order instead of YVU.
1129 int attribute_align_arg
sws_scale(struct SwsContext
*c
,
1130 const uint8_t * const srcSlice
[],
1131 const int srcStride
[], int srcSliceY
,
1132 int srcSliceH
, uint8_t *const dst
[],
1133 const int dstStride
[])
1136 const uint8_t *src2
[4] = { srcSlice
[0], srcSlice
[1], srcSlice
[2], srcSlice
[3] };
1137 uint8_t *dst2
[4] = { dst
[0], dst
[1], dst
[2], dst
[3] };
1139 // do not mess up sliceDir if we have a "trailing" 0-size slice
1143 if (!check_image_pointers(srcSlice
, c
->srcFormat
, srcStride
)) {
1144 av_log(c
, AV_LOG_ERROR
, "bad src image pointers\n");
1147 if (!check_image_pointers(dst
, c
->dstFormat
, dstStride
)) {
1148 av_log(c
, AV_LOG_ERROR
, "bad dst image pointers\n");
1152 if (c
->sliceDir
== 0 && srcSliceY
!= 0 && srcSliceY
+ srcSliceH
!= c
->srcH
) {
1153 av_log(c
, AV_LOG_ERROR
, "Slices start in the middle!\n");
1156 if (c
->sliceDir
== 0) {
1157 if (srcSliceY
== 0) c
->sliceDir
= 1; else c
->sliceDir
= -1;
1160 if (usePal(c
->srcFormat
)) {
1161 for (i
= 0; i
< 256; i
++) {
1162 int p
, r
, g
, b
, y
, u
, v
;
1163 if (c
->srcFormat
== AV_PIX_FMT_PAL8
) {
1164 p
= ((const uint32_t *)(srcSlice
[1]))[i
];
1165 r
= (p
>> 16) & 0xFF;
1166 g
= (p
>> 8) & 0xFF;
1168 } else if (c
->srcFormat
== AV_PIX_FMT_RGB8
) {
1169 r
= ( i
>> 5 ) * 36;
1170 g
= ((i
>> 2) & 7) * 36;
1172 } else if (c
->srcFormat
== AV_PIX_FMT_BGR8
) {
1173 b
= ( i
>> 6 ) * 85;
1174 g
= ((i
>> 3) & 7) * 36;
1176 } else if (c
->srcFormat
== AV_PIX_FMT_RGB4_BYTE
) {
1177 r
= ( i
>> 3 ) * 255;
1178 g
= ((i
>> 1) & 3) * 85;
1180 } else if (c
->srcFormat
== AV_PIX_FMT_GRAY8
||
1181 c
->srcFormat
== AV_PIX_FMT_Y400A
) {
1184 assert(c
->srcFormat
== AV_PIX_FMT_BGR4_BYTE
);
1185 b
= ( i
>> 3 ) * 255;
1186 g
= ((i
>> 1) & 3) * 85;
1189 y
= av_clip_uint8((RY
* r
+ GY
* g
+ BY
* b
+ ( 33 << (RGB2YUV_SHIFT
- 1))) >> RGB2YUV_SHIFT
);
1190 u
= av_clip_uint8((RU
* r
+ GU
* g
+ BU
* b
+ (257 << (RGB2YUV_SHIFT
- 1))) >> RGB2YUV_SHIFT
);
1191 v
= av_clip_uint8((RV
* r
+ GV
* g
+ BV
* b
+ (257 << (RGB2YUV_SHIFT
- 1))) >> RGB2YUV_SHIFT
);
1192 c
->pal_yuv
[i
] = y
+ (u
<< 8) + (v
<< 16);
1194 switch (c
->dstFormat
) {
1195 case AV_PIX_FMT_BGR32
:
1197 case AV_PIX_FMT_RGB24
:
1199 c
->pal_rgb
[i
] = r
+ (g
<< 8) + (b
<< 16);
1201 case AV_PIX_FMT_BGR32_1
:
1203 case AV_PIX_FMT_BGR24
:
1205 c
->pal_rgb
[i
] = (r
+ (g
<< 8) + (b
<< 16)) << 8;
1207 case AV_PIX_FMT_RGB32_1
:
1209 case AV_PIX_FMT_RGB24
:
1211 c
->pal_rgb
[i
] = (b
+ (g
<< 8) + (r
<< 16)) << 8;
1213 case AV_PIX_FMT_RGB32
:
1215 case AV_PIX_FMT_BGR24
:
1218 c
->pal_rgb
[i
] = b
+ (g
<< 8) + (r
<< 16);
1223 // copy strides, so they can safely be modified
1224 if (c
->sliceDir
== 1) {
1225 // slices go from top to bottom
1226 int srcStride2
[4] = { srcStride
[0], srcStride
[1], srcStride
[2],
1228 int dstStride2
[4] = { dstStride
[0], dstStride
[1], dstStride
[2],
1231 reset_ptr(src2
, c
->srcFormat
);
1232 reset_ptr((const uint8_t **) dst2
, c
->dstFormat
);
1234 /* reset slice direction at end of frame */
1235 if (srcSliceY
+ srcSliceH
== c
->srcH
)
1238 return c
->swScale(c
, src2
, srcStride2
, srcSliceY
, srcSliceH
, dst2
,
1241 // slices go from bottom to top => we flip the image internally
1242 int srcStride2
[4] = { -srcStride
[0], -srcStride
[1], -srcStride
[2],
1244 int dstStride2
[4] = { -dstStride
[0], -dstStride
[1], -dstStride
[2],
1247 src2
[0] += (srcSliceH
- 1) * srcStride
[0];
1248 if (!usePal(c
->srcFormat
))
1249 src2
[1] += ((srcSliceH
>> c
->chrSrcVSubSample
) - 1) * srcStride
[1];
1250 src2
[2] += ((srcSliceH
>> c
->chrSrcVSubSample
) - 1) * srcStride
[2];
1251 src2
[3] += (srcSliceH
- 1) * srcStride
[3];
1252 dst2
[0] += ( c
->dstH
- 1) * dstStride
[0];
1253 dst2
[1] += ((c
->dstH
>> c
->chrDstVSubSample
) - 1) * dstStride
[1];
1254 dst2
[2] += ((c
->dstH
>> c
->chrDstVSubSample
) - 1) * dstStride
[2];
1255 dst2
[3] += ( c
->dstH
- 1) * dstStride
[3];
1257 reset_ptr(src2
, c
->srcFormat
);
1258 reset_ptr((const uint8_t **) dst2
, c
->dstFormat
);
1260 /* reset slice direction at end of frame */
1264 return c
->swScale(c
, src2
, srcStride2
, c
->srcH
-srcSliceY
-srcSliceH
,
1265 srcSliceH
, dst2
, dstStride2
);
1269 /* Convert the palette to the same packed 32-bit format as the palette */
1270 void sws_convertPalette8ToPacked32(const uint8_t *src
, uint8_t *dst
,
1271 int num_pixels
, const uint8_t *palette
)
1275 for (i
= 0; i
< num_pixels
; i
++)
1276 ((uint32_t *) dst
)[i
] = ((const uint32_t *) palette
)[src
[i
]];
1279 /* Palette format: ABCD -> dst format: ABC */
1280 void sws_convertPalette8ToPacked24(const uint8_t *src
, uint8_t *dst
,
1281 int num_pixels
, const uint8_t *palette
)
1285 for (i
= 0; i
< num_pixels
; i
++) {
1287 dst
[0] = palette
[src
[i
] * 4 + 0];
1288 dst
[1] = palette
[src
[i
] * 4 + 1];
1289 dst
[2] = palette
[src
[i
] * 4 + 2];