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