swscale_unscaled.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of Libav.
5  *
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.
10  *
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.
15  *
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
19  */
20 
21 #include <inttypes.h>
22 #include <string.h>
23 #include <math.h>
24 #include <stdio.h>
25 #include "config.h"
26 #include <assert.h>
27 #include "swscale.h"
28 #include "swscale_internal.h"
29 #include "rgb2rgb.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"
36 
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,},
46 };
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,},
56 };
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,},
66 };
67 extern const uint8_t dither_8x8_128[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,},
77 };
78 
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))
89 
90 static void fillPlane(uint8_t *plane, int stride, int width, int height, int y,
91  uint8_t val)
92 {
93  int i;
94  uint8_t *ptr = plane + stride * y;
95  for (i = 0; i < height; i++) {
96  memset(ptr, val, width);
97  ptr += stride;
98  }
99 }
100 
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)
104 {
105  int i, j;
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))); \
112  } \
113  dst += stride / 2; \
114  }
115  if (big_endian) {
117  } else {
119  }
120 }
121 
122 static void copyPlane(const uint8_t *src, int srcStride,
123  int srcSliceY, int srcSliceH, int width,
124  uint8_t *dst, int dstStride)
125 {
126  dst += dstStride * srcSliceY;
127  if (dstStride == srcStride && srcStride > 0) {
128  memcpy(dst, src, srcSliceH * dstStride);
129  } else {
130  int i;
131  for (i = 0; i < srcSliceH; i++) {
132  memcpy(dst, src, width);
133  src += srcStride;
134  dst += dstStride;
135  }
136  }
137 }
138 
139 static int planarToNv12Wrapper(SwsContext *c, const uint8_t *src[],
140  int srcStride[], int srcSliceY,
141  int srcSliceH, uint8_t *dstParam[],
142  int dstStride[])
143 {
144  uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY / 2;
145 
146  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
147  dstParam[0], dstStride[0]);
148 
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]);
152  else
153  interleaveBytes(src[2], src[1], dst, c->srcW / 2, srcSliceH / 2,
154  srcStride[2], srcStride[1], dstStride[0]);
155 
156  return srcSliceH;
157 }
158 
159 static int planarToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
160  int srcStride[], int srcSliceY, int srcSliceH,
161  uint8_t *dstParam[], int dstStride[])
162 {
163  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
164 
165  yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
166  srcStride[1], dstStride[0]);
167 
168  return srcSliceH;
169 }
170 
171 static int planarToUyvyWrapper(SwsContext *c, const uint8_t *src[],
172  int srcStride[], int srcSliceY, int srcSliceH,
173  uint8_t *dstParam[], int dstStride[])
174 {
175  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
176 
177  yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
178  srcStride[1], dstStride[0]);
179 
180  return srcSliceH;
181 }
182 
183 static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
184  int srcStride[], int srcSliceY, int srcSliceH,
185  uint8_t *dstParam[], int dstStride[])
186 {
187  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
188 
189  yuv422ptoyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
190  srcStride[1], dstStride[0]);
191 
192  return srcSliceH;
193 }
194 
195 static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t *src[],
196  int srcStride[], int srcSliceY, int srcSliceH,
197  uint8_t *dstParam[], int dstStride[])
198 {
199  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
200 
201  yuv422ptouyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
202  srcStride[1], dstStride[0]);
203 
204  return srcSliceH;
205 }
206 
207 static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
208  int srcStride[], int srcSliceY, int srcSliceH,
209  uint8_t *dstParam[], int dstStride[])
210 {
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;
214 
215  yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
216  dstStride[1], srcStride[0]);
217 
218  if (dstParam[3])
219  fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
220 
221  return srcSliceH;
222 }
223 
224 static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
225  int srcStride[], int srcSliceY, int srcSliceH,
226  uint8_t *dstParam[], int dstStride[])
227 {
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;
231 
232  yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
233  dstStride[1], srcStride[0]);
234 
235  return srcSliceH;
236 }
237 
238 static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
239  int srcStride[], int srcSliceY, int srcSliceH,
240  uint8_t *dstParam[], int dstStride[])
241 {
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;
245 
246  uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
247  dstStride[1], srcStride[0]);
248 
249  if (dstParam[3])
250  fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
251 
252  return srcSliceH;
253 }
254 
255 static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
256  int srcStride[], int srcSliceY, int srcSliceH,
257  uint8_t *dstParam[], int dstStride[])
258 {
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;
262 
263  uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
264  dstStride[1], srcStride[0]);
265 
266  return srcSliceH;
267 }
268 
269 static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels,
270  const uint8_t *palette)
271 {
272  int i;
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);
275 }
276 
277 static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels,
278  const uint8_t *palette)
279 {
280  int i;
281 
282  for (i = 0; i < num_pixels; i++)
283  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | src[(i << 1) + 1];
284 }
285 
286 static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels,
287  const uint8_t *palette)
288 {
289  int i;
290 
291  for (i = 0; i < num_pixels; i++) {
292  //FIXME slow?
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];
296  dst += 3;
297  }
298 }
299 
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[])
303 {
304  int i, j;
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);
310 
311  for (i = 0; i < srcSliceH; i++) {
312  for (j = 0; j < min_stride; j++) {
313  dstPtr[j] = av_bswap16(srcPtr[j]);
314  }
315  srcPtr += srcstr;
316  dstPtr += dststr;
317  }
318 
319  return srcSliceH;
320 }
321 
322 static int palToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
323  int srcSliceY, int srcSliceH, uint8_t *dst[],
324  int dstStride[])
325 {
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;
330  int i;
331  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
332  const uint8_t *srcPtr = src[0];
333 
334  if (srcFormat == AV_PIX_FMT_Y400A) {
335  switch (dstFormat) {
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;
342  }
343  } else if (usePal(srcFormat)) {
344  switch (dstFormat) {
345  case AV_PIX_FMT_RGB32 : conv = sws_convertPalette8ToPacked32; break;
346  case AV_PIX_FMT_BGR32 : conv = sws_convertPalette8ToPacked32; break;
349  case AV_PIX_FMT_RGB24 : conv = sws_convertPalette8ToPacked24; break;
350  case AV_PIX_FMT_BGR24 : conv = sws_convertPalette8ToPacked24; break;
351  }
352  }
353 
354  if (!conv)
355  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
356  sws_format_name(srcFormat), sws_format_name(dstFormat));
357  else {
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];
362  }
363  }
364 
365  return srcSliceH;
366 }
367 
368 static void gbr24ptopacked24(const uint8_t *src[], int srcStride[],
369  uint8_t *dst, int dstStride, int srcSliceH,
370  int width)
371 {
372  int x, h, i;
373  for (h = 0; h < srcSliceH; h++) {
374  uint8_t *dest = dst + dstStride * h;
375  for (x = 0; x < width; x++) {
376  *dest++ = src[0][x];
377  *dest++ = src[1][x];
378  *dest++ = src[2][x];
379  }
380 
381  for (i = 0; i < 3; i++)
382  src[i] += srcStride[i];
383  }
384 }
385 
386 static void gbr24ptopacked32(const uint8_t *src[], int srcStride[],
387  uint8_t *dst, int dstStride, int srcSliceH,
388  int alpha_first, int width)
389 {
390  int x, h, i;
391  for (h = 0; h < srcSliceH; h++) {
392  uint8_t *dest = dst + dstStride * h;
393 
394  if (alpha_first) {
395  for (x = 0; x < width; x++) {
396  *dest++ = 0xff;
397  *dest++ = src[0][x];
398  *dest++ = src[1][x];
399  *dest++ = src[2][x];
400  }
401  } else {
402  for (x = 0; x < width; x++) {
403  *dest++ = src[0][x];
404  *dest++ = src[1][x];
405  *dest++ = src[2][x];
406  *dest++ = 0xff;
407  }
408  }
409 
410  for (i = 0; i < 3; i++)
411  src[i] += srcStride[i];
412  }
413 }
414 
415 static int planarRgbToRgbWrapper(SwsContext *c, const uint8_t *src[],
416  int srcStride[], int srcSliceY, int srcSliceH,
417  uint8_t *dst[], int dstStride[])
418 {
419  int alpha_first = 0;
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] };
424 
425  if (c->srcFormat != AV_PIX_FMT_GBRP) {
426  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
429  return srcSliceH;
430  }
431 
432  switch (c->dstFormat) {
433  case AV_PIX_FMT_BGR24:
434  gbr24ptopacked24(src102, stride102,
435  dst[0] + srcSliceY * dstStride[0], dstStride[0],
436  srcSliceH, c->srcW);
437  break;
438 
439  case AV_PIX_FMT_RGB24:
440  gbr24ptopacked24(src201, stride201,
441  dst[0] + srcSliceY * dstStride[0], dstStride[0],
442  srcSliceH, c->srcW);
443  break;
444 
445  case AV_PIX_FMT_ARGB:
446  alpha_first = 1;
447  case AV_PIX_FMT_RGBA:
448  gbr24ptopacked32(src201, stride201,
449  dst[0] + srcSliceY * dstStride[0], dstStride[0],
450  srcSliceH, alpha_first, c->srcW);
451  break;
452 
453  case AV_PIX_FMT_ABGR:
454  alpha_first = 1;
455  case AV_PIX_FMT_BGRA:
456  gbr24ptopacked32(src102, stride102,
457  dst[0] + srcSliceY * dstStride[0], dstStride[0],
458  srcSliceH, alpha_first, c->srcW);
459  break;
460 
461  default:
462  av_log(c, AV_LOG_ERROR,
463  "unsupported planar RGB conversion %s -> %s\n",
466  }
467 
468  return srcSliceH;
469 }
470 
471 #define isRGBA32(x) ( \
472  (x) == AV_PIX_FMT_ARGB \
473  || (x) == AV_PIX_FMT_RGBA \
474  || (x) == AV_PIX_FMT_BGRA \
475  || (x) == AV_PIX_FMT_ABGR \
476  )
477 
478 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
479 typedef void (* rgbConvFn) (const uint8_t *, uint8_t *, int);
481 {
482  const enum AVPixelFormat srcFormat = c->srcFormat;
483  const enum AVPixelFormat dstFormat = c->dstFormat;
484  const int srcId = c->srcFormatBpp;
485  const int dstId = c->dstFormatBpp;
486  rgbConvFn conv = NULL;
487  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(srcFormat);
488  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(dstFormat);
489 
490 #define IS_NOT_NE(bpp, desc) \
491  (((bpp + 7) >> 3) == 2 && \
492  (!(desc->flags & PIX_FMT_BE) != !HAVE_BIGENDIAN))
493 
494  /* if this is non-native rgb444/555/565, don't handle it here. */
495  if (IS_NOT_NE(srcId, desc_src) || IS_NOT_NE(dstId, desc_dst))
496  return NULL;
497 
498 #define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
499 
500  if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
501  if ( CONV_IS(ABGR, RGBA)
502  || CONV_IS(ARGB, BGRA)
503  || CONV_IS(BGRA, ARGB)
504  || CONV_IS(RGBA, ABGR)) conv = shuffle_bytes_3210;
505  else if (CONV_IS(ABGR, ARGB)
506  || CONV_IS(ARGB, ABGR)) conv = shuffle_bytes_0321;
507  else if (CONV_IS(ABGR, BGRA)
508  || CONV_IS(ARGB, RGBA)) conv = shuffle_bytes_1230;
509  else if (CONV_IS(BGRA, RGBA)
510  || CONV_IS(RGBA, BGRA)) conv = shuffle_bytes_2103;
511  else if (CONV_IS(BGRA, ABGR)
512  || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
513  } else
514  /* BGR -> BGR */
515  if ((isBGRinInt(srcFormat) && isBGRinInt(dstFormat)) ||
516  (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
517  switch (srcId | (dstId << 16)) {
518  case 0x000F000C: conv = rgb12to15; break;
519  case 0x000F0010: conv = rgb16to15; break;
520  case 0x000F0018: conv = rgb24to15; break;
521  case 0x000F0020: conv = rgb32to15; break;
522  case 0x0010000F: conv = rgb15to16; break;
523  case 0x00100018: conv = rgb24to16; break;
524  case 0x00100020: conv = rgb32to16; break;
525  case 0x0018000F: conv = rgb15to24; break;
526  case 0x00180010: conv = rgb16to24; break;
527  case 0x00180020: conv = rgb32to24; break;
528  case 0x0020000F: conv = rgb15to32; break;
529  case 0x00200010: conv = rgb16to32; break;
530  case 0x00200018: conv = rgb24to32; break;
531  }
532  } else if ((isBGRinInt(srcFormat) && isRGBinInt(dstFormat)) ||
533  (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
534  switch (srcId | (dstId << 16)) {
535  case 0x000C000C: conv = rgb12tobgr12; break;
536  case 0x000F000F: conv = rgb15tobgr15; break;
537  case 0x000F0010: conv = rgb16tobgr15; break;
538  case 0x000F0018: conv = rgb24tobgr15; break;
539  case 0x000F0020: conv = rgb32tobgr15; break;
540  case 0x0010000F: conv = rgb15tobgr16; break;
541  case 0x00100010: conv = rgb16tobgr16; break;
542  case 0x00100018: conv = rgb24tobgr16; break;
543  case 0x00100020: conv = rgb32tobgr16; break;
544  case 0x0018000F: conv = rgb15tobgr24; break;
545  case 0x00180010: conv = rgb16tobgr24; break;
546  case 0x00180018: conv = rgb24tobgr24; break;
547  case 0x00180020: conv = rgb32tobgr24; break;
548  case 0x0020000F: conv = rgb15tobgr32; break;
549  case 0x00200010: conv = rgb16tobgr32; break;
550  case 0x00200018: conv = rgb24tobgr32; break;
551  }
552  }
553 
554  return conv;
555 }
556 
557 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
558 static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
559  int srcSliceY, int srcSliceH, uint8_t *dst[],
560  int dstStride[])
561 
562 {
563  const enum AVPixelFormat srcFormat = c->srcFormat;
564  const enum AVPixelFormat dstFormat = c->dstFormat;
565  const int srcBpp = (c->srcFormatBpp + 7) >> 3;
566  const int dstBpp = (c->dstFormatBpp + 7) >> 3;
567  rgbConvFn conv = findRgbConvFn(c);
568 
569  if (!conv) {
570  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
571  sws_format_name(srcFormat), sws_format_name(dstFormat));
572  } else {
573  const uint8_t *srcPtr = src[0];
574  uint8_t *dstPtr = dst[0];
575  if ((srcFormat == AV_PIX_FMT_RGB32_1 || srcFormat == AV_PIX_FMT_BGR32_1) &&
576  !isRGBA32(dstFormat))
577  srcPtr += ALT32_CORR;
578 
579  if ((dstFormat == AV_PIX_FMT_RGB32_1 || dstFormat == AV_PIX_FMT_BGR32_1) &&
580  !isRGBA32(srcFormat))
581  dstPtr += ALT32_CORR;
582 
583  if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
584  !(srcStride[0] % srcBpp))
585  conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
586  srcSliceH * srcStride[0]);
587  else {
588  int i;
589  dstPtr += dstStride[0] * srcSliceY;
590 
591  for (i = 0; i < srcSliceH; i++) {
592  conv(srcPtr, dstPtr, c->srcW * srcBpp);
593  srcPtr += srcStride[0];
594  dstPtr += dstStride[0];
595  }
596  }
597  }
598  return srcSliceH;
599 }
600 
601 static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
602  int srcStride[], int srcSliceY, int srcSliceH,
603  uint8_t *dst[], int dstStride[])
604 {
605  rgb24toyv12(
606  src[0],
607  dst[0] + srcSliceY * dstStride[0],
608  dst[1] + (srcSliceY >> 1) * dstStride[1],
609  dst[2] + (srcSliceY >> 1) * dstStride[2],
610  c->srcW, srcSliceH,
611  dstStride[0], dstStride[1], srcStride[0]);
612  if (dst[3])
613  fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
614  return srcSliceH;
615 }
616 
617 static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
618  int srcStride[], int srcSliceY, int srcSliceH,
619  uint8_t *dst[], int dstStride[])
620 {
621  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
622  dst[0], dstStride[0]);
623 
624  planar2x(src[1], dst[1] + dstStride[1] * (srcSliceY >> 1), c->chrSrcW,
625  srcSliceH >> 2, srcStride[1], dstStride[1]);
626  planar2x(src[2], dst[2] + dstStride[2] * (srcSliceY >> 1), c->chrSrcW,
627  srcSliceH >> 2, srcStride[2], dstStride[2]);
628  if (dst[3])
629  fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
630  return srcSliceH;
631 }
632 
633 /* unscaled copy like stuff (assumes nearly identical formats) */
634 static int packedCopyWrapper(SwsContext *c, const uint8_t *src[],
635  int srcStride[], int srcSliceY, int srcSliceH,
636  uint8_t *dst[], int dstStride[])
637 {
638  if (dstStride[0] == srcStride[0] && srcStride[0] > 0)
639  memcpy(dst[0] + dstStride[0] * srcSliceY, src[0], srcSliceH * dstStride[0]);
640  else {
641  int i;
642  const uint8_t *srcPtr = src[0];
643  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
644  int length = 0;
645 
646  /* universal length finder */
647  while (length + c->srcW <= FFABS(dstStride[0]) &&
648  length + c->srcW <= FFABS(srcStride[0]))
649  length += c->srcW;
650  assert(length != 0);
651 
652  for (i = 0; i < srcSliceH; i++) {
653  memcpy(dstPtr, srcPtr, length);
654  srcPtr += srcStride[0];
655  dstPtr += dstStride[0];
656  }
657  }
658  return srcSliceH;
659 }
660 
661 #define clip9(x) av_clip_uintp2(x, 9)
662 #define clip10(x) av_clip_uintp2(x, 10)
663 #define DITHER_COPY(dst, dstStride, wfunc, src, srcStride, rfunc, dithers, shift, clip) \
664  for (i = 0; i < height; i++) { \
665  const uint8_t *dither = dithers[i & 7]; \
666  for (j = 0; j < length - 7; j += 8) { \
667  wfunc(&dst[j + 0], clip((rfunc(&src[j + 0]) + dither[0]) >> shift)); \
668  wfunc(&dst[j + 1], clip((rfunc(&src[j + 1]) + dither[1]) >> shift)); \
669  wfunc(&dst[j + 2], clip((rfunc(&src[j + 2]) + dither[2]) >> shift)); \
670  wfunc(&dst[j + 3], clip((rfunc(&src[j + 3]) + dither[3]) >> shift)); \
671  wfunc(&dst[j + 4], clip((rfunc(&src[j + 4]) + dither[4]) >> shift)); \
672  wfunc(&dst[j + 5], clip((rfunc(&src[j + 5]) + dither[5]) >> shift)); \
673  wfunc(&dst[j + 6], clip((rfunc(&src[j + 6]) + dither[6]) >> shift)); \
674  wfunc(&dst[j + 7], clip((rfunc(&src[j + 7]) + dither[7]) >> shift)); \
675  } \
676  for (; j < length; j++) \
677  wfunc(&dst[j], (rfunc(&src[j]) + dither[j & 7]) >> shift); \
678  dst += dstStride; \
679  src += srcStride; \
680  }
681 
682 static int planarCopyWrapper(SwsContext *c, const uint8_t *src[],
683  int srcStride[], int srcSliceY, int srcSliceH,
684  uint8_t *dst[], int dstStride[])
685 {
686  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat);
687  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat);
688  int plane, i, j;
689  for (plane = 0; plane < 4; plane++) {
690  int length = (plane == 0 || plane == 3) ? c->srcW : -((-c->srcW ) >> c->chrDstHSubSample);
691  int y = (plane == 0 || plane == 3) ? srcSliceY: -((-srcSliceY) >> c->chrDstVSubSample);
692  int height = (plane == 0 || plane == 3) ? srcSliceH: -((-srcSliceH) >> c->chrDstVSubSample);
693  const uint8_t *srcPtr = src[plane];
694  uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
695 
696  if (!dst[plane])
697  continue;
698  // ignore palette for GRAY8
699  if (plane == 1 && !dst[2]) continue;
700  if (!src[plane] || (plane == 1 && !src[2])) {
701  int val = (plane == 3) ? 255 : 128;
702  if (is16BPS(c->dstFormat))
703  length *= 2;
704  if (is9_OR_10BPS(c->dstFormat)) {
705  fill_plane9or10(dst[plane], dstStride[plane],
706  length, height, y, val,
707  desc_dst->comp[plane].depth_minus1 + 1,
708  isBE(c->dstFormat));
709  } else
710  fillPlane(dst[plane], dstStride[plane], length, height, y,
711  val);
712  } else {
713  if (is9_OR_10BPS(c->srcFormat)) {
714  const int src_depth = desc_src->comp[plane].depth_minus1 + 1;
715  const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
716  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
717 
718  if (is16BPS(c->dstFormat)) {
719  uint16_t *dstPtr2 = (uint16_t *) dstPtr;
720 #define COPY9_OR_10TO16(rfunc, wfunc) \
721  for (i = 0; i < height; i++) { \
722  for (j = 0; j < length; j++) { \
723  int srcpx = rfunc(&srcPtr2[j]); \
724  wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
725  } \
726  dstPtr2 += dstStride[plane] / 2; \
727  srcPtr2 += srcStride[plane] / 2; \
728  }
729  if (isBE(c->dstFormat)) {
730  if (isBE(c->srcFormat)) {
732  } else {
734  }
735  } else {
736  if (isBE(c->srcFormat)) {
738  } else {
740  }
741  }
742  } else if (is9_OR_10BPS(c->dstFormat)) {
743  uint16_t *dstPtr2 = (uint16_t *) dstPtr;
744 #define COPY9_OR_10TO9_OR_10(loop) \
745  for (i = 0; i < height; i++) { \
746  for (j = 0; j < length; j++) { \
747  loop; \
748  } \
749  dstPtr2 += dstStride[plane] / 2; \
750  srcPtr2 += srcStride[plane] / 2; \
751  }
752 #define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
753  if (dst_depth > src_depth) { \
754  COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
755  wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
756  } else if (dst_depth < src_depth) { \
757  DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
758  srcPtr2, srcStride[plane] / 2, rfunc, \
759  dither_8x8_1, 1, clip9); \
760  } else { \
761  COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
762  }
763  if (isBE(c->dstFormat)) {
764  if (isBE(c->srcFormat)) {
766  } else {
768  }
769  } else {
770  if (isBE(c->srcFormat)) {
772  } else {
774  }
775  }
776  } else {
777 #define W8(a, b) { *(a) = (b); }
778 #define COPY9_OR_10TO8(rfunc) \
779  if (src_depth == 9) { \
780  DITHER_COPY(dstPtr, dstStride[plane], W8, \
781  srcPtr2, srcStride[plane] / 2, rfunc, \
782  dither_8x8_1, 1, av_clip_uint8); \
783  } else { \
784  DITHER_COPY(dstPtr, dstStride[plane], W8, \
785  srcPtr2, srcStride[plane] / 2, rfunc, \
786  dither_8x8_3, 2, av_clip_uint8); \
787  }
788  if (isBE(c->srcFormat)) {
790  } else {
792  }
793  }
794  } else if (is9_OR_10BPS(c->dstFormat)) {
795  const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
796  uint16_t *dstPtr2 = (uint16_t *) dstPtr;
797 
798  if (is16BPS(c->srcFormat)) {
799  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
800 #define COPY16TO9_OR_10(rfunc, wfunc) \
801  if (dst_depth == 9) { \
802  DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
803  srcPtr2, srcStride[plane] / 2, rfunc, \
804  dither_8x8_128, 7, clip9); \
805  } else { \
806  DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
807  srcPtr2, srcStride[plane] / 2, rfunc, \
808  dither_8x8_64, 6, clip10); \
809  }
810  if (isBE(c->dstFormat)) {
811  if (isBE(c->srcFormat)) {
813  } else {
815  }
816  } else {
817  if (isBE(c->srcFormat)) {
819  } else {
821  }
822  }
823  } else /* 8bit */ {
824 #define COPY8TO9_OR_10(wfunc) \
825  for (i = 0; i < height; i++) { \
826  for (j = 0; j < length; j++) { \
827  const int srcpx = srcPtr[j]; \
828  wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
829  } \
830  dstPtr2 += dstStride[plane] / 2; \
831  srcPtr += srcStride[plane]; \
832  }
833  if (isBE(c->dstFormat)) {
835  } else {
837  }
838  }
839  } else if (is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
840  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
841 #define COPY16TO8(rfunc) \
842  DITHER_COPY(dstPtr, dstStride[plane], W8, \
843  srcPtr2, srcStride[plane] / 2, rfunc, \
844  dither_8x8_256, 8, av_clip_uint8);
845  if (isBE(c->srcFormat)) {
847  } else {
849  }
850  } else if (!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
851  for (i = 0; i < height; i++) {
852  for (j = 0; j < length; j++) {
853  dstPtr[ j << 1 ] = srcPtr[j];
854  dstPtr[(j << 1) + 1] = srcPtr[j];
855  }
856  srcPtr += srcStride[plane];
857  dstPtr += dstStride[plane];
858  }
859  } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
860  isBE(c->srcFormat) != isBE(c->dstFormat)) {
861 
862  for (i = 0; i < height; i++) {
863  for (j = 0; j < length; j++)
864  ((uint16_t *) dstPtr)[j] = av_bswap16(((const uint16_t *) srcPtr)[j]);
865  srcPtr += srcStride[plane];
866  dstPtr += dstStride[plane];
867  }
868  } else if (dstStride[plane] == srcStride[plane] &&
869  srcStride[plane] > 0 && srcStride[plane] == length) {
870  memcpy(dst[plane] + dstStride[plane] * y, src[plane],
871  height * dstStride[plane]);
872  } else {
873  if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
874  length *= 2;
875  else if (!desc_src->comp[0].depth_minus1)
876  length >>= 3; // monowhite/black
877  for (i = 0; i < height; i++) {
878  memcpy(dstPtr, srcPtr, length);
879  srcPtr += srcStride[plane];
880  dstPtr += dstStride[plane];
881  }
882  }
883  }
884  }
885  return srcSliceH;
886 }
887 
888 
889 #define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt) \
890  ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) || \
891  (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))
892 
893 
895 {
896  const enum AVPixelFormat srcFormat = c->srcFormat;
897  const enum AVPixelFormat dstFormat = c->dstFormat;
898  const int flags = c->flags;
899  const int dstH = c->dstH;
900  int needsDither;
901 
902  needsDither = isAnyRGB(dstFormat) &&
903  c->dstFormatBpp < 24 &&
904  (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
905 
906  /* yv12_to_nv12 */
907  if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) &&
908  (dstFormat == AV_PIX_FMT_NV12 || dstFormat == AV_PIX_FMT_NV21)) {
910  }
911  /* yuv2bgr */
912  if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUV422P ||
913  srcFormat == AV_PIX_FMT_YUVA420P) && isAnyRGB(dstFormat) &&
914  !(flags & SWS_ACCURATE_RND) && !(dstH & 1)) {
916  }
917 
918  if (srcFormat == AV_PIX_FMT_YUV410P &&
919  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
920  !(flags & SWS_BITEXACT)) {
922  }
923 
924  /* bgr24toYV12 */
925  if (srcFormat == AV_PIX_FMT_BGR24 &&
926  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
927  !(flags & SWS_ACCURATE_RND))
929 
930  /* RGB/BGR -> RGB/BGR (no dither needed forms) */
931  if (isAnyRGB(srcFormat) && isAnyRGB(dstFormat) && findRgbConvFn(c)
932  && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
934 
935  if (isPlanarRGB(srcFormat) && isPackedRGB(dstFormat))
937 
938  /* bswap 16 bits per pixel/component packed formats */
939  if (IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR444) ||
940  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR48) ||
941  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR555) ||
942  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR565) ||
943  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY16) ||
944  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB444) ||
945  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB48) ||
946  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB555) ||
947  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB565))
949 
950  if ((usePal(srcFormat) && (
951  dstFormat == AV_PIX_FMT_RGB32 ||
952  dstFormat == AV_PIX_FMT_RGB32_1 ||
953  dstFormat == AV_PIX_FMT_RGB24 ||
954  dstFormat == AV_PIX_FMT_BGR32 ||
955  dstFormat == AV_PIX_FMT_BGR32_1 ||
956  dstFormat == AV_PIX_FMT_BGR24)))
958 
959  if (srcFormat == AV_PIX_FMT_YUV422P) {
960  if (dstFormat == AV_PIX_FMT_YUYV422)
962  else if (dstFormat == AV_PIX_FMT_UYVY422)
964  }
965 
966  /* LQ converters if -sws 0 or -sws 4*/
967  if (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)) {
968  /* yv12_to_yuy2 */
969  if (srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) {
970  if (dstFormat == AV_PIX_FMT_YUYV422)
972  else if (dstFormat == AV_PIX_FMT_UYVY422)
974  }
975  }
976  if (srcFormat == AV_PIX_FMT_YUYV422 &&
977  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
979  if (srcFormat == AV_PIX_FMT_UYVY422 &&
980  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
982  if (srcFormat == AV_PIX_FMT_YUYV422 && dstFormat == AV_PIX_FMT_YUV422P)
984  if (srcFormat == AV_PIX_FMT_UYVY422 && dstFormat == AV_PIX_FMT_YUV422P)
986 
987  /* simple copy */
988  if ( srcFormat == dstFormat ||
989  (srcFormat == AV_PIX_FMT_YUVA420P && dstFormat == AV_PIX_FMT_YUV420P) ||
990  (srcFormat == AV_PIX_FMT_YUV420P && dstFormat == AV_PIX_FMT_YUVA420P) ||
991  (isPlanarYUV(srcFormat) && isGray(dstFormat)) ||
992  (isPlanarYUV(dstFormat) && isGray(srcFormat)) ||
993  (isGray(dstFormat) && isGray(srcFormat)) ||
994  (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat) &&
997  dstFormat != AV_PIX_FMT_NV12 && dstFormat != AV_PIX_FMT_NV21 &&
998  srcFormat != AV_PIX_FMT_NV12 && srcFormat != AV_PIX_FMT_NV21))
999  {
1000  if (isPacked(c->srcFormat))
1002  else /* Planar YUV or gray */
1004  }
1005 
1006  if (ARCH_BFIN)
1008  if (HAVE_ALTIVEC)
1010 }
1011 
1012 static void reset_ptr(const uint8_t *src[], int format)
1013 {
1014  if (!isALPHA(format))
1015  src[3] = NULL;
1016  if (!isPlanar(format)) {
1017  src[3] = src[2] = NULL;
1018 
1019  if (!usePal(format))
1020  src[1] = NULL;
1021  }
1022 }
1023 
1025  const int linesizes[4])
1026 {
1027  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
1028  int i;
1029 
1030  for (i = 0; i < 4; i++) {
1031  int plane = desc->comp[i].plane;
1032  if (!data[plane] || !linesizes[plane])
1033  return 0;
1034  }
1035 
1036  return 1;
1037 }
1038 
1044  const uint8_t * const srcSlice[],
1045  const int srcStride[], int srcSliceY,
1046  int srcSliceH, uint8_t *const dst[],
1047  const int dstStride[])
1048 {
1049  int i;
1050  const uint8_t *src2[4] = { srcSlice[0], srcSlice[1], srcSlice[2], srcSlice[3] };
1051  uint8_t *dst2[4] = { dst[0], dst[1], dst[2], dst[3] };
1052 
1053  // do not mess up sliceDir if we have a "trailing" 0-size slice
1054  if (srcSliceH == 0)
1055  return 0;
1056 
1057  if (!check_image_pointers(srcSlice, c->srcFormat, srcStride)) {
1058  av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
1059  return 0;
1060  }
1061  if (!check_image_pointers(dst, c->dstFormat, dstStride)) {
1062  av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
1063  return 0;
1064  }
1065 
1066  if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
1067  av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
1068  return 0;
1069  }
1070  if (c->sliceDir == 0) {
1071  if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
1072  }
1073 
1074  if (usePal(c->srcFormat)) {
1075  for (i = 0; i < 256; i++) {
1076  int p, r, g, b, y, u, v;
1077  if (c->srcFormat == AV_PIX_FMT_PAL8) {
1078  p = ((const uint32_t *)(srcSlice[1]))[i];
1079  r = (p >> 16) & 0xFF;
1080  g = (p >> 8) & 0xFF;
1081  b = p & 0xFF;
1082  } else if (c->srcFormat == AV_PIX_FMT_RGB8) {
1083  r = ( i >> 5 ) * 36;
1084  g = ((i >> 2) & 7) * 36;
1085  b = ( i & 3) * 85;
1086  } else if (c->srcFormat == AV_PIX_FMT_BGR8) {
1087  b = ( i >> 6 ) * 85;
1088  g = ((i >> 3) & 7) * 36;
1089  r = ( i & 7) * 36;
1090  } else if (c->srcFormat == AV_PIX_FMT_RGB4_BYTE) {
1091  r = ( i >> 3 ) * 255;
1092  g = ((i >> 1) & 3) * 85;
1093  b = ( i & 1) * 255;
1094  } else if (c->srcFormat == AV_PIX_FMT_GRAY8 ||
1095  c->srcFormat == AV_PIX_FMT_Y400A) {
1096  r = g = b = i;
1097  } else {
1098  assert(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
1099  b = ( i >> 3 ) * 255;
1100  g = ((i >> 1) & 3) * 85;
1101  r = ( i & 1) * 255;
1102  }
1103  y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1104  u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1105  v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1106  c->pal_yuv[i] = y + (u << 8) + (v << 16);
1107 
1108  switch (c->dstFormat) {
1109  case AV_PIX_FMT_BGR32:
1110 #if !HAVE_BIGENDIAN
1111  case AV_PIX_FMT_RGB24:
1112 #endif
1113  c->pal_rgb[i] = r + (g << 8) + (b << 16);
1114  break;
1115  case AV_PIX_FMT_BGR32_1:
1116 #if HAVE_BIGENDIAN
1117  case AV_PIX_FMT_BGR24:
1118 #endif
1119  c->pal_rgb[i] = (r + (g << 8) + (b << 16)) << 8;
1120  break;
1121  case AV_PIX_FMT_RGB32_1:
1122 #if HAVE_BIGENDIAN
1123  case AV_PIX_FMT_RGB24:
1124 #endif
1125  c->pal_rgb[i] = (b + (g << 8) + (r << 16)) << 8;
1126  break;
1127  case AV_PIX_FMT_RGB32:
1128 #if !HAVE_BIGENDIAN
1129  case AV_PIX_FMT_BGR24:
1130 #endif
1131  default:
1132  c->pal_rgb[i] = b + (g << 8) + (r << 16);
1133  }
1134  }
1135  }
1136 
1137  // copy strides, so they can safely be modified
1138  if (c->sliceDir == 1) {
1139  // slices go from top to bottom
1140  int srcStride2[4] = { srcStride[0], srcStride[1], srcStride[2],
1141  srcStride[3] };
1142  int dstStride2[4] = { dstStride[0], dstStride[1], dstStride[2],
1143  dstStride[3] };
1144 
1145  reset_ptr(src2, c->srcFormat);
1146  reset_ptr((const uint8_t **) dst2, c->dstFormat);
1147 
1148  /* reset slice direction at end of frame */
1149  if (srcSliceY + srcSliceH == c->srcH)
1150  c->sliceDir = 0;
1151 
1152  return c->swScale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2,
1153  dstStride2);
1154  } else {
1155  // slices go from bottom to top => we flip the image internally
1156  int srcStride2[4] = { -srcStride[0], -srcStride[1], -srcStride[2],
1157  -srcStride[3] };
1158  int dstStride2[4] = { -dstStride[0], -dstStride[1], -dstStride[2],
1159  -dstStride[3] };
1160 
1161  src2[0] += (srcSliceH - 1) * srcStride[0];
1162  if (!usePal(c->srcFormat))
1163  src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
1164  src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
1165  src2[3] += (srcSliceH - 1) * srcStride[3];
1166  dst2[0] += ( c->dstH - 1) * dstStride[0];
1167  dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
1168  dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
1169  dst2[3] += ( c->dstH - 1) * dstStride[3];
1170 
1171  reset_ptr(src2, c->srcFormat);
1172  reset_ptr((const uint8_t **) dst2, c->dstFormat);
1173 
1174  /* reset slice direction at end of frame */
1175  if (!srcSliceY)
1176  c->sliceDir = 0;
1177 
1178  return c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH,
1179  srcSliceH, dst2, dstStride2);
1180  }
1181 }
1182 
1183 /* Convert the palette to the same packed 32-bit format as the palette */
1185  int num_pixels, const uint8_t *palette)
1186 {
1187  int i;
1188 
1189  for (i = 0; i < num_pixels; i++)
1190  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
1191 }
1192 
1193 /* Palette format: ABCD -> dst format: ABC */
1195  int num_pixels, const uint8_t *palette)
1196 {
1197  int i;
1198 
1199  for (i = 0; i < num_pixels; i++) {
1200  //FIXME slow?
1201  dst[0] = palette[src[i] * 4 + 0];
1202  dst[1] = palette[src[i] * 4 + 1];
1203  dst[2] = palette[src[i] * 4 + 2];
1204  dst += 3;
1205  }
1206 }