FFmpeg
swscale_unscaled.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
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.
10  *
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.
15  *
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
19  */
20 
21 #include <inttypes.h>
22 #include <string.h>
23 #include <math.h>
24 #include <stdio.h>
25 #include "config.h"
26 #include "swscale.h"
27 #include "swscale_internal.h"
28 #include "rgb2rgb.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/avutil.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/mem_internal.h"
33 #include "libavutil/bswap.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/avconfig.h"
37 
38 DECLARE_ALIGNED(8, static const uint8_t, dithers)[8][8][8]={
39 {
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  { 0, 1, 0, 1, 0, 1, 0, 1,},
47  { 1, 0, 1, 0, 1, 0, 1, 0,},
48 },{
49  { 1, 2, 1, 2, 1, 2, 1, 2,},
50  { 3, 0, 3, 0, 3, 0, 3, 0,},
51  { 1, 2, 1, 2, 1, 2, 1, 2,},
52  { 3, 0, 3, 0, 3, 0, 3, 0,},
53  { 1, 2, 1, 2, 1, 2, 1, 2,},
54  { 3, 0, 3, 0, 3, 0, 3, 0,},
55  { 1, 2, 1, 2, 1, 2, 1, 2,},
56  { 3, 0, 3, 0, 3, 0, 3, 0,},
57 },{
58  { 2, 4, 3, 5, 2, 4, 3, 5,},
59  { 6, 0, 7, 1, 6, 0, 7, 1,},
60  { 3, 5, 2, 4, 3, 5, 2, 4,},
61  { 7, 1, 6, 0, 7, 1, 6, 0,},
62  { 2, 4, 3, 5, 2, 4, 3, 5,},
63  { 6, 0, 7, 1, 6, 0, 7, 1,},
64  { 3, 5, 2, 4, 3, 5, 2, 4,},
65  { 7, 1, 6, 0, 7, 1, 6, 0,},
66 },{
67  { 4, 8, 7, 11, 4, 8, 7, 11,},
68  { 12, 0, 15, 3, 12, 0, 15, 3,},
69  { 6, 10, 5, 9, 6, 10, 5, 9,},
70  { 14, 2, 13, 1, 14, 2, 13, 1,},
71  { 4, 8, 7, 11, 4, 8, 7, 11,},
72  { 12, 0, 15, 3, 12, 0, 15, 3,},
73  { 6, 10, 5, 9, 6, 10, 5, 9,},
74  { 14, 2, 13, 1, 14, 2, 13, 1,},
75 },{
76  { 9, 17, 15, 23, 8, 16, 14, 22,},
77  { 25, 1, 31, 7, 24, 0, 30, 6,},
78  { 13, 21, 11, 19, 12, 20, 10, 18,},
79  { 29, 5, 27, 3, 28, 4, 26, 2,},
80  { 8, 16, 14, 22, 9, 17, 15, 23,},
81  { 24, 0, 30, 6, 25, 1, 31, 7,},
82  { 12, 20, 10, 18, 13, 21, 11, 19,},
83  { 28, 4, 26, 2, 29, 5, 27, 3,},
84 },{
85  { 18, 34, 30, 46, 17, 33, 29, 45,},
86  { 50, 2, 62, 14, 49, 1, 61, 13,},
87  { 26, 42, 22, 38, 25, 41, 21, 37,},
88  { 58, 10, 54, 6, 57, 9, 53, 5,},
89  { 16, 32, 28, 44, 19, 35, 31, 47,},
90  { 48, 0, 60, 12, 51, 3, 63, 15,},
91  { 24, 40, 20, 36, 27, 43, 23, 39,},
92  { 56, 8, 52, 4, 59, 11, 55, 7,},
93 },{
94  { 18, 34, 30, 46, 17, 33, 29, 45,},
95  { 50, 2, 62, 14, 49, 1, 61, 13,},
96  { 26, 42, 22, 38, 25, 41, 21, 37,},
97  { 58, 10, 54, 6, 57, 9, 53, 5,},
98  { 16, 32, 28, 44, 19, 35, 31, 47,},
99  { 48, 0, 60, 12, 51, 3, 63, 15,},
100  { 24, 40, 20, 36, 27, 43, 23, 39,},
101  { 56, 8, 52, 4, 59, 11, 55, 7,},
102 },{
103  { 36, 68, 60, 92, 34, 66, 58, 90,},
104  { 100, 4,124, 28, 98, 2,122, 26,},
105  { 52, 84, 44, 76, 50, 82, 42, 74,},
106  { 116, 20,108, 12,114, 18,106, 10,},
107  { 32, 64, 56, 88, 38, 70, 62, 94,},
108  { 96, 0,120, 24,102, 6,126, 30,},
109  { 48, 80, 40, 72, 54, 86, 46, 78,},
110  { 112, 16,104, 8,118, 22,110, 14,},
111 }};
112 
113 
114 static void fillPlane(uint8_t *plane, int stride, int width, int height, int y,
115  uint8_t val)
116 {
117  int i;
118  uint8_t *ptr = plane + stride * y;
119  for (i = 0; i < height; i++) {
120  memset(ptr, val, width);
121  ptr += stride;
122  }
123 }
124 
125 static void copyPlane(const uint8_t *src, int srcStride,
126  int srcSliceY, int srcSliceH, int width,
127  uint8_t *dst, int dstStride)
128 {
129  dst += dstStride * srcSliceY;
130  if (dstStride == srcStride && srcStride > 0) {
131  memcpy(dst, src, srcSliceH * dstStride);
132  } else {
133  int i;
134  for (i = 0; i < srcSliceH; i++) {
135  memcpy(dst, src, width);
136  src += srcStride;
137  dst += dstStride;
138  }
139  }
140 }
141 
142 static int planarToNv12Wrapper(SwsContext *c, const uint8_t *src[],
143  int srcStride[], int srcSliceY,
144  int srcSliceH, uint8_t *dstParam[],
145  int dstStride[])
146 {
147  uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY / 2;
148 
149  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
150  dstParam[0], dstStride[0]);
151 
152  if (c->dstFormat == AV_PIX_FMT_NV12)
153  interleaveBytes(src[1], src[2], dst, c->chrSrcW, (srcSliceH + 1) / 2,
154  srcStride[1], srcStride[2], dstStride[1]);
155  else
156  interleaveBytes(src[2], src[1], dst, c->chrSrcW, (srcSliceH + 1) / 2,
157  srcStride[2], srcStride[1], dstStride[1]);
158 
159  return srcSliceH;
160 }
161 
162 static int nv12ToPlanarWrapper(SwsContext *c, const uint8_t *src[],
163  int srcStride[], int srcSliceY,
164  int srcSliceH, uint8_t *dstParam[],
165  int dstStride[])
166 {
167  uint8_t *dst1 = dstParam[1] + dstStride[1] * srcSliceY / 2;
168  uint8_t *dst2 = dstParam[2] + dstStride[2] * srcSliceY / 2;
169 
170  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
171  dstParam[0], dstStride[0]);
172 
173  if (c->srcFormat == AV_PIX_FMT_NV12)
174  deinterleaveBytes(src[1], dst1, dst2, c->chrSrcW, (srcSliceH + 1) / 2,
175  srcStride[1], dstStride[1], dstStride[2]);
176  else
177  deinterleaveBytes(src[1], dst2, dst1, c->chrSrcW, (srcSliceH + 1) / 2,
178  srcStride[1], dstStride[2], dstStride[1]);
179 
180  return srcSliceH;
181 }
182 
183 static int planarToNv24Wrapper(SwsContext *c, const uint8_t *src[],
184  int srcStride[], int srcSliceY,
185  int srcSliceH, uint8_t *dstParam[],
186  int dstStride[])
187 {
188  uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY;
189 
190  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
191  dstParam[0], dstStride[0]);
192 
193  if (c->dstFormat == AV_PIX_FMT_NV24)
194  interleaveBytes(src[1], src[2], dst, c->chrSrcW, srcSliceH,
195  srcStride[1], srcStride[2], dstStride[1]);
196  else
197  interleaveBytes(src[2], src[1], dst, c->chrSrcW, srcSliceH,
198  srcStride[2], srcStride[1], dstStride[1]);
199 
200  return srcSliceH;
201 }
202 
203 static int nv24ToPlanarWrapper(SwsContext *c, const uint8_t *src[],
204  int srcStride[], int srcSliceY,
205  int srcSliceH, uint8_t *dstParam[],
206  int dstStride[])
207 {
208  uint8_t *dst1 = dstParam[1] + dstStride[1] * srcSliceY;
209  uint8_t *dst2 = dstParam[2] + dstStride[2] * srcSliceY;
210 
211  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
212  dstParam[0], dstStride[0]);
213 
214  if (c->srcFormat == AV_PIX_FMT_NV24)
215  deinterleaveBytes(src[1], dst1, dst2, c->chrSrcW, srcSliceH,
216  srcStride[1], dstStride[1], dstStride[2]);
217  else
218  deinterleaveBytes(src[1], dst2, dst1, c->chrSrcW, srcSliceH,
219  srcStride[1], dstStride[2], dstStride[1]);
220 
221  return srcSliceH;
222 }
223 
224 static int planarToP01xWrapper(SwsContext *c, const uint8_t *src8[],
225  int srcStride[], int srcSliceY,
226  int srcSliceH, uint8_t *dstParam8[],
227  int dstStride[])
228 {
229  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->srcFormat);
230  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->dstFormat);
231  const uint16_t **src = (const uint16_t**)src8;
232  uint16_t *dstY = (uint16_t*)(dstParam8[0] + dstStride[0] * srcSliceY);
233  uint16_t *dstUV = (uint16_t*)(dstParam8[1] + dstStride[1] * srcSliceY / 2);
234  int x, y;
235 
236  /* Calculate net shift required for values. */
237  const int shift[3] = {
238  dst_format->comp[0].depth + dst_format->comp[0].shift -
239  src_format->comp[0].depth - src_format->comp[0].shift,
240  dst_format->comp[1].depth + dst_format->comp[1].shift -
241  src_format->comp[1].depth - src_format->comp[1].shift,
242  dst_format->comp[2].depth + dst_format->comp[2].shift -
243  src_format->comp[2].depth - src_format->comp[2].shift,
244  };
245 
246  av_assert0(!(srcStride[0] % 2 || srcStride[1] % 2 || srcStride[2] % 2 ||
247  dstStride[0] % 2 || dstStride[1] % 2));
248 
249  for (y = 0; y < srcSliceH; y++) {
250  uint16_t *tdstY = dstY;
251  const uint16_t *tsrc0 = src[0];
252  for (x = c->srcW; x > 0; x--) {
253  *tdstY++ = *tsrc0++ << shift[0];
254  }
255  src[0] += srcStride[0] / 2;
256  dstY += dstStride[0] / 2;
257 
258  if (!(y & 1)) {
259  uint16_t *tdstUV = dstUV;
260  const uint16_t *tsrc1 = src[1];
261  const uint16_t *tsrc2 = src[2];
262  for (x = c->srcW / 2; x > 0; x--) {
263  *tdstUV++ = *tsrc1++ << shift[1];
264  *tdstUV++ = *tsrc2++ << shift[2];
265  }
266  src[1] += srcStride[1] / 2;
267  src[2] += srcStride[2] / 2;
268  dstUV += dstStride[1] / 2;
269  }
270  }
271 
272  return srcSliceH;
273 }
274 
275 #if AV_HAVE_BIGENDIAN
276 #define output_pixel(p, v) do { \
277  uint16_t *pp = (p); \
278  AV_WL16(pp, (v)); \
279  } while(0)
280 #else
281 #define output_pixel(p, v) (*p) = (v)
282 #endif
283 
284 static int planar8ToP01xleWrapper(SwsContext *c, const uint8_t *src[],
285  int srcStride[], int srcSliceY,
286  int srcSliceH, uint8_t *dstParam8[],
287  int dstStride[])
288 {
289  uint16_t *dstY = (uint16_t*)(dstParam8[0] + dstStride[0] * srcSliceY);
290  uint16_t *dstUV = (uint16_t*)(dstParam8[1] + dstStride[1] * srcSliceY / 2);
291  int x, y, t;
292 
293  av_assert0(!(dstStride[0] % 2 || dstStride[1] % 2));
294 
295  for (y = 0; y < srcSliceH; y++) {
296  uint16_t *tdstY = dstY;
297  const uint8_t *tsrc0 = src[0];
298  for (x = c->srcW; x > 0; x--) {
299  t = *tsrc0++;
300  output_pixel(tdstY++, t | (t << 8));
301  }
302  src[0] += srcStride[0];
303  dstY += dstStride[0] / 2;
304 
305  if (!(y & 1)) {
306  uint16_t *tdstUV = dstUV;
307  const uint8_t *tsrc1 = src[1];
308  const uint8_t *tsrc2 = src[2];
309  for (x = c->srcW / 2; x > 0; x--) {
310  t = *tsrc1++;
311  output_pixel(tdstUV++, t | (t << 8));
312  t = *tsrc2++;
313  output_pixel(tdstUV++, t | (t << 8));
314  }
315  src[1] += srcStride[1];
316  src[2] += srcStride[2];
317  dstUV += dstStride[1] / 2;
318  }
319  }
320 
321  return srcSliceH;
322 }
323 
324 #undef output_pixel
325 
326 static int planarToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
327  int srcStride[], int srcSliceY, int srcSliceH,
328  uint8_t *dstParam[], int dstStride[])
329 {
330  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
331 
332  yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
333  srcStride[1], dstStride[0]);
334 
335  return srcSliceH;
336 }
337 
338 static int planarToUyvyWrapper(SwsContext *c, const uint8_t *src[],
339  int srcStride[], int srcSliceY, int srcSliceH,
340  uint8_t *dstParam[], int dstStride[])
341 {
342  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
343 
344  yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
345  srcStride[1], dstStride[0]);
346 
347  return srcSliceH;
348 }
349 
350 static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
351  int srcStride[], int srcSliceY, int srcSliceH,
352  uint8_t *dstParam[], int dstStride[])
353 {
354  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
355 
356  yuv422ptoyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
357  srcStride[1], dstStride[0]);
358 
359  return srcSliceH;
360 }
361 
362 static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t *src[],
363  int srcStride[], int srcSliceY, int srcSliceH,
364  uint8_t *dstParam[], int dstStride[])
365 {
366  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
367 
368  yuv422ptouyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
369  srcStride[1], dstStride[0]);
370 
371  return srcSliceH;
372 }
373 
374 static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
375  int srcStride[], int srcSliceY, int srcSliceH,
376  uint8_t *dstParam[], int dstStride[])
377 {
378  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
379  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
380  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
381 
382  yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
383  dstStride[1], srcStride[0]);
384 
385  if (dstParam[3])
386  fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
387 
388  return srcSliceH;
389 }
390 
391 static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
392  int srcStride[], int srcSliceY, int srcSliceH,
393  uint8_t *dstParam[], int dstStride[])
394 {
395  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
396  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
397  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
398 
399  yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
400  dstStride[1], srcStride[0]);
401 
402  return srcSliceH;
403 }
404 
405 static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
406  int srcStride[], int srcSliceY, int srcSliceH,
407  uint8_t *dstParam[], int dstStride[])
408 {
409  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
410  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
411  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
412 
413  uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
414  dstStride[1], srcStride[0]);
415 
416  if (dstParam[3])
417  fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
418 
419  return srcSliceH;
420 }
421 
422 static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
423  int srcStride[], int srcSliceY, int srcSliceH,
424  uint8_t *dstParam[], int dstStride[])
425 {
426  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
427  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
428  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
429 
430  uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
431  dstStride[1], srcStride[0]);
432 
433  return srcSliceH;
434 }
435 
436 static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels,
437  const uint8_t *palette)
438 {
439  int i;
440  for (i = 0; i < num_pixels; i++)
441  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | (src[(i << 1) + 1] << 24);
442 }
443 
444 static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels,
445  const uint8_t *palette)
446 {
447  int i;
448 
449  for (i = 0; i < num_pixels; i++)
450  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | src[(i << 1) + 1];
451 }
452 
453 static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels,
454  const uint8_t *palette)
455 {
456  int i;
457 
458  for (i = 0; i < num_pixels; i++) {
459  //FIXME slow?
460  dst[0] = palette[src[i << 1] * 4 + 0];
461  dst[1] = palette[src[i << 1] * 4 + 1];
462  dst[2] = palette[src[i << 1] * 4 + 2];
463  dst += 3;
464  }
465 }
466 
467 static int bswap_16bpc(SwsContext *c, const uint8_t *src[],
468  int srcStride[], int srcSliceY, int srcSliceH,
469  uint8_t *dst[], int dstStride[])
470 {
471  int i, j, p;
472 
473  for (p = 0; p < 4; p++) {
474  int srcstr = srcStride[p] / 2;
475  int dststr = dstStride[p] / 2;
476  uint16_t *dstPtr = (uint16_t *) dst[p];
477  const uint16_t *srcPtr = (const uint16_t *) src[p];
478  int min_stride = FFMIN(FFABS(srcstr), FFABS(dststr));
479  if(!dstPtr || !srcPtr)
480  continue;
481  dstPtr += (srcSliceY >> c->chrDstVSubSample) * dststr;
482  for (i = 0; i < (srcSliceH >> c->chrDstVSubSample); i++) {
483  for (j = 0; j < min_stride; j++) {
484  dstPtr[j] = av_bswap16(srcPtr[j]);
485  }
486  srcPtr += srcstr;
487  dstPtr += dststr;
488  }
489  }
490 
491  return srcSliceH;
492 }
493 
494 static int bswap_32bpc(SwsContext *c, const uint8_t *src[],
495  int srcStride[], int srcSliceY, int srcSliceH,
496  uint8_t *dst[], int dstStride[])
497 {
498  int i, j, p;
499 
500  for (p = 0; p < 4; p++) {
501  int srcstr = srcStride[p] / 4;
502  int dststr = dstStride[p] / 4;
503  uint32_t *dstPtr = (uint32_t *) dst[p];
504  const uint32_t *srcPtr = (const uint32_t *) src[p];
505  int min_stride = FFMIN(FFABS(srcstr), FFABS(dststr));
506  if(!dstPtr || !srcPtr)
507  continue;
508  dstPtr += (srcSliceY >> c->chrDstVSubSample) * dststr;
509  for (i = 0; i < (srcSliceH >> c->chrDstVSubSample); i++) {
510  for (j = 0; j < min_stride; j++) {
511  dstPtr[j] = av_bswap32(srcPtr[j]);
512  }
513  srcPtr += srcstr;
514  dstPtr += dststr;
515  }
516  }
517 
518  return srcSliceH;
519 }
520 
521 
522 static int palToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
523  int srcSliceY, int srcSliceH, uint8_t *dst[],
524  int dstStride[])
525 {
526  const enum AVPixelFormat srcFormat = c->srcFormat;
527  const enum AVPixelFormat dstFormat = c->dstFormat;
528  void (*conv)(const uint8_t *src, uint8_t *dst, int num_pixels,
529  const uint8_t *palette) = NULL;
530  int i;
531  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
532  const uint8_t *srcPtr = src[0];
533 
534  if (srcFormat == AV_PIX_FMT_YA8) {
535  switch (dstFormat) {
536  case AV_PIX_FMT_RGB32 : conv = gray8aToPacked32; break;
537  case AV_PIX_FMT_BGR32 : conv = gray8aToPacked32; break;
540  case AV_PIX_FMT_RGB24 : conv = gray8aToPacked24; break;
541  case AV_PIX_FMT_BGR24 : conv = gray8aToPacked24; break;
542  }
543  } else if (usePal(srcFormat)) {
544  switch (dstFormat) {
551  }
552  }
553 
554  if (!conv)
555  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
557  else {
558  for (i = 0; i < srcSliceH; i++) {
559  conv(srcPtr, dstPtr, c->srcW, (uint8_t *) c->pal_rgb);
560  srcPtr += srcStride[0];
561  dstPtr += dstStride[0];
562  }
563  }
564 
565  return srcSliceH;
566 }
567 
568 static void packed16togbra16(const uint8_t *src, int srcStride,
569  uint16_t *dst[], int dstStride[], int srcSliceH,
570  int src_alpha, int swap, int shift, int width)
571 {
572  int x, h, i;
573  int dst_alpha = dst[3] != NULL;
574  for (h = 0; h < srcSliceH; h++) {
575  uint16_t *src_line = (uint16_t *)(src + srcStride * h);
576  switch (swap) {
577  case 3:
578  if (src_alpha && dst_alpha) {
579  for (x = 0; x < width; x++) {
580  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
581  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
582  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
583  dst[3][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
584  }
585  } else if (dst_alpha) {
586  for (x = 0; x < width; x++) {
587  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
588  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
589  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
590  dst[3][x] = 0xFFFF;
591  }
592  } else if (src_alpha) {
593  for (x = 0; x < width; x++) {
594  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
595  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
596  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
597  src_line++;
598  }
599  } else {
600  for (x = 0; x < width; x++) {
601  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
602  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
603  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
604  }
605  }
606  break;
607  case 2:
608  if (src_alpha && dst_alpha) {
609  for (x = 0; x < width; x++) {
610  dst[0][x] = av_bswap16(*src_line++ >> shift);
611  dst[1][x] = av_bswap16(*src_line++ >> shift);
612  dst[2][x] = av_bswap16(*src_line++ >> shift);
613  dst[3][x] = av_bswap16(*src_line++ >> shift);
614  }
615  } else if (dst_alpha) {
616  for (x = 0; x < width; x++) {
617  dst[0][x] = av_bswap16(*src_line++ >> shift);
618  dst[1][x] = av_bswap16(*src_line++ >> shift);
619  dst[2][x] = av_bswap16(*src_line++ >> shift);
620  dst[3][x] = 0xFFFF;
621  }
622  } else if (src_alpha) {
623  for (x = 0; x < width; x++) {
624  dst[0][x] = av_bswap16(*src_line++ >> shift);
625  dst[1][x] = av_bswap16(*src_line++ >> shift);
626  dst[2][x] = av_bswap16(*src_line++ >> shift);
627  src_line++;
628  }
629  } else {
630  for (x = 0; x < width; x++) {
631  dst[0][x] = av_bswap16(*src_line++ >> shift);
632  dst[1][x] = av_bswap16(*src_line++ >> shift);
633  dst[2][x] = av_bswap16(*src_line++ >> shift);
634  }
635  }
636  break;
637  case 1:
638  if (src_alpha && dst_alpha) {
639  for (x = 0; x < width; x++) {
640  dst[0][x] = av_bswap16(*src_line++) >> shift;
641  dst[1][x] = av_bswap16(*src_line++) >> shift;
642  dst[2][x] = av_bswap16(*src_line++) >> shift;
643  dst[3][x] = av_bswap16(*src_line++) >> shift;
644  }
645  } else if (dst_alpha) {
646  for (x = 0; x < width; x++) {
647  dst[0][x] = av_bswap16(*src_line++) >> shift;
648  dst[1][x] = av_bswap16(*src_line++) >> shift;
649  dst[2][x] = av_bswap16(*src_line++) >> shift;
650  dst[3][x] = 0xFFFF;
651  }
652  } else if (src_alpha) {
653  for (x = 0; x < width; x++) {
654  dst[0][x] = av_bswap16(*src_line++) >> shift;
655  dst[1][x] = av_bswap16(*src_line++) >> shift;
656  dst[2][x] = av_bswap16(*src_line++) >> shift;
657  src_line++;
658  }
659  } else {
660  for (x = 0; x < width; x++) {
661  dst[0][x] = av_bswap16(*src_line++) >> shift;
662  dst[1][x] = av_bswap16(*src_line++) >> shift;
663  dst[2][x] = av_bswap16(*src_line++) >> shift;
664  }
665  }
666  break;
667  default:
668  if (src_alpha && dst_alpha) {
669  for (x = 0; x < width; x++) {
670  dst[0][x] = *src_line++ >> shift;
671  dst[1][x] = *src_line++ >> shift;
672  dst[2][x] = *src_line++ >> shift;
673  dst[3][x] = *src_line++ >> shift;
674  }
675  } else if (dst_alpha) {
676  for (x = 0; x < width; x++) {
677  dst[0][x] = *src_line++ >> shift;
678  dst[1][x] = *src_line++ >> shift;
679  dst[2][x] = *src_line++ >> shift;
680  dst[3][x] = 0xFFFF;
681  }
682  } else if (src_alpha) {
683  for (x = 0; x < width; x++) {
684  dst[0][x] = *src_line++ >> shift;
685  dst[1][x] = *src_line++ >> shift;
686  dst[2][x] = *src_line++ >> shift;
687  src_line++;
688  }
689  } else {
690  for (x = 0; x < width; x++) {
691  dst[0][x] = *src_line++ >> shift;
692  dst[1][x] = *src_line++ >> shift;
693  dst[2][x] = *src_line++ >> shift;
694  }
695  }
696  }
697  for (i = 0; i < 4; i++)
698  dst[i] += dstStride[i] >> 1;
699  }
700 }
701 
702 static int Rgb16ToPlanarRgb16Wrapper(SwsContext *c, const uint8_t *src[],
703  int srcStride[], int srcSliceY, int srcSliceH,
704  uint8_t *dst[], int dstStride[])
705 {
706  uint16_t *dst2013[] = { (uint16_t *)dst[2], (uint16_t *)dst[0], (uint16_t *)dst[1], (uint16_t *)dst[3] };
707  uint16_t *dst1023[] = { (uint16_t *)dst[1], (uint16_t *)dst[0], (uint16_t *)dst[2], (uint16_t *)dst[3] };
708  int stride2013[] = { dstStride[2], dstStride[0], dstStride[1], dstStride[3] };
709  int stride1023[] = { dstStride[1], dstStride[0], dstStride[2], dstStride[3] };
710  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->srcFormat);
711  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->dstFormat);
712  int bpc = dst_format->comp[0].depth;
713  int alpha = src_format->flags & AV_PIX_FMT_FLAG_ALPHA;
714  int swap = 0;
715  int i;
716 
717  if ( HAVE_BIGENDIAN && !(src_format->flags & AV_PIX_FMT_FLAG_BE) ||
718  !HAVE_BIGENDIAN && src_format->flags & AV_PIX_FMT_FLAG_BE)
719  swap++;
720  if ( HAVE_BIGENDIAN && !(dst_format->flags & AV_PIX_FMT_FLAG_BE) ||
721  !HAVE_BIGENDIAN && dst_format->flags & AV_PIX_FMT_FLAG_BE)
722  swap += 2;
723 
724  if ((dst_format->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) !=
726  av_log(c, AV_LOG_ERROR, "unsupported conversion to planar RGB %s -> %s\n",
727  src_format->name, dst_format->name);
728  return srcSliceH;
729  }
730 
731  for(i=0; i<4; i++) {
732  dst2013[i] += stride2013[i] * srcSliceY / 2;
733  dst1023[i] += stride1023[i] * srcSliceY / 2;
734  }
735 
736  switch (c->srcFormat) {
737  case AV_PIX_FMT_RGB48LE:
738  case AV_PIX_FMT_RGB48BE:
739  case AV_PIX_FMT_RGBA64LE:
740  case AV_PIX_FMT_RGBA64BE:
741  packed16togbra16(src[0], srcStride[0],
742  dst2013, stride2013, srcSliceH, alpha, swap,
743  16 - bpc, c->srcW);
744  break;
745  case AV_PIX_FMT_BGR48LE:
746  case AV_PIX_FMT_BGR48BE:
747  case AV_PIX_FMT_BGRA64LE:
748  case AV_PIX_FMT_BGRA64BE:
749  packed16togbra16(src[0], srcStride[0],
750  dst1023, stride1023, srcSliceH, alpha, swap,
751  16 - bpc, c->srcW);
752  break;
753  default:
755  "unsupported conversion to planar RGB %s -> %s\n",
756  src_format->name, dst_format->name);
757  }
758 
759  return srcSliceH;
760 }
761 
762 static void gbr16ptopacked16(const uint16_t *src[], int srcStride[],
763  uint8_t *dst, int dstStride, int srcSliceH,
764  int alpha, int swap, int bpp, int width)
765 {
766  int x, h, i;
767  int src_alpha = src[3] != NULL;
768  int scale_high = 16 - bpp, scale_low = (bpp - 8) * 2;
769  for (h = 0; h < srcSliceH; h++) {
770  uint16_t *dest = (uint16_t *)(dst + dstStride * h);
771  uint16_t component;
772 
773  switch(swap) {
774  case 3:
775  if (alpha && !src_alpha) {
776  for (x = 0; x < width; x++) {
777  component = av_bswap16(src[0][x]);
778  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
779  component = av_bswap16(src[1][x]);
780  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
781  component = av_bswap16(src[2][x]);
782  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
783  *dest++ = 0xffff;
784  }
785  } else if (alpha && src_alpha) {
786  for (x = 0; x < width; x++) {
787  component = av_bswap16(src[0][x]);
788  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
789  component = av_bswap16(src[1][x]);
790  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
791  component = av_bswap16(src[2][x]);
792  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
793  component = av_bswap16(src[3][x]);
794  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
795  }
796  } else {
797  for (x = 0; x < width; x++) {
798  component = av_bswap16(src[0][x]);
799  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
800  component = av_bswap16(src[1][x]);
801  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
802  component = av_bswap16(src[2][x]);
803  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
804  }
805  }
806  break;
807  case 2:
808  if (alpha && !src_alpha) {
809  for (x = 0; x < width; x++) {
810  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
811  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
812  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
813  *dest++ = 0xffff;
814  }
815  } else if (alpha && src_alpha) {
816  for (x = 0; x < width; x++) {
817  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
818  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
819  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
820  *dest++ = av_bswap16(src[3][x] << scale_high | src[3][x] >> scale_low);
821  }
822  } else {
823  for (x = 0; x < width; x++) {
824  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
825  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
826  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
827  }
828  }
829  break;
830  case 1:
831  if (alpha && !src_alpha) {
832  for (x = 0; x < width; x++) {
833  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
834  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
835  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
836  *dest++ = 0xffff;
837  }
838  } else if (alpha && src_alpha) {
839  for (x = 0; x < width; x++) {
840  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
841  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
842  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
843  *dest++ = av_bswap16(src[3][x]) << scale_high | av_bswap16(src[3][x]) >> scale_low;
844  }
845  } else {
846  for (x = 0; x < width; x++) {
847  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
848  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
849  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
850  }
851  }
852  break;
853  default:
854  if (alpha && !src_alpha) {
855  for (x = 0; x < width; x++) {
856  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
857  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
858  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
859  *dest++ = 0xffff;
860  }
861  } else if (alpha && src_alpha) {
862  for (x = 0; x < width; x++) {
863  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
864  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
865  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
866  *dest++ = src[3][x] << scale_high | src[3][x] >> scale_low;
867  }
868  } else {
869  for (x = 0; x < width; x++) {
870  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
871  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
872  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
873  }
874  }
875  }
876  for (i = 0; i < 3 + src_alpha; i++)
877  src[i] += srcStride[i] >> 1;
878  }
879 }
880 
881 static int planarRgb16ToRgb16Wrapper(SwsContext *c, const uint8_t *src[],
882  int srcStride[], int srcSliceY, int srcSliceH,
883  uint8_t *dst[], int dstStride[])
884 {
885  const uint16_t *src102[] = { (uint16_t *)src[1], (uint16_t *)src[0], (uint16_t *)src[2], (uint16_t *)src[3] };
886  const uint16_t *src201[] = { (uint16_t *)src[2], (uint16_t *)src[0], (uint16_t *)src[1], (uint16_t *)src[3] };
887  int stride102[] = { srcStride[1], srcStride[0], srcStride[2], srcStride[3] };
888  int stride201[] = { srcStride[2], srcStride[0], srcStride[1], srcStride[3] };
889  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->srcFormat);
890  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->dstFormat);
891  int bits_per_sample = src_format->comp[0].depth;
892  int swap = 0;
893  if ( HAVE_BIGENDIAN && !(src_format->flags & AV_PIX_FMT_FLAG_BE) ||
894  !HAVE_BIGENDIAN && src_format->flags & AV_PIX_FMT_FLAG_BE)
895  swap++;
896  if ( HAVE_BIGENDIAN && !(dst_format->flags & AV_PIX_FMT_FLAG_BE) ||
897  !HAVE_BIGENDIAN && dst_format->flags & AV_PIX_FMT_FLAG_BE)
898  swap += 2;
899 
900  if ((src_format->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) !=
902  bits_per_sample <= 8) {
903  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
904  src_format->name, dst_format->name);
905  return srcSliceH;
906  }
907  switch (c->dstFormat) {
908  case AV_PIX_FMT_BGR48LE:
909  case AV_PIX_FMT_BGR48BE:
910  gbr16ptopacked16(src102, stride102,
911  dst[0] + srcSliceY * dstStride[0], dstStride[0],
912  srcSliceH, 0, swap, bits_per_sample, c->srcW);
913  break;
914  case AV_PIX_FMT_RGB48LE:
915  case AV_PIX_FMT_RGB48BE:
916  gbr16ptopacked16(src201, stride201,
917  dst[0] + srcSliceY * dstStride[0], dstStride[0],
918  srcSliceH, 0, swap, bits_per_sample, c->srcW);
919  break;
920  case AV_PIX_FMT_RGBA64LE:
921  case AV_PIX_FMT_RGBA64BE:
922  gbr16ptopacked16(src201, stride201,
923  dst[0] + srcSliceY * dstStride[0], dstStride[0],
924  srcSliceH, 1, swap, bits_per_sample, c->srcW);
925  break;
926  case AV_PIX_FMT_BGRA64LE:
927  case AV_PIX_FMT_BGRA64BE:
928  gbr16ptopacked16(src102, stride102,
929  dst[0] + srcSliceY * dstStride[0], dstStride[0],
930  srcSliceH, 1, swap, bits_per_sample, c->srcW);
931  break;
932  default:
934  "unsupported planar RGB conversion %s -> %s\n",
935  src_format->name, dst_format->name);
936  }
937 
938  return srcSliceH;
939 }
940 
941 static void gbr24ptopacked24(const uint8_t *src[], int srcStride[],
942  uint8_t *dst, int dstStride, int srcSliceH,
943  int width)
944 {
945  int x, h, i;
946  for (h = 0; h < srcSliceH; h++) {
947  uint8_t *dest = dst + dstStride * h;
948  for (x = 0; x < width; x++) {
949  *dest++ = src[0][x];
950  *dest++ = src[1][x];
951  *dest++ = src[2][x];
952  }
953 
954  for (i = 0; i < 3; i++)
955  src[i] += srcStride[i];
956  }
957 }
958 
959 static void gbr24ptopacked32(const uint8_t *src[], int srcStride[],
960  uint8_t *dst, int dstStride, int srcSliceH,
961  int alpha_first, int width)
962 {
963  int x, h, i;
964  for (h = 0; h < srcSliceH; h++) {
965  uint8_t *dest = dst + dstStride * h;
966 
967  if (alpha_first) {
968  for (x = 0; x < width; x++) {
969  *dest++ = 0xff;
970  *dest++ = src[0][x];
971  *dest++ = src[1][x];
972  *dest++ = src[2][x];
973  }
974  } else {
975  for (x = 0; x < width; x++) {
976  *dest++ = src[0][x];
977  *dest++ = src[1][x];
978  *dest++ = src[2][x];
979  *dest++ = 0xff;
980  }
981  }
982 
983  for (i = 0; i < 3; i++)
984  src[i] += srcStride[i];
985  }
986 }
987 
988 static void gbraptopacked32(const uint8_t *src[], int srcStride[],
989  uint8_t *dst, int dstStride, int srcSliceH,
990  int alpha_first, int width)
991 {
992  int x, h, i;
993  for (h = 0; h < srcSliceH; h++) {
994  uint8_t *dest = dst + dstStride * h;
995 
996  if (alpha_first) {
997  for (x = 0; x < width; x++) {
998  *dest++ = src[3][x];
999  *dest++ = src[0][x];
1000  *dest++ = src[1][x];
1001  *dest++ = src[2][x];
1002  }
1003  } else {
1004  for (x = 0; x < width; x++) {
1005  *dest++ = src[0][x];
1006  *dest++ = src[1][x];
1007  *dest++ = src[2][x];
1008  *dest++ = src[3][x];
1009  }
1010  }
1011 
1012  for (i = 0; i < 4; i++)
1013  src[i] += srcStride[i];
1014  }
1015 }
1016 
1017 static int planarRgbaToRgbWrapper(SwsContext *c, const uint8_t *src[],
1018  int srcStride[], int srcSliceY, int srcSliceH,
1019  uint8_t *dst[], int dstStride[])
1020 {
1021  int alpha_first = 0;
1022  const uint8_t *src102[] = { src[1], src[0], src[2], src[3] };
1023  const uint8_t *src201[] = { src[2], src[0], src[1], src[3] };
1024  int stride102[] = { srcStride[1], srcStride[0], srcStride[2], srcStride[3] };
1025  int stride201[] = { srcStride[2], srcStride[0], srcStride[1], srcStride[3] };
1026 
1027  if (c->srcFormat != AV_PIX_FMT_GBRAP) {
1028  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
1029  av_get_pix_fmt_name(c->srcFormat),
1030  av_get_pix_fmt_name(c->dstFormat));
1031  return srcSliceH;
1032  }
1033 
1034  switch (c->dstFormat) {
1035  case AV_PIX_FMT_BGR24:
1036  gbr24ptopacked24(src102, stride102,
1037  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1038  srcSliceH, c->srcW);
1039  break;
1040 
1041  case AV_PIX_FMT_RGB24:
1042  gbr24ptopacked24(src201, stride201,
1043  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1044  srcSliceH, c->srcW);
1045  break;
1046 
1047  case AV_PIX_FMT_ARGB:
1048  alpha_first = 1;
1049  case AV_PIX_FMT_RGBA:
1050  gbraptopacked32(src201, stride201,
1051  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1052  srcSliceH, alpha_first, c->srcW);
1053  break;
1054 
1055  case AV_PIX_FMT_ABGR:
1056  alpha_first = 1;
1057  case AV_PIX_FMT_BGRA:
1058  gbraptopacked32(src102, stride102,
1059  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1060  srcSliceH, alpha_first, c->srcW);
1061  break;
1062 
1063  default:
1065  "unsupported planar RGB conversion %s -> %s\n",
1066  av_get_pix_fmt_name(c->srcFormat),
1067  av_get_pix_fmt_name(c->dstFormat));
1068  }
1069 
1070  return srcSliceH;
1071 }
1072 
1073 static int planarRgbToRgbWrapper(SwsContext *c, const uint8_t *src[],
1074  int srcStride[], int srcSliceY, int srcSliceH,
1075  uint8_t *dst[], int dstStride[])
1076 {
1077  int alpha_first = 0;
1078  const uint8_t *src102[] = { src[1], src[0], src[2] };
1079  const uint8_t *src201[] = { src[2], src[0], src[1] };
1080  int stride102[] = { srcStride[1], srcStride[0], srcStride[2] };
1081  int stride201[] = { srcStride[2], srcStride[0], srcStride[1] };
1082 
1083  if (c->srcFormat != AV_PIX_FMT_GBRP) {
1084  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
1085  av_get_pix_fmt_name(c->srcFormat),
1086  av_get_pix_fmt_name(c->dstFormat));
1087  return srcSliceH;
1088  }
1089 
1090  switch (c->dstFormat) {
1091  case AV_PIX_FMT_BGR24:
1092  gbr24ptopacked24(src102, stride102,
1093  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1094  srcSliceH, c->srcW);
1095  break;
1096 
1097  case AV_PIX_FMT_RGB24:
1098  gbr24ptopacked24(src201, stride201,
1099  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1100  srcSliceH, c->srcW);
1101  break;
1102 
1103  case AV_PIX_FMT_ARGB:
1104  alpha_first = 1;
1105  case AV_PIX_FMT_RGBA:
1106  gbr24ptopacked32(src201, stride201,
1107  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1108  srcSliceH, alpha_first, c->srcW);
1109  break;
1110 
1111  case AV_PIX_FMT_ABGR:
1112  alpha_first = 1;
1113  case AV_PIX_FMT_BGRA:
1114  gbr24ptopacked32(src102, stride102,
1115  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1116  srcSliceH, alpha_first, c->srcW);
1117  break;
1118 
1119  default:
1121  "unsupported planar RGB conversion %s -> %s\n",
1122  av_get_pix_fmt_name(c->srcFormat),
1123  av_get_pix_fmt_name(c->dstFormat));
1124  }
1125 
1126  return srcSliceH;
1127 }
1128 
1130  const uint8_t *src[], int srcStride[],
1131  int srcSliceY, int srcSliceH,
1132  uint8_t *dst[], int dstStride[])
1133 {
1134  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
1135  dst[0], dstStride[0]);
1136  copyPlane(src[1], srcStride[1], srcSliceY, srcSliceH, c->srcW,
1137  dst[1], dstStride[1]);
1138  copyPlane(src[2], srcStride[2], srcSliceY, srcSliceH, c->srcW,
1139  dst[2], dstStride[2]);
1140  if (dst[3])
1141  fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1142 
1143  return srcSliceH;
1144 }
1145 
1146 static void packedtogbr24p(const uint8_t *src, int srcStride,
1147  uint8_t *dst[], int dstStride[], int srcSliceH,
1148  int alpha_first, int inc_size, int width)
1149 {
1150  uint8_t *dest[3];
1151  int x, h;
1152 
1153  dest[0] = dst[0];
1154  dest[1] = dst[1];
1155  dest[2] = dst[2];
1156 
1157  if (alpha_first)
1158  src++;
1159 
1160  for (h = 0; h < srcSliceH; h++) {
1161  for (x = 0; x < width; x++) {
1162  dest[0][x] = src[0];
1163  dest[1][x] = src[1];
1164  dest[2][x] = src[2];
1165 
1166  src += inc_size;
1167  }
1168  src += srcStride - width * inc_size;
1169  dest[0] += dstStride[0];
1170  dest[1] += dstStride[1];
1171  dest[2] += dstStride[2];
1172  }
1173 }
1174 
1175 static int rgbToPlanarRgbWrapper(SwsContext *c, const uint8_t *src[],
1176  int srcStride[], int srcSliceY, int srcSliceH,
1177  uint8_t *dst[], int dstStride[])
1178 {
1179  int alpha_first = 0;
1180  int stride102[] = { dstStride[1], dstStride[0], dstStride[2] };
1181  int stride201[] = { dstStride[2], dstStride[0], dstStride[1] };
1182  uint8_t *dst102[] = { dst[1] + srcSliceY * dstStride[1],
1183  dst[0] + srcSliceY * dstStride[0],
1184  dst[2] + srcSliceY * dstStride[2] };
1185  uint8_t *dst201[] = { dst[2] + srcSliceY * dstStride[2],
1186  dst[0] + srcSliceY * dstStride[0],
1187  dst[1] + srcSliceY * dstStride[1] };
1188 
1189  switch (c->srcFormat) {
1190  case AV_PIX_FMT_RGB24:
1191  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
1192  stride201, srcSliceH, alpha_first, 3, c->srcW);
1193  break;
1194  case AV_PIX_FMT_BGR24:
1195  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
1196  stride102, srcSliceH, alpha_first, 3, c->srcW);
1197  break;
1198  case AV_PIX_FMT_ARGB:
1199  alpha_first = 1;
1200  case AV_PIX_FMT_RGBA:
1201  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
1202  stride201, srcSliceH, alpha_first, 4, c->srcW);
1203  break;
1204  case AV_PIX_FMT_ABGR:
1205  alpha_first = 1;
1206  case AV_PIX_FMT_BGRA:
1207  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
1208  stride102, srcSliceH, alpha_first, 4, c->srcW);
1209  break;
1210  default:
1212  "unsupported planar RGB conversion %s -> %s\n",
1213  av_get_pix_fmt_name(c->srcFormat),
1214  av_get_pix_fmt_name(c->dstFormat));
1215  }
1216 
1217  return srcSliceH;
1218 }
1219 
1220 #define BAYER_GBRG
1221 #define BAYER_8
1222 #define BAYER_RENAME(x) bayer_gbrg8_to_##x
1223 #include "bayer_template.c"
1224 
1225 #define BAYER_GBRG
1226 #define BAYER_16LE
1227 #define BAYER_RENAME(x) bayer_gbrg16le_to_##x
1228 #include "bayer_template.c"
1229 
1230 #define BAYER_GBRG
1231 #define BAYER_16BE
1232 #define BAYER_RENAME(x) bayer_gbrg16be_to_##x
1233 #include "bayer_template.c"
1234 
1235 #define BAYER_GRBG
1236 #define BAYER_8
1237 #define BAYER_RENAME(x) bayer_grbg8_to_##x
1238 #include "bayer_template.c"
1239 
1240 #define BAYER_GRBG
1241 #define BAYER_16LE
1242 #define BAYER_RENAME(x) bayer_grbg16le_to_##x
1243 #include "bayer_template.c"
1244 
1245 #define BAYER_GRBG
1246 #define BAYER_16BE
1247 #define BAYER_RENAME(x) bayer_grbg16be_to_##x
1248 #include "bayer_template.c"
1249 
1250 #define BAYER_BGGR
1251 #define BAYER_8
1252 #define BAYER_RENAME(x) bayer_bggr8_to_##x
1253 #include "bayer_template.c"
1254 
1255 #define BAYER_BGGR
1256 #define BAYER_16LE
1257 #define BAYER_RENAME(x) bayer_bggr16le_to_##x
1258 #include "bayer_template.c"
1259 
1260 #define BAYER_BGGR
1261 #define BAYER_16BE
1262 #define BAYER_RENAME(x) bayer_bggr16be_to_##x
1263 #include "bayer_template.c"
1264 
1265 #define BAYER_RGGB
1266 #define BAYER_8
1267 #define BAYER_RENAME(x) bayer_rggb8_to_##x
1268 #include "bayer_template.c"
1269 
1270 #define BAYER_RGGB
1271 #define BAYER_16LE
1272 #define BAYER_RENAME(x) bayer_rggb16le_to_##x
1273 #include "bayer_template.c"
1274 
1275 #define BAYER_RGGB
1276 #define BAYER_16BE
1277 #define BAYER_RENAME(x) bayer_rggb16be_to_##x
1278 #include "bayer_template.c"
1279 
1280 static int bayer_to_rgb24_wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1281  int srcSliceH, uint8_t* dst[], int dstStride[])
1282 {
1283  uint8_t *dstPtr= dst[0] + srcSliceY * dstStride[0];
1284  const uint8_t *srcPtr= src[0];
1285  int i;
1286  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1287  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1288 
1289  switch(c->srcFormat) {
1290 #define CASE(pixfmt, prefix) \
1291  case pixfmt: copy = bayer_##prefix##_to_rgb24_copy; \
1292  interpolate = bayer_##prefix##_to_rgb24_interpolate; \
1293  break;
1295  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1296  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1298  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1299  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1301  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1302  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1304  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1305  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1306 #undef CASE
1307  default: return 0;
1308  }
1309 
1310  av_assert0(srcSliceH > 1);
1311 
1312  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1313  srcPtr += 2 * srcStride[0];
1314  dstPtr += 2 * dstStride[0];
1315 
1316  for (i = 2; i < srcSliceH - 2; i += 2) {
1317  interpolate(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1318  srcPtr += 2 * srcStride[0];
1319  dstPtr += 2 * dstStride[0];
1320  }
1321 
1322  if (i + 1 == srcSliceH) {
1323  copy(srcPtr, -srcStride[0], dstPtr, -dstStride[0], c->srcW);
1324  } else if (i < srcSliceH)
1325  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1326  return srcSliceH;
1327 }
1328 
1329 static int bayer_to_rgb48_wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1330  int srcSliceH, uint8_t* dst[], int dstStride[])
1331 {
1332  uint8_t *dstPtr= dst[0] + srcSliceY * dstStride[0];
1333  const uint8_t *srcPtr= src[0];
1334  int i;
1335  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1336  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1337 
1338  switch(c->srcFormat) {
1339 #define CASE(pixfmt, prefix) \
1340  case pixfmt: copy = bayer_##prefix##_to_rgb48_copy; \
1341  interpolate = bayer_##prefix##_to_rgb48_interpolate; \
1342  break;
1344  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1345  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1347  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1348  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1350  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1351  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1353  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1354  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1355 #undef CASE
1356  default: return 0;
1357  }
1358 
1359  av_assert0(srcSliceH > 1);
1360 
1361  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1362  srcPtr += 2 * srcStride[0];
1363  dstPtr += 2 * dstStride[0];
1364 
1365  for (i = 2; i < srcSliceH - 2; i += 2) {
1366  interpolate(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1367  srcPtr += 2 * srcStride[0];
1368  dstPtr += 2 * dstStride[0];
1369  }
1370 
1371  if (i + 1 == srcSliceH) {
1372  copy(srcPtr, -srcStride[0], dstPtr, -dstStride[0], c->srcW);
1373  } else if (i < srcSliceH)
1374  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->srcW);
1375  return srcSliceH;
1376 }
1377 
1378 static int bayer_to_yv12_wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1379  int srcSliceH, uint8_t* dst[], int dstStride[])
1380 {
1381  const uint8_t *srcPtr= src[0];
1382  uint8_t *dstY= dst[0] + srcSliceY * dstStride[0];
1383  uint8_t *dstU= dst[1] + srcSliceY * dstStride[1] / 2;
1384  uint8_t *dstV= dst[2] + srcSliceY * dstStride[2] / 2;
1385  int i;
1386  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dstY, uint8_t *dstU, uint8_t *dstV, int luma_stride, int width, int32_t *rgb2yuv);
1387  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dstY, uint8_t *dstU, uint8_t *dstV, int luma_stride, int width, int32_t *rgb2yuv);
1388 
1389  switch(c->srcFormat) {
1390 #define CASE(pixfmt, prefix) \
1391  case pixfmt: copy = bayer_##prefix##_to_yv12_copy; \
1392  interpolate = bayer_##prefix##_to_yv12_interpolate; \
1393  break;
1395  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1396  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1398  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1399  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1401  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1402  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1404  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1405  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1406 #undef CASE
1407  default: return 0;
1408  }
1409 
1410  av_assert0(srcSliceH > 1);
1411 
1412  copy(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->srcW, c->input_rgb2yuv_table);
1413  srcPtr += 2 * srcStride[0];
1414  dstY += 2 * dstStride[0];
1415  dstU += dstStride[1];
1416  dstV += dstStride[1];
1417 
1418  for (i = 2; i < srcSliceH - 2; i += 2) {
1419  interpolate(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->srcW, c->input_rgb2yuv_table);
1420  srcPtr += 2 * srcStride[0];
1421  dstY += 2 * dstStride[0];
1422  dstU += dstStride[1];
1423  dstV += dstStride[1];
1424  }
1425 
1426  if (i + 1 == srcSliceH) {
1427  copy(srcPtr, -srcStride[0], dstY, dstU, dstV, -dstStride[0], c->srcW, c->input_rgb2yuv_table);
1428  } else if (i < srcSliceH)
1429  copy(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->srcW, c->input_rgb2yuv_table);
1430  return srcSliceH;
1431 }
1432 
1433 #define isRGBA32(x) ( \
1434  (x) == AV_PIX_FMT_ARGB \
1435  || (x) == AV_PIX_FMT_RGBA \
1436  || (x) == AV_PIX_FMT_BGRA \
1437  || (x) == AV_PIX_FMT_ABGR \
1438  )
1439 
1440 #define isRGBA64(x) ( \
1441  (x) == AV_PIX_FMT_RGBA64LE \
1442  || (x) == AV_PIX_FMT_RGBA64BE \
1443  || (x) == AV_PIX_FMT_BGRA64LE \
1444  || (x) == AV_PIX_FMT_BGRA64BE \
1445  )
1446 
1447 #define isRGB48(x) ( \
1448  (x) == AV_PIX_FMT_RGB48LE \
1449  || (x) == AV_PIX_FMT_RGB48BE \
1450  || (x) == AV_PIX_FMT_BGR48LE \
1451  || (x) == AV_PIX_FMT_BGR48BE \
1452  )
1453 
1454 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1455 typedef void (* rgbConvFn) (const uint8_t *, uint8_t *, int);
1457 {
1458  const enum AVPixelFormat srcFormat = c->srcFormat;
1459  const enum AVPixelFormat dstFormat = c->dstFormat;
1460  const int srcId = c->srcFormatBpp;
1461  const int dstId = c->dstFormatBpp;
1462  rgbConvFn conv = NULL;
1463 
1464 #define IS_NOT_NE(bpp, desc) \
1465  (((bpp + 7) >> 3) == 2 && \
1466  (!(desc->flags & AV_PIX_FMT_FLAG_BE) != !HAVE_BIGENDIAN))
1467 
1468 #define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
1469 
1470  if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
1471  if ( CONV_IS(ABGR, RGBA)
1472  || CONV_IS(ARGB, BGRA)
1473  || CONV_IS(BGRA, ARGB)
1474  || CONV_IS(RGBA, ABGR)) conv = shuffle_bytes_3210;
1475  else if (CONV_IS(ABGR, ARGB)
1476  || CONV_IS(ARGB, ABGR)) conv = shuffle_bytes_0321;
1477  else if (CONV_IS(ABGR, BGRA)
1478  || CONV_IS(ARGB, RGBA)) conv = shuffle_bytes_1230;
1479  else if (CONV_IS(BGRA, RGBA)
1480  || CONV_IS(RGBA, BGRA)) conv = shuffle_bytes_2103;
1481  else if (CONV_IS(BGRA, ABGR)
1482  || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
1483  } else if (isRGB48(srcFormat) && isRGB48(dstFormat)) {
1484  if (CONV_IS(RGB48LE, BGR48LE)
1485  || CONV_IS(BGR48LE, RGB48LE)
1486  || CONV_IS(RGB48BE, BGR48BE)
1487  || CONV_IS(BGR48BE, RGB48BE)) conv = rgb48tobgr48_nobswap;
1488  else if (CONV_IS(RGB48LE, BGR48BE)
1489  || CONV_IS(BGR48LE, RGB48BE)
1490  || CONV_IS(RGB48BE, BGR48LE)
1491  || CONV_IS(BGR48BE, RGB48LE)) conv = rgb48tobgr48_bswap;
1492  } else if (isRGB48(srcFormat) && isRGBA64(dstFormat)) {
1493  if (CONV_IS(RGB48LE, BGRA64LE)
1494  || CONV_IS(BGR48LE, RGBA64LE)
1495  || CONV_IS(RGB48BE, BGRA64BE)
1496  || CONV_IS(BGR48BE, RGBA64BE)) conv = rgb48tobgr64_nobswap;
1497  else if (CONV_IS(RGB48LE, BGRA64BE)
1498  || CONV_IS(BGR48LE, RGBA64BE)
1499  || CONV_IS(RGB48BE, BGRA64LE)
1500  || CONV_IS(BGR48BE, RGBA64LE)) conv = rgb48tobgr64_bswap;
1501  if (CONV_IS(RGB48LE, RGBA64LE)
1502  || CONV_IS(BGR48LE, BGRA64LE)
1503  || CONV_IS(RGB48BE, RGBA64BE)
1504  || CONV_IS(BGR48BE, BGRA64BE)) conv = rgb48to64_nobswap;
1505  else if (CONV_IS(RGB48LE, RGBA64BE)
1506  || CONV_IS(BGR48LE, BGRA64BE)
1507  || CONV_IS(RGB48BE, RGBA64LE)
1508  || CONV_IS(BGR48BE, BGRA64LE)) conv = rgb48to64_bswap;
1509  } else if (isRGBA64(srcFormat) && isRGB48(dstFormat)) {
1510  if (CONV_IS(RGBA64LE, BGR48LE)
1511  || CONV_IS(BGRA64LE, RGB48LE)
1512  || CONV_IS(RGBA64BE, BGR48BE)
1513  || CONV_IS(BGRA64BE, RGB48BE)) conv = rgb64tobgr48_nobswap;
1514  else if (CONV_IS(RGBA64LE, BGR48BE)
1515  || CONV_IS(BGRA64LE, RGB48BE)
1516  || CONV_IS(RGBA64BE, BGR48LE)
1517  || CONV_IS(BGRA64BE, RGB48LE)) conv = rgb64tobgr48_bswap;
1518  else if (CONV_IS(RGBA64LE, RGB48LE)
1519  || CONV_IS(BGRA64LE, BGR48LE)
1520  || CONV_IS(RGBA64BE, RGB48BE)
1521  || CONV_IS(BGRA64BE, BGR48BE)) conv = rgb64to48_nobswap;
1522  else if (CONV_IS(RGBA64LE, RGB48BE)
1523  || CONV_IS(BGRA64LE, BGR48BE)
1524  || CONV_IS(RGBA64BE, RGB48LE)
1525  || CONV_IS(BGRA64BE, BGR48LE)) conv = rgb64to48_bswap;
1526  } else
1527  /* BGR -> BGR */
1530  switch (srcId | (dstId << 16)) {
1531  case 0x000F000C: conv = rgb12to15; break;
1532  case 0x000F0010: conv = rgb16to15; break;
1533  case 0x000F0018: conv = rgb24to15; break;
1534  case 0x000F0020: conv = rgb32to15; break;
1535  case 0x0010000F: conv = rgb15to16; break;
1536  case 0x00100018: conv = rgb24to16; break;
1537  case 0x00100020: conv = rgb32to16; break;
1538  case 0x0018000F: conv = rgb15to24; break;
1539  case 0x00180010: conv = rgb16to24; break;
1540  case 0x00180020: conv = rgb32to24; break;
1541  case 0x0020000F: conv = rgb15to32; break;
1542  case 0x00200010: conv = rgb16to32; break;
1543  case 0x00200018: conv = rgb24to32; break;
1544  }
1545  } else if ((isBGRinInt(srcFormat) && isRGBinInt(dstFormat)) ||
1547  switch (srcId | (dstId << 16)) {
1548  case 0x000C000C: conv = rgb12tobgr12; break;
1549  case 0x000F000F: conv = rgb15tobgr15; break;
1550  case 0x000F0010: conv = rgb16tobgr15; break;
1551  case 0x000F0018: conv = rgb24tobgr15; break;
1552  case 0x000F0020: conv = rgb32tobgr15; break;
1553  case 0x0010000F: conv = rgb15tobgr16; break;
1554  case 0x00100010: conv = rgb16tobgr16; break;
1555  case 0x00100018: conv = rgb24tobgr16; break;
1556  case 0x00100020: conv = rgb32tobgr16; break;
1557  case 0x0018000F: conv = rgb15tobgr24; break;
1558  case 0x00180010: conv = rgb16tobgr24; break;
1559  case 0x00180018: conv = rgb24tobgr24; break;
1560  case 0x00180020: conv = rgb32tobgr24; break;
1561  case 0x0020000F: conv = rgb15tobgr32; break;
1562  case 0x00200010: conv = rgb16tobgr32; break;
1563  case 0x00200018: conv = rgb24tobgr32; break;
1564  }
1565  }
1566 
1568  return NULL;
1569 
1570  // Maintain symmetry between endianness
1571  if (c->flags & SWS_BITEXACT)
1573  return NULL;
1574 
1575  return conv;
1576 }
1577 
1578 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1579 static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
1580  int srcSliceY, int srcSliceH, uint8_t *dst[],
1581  int dstStride[])
1582 
1583 {
1584  const enum AVPixelFormat srcFormat = c->srcFormat;
1585  const enum AVPixelFormat dstFormat = c->dstFormat;
1586  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat);
1587  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat);
1588  const int srcBpp = (c->srcFormatBpp + 7) >> 3;
1589  const int dstBpp = (c->dstFormatBpp + 7) >> 3;
1591 
1592  if (!conv) {
1593  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
1595  } else {
1596  const uint8_t *srcPtr = src[0];
1597  uint8_t *dstPtr = dst[0];
1598  int src_bswap = IS_NOT_NE(c->srcFormatBpp, desc_src);
1599  int dst_bswap = IS_NOT_NE(c->dstFormatBpp, desc_dst);
1600 
1602  !isRGBA32(dstFormat))
1603  srcPtr += ALT32_CORR;
1604 
1606  !isRGBA32(srcFormat)) {
1607  int i;
1608  av_assert0(ALT32_CORR == 1);
1609  for (i = 0; i < srcSliceH; i++)
1610  dstPtr[dstStride[0] * (srcSliceY + i)] = 255;
1611  dstPtr += ALT32_CORR;
1612  }
1613 
1614  if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
1615  !(srcStride[0] % srcBpp) && !dst_bswap && !src_bswap)
1616  conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
1617  (srcSliceH - 1) * srcStride[0] + c->srcW * srcBpp);
1618  else {
1619  int i, j;
1620  dstPtr += dstStride[0] * srcSliceY;
1621 
1622  for (i = 0; i < srcSliceH; i++) {
1623  if(src_bswap) {
1624  for(j=0; j<c->srcW; j++)
1625  ((uint16_t*)c->formatConvBuffer)[j] = av_bswap16(((uint16_t*)srcPtr)[j]);
1626  conv(c->formatConvBuffer, dstPtr, c->srcW * srcBpp);
1627  }else
1628  conv(srcPtr, dstPtr, c->srcW * srcBpp);
1629  if(dst_bswap)
1630  for(j=0; j<c->srcW; j++)
1631  ((uint16_t*)dstPtr)[j] = av_bswap16(((uint16_t*)dstPtr)[j]);
1632  srcPtr += srcStride[0];
1633  dstPtr += dstStride[0];
1634  }
1635  }
1636  }
1637  return srcSliceH;
1638 }
1639 
1640 static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
1641  int srcStride[], int srcSliceY, int srcSliceH,
1642  uint8_t *dst[], int dstStride[])
1643 {
1645  src[0],
1646  dst[0] + srcSliceY * dstStride[0],
1647  dst[1] + (srcSliceY >> 1) * dstStride[1],
1648  dst[2] + (srcSliceY >> 1) * dstStride[2],
1649  c->srcW, srcSliceH,
1650  dstStride[0], dstStride[1], srcStride[0],
1651  c->input_rgb2yuv_table);
1652  if (dst[3])
1653  fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1654  return srcSliceH;
1655 }
1656 
1657 static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
1658  int srcStride[], int srcSliceY, int srcSliceH,
1659  uint8_t *dst[], int dstStride[])
1660 {
1661  copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
1662  dst[0], dstStride[0]);
1663 
1664  planar2x(src[1], dst[1] + dstStride[1] * (srcSliceY >> 1), c->chrSrcW,
1665  srcSliceH >> 2, srcStride[1], dstStride[1]);
1666  planar2x(src[2], dst[2] + dstStride[2] * (srcSliceY >> 1), c->chrSrcW,
1667  srcSliceH >> 2, srcStride[2], dstStride[2]);
1668  if (dst[3])
1669  fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1670  return srcSliceH;
1671 }
1672 
1673 static int uint_y_to_float_y_wrapper(SwsContext *c, const uint8_t *src[],
1674  int srcStride[], int srcSliceY,
1675  int srcSliceH, uint8_t *dst[], int dstStride[])
1676 {
1677  int y, x;
1678  ptrdiff_t dstStrideFloat = dstStride[0] >> 2;
1679  const uint8_t *srcPtr = src[0];
1680  float *dstPtr = (float *)(dst[0] + dstStride[0] * srcSliceY);
1681 
1682  for (y = 0; y < srcSliceH; ++y){
1683  for (x = 0; x < c->srcW; ++x){
1684  dstPtr[x] = c->uint2float_lut[srcPtr[x]];
1685  }
1686  srcPtr += srcStride[0];
1687  dstPtr += dstStrideFloat;
1688  }
1689 
1690  return srcSliceH;
1691 }
1692 
1693 static int float_y_to_uint_y_wrapper(SwsContext *c, const uint8_t* src[],
1694  int srcStride[], int srcSliceY,
1695  int srcSliceH, uint8_t* dst[], int dstStride[])
1696 {
1697  int y, x;
1698  ptrdiff_t srcStrideFloat = srcStride[0] >> 2;
1699  const float *srcPtr = (const float *)src[0];
1700  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
1701 
1702  for (y = 0; y < srcSliceH; ++y){
1703  for (x = 0; x < c->srcW; ++x){
1704  dstPtr[x] = av_clip_uint8(lrintf(255.0f * srcPtr[x]));
1705  }
1706  srcPtr += srcStrideFloat;
1707  dstPtr += dstStride[0];
1708  }
1709 
1710  return srcSliceH;
1711 }
1712 
1713 /* unscaled copy like stuff (assumes nearly identical formats) */
1714 static int packedCopyWrapper(SwsContext *c, const uint8_t *src[],
1715  int srcStride[], int srcSliceY, int srcSliceH,
1716  uint8_t *dst[], int dstStride[])
1717 {
1718  if (dstStride[0] == srcStride[0] && srcStride[0] > 0)
1719  memcpy(dst[0] + dstStride[0] * srcSliceY, src[0], srcSliceH * dstStride[0]);
1720  else {
1721  int i;
1722  const uint8_t *srcPtr = src[0];
1723  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
1724  int length = 0;
1725 
1726  /* universal length finder */
1727  while (length + c->srcW <= FFABS(dstStride[0]) &&
1728  length + c->srcW <= FFABS(srcStride[0]))
1729  length += c->srcW;
1730  av_assert1(length != 0);
1731 
1732  for (i = 0; i < srcSliceH; i++) {
1733  memcpy(dstPtr, srcPtr, length);
1734  srcPtr += srcStride[0];
1735  dstPtr += dstStride[0];
1736  }
1737  }
1738  return srcSliceH;
1739 }
1740 
1741 #define DITHER_COPY(dst, dstStride, src, srcStride, bswap, dbswap)\
1742  unsigned shift= src_depth-dst_depth, tmp;\
1743  if (c->dither == SWS_DITHER_NONE) {\
1744  for (i = 0; i < height; i++) {\
1745  for (j = 0; j < length-7; j+=8) {\
1746  dst[j+0] = dbswap(bswap(src[j+0])>>shift);\
1747  dst[j+1] = dbswap(bswap(src[j+1])>>shift);\
1748  dst[j+2] = dbswap(bswap(src[j+2])>>shift);\
1749  dst[j+3] = dbswap(bswap(src[j+3])>>shift);\
1750  dst[j+4] = dbswap(bswap(src[j+4])>>shift);\
1751  dst[j+5] = dbswap(bswap(src[j+5])>>shift);\
1752  dst[j+6] = dbswap(bswap(src[j+6])>>shift);\
1753  dst[j+7] = dbswap(bswap(src[j+7])>>shift);\
1754  }\
1755  for (; j < length; j++) {\
1756  dst[j] = dbswap(bswap(src[j])>>shift);\
1757  }\
1758  dst += dstStride;\
1759  src += srcStride;\
1760  }\
1761  } else if (shiftonly) {\
1762  for (i = 0; i < height; i++) {\
1763  const uint8_t *dither= dithers[shift-1][i&7];\
1764  for (j = 0; j < length-7; j+=8) {\
1765  tmp = (bswap(src[j+0]) + dither[0])>>shift; dst[j+0] = dbswap(tmp - (tmp>>dst_depth));\
1766  tmp = (bswap(src[j+1]) + dither[1])>>shift; dst[j+1] = dbswap(tmp - (tmp>>dst_depth));\
1767  tmp = (bswap(src[j+2]) + dither[2])>>shift; dst[j+2] = dbswap(tmp - (tmp>>dst_depth));\
1768  tmp = (bswap(src[j+3]) + dither[3])>>shift; dst[j+3] = dbswap(tmp - (tmp>>dst_depth));\
1769  tmp = (bswap(src[j+4]) + dither[4])>>shift; dst[j+4] = dbswap(tmp - (tmp>>dst_depth));\
1770  tmp = (bswap(src[j+5]) + dither[5])>>shift; dst[j+5] = dbswap(tmp - (tmp>>dst_depth));\
1771  tmp = (bswap(src[j+6]) + dither[6])>>shift; dst[j+6] = dbswap(tmp - (tmp>>dst_depth));\
1772  tmp = (bswap(src[j+7]) + dither[7])>>shift; dst[j+7] = dbswap(tmp - (tmp>>dst_depth));\
1773  }\
1774  for (; j < length; j++) {\
1775  tmp = (bswap(src[j]) + dither[j&7])>>shift; dst[j] = dbswap(tmp - (tmp>>dst_depth));\
1776  }\
1777  dst += dstStride;\
1778  src += srcStride;\
1779  }\
1780  } else {\
1781  for (i = 0; i < height; i++) {\
1782  const uint8_t *dither= dithers[shift-1][i&7];\
1783  for (j = 0; j < length-7; j+=8) {\
1784  tmp = bswap(src[j+0]); dst[j+0] = dbswap((tmp - (tmp>>dst_depth) + dither[0])>>shift);\
1785  tmp = bswap(src[j+1]); dst[j+1] = dbswap((tmp - (tmp>>dst_depth) + dither[1])>>shift);\
1786  tmp = bswap(src[j+2]); dst[j+2] = dbswap((tmp - (tmp>>dst_depth) + dither[2])>>shift);\
1787  tmp = bswap(src[j+3]); dst[j+3] = dbswap((tmp - (tmp>>dst_depth) + dither[3])>>shift);\
1788  tmp = bswap(src[j+4]); dst[j+4] = dbswap((tmp - (tmp>>dst_depth) + dither[4])>>shift);\
1789  tmp = bswap(src[j+5]); dst[j+5] = dbswap((tmp - (tmp>>dst_depth) + dither[5])>>shift);\
1790  tmp = bswap(src[j+6]); dst[j+6] = dbswap((tmp - (tmp>>dst_depth) + dither[6])>>shift);\
1791  tmp = bswap(src[j+7]); dst[j+7] = dbswap((tmp - (tmp>>dst_depth) + dither[7])>>shift);\
1792  }\
1793  for (; j < length; j++) {\
1794  tmp = bswap(src[j]); dst[j] = dbswap((tmp - (tmp>>dst_depth) + dither[j&7])>>shift);\
1795  }\
1796  dst += dstStride;\
1797  src += srcStride;\
1798  }\
1799  }
1800 
1801 static int planarCopyWrapper(SwsContext *c, const uint8_t *src[],
1802  int srcStride[], int srcSliceY, int srcSliceH,
1803  uint8_t *dst[], int dstStride[])
1804 {
1805  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat);
1806  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat);
1807  int plane, i, j;
1808  for (plane = 0; plane < 4 && dst[plane] != NULL; plane++) {
1809  int length = (plane == 0 || plane == 3) ? c->srcW : AV_CEIL_RSHIFT(c->srcW, c->chrDstHSubSample);
1810  int y = (plane == 0 || plane == 3) ? srcSliceY: AV_CEIL_RSHIFT(srcSliceY, c->chrDstVSubSample);
1811  int height = (plane == 0 || plane == 3) ? srcSliceH: AV_CEIL_RSHIFT(srcSliceH, c->chrDstVSubSample);
1812  const uint8_t *srcPtr = src[plane];
1813  uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
1814  int shiftonly = plane == 1 || plane == 2 || (!c->srcRange && plane == 0);
1815 
1816  // ignore palette for GRAY8
1817  if (plane == 1 && !dst[2]) continue;
1818  if (!src[plane] || (plane == 1 && !src[2])) {
1819  if (is16BPS(c->dstFormat) || isNBPS(c->dstFormat)) {
1820  fillPlane16(dst[plane], dstStride[plane], length, height, y,
1821  plane == 3, desc_dst->comp[plane].depth,
1822  isBE(c->dstFormat));
1823  } else {
1824  fillPlane(dst[plane], dstStride[plane], length, height, y,
1825  (plane == 3) ? 255 : 128);
1826  }
1827  } else {
1828  if(isNBPS(c->srcFormat) || isNBPS(c->dstFormat)
1829  || (is16BPS(c->srcFormat) != is16BPS(c->dstFormat))
1830  ) {
1831  const int src_depth = desc_src->comp[plane].depth;
1832  const int dst_depth = desc_dst->comp[plane].depth;
1833  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
1834  uint16_t *dstPtr2 = (uint16_t*)dstPtr;
1835 
1836  if (dst_depth == 8) {
1837  if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
1838  DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, , )
1839  } else {
1840  DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, av_bswap16, )
1841  }
1842  } else if (src_depth == 8) {
1843  for (i = 0; i < height; i++) {
1844  #define COPY816(w)\
1845  if (shiftonly) {\
1846  for (j = 0; j < length; j++)\
1847  w(&dstPtr2[j], srcPtr[j]<<(dst_depth-8));\
1848  } else {\
1849  for (j = 0; j < length; j++)\
1850  w(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) |\
1851  (srcPtr[j]>>(2*8-dst_depth)));\
1852  }
1853  if(isBE(c->dstFormat)){
1854  COPY816(AV_WB16)
1855  } else {
1856  COPY816(AV_WL16)
1857  }
1858  dstPtr2 += dstStride[plane]/2;
1859  srcPtr += srcStride[plane];
1860  }
1861  } else if (src_depth <= dst_depth) {
1862  for (i = 0; i < height; i++) {
1863  j = 0;
1864  if(isBE(c->srcFormat) == HAVE_BIGENDIAN &&
1865  isBE(c->dstFormat) == HAVE_BIGENDIAN &&
1866  shiftonly) {
1867  unsigned shift = dst_depth - src_depth;
1868 #if HAVE_FAST_64BIT
1869 #define FAST_COPY_UP(shift) \
1870  for (; j < length - 3; j += 4) { \
1871  uint64_t v = AV_RN64A(srcPtr2 + j); \
1872  AV_WN64A(dstPtr2 + j, v << shift); \
1873  }
1874 #else
1875 #define FAST_COPY_UP(shift) \
1876  for (; j < length - 1; j += 2) { \
1877  uint32_t v = AV_RN32A(srcPtr2 + j); \
1878  AV_WN32A(dstPtr2 + j, v << shift); \
1879  }
1880 #endif
1881  switch (shift)
1882  {
1883  case 6: FAST_COPY_UP(6); break;
1884  case 7: FAST_COPY_UP(7); break;
1885  }
1886  }
1887 #define COPY_UP(r,w) \
1888  if(shiftonly){\
1889  for (; j < length; j++){ \
1890  unsigned int v= r(&srcPtr2[j]);\
1891  w(&dstPtr2[j], v<<(dst_depth-src_depth));\
1892  }\
1893  }else{\
1894  for (; j < length; j++){ \
1895  unsigned int v= r(&srcPtr2[j]);\
1896  w(&dstPtr2[j], (v<<(dst_depth-src_depth)) | \
1897  (v>>(2*src_depth-dst_depth)));\
1898  }\
1899  }
1900  if(isBE(c->srcFormat)){
1901  if(isBE(c->dstFormat)){
1903  } else {
1905  }
1906  } else {
1907  if(isBE(c->dstFormat)){
1909  } else {
1911  }
1912  }
1913  dstPtr2 += dstStride[plane]/2;
1914  srcPtr2 += srcStride[plane]/2;
1915  }
1916  } else {
1917  if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
1918  if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
1919  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , )
1920  } else {
1921  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , av_bswap16)
1922  }
1923  }else{
1924  if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
1925  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, )
1926  } else {
1927  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, av_bswap16)
1928  }
1929  }
1930  }
1931  } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
1932  isBE(c->srcFormat) != isBE(c->dstFormat)) {
1933 
1934  for (i = 0; i < height; i++) {
1935  for (j = 0; j < length; j++)
1936  ((uint16_t *) dstPtr)[j] = av_bswap16(((const uint16_t *) srcPtr)[j]);
1937  srcPtr += srcStride[plane];
1938  dstPtr += dstStride[plane];
1939  }
1940  } else if (isFloat(c->srcFormat) && isFloat(c->dstFormat) &&
1941  isBE(c->srcFormat) != isBE(c->dstFormat)) { /* swap float plane */
1942  for (i = 0; i < height; i++) {
1943  for (j = 0; j < length; j++)
1944  ((uint32_t *) dstPtr)[j] = av_bswap32(((const uint32_t *) srcPtr)[j]);
1945  srcPtr += srcStride[plane];
1946  dstPtr += dstStride[plane];
1947  }
1948  } else if (dstStride[plane] == srcStride[plane] &&
1949  srcStride[plane] > 0 && srcStride[plane] == length) {
1950  memcpy(dst[plane] + dstStride[plane] * y, src[plane],
1951  height * dstStride[plane]);
1952  } else {
1953  if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
1954  length *= 2;
1955  else if (desc_src->comp[0].depth == 1)
1956  length >>= 3; // monowhite/black
1957  for (i = 0; i < height; i++) {
1958  memcpy(dstPtr, srcPtr, length);
1959  srcPtr += srcStride[plane];
1960  dstPtr += dstStride[plane];
1961  }
1962  }
1963  }
1964  }
1965  return srcSliceH;
1966 }
1967 
1968 
1969 #define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt) \
1970  ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) || \
1971  (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))
1972 
1973 
1975 {
1976  const enum AVPixelFormat srcFormat = c->srcFormat;
1977  const enum AVPixelFormat dstFormat = c->dstFormat;
1978  const int flags = c->flags;
1979  const int dstH = c->dstH;
1980  const int dstW = c->dstW;
1981  int needsDither;
1982 
1983  needsDither = isAnyRGB(dstFormat) &&
1984  c->dstFormatBpp < 24 &&
1985  (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
1986 
1987  /* yv12_to_nv12 */
1990  c->convert_unscaled = planarToNv12Wrapper;
1991  }
1992  /* yv24_to_nv24 */
1995  c->convert_unscaled = planarToNv24Wrapper;
1996  }
1997  /* nv12_to_yv12 */
1998  if (dstFormat == AV_PIX_FMT_YUV420P &&
2000  c->convert_unscaled = nv12ToPlanarWrapper;
2001  }
2002  /* nv24_to_yv24 */
2003  if (dstFormat == AV_PIX_FMT_YUV444P &&
2005  c->convert_unscaled = nv24ToPlanarWrapper;
2006  }
2007  /* yuv2bgr */
2010  !(flags & SWS_ACCURATE_RND) && (c->dither == SWS_DITHER_BAYER || c->dither == SWS_DITHER_AUTO) && !(dstH & 1)) {
2011  c->convert_unscaled = ff_yuv2rgb_get_func_ptr(c);
2012  c->dst_slice_align = 2;
2013  }
2014  /* yuv420p1x_to_p01x */
2020  c->convert_unscaled = planarToP01xWrapper;
2021  }
2022  /* yuv420p_to_p01xle */
2025  c->convert_unscaled = planar8ToP01xleWrapper;
2026  }
2027 
2028  if (srcFormat == AV_PIX_FMT_YUV410P && !(dstH & 3) &&
2030  !(flags & SWS_BITEXACT)) {
2031  c->convert_unscaled = yvu9ToYv12Wrapper;
2032  c->dst_slice_align = 4;
2033  }
2034 
2035  /* bgr24toYV12 */
2036  if (srcFormat == AV_PIX_FMT_BGR24 &&
2038  !(flags & SWS_ACCURATE_RND) && !(dstW&1))
2039  c->convert_unscaled = bgr24ToYv12Wrapper;
2040 
2041  /* RGB/BGR -> RGB/BGR (no dither needed forms) */
2043  && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
2044  c->convert_unscaled = rgbToRgbWrapper;
2045 
2046  /* RGB to planar RGB */
2049  c->convert_unscaled = planarRgbToplanarRgbWrapper;
2050 
2051 #define isByteRGB(f) ( \
2052  f == AV_PIX_FMT_RGB32 || \
2053  f == AV_PIX_FMT_RGB32_1 || \
2054  f == AV_PIX_FMT_RGB24 || \
2055  f == AV_PIX_FMT_BGR32 || \
2056  f == AV_PIX_FMT_BGR32_1 || \
2057  f == AV_PIX_FMT_BGR24)
2058 
2060  c->convert_unscaled = planarRgbToRgbWrapper;
2061 
2063  c->convert_unscaled = planarRgbaToRgbWrapper;
2064 
2077  c->convert_unscaled = Rgb16ToPlanarRgb16Wrapper;
2078 
2091  c->convert_unscaled = planarRgb16ToRgb16Wrapper;
2092 
2093  if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
2095  c->convert_unscaled = rgbToPlanarRgbWrapper;
2096 
2097  if (isBayer(srcFormat)) {
2098  if (dstFormat == AV_PIX_FMT_RGB24)
2099  c->convert_unscaled = bayer_to_rgb24_wrapper;
2100  else if (dstFormat == AV_PIX_FMT_RGB48)
2101  c->convert_unscaled = bayer_to_rgb48_wrapper;
2102  else if (dstFormat == AV_PIX_FMT_YUV420P)
2103  c->convert_unscaled = bayer_to_yv12_wrapper;
2104  else if (!isBayer(dstFormat)) {
2105  av_log(c, AV_LOG_ERROR, "unsupported bayer conversion\n");
2106  av_assert0(0);
2107  }
2108  }
2109 
2110  /* bswap 16 bits per pixel/component packed formats */
2158  c->convert_unscaled = bswap_16bpc;
2159 
2160  /* bswap 32 bits per pixel/component formats */
2163  c->convert_unscaled = bswap_32bpc;
2164 
2166  c->convert_unscaled = palToRgbWrapper;
2167 
2168  if (srcFormat == AV_PIX_FMT_YUV422P) {
2170  c->convert_unscaled = yuv422pToYuy2Wrapper;
2171  else if (dstFormat == AV_PIX_FMT_UYVY422)
2172  c->convert_unscaled = yuv422pToUyvyWrapper;
2173  }
2174 
2175  /* uint Y to float Y */
2177  c->convert_unscaled = uint_y_to_float_y_wrapper;
2178  }
2179 
2180  /* float Y to uint Y */
2182  c->convert_unscaled = float_y_to_uint_y_wrapper;
2183  }
2184 
2185  /* LQ converters if -sws 0 or -sws 4*/
2186  if (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)) {
2187  /* yv12_to_yuy2 */
2190  c->convert_unscaled = planarToYuy2Wrapper;
2191  else if (dstFormat == AV_PIX_FMT_UYVY422)
2192  c->convert_unscaled = planarToUyvyWrapper;
2193  }
2194  }
2195  if (srcFormat == AV_PIX_FMT_YUYV422 &&
2197  c->convert_unscaled = yuyvToYuv420Wrapper;
2198  if (srcFormat == AV_PIX_FMT_UYVY422 &&
2200  c->convert_unscaled = uyvyToYuv420Wrapper;
2202  c->convert_unscaled = yuyvToYuv422Wrapper;
2204  c->convert_unscaled = uyvyToYuv422Wrapper;
2205 
2206 #define isPlanarGray(x) (isGray(x) && (x) != AV_PIX_FMT_YA8 && (x) != AV_PIX_FMT_YA16LE && (x) != AV_PIX_FMT_YA16BE)
2207  /* simple copy */
2208  if ( srcFormat == dstFormat ||
2215  c->chrDstHSubSample == c->chrSrcHSubSample &&
2216  c->chrDstVSubSample == c->chrSrcVSubSample &&
2218  {
2219  if (isPacked(c->srcFormat))
2220  c->convert_unscaled = packedCopyWrapper;
2221  else /* Planar YUV or gray */
2222  c->convert_unscaled = planarCopyWrapper;
2223  }
2224 
2225  if (ARCH_PPC)
2227  if (ARCH_ARM)
2229  if (ARCH_AARCH64)
2231 }
2232 
2233 /* Convert the palette to the same packed 32-bit format as the palette */
2234 void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst,
2235  int num_pixels, const uint8_t *palette)
2236 {
2237  int i;
2238 
2239  for (i = 0; i < num_pixels; i++)
2240  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
2241 }
2242 
2243 /* Palette format: ABCD -> dst format: ABC */
2244 void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst,
2245  int num_pixels, const uint8_t *palette)
2246 {
2247  int i;
2248 
2249  for (i = 0; i < num_pixels; i++) {
2250  //FIXME slow?
2251  dst[0] = palette[src[i] * 4 + 0];
2252  dst[1] = palette[src[i] * 4 + 1];
2253  dst[2] = palette[src[i] * 4 + 2];
2254  dst += 3;
2255  }
2256 }
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:811
yuv422pToYuy2Wrapper
static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:350
rgbToRgbWrapper
static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1579
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:413
rgb12tobgr12
void rgb12tobgr12(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:316
stride
int stride
Definition: mace.c:144
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_PIX_FMT_BAYER_GBRG16LE
@ AV_PIX_FMT_BAYER_GBRG16LE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:258
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:139
rgb32tobgr24
void(* rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:35
shuffle_bytes_3012
void(* shuffle_bytes_3012)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:57
bswap_16bpc
static int bswap_16bpc(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:467
isPacked
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:849
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:133
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:197
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:515
mem_internal.h
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale_internal.h:73
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:366
yv12toyuy2
void(* yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, int width, int height, int lumStride, int chromStride, int dstStride)
Height should be a multiple of 2 and width should be a multiple of 16.
Definition: rgb2rgb.c:61
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:164
rgb15to24
void rgb15to24(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:281
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:162
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2564
SwsContext::dstY
int dstY
Last destination vertical line output from last slice.
Definition: swscale_internal.h:431
Rgb16ToPlanarRgb16Wrapper
static int Rgb16ToPlanarRgb16Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:702
planarToNv24Wrapper
static int planarToNv24Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:183
palToRgbWrapper
static int palToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:522
pixdesc.h
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:433
rgb16tobgr32
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:184
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:428
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
uyvyToYuv422Wrapper
static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:422
CONV_IS
#define CONV_IS(src, dst)
shuffle_bytes_3210
void(* shuffle_bytes_3210)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:58
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:65
rgb48tobgr48_nobswap
void rgb48tobgr48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:391
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:365
rgb32tobgr16
void(* rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:36
yuyvtoyuv422
void(* yuyvtoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition: rgb2rgb.c:113
gbr24ptopacked32
static void gbr24ptopacked32(const uint8_t *src[], int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha_first, int width)
Definition: swscale_unscaled.c:959
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:246
rgb24tobgr16
void(* rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:40
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
rgb15to32
void(* rgb15to32)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:52
mathematics.h
sws_convertPalette8ToPacked24
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Convert an 8-bit paletted frame into a frame with a color depth of 24 bits.
Definition: swscale_unscaled.c:2244
AV_PIX_FMT_BAYER_GRBG16BE
@ AV_PIX_FMT_BAYER_GRBG16BE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:261
AV_PIX_FMT_BAYER_GRBG16
#define AV_PIX_FMT_BAYER_GRBG16
Definition: pixfmt.h:418
yv12touyvy
void(* yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, int width, int height, int lumStride, int chromStride, int dstStride)
Height should be a multiple of 2 and width should be a multiple of 16.
Definition: rgb2rgb.c:65
bayer_template.c
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:371
rgb32to16
void(* rgb32to16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:45
AV_PIX_FMT_BAYER_GBRG16BE
@ AV_PIX_FMT_BAYER_GBRG16BE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:259
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:278
SWS_FAST_BILINEAR
#define SWS_FAST_BILINEAR
Definition: swscale.h:59
isRGBA32
#define isRGBA32(x)
Definition: swscale_unscaled.c:1433
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:696
SWS_BITEXACT
#define SWS_BITEXACT
Definition: swscale.h:85
planarRgbToplanarRgbWrapper
static int planarRgbToplanarRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1129
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:409
planarCopyWrapper
static int planarCopyWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1801
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
isRGBA64
#define isRGBA64(x)
Definition: swscale_unscaled.c:1440
planarToP01xWrapper
static int planarToP01xWrapper(SwsContext *c, const uint8_t *src8[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam8[], int dstStride[])
Definition: swscale_unscaled.c:224
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:407
ff_get_unscaled_swscale_aarch64
void ff_get_unscaled_swscale_aarch64(SwsContext *c)
Definition: swscale_unscaled.c:124
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:389
rgb16tobgr16
void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:239
gbraptopacked32
static void gbraptopacked32(const uint8_t *src[], int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha_first, int width)
Definition: swscale_unscaled.c:988
val
static double val(void *priv, double ch)
Definition: aeval.c:76
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:710
ff_rgb24toyv12
void(* ff_rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, int width, int height, int lumStride, int chromStride, int srcStride, int32_t *rgb2yuv)
Height should be a multiple of 2 and width should be a multiple of 2.
Definition: rgb2rgb.c:81
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:375
rgb48tobgr64_bswap
void rgb48tobgr64_bswap(const uint8_t *src, uint8_t *dst, int src_size)
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:1974
DITHER_COPY
#define DITHER_COPY(dst, dstStride, src, srcStride, bswap, dbswap)
Definition: swscale_unscaled.c:1741
SWS_POINT
#define SWS_POINT
Definition: swscale.h:63
bswap_32bpc
static int bswap_32bpc(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:494
av_bswap32
#define av_bswap32
Definition: bswap.h:33
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:394
isRGB48
#define isRGB48(x)
Definition: swscale_unscaled.c:1447
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_PIX_FMT_BAYER_RGGB16BE
@ AV_PIX_FMT_BAYER_RGGB16BE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:257
SwsContext::srcFormat
enum AVPixelFormat srcFormat
Source pixel format.
Definition: swscale_internal.h:332
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:403
rgb16tobgr24
void(* rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:42
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:411
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:206
planarRgb16ToRgb16Wrapper
static int planarRgb16ToRgb16Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:881
width
#define width
intreadwrite.h
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:165
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:412
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
copyPlane
static void copyPlane(const uint8_t *src, int srcStride, int srcSliceY, int srcSliceH, int width, uint8_t *dst, int dstStride)
Definition: swscale_unscaled.c:125
AV_PIX_FMT_BAYER_RGGB16LE
@ AV_PIX_FMT_BAYER_RGGB16LE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:256
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:404
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
AV_PIX_FMT_BAYER_BGGR8
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
Definition: pixfmt.h:250
shuffle_bytes_1230
void(* shuffle_bytes_1230)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:56
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:245
rgb15tobgr24
void(* rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:43
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:388
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:402
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:374
yuv422ptoyuy2
void(* yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, int width, int height, int lumStride, int chromStride, int dstStride)
Width should be a multiple of 16.
Definition: rgb2rgb.c:69
shuffle_bytes_2103
void(* shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:55
rgb32tobgr15
void(* rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:37
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:163
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
rgb48to64_bswap
void rgb48to64_bswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:423
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:367
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
SwsContext::dstFormat
enum AVPixelFormat dstFormat
Destination pixel format.
Definition: swscale_internal.h:331
conv
static int conv(int samples, float **pcm, char *buf, int channels)
Definition: libvorbisdec.c:131
AV_PIX_FMT_BAYER_RGGB8
@ AV_PIX_FMT_BAYER_RGGB8
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
Definition: pixfmt.h:251
rgb16to24
void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:225
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AV_PIX_FMT_BAYER_BGGR16
#define AV_PIX_FMT_BAYER_BGGR16
Definition: pixfmt.h:415
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:372
rgb12to15
void rgb12to15(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:206
interleaveBytes
void(* interleaveBytes)(const uint8_t *src1, const uint8_t *src2, uint8_t *dst, int width, int height, int src1Stride, int src2Stride, int dstStride)
Definition: rgb2rgb.c:88
isSemiPlanarYUV
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:742
AV_PIX_FMT_BAYER_GRBG16LE
@ AV_PIX_FMT_BAYER_GRBG16LE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:260
rgbToPlanarRgbWrapper
static int rgbToPlanarRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1175
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:410
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:381
float_y_to_uint_y_wrapper
static int float_y_to_uint_y_wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1693
packedCopyWrapper
static int packedCopyWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1714
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:277
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:382
NULL
#define NULL
Definition: coverity.c:32
rgb16to15
void(* rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:50
bgr24ToYv12Wrapper
static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1640
bayer_to_yv12_wrapper
static int bayer_to_yv12_wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1378
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
gray8aToPacked24
static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:453
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:196
src
#define src
Definition: vp8dsp.c:255
findRgbConvFn
static rgbConvFn findRgbConvFn(SwsContext *c)
Definition: swscale_unscaled.c:1456
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:393
AV_PIX_FMT_BAYER_GBRG16
#define AV_PIX_FMT_BAYER_GBRG16
Definition: pixfmt.h:417
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:392
ff_get_unscaled_swscale_ppc
av_cold void ff_get_unscaled_swscale_ppc(SwsContext *c)
Definition: yuv2yuv_altivec.c:187
yvu9ToYv12Wrapper
static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1657
rgbConvFn
void(* rgbConvFn)(const uint8_t *, uint8_t *, int)
Definition: swscale_unscaled.c:1455
COPY816
#define COPY816(w)
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
gbr24ptopacked24
static void gbr24ptopacked24(const uint8_t *src[], int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int width)
Definition: swscale_unscaled.c:941
yuyvtoyuv420
void(* yuyvtoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition: rgb2rgb.c:110
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:406
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
rgb15tobgr16
void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:295
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
rgb64tobgr48_bswap
void rgb64tobgr48_bswap(const uint8_t *src, uint8_t *dst, int src_size)
dithers
static const uint8_t dithers[8][8][8]
Definition: swscale_unscaled.c:38
rgb24tobgr32
void(* rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:38
rgb64to48_nobswap
void rgb64to48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
planar8ToP01xleWrapper
static int planar8ToP01xleWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam8[], int dstStride[])
Definition: swscale_unscaled.c:284
packed16togbra16
static void packed16togbra16(const uint8_t *src, int srcStride, uint16_t *dst[], int dstStride[], int srcSliceH, int src_alpha, int swap, int shift, int width)
Definition: swscale_unscaled.c:568
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:717
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
planarRgbToRgbWrapper
static int planarRgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1073
planarRgbaToRgbWrapper
static int planarRgbaToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1017
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:187
planarToNv12Wrapper
static int planarToNv12Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:142
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
fillPlane16
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
Definition: swscale_internal.h:966
AV_PIX_FMT_BAYER_BGGR16LE
@ AV_PIX_FMT_BAYER_BGGR16LE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:254
usePal
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:880
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:825
gbr16ptopacked16
static void gbr16ptopacked16(const uint16_t *src[], int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha, int swap, int bpp, int width)
Definition: swscale_unscaled.c:762
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:420
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:396
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:377
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:384
srcSliceH
return srcSliceH
Definition: yuv2rgb_template.c:87
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:398
gray8aToPacked32_1
static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:444
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:160
rgb64tobgr48_nobswap
void rgb64tobgr48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_AYUV64
#define AV_PIX_FMT_AYUV64
Definition: pixfmt.h:439
shuffle_bytes_0321
void(* shuffle_bytes_0321)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:54
IS_DIFFERENT_ENDIANESS
#define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt)
Definition: swscale_unscaled.c:1969
rgb32to24
void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:146
rgb15tobgr15
void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:305
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:678
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:161
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:364
isBGRinInt
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:789
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:281
CASE
#define CASE(pixfmt, prefix)
av_bswap16
#define av_bswap16
Definition: bswap.h:31
rgb24to16
void(* rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:47
SWS_ACCURATE_RND
#define SWS_ACCURATE_RND
Definition: swscale.h:84
interpolate
static void interpolate(float *out, float v1, float v2, int size)
Definition: twinvq.c:84
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:198
yuyvToYuv420Wrapper
static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:374
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
uyvytoyuv422
void(* uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition: rgb2rgb.c:107
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:437
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:386
AVComponentDescriptor::shift
int shift
Number of least significant bits that must be shifted away to get the value.
Definition: pixdesc.h:52
FAST_COPY_UP
#define FAST_COPY_UP(shift)
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:376
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
rgb24to15
void(* rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:48
planarToYuy2Wrapper
static int planarToYuy2Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:326
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:408
AV_PIX_FMT_NV24
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:338
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:385
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
yuv422pToUyvyWrapper
static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:362
AV_PIX_FMT_BAYER_GBRG8
@ AV_PIX_FMT_BAYER_GBRG8
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
Definition: pixfmt.h:252
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:379
rgb32to15
void(* rgb32to15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:46
rgb48tobgr64_nobswap
void rgb48tobgr64_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
swscale_internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
fillPlane
static void fillPlane(uint8_t *plane, int stride, int width, int height, int y, uint8_t val)
Definition: swscale_unscaled.c:114
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:383
uint_y_to_float_y_wrapper
static int uint_y_to_float_y_wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1673
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:339
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:390
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:833
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:441
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:378
output_pixel
#define output_pixel(p, v)
Definition: swscale_unscaled.c:281
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:207
uyvyToYuv420Wrapper
static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:405
bswap.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
planarToUyvyWrapper
static int planarToUyvyWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:338
AV_PIX_FMT_BAYER_BGGR16BE
@ AV_PIX_FMT_BAYER_BGGR16BE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:255
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:290
nv24ToPlanarWrapper
static int nv24ToPlanarWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:203
deinterleaveBytes
void(* deinterleaveBytes)(const uint8_t *src, uint8_t *dst1, uint8_t *dst2, int width, int height, int srcStride, int dst1Stride, int dst2Stride)
Definition: rgb2rgb.c:91
isPlanarGray
#define isPlanarGray(x)
rgb48to64_nobswap
void rgb48to64_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
rgb48tobgr48_bswap
void rgb48tobgr48_bswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:395
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:244
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
uyvytoyuv420
void(* uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, int width, int height, int lumStride, int chromStride, int srcStride)
Definition: rgb2rgb.c:104
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:400
rgb16to32
void(* rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:49
gray8aToPacked32
static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:436
isPackedRGB
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:865
rgb24to32
void rgb24to32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:164
rgb24tobgr15
void(* rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:41
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:421
rgb15tobgr32
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:259
rgb15to16
void(* rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:51
nv12ToPlanarWrapper
static int nv12ToPlanarWrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:162
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
COPY_UP
#define COPY_UP(r, w)
yuv422ptouyvy
void(* yuv422ptouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, int width, int height, int lumStride, int chromStride, int dstStride)
Width should be a multiple of 16.
Definition: rgb2rgb.c:73
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
ALT32_CORR
#define ALT32_CORR
Definition: swscale_internal.h:53
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
rgb24tobgr24
void(* rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:39
ff_get_unscaled_swscale_arm
void ff_get_unscaled_swscale_arm(SwsContext *c)
Definition: swscale_unscaled.c:183
isPlanarYUV
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: vf_dnn_processing.c:155
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:440
rgb64to48_bswap
void rgb64to48_bswap(const uint8_t *src, uint8_t *dst, int src_size)
shift
static int shift(int a, int b)
Definition: sonic.c:83
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
bayer_to_rgb24_wrapper
static int bayer_to_rgb24_wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1280
avutil.h
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AV_PIX_FMT_P010LE
@ AV_PIX_FMT_P010LE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:274
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
yuyvToYuv422Wrapper
static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dstParam[], int dstStride[])
Definition: swscale_unscaled.c:391
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:72
isRGBinInt
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:767
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:247
bayer_to_rgb48_wrapper
static int bayer_to_rgb48_wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_unscaled.c:1329
int32_t
int32_t
Definition: audioconvert.c:56
IS_NOT_NE
#define IS_NOT_NE(bpp, desc)
RGBA
#define RGBA(r, g, b, a)
Definition: dvbsubdec.c:40
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
planar2x
void(* planar2x)(const uint8_t *src, uint8_t *dst, int width, int height, int srcStride, int dstStride)
Definition: rgb2rgb.c:86
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
packedtogbr24p
static void packedtogbr24p(const uint8_t *src, int srcStride, uint8_t *dst[], int dstStride[], int srcSliceH, int alpha_first, int inc_size, int width)
Definition: swscale_unscaled.c:1146
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:280
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:397
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:401
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:858
sws_convertPalette8ToPacked32
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Convert an 8-bit paletted frame into a frame with a color depth of 32 bits.
Definition: swscale_unscaled.c:2234
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:373
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:416
int
int
Definition: ffmpeg_filter.c:156
SwsContext
Definition: swscale_internal.h:300
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:324
AV_PIX_FMT_BAYER_GRBG8
@ AV_PIX_FMT_BAYER_GRBG8
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
Definition: pixfmt.h:253
rgb2rgb.h
swscale.h
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:399
isByteRGB
#define isByteRGB(f)
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2484
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:138
rgb16tobgr15
void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:249
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:380