FFmpeg
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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(SwsInternal *c, const uint8_t *const src[],
143  const int srcStride[], int srcSliceY,
144  int srcSliceH, uint8_t *const dstParam[],
145  const int dstStride[])
146 {
147  uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY / 2;
148 
149  ff_copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->opts.src_w,
150  dstParam[0], dstStride[0]);
151 
152  if (c->opts.dst_format == 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(SwsInternal *c, const uint8_t *const src[],
163  const int srcStride[], int srcSliceY,
164  int srcSliceH, uint8_t *const dstParam[],
165  const 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->opts.src_w,
171  dstParam[0], dstStride[0]);
172 
173  if (c->opts.src_format == 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(SwsInternal *c, const uint8_t *const src[],
184  const int srcStride[], int srcSliceY,
185  int srcSliceH, uint8_t *const dstParam[],
186  const int dstStride[])
187 {
188  uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY;
189 
190  ff_copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->opts.src_w,
191  dstParam[0], dstStride[0]);
192 
193  if (c->opts.dst_format == 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(SwsInternal *c, const uint8_t *const src[],
204  const int srcStride[], int srcSliceY,
205  int srcSliceH, uint8_t *const dstParam[],
206  const 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->opts.src_w,
212  dstParam[0], dstStride[0]);
213 
214  if (c->opts.src_format == 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(SwsInternal *c, const uint8_t *const src[],
249  const int srcStride[], int srcSliceY, int srcSliceH,
250  uint8_t *const dstParam[], const 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->opts.src_w,
256  dstParam[0], dstStride[0]);
257 
258  if (c->opts.src_format == AV_PIX_FMT_NV24)
259  nv24_to_yuv420p_chroma(dst1, dstStride[1], dst2, dstStride[2],
260  src[1], srcStride[1], c->opts.src_w / 2, srcSliceH);
261  else
262  nv24_to_yuv420p_chroma(dst2, dstStride[2], dst1, dstStride[1],
263  src[1], srcStride[1], c->opts.src_w / 2, srcSliceH);
264 
265  return srcSliceH;
266 }
267 
268 static int planarToP01xWrapper(SwsInternal *c, const uint8_t *const src8[],
269  const int srcStride[], int srcSliceY,
270  int srcSliceH, uint8_t *const dstParam8[],
271  const int dstStride[])
272 {
273  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->opts.src_format);
274  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->opts.dst_format);
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->opts.src_w; 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->opts.src_w / 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(SwsInternal *c, const uint8_t *const src[],
329  const int srcStride[], int srcSliceY,
330  int srcSliceH, uint8_t *const dstParam8[],
331  const int dstStride[])
332 {
333  const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
334  uint16_t *dstY = (uint16_t*)(dstParam8[0] + dstStride[0] * srcSliceY);
335  uint16_t *dstUV = (uint16_t*)(dstParam8[1] + dstStride[1] * srcSliceY / 2);
336  int x, y, t;
337 
338  av_assert0(!(dstStride[0] % 2 || dstStride[1] % 2));
339 
340  for (y = 0; y < srcSliceH; y++) {
341  uint16_t *tdstY = dstY;
342  const uint8_t *tsrc0 = src0;
343  for (x = c->opts.src_w; x > 0; x--) {
344  t = *tsrc0++;
345  output_pixel(tdstY++, t << 8);
346  }
347  src0 += srcStride[0];
348  dstY += dstStride[0] / 2;
349 
350  if (!(y & 1)) {
351  uint16_t *tdstUV = dstUV;
352  const uint8_t *tsrc1 = src1;
353  const uint8_t *tsrc2 = src2;
354  for (x = c->opts.src_w / 2; x > 0; x--) {
355  t = *tsrc1++;
356  output_pixel(tdstUV++, t << 8);
357  t = *tsrc2++;
358  output_pixel(tdstUV++, t << 8);
359  }
360  src1 += srcStride[1];
361  src2 += srcStride[2];
362  dstUV += dstStride[1] / 2;
363  }
364  }
365 
366  return srcSliceH;
367 }
368 
369 #undef output_pixel
370 
371 static int planarToYuy2Wrapper(SwsInternal *c, const uint8_t *const src[],
372  const int srcStride[], int srcSliceY, int srcSliceH,
373  uint8_t *const dstParam[], const int dstStride[])
374 {
375  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
376 
377  yv12toyuy2(src[0], src[1], src[2], dst, c->opts.src_w, srcSliceH, srcStride[0],
378  srcStride[1], dstStride[0]);
379 
380  return srcSliceH;
381 }
382 
383 static int planarToUyvyWrapper(SwsInternal *c, const uint8_t *const src[],
384  const int srcStride[], int srcSliceY, int srcSliceH,
385  uint8_t *const dstParam[], const int dstStride[])
386 {
387  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
388 
389  yv12touyvy(src[0], src[1], src[2], dst, c->opts.src_w, srcSliceH, srcStride[0],
390  srcStride[1], dstStride[0]);
391 
392  return srcSliceH;
393 }
394 
395 static int yuv422pToYuy2Wrapper(SwsInternal *c, const uint8_t *const src[],
396  const int srcStride[], int srcSliceY, int srcSliceH,
397  uint8_t *const dstParam[], const int dstStride[])
398 {
399  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
400 
401  yuv422ptoyuy2(src[0], src[1], src[2], dst, c->opts.src_w, srcSliceH, srcStride[0],
402  srcStride[1], dstStride[0]);
403 
404  return srcSliceH;
405 }
406 
407 static int yuv422pToUyvyWrapper(SwsInternal *c, const uint8_t *const src[],
408  const int srcStride[], int srcSliceY, int srcSliceH,
409  uint8_t *const dstParam[], const int dstStride[])
410 {
411  uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
412 
413  yuv422ptouyvy(src[0], src[1], src[2], dst, c->opts.src_w, srcSliceH, srcStride[0],
414  srcStride[1], dstStride[0]);
415 
416  return srcSliceH;
417 }
418 
419 static int yuyvToYuv420Wrapper(SwsInternal *c, const uint8_t *const src[],
420  const int srcStride[], int srcSliceY, int srcSliceH,
421  uint8_t *const dstParam[], const int dstStride[])
422 {
423  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
424  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
425  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
426 
427  yuyvtoyuv420(ydst, udst, vdst, src[0], c->opts.src_w, srcSliceH, dstStride[0],
428  dstStride[1], srcStride[0]);
429 
430  if (dstParam[3])
431  fillPlane(dstParam[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 255);
432 
433  return srcSliceH;
434 }
435 
436 static int yuyvToYuv422Wrapper(SwsInternal *c, const uint8_t *const src[],
437  const int srcStride[], int srcSliceY, int srcSliceH,
438  uint8_t *const dstParam[], const int dstStride[])
439 {
440  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
441  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
442  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
443 
444  yuyvtoyuv422(ydst, udst, vdst, src[0], c->opts.src_w, srcSliceH, dstStride[0],
445  dstStride[1], srcStride[0]);
446 
447  return srcSliceH;
448 }
449 
450 static int uyvyToYuv420Wrapper(SwsInternal *c, const uint8_t *const src[],
451  const int srcStride[], int srcSliceY, int srcSliceH,
452  uint8_t *const dstParam[], const int dstStride[])
453 {
454  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
455  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
456  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
457 
458  uyvytoyuv420(ydst, udst, vdst, src[0], c->opts.src_w, srcSliceH, dstStride[0],
459  dstStride[1], srcStride[0]);
460 
461  if (dstParam[3])
462  fillPlane(dstParam[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 255);
463 
464  return srcSliceH;
465 }
466 
467 static int uyvyToYuv422Wrapper(SwsInternal *c, const uint8_t *const src[],
468  const int srcStride[], int srcSliceY, int srcSliceH,
469  uint8_t *const dstParam[], const int dstStride[])
470 {
471  uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
472  uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
473  uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
474 
475  uyvytoyuv422(ydst, udst, vdst, src[0], c->opts.src_w, srcSliceH, dstStride[0],
476  dstStride[1], srcStride[0]);
477 
478  return srcSliceH;
479 }
480 
481 static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels,
482  const uint8_t *palette)
483 {
484  int i;
485  for (i = 0; i < num_pixels; i++)
486  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | (src[(i << 1) + 1] << 24);
487 }
488 
489 static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels,
490  const uint8_t *palette)
491 {
492  int i;
493 
494  for (i = 0; i < num_pixels; i++)
495  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | src[(i << 1) + 1];
496 }
497 
498 static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels,
499  const uint8_t *palette)
500 {
501  int i;
502 
503  for (i = 0; i < num_pixels; i++) {
504  //FIXME slow?
505  dst[0] = palette[src[i << 1] * 4 + 0];
506  dst[1] = palette[src[i << 1] * 4 + 1];
507  dst[2] = palette[src[i << 1] * 4 + 2];
508  dst += 3;
509  }
510 }
511 
512 static void gray8aToPlanar8(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
513  uint8_t *dst2, uint8_t *dstA, int num_pixels,
514  const uint8_t *palette)
515 {
516  for (int i = 0; i < num_pixels; i++) {
517  const uint8_t *rgb = &palette[src[i << 1] * 4];
518  dst0[i] = rgb[0];
519  dst1[i] = rgb[1];
520  dst2[i] = rgb[2];
521  if (dstA)
522  dstA[i] = src[(i << 1) + 1];
523  }
524 }
525 
526 static void pal8ToPlanar8(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
527  uint8_t *dst2, uint8_t *dstA, int num_pixels,
528  const uint8_t *palette)
529 {
530  for (int i = 0; i < num_pixels; i++) {
531  const uint8_t *rgba = &palette[src[i] * 4];
532  dst0[i] = rgba[0];
533  dst1[i] = rgba[1];
534  dst2[i] = rgba[2];
535  if (dstA)
536  dstA[i] = rgba[3];
537  }
538 }
539 
540 static int bswap_16bpc(SwsInternal *c, const uint8_t *const src[],
541  const int srcStride[], int srcSliceY, int srcSliceH,
542  uint8_t *const dst[], const int dstStride[])
543 {
544  int i, j, p;
545 
546  for (p = 0; p < 4; p++) {
547  int srcstr = srcStride[p] / 2;
548  int dststr = dstStride[p] / 2;
549  uint16_t *dstPtr = (uint16_t *) dst[p];
550  const uint16_t *srcPtr = (const uint16_t *) src[p];
551  int min_stride = FFMIN(FFABS(srcstr), FFABS(dststr));
552  if(!dstPtr || !srcPtr)
553  continue;
554  dstPtr += (srcSliceY >> c->chrDstVSubSample) * dststr;
555  for (i = 0; i < (srcSliceH >> c->chrDstVSubSample); i++) {
556  for (j = 0; j < min_stride; j++) {
557  dstPtr[j] = av_bswap16(srcPtr[j]);
558  }
559  srcPtr += srcstr;
560  dstPtr += dststr;
561  }
562  }
563 
564  return srcSliceH;
565 }
566 
567 static int bswap_32bpc(SwsInternal *c, const uint8_t *const src[],
568  const int srcStride[], int srcSliceY, int srcSliceH,
569  uint8_t *const dst[], const int dstStride[])
570 {
571  int i, j, p;
572 
573  for (p = 0; p < 4; p++) {
574  int srcstr = srcStride[p] / 4;
575  int dststr = dstStride[p] / 4;
576  uint32_t *dstPtr = (uint32_t *) dst[p];
577  const uint32_t *srcPtr = (const uint32_t *) src[p];
578  int min_stride = FFMIN(FFABS(srcstr), FFABS(dststr));
579  if(!dstPtr || !srcPtr)
580  continue;
581  dstPtr += (srcSliceY >> c->chrDstVSubSample) * dststr;
582  for (i = 0; i < (srcSliceH >> c->chrDstVSubSample); i++) {
583  for (j = 0; j < min_stride; j++) {
584  dstPtr[j] = av_bswap32(srcPtr[j]);
585  }
586  srcPtr += srcstr;
587  dstPtr += dststr;
588  }
589  }
590 
591  return srcSliceH;
592 }
593 
594 
595 static int palToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[],
596  int srcSliceY, int srcSliceH, uint8_t *const dst[],
597  const int dstStride[])
598 {
599  const enum AVPixelFormat srcFormat = c->opts.src_format;
600  const enum AVPixelFormat dstFormat = c->opts.dst_format;
601  void (*conv)(const uint8_t *src, uint8_t *dst, int num_pixels,
602  const uint8_t *palette) = NULL;
603  int i;
604  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
605  const uint8_t *srcPtr = src[0];
606 
607  if (srcFormat == AV_PIX_FMT_YA8) {
608  switch (dstFormat) {
609  case AV_PIX_FMT_RGB32 : conv = gray8aToPacked32; break;
610  case AV_PIX_FMT_BGR32 : conv = gray8aToPacked32; break;
611  case AV_PIX_FMT_BGR32_1: conv = gray8aToPacked32_1; break;
612  case AV_PIX_FMT_RGB32_1: conv = gray8aToPacked32_1; break;
613  case AV_PIX_FMT_RGB24 : conv = gray8aToPacked24; break;
614  case AV_PIX_FMT_BGR24 : conv = gray8aToPacked24; break;
615  }
616  } else if (usePal(srcFormat)) {
617  switch (dstFormat) {
618  case AV_PIX_FMT_RGB32 : conv = sws_convertPalette8ToPacked32; break;
619  case AV_PIX_FMT_BGR32 : conv = sws_convertPalette8ToPacked32; break;
620  case AV_PIX_FMT_BGR32_1: conv = sws_convertPalette8ToPacked32; break;
621  case AV_PIX_FMT_RGB32_1: conv = sws_convertPalette8ToPacked32; break;
622  case AV_PIX_FMT_RGB24 : conv = sws_convertPalette8ToPacked24; break;
623  case AV_PIX_FMT_BGR24 : conv = sws_convertPalette8ToPacked24; break;
624  }
625  }
626 
627  if (!conv)
628  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
629  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
630  else {
631  for (i = 0; i < srcSliceH; i++) {
632  conv(srcPtr, dstPtr, c->opts.src_w, (uint8_t *) c->pal_rgb);
633  srcPtr += srcStride[0];
634  dstPtr += dstStride[0];
635  }
636  }
637 
638  return srcSliceH;
639 }
640 
641 static int palToGbrpWrapper(SwsInternal *c, const uint8_t *const src[],
642  const int srcStride[], int srcSliceY, int srcSliceH,
643  uint8_t *const dst[], const int dstStride[])
644 {
645  const enum AVPixelFormat srcFormat = c->opts.src_format;
646  const enum AVPixelFormat dstFormat = c->opts.dst_format;
647  void (*conv)(const uint8_t *src, uint8_t *dstG, uint8_t *dstB, uint8_t *dstR,
648  uint8_t *dstA, int num_pixels, const uint8_t *palette) = NULL;
649 
650  const int num_planes = isALPHA(dstFormat) ? 4 : 3;
651  const uint8_t *srcPtr = src[0];
652  uint8_t *dstPtr[4] = {0};
653  for (int i = 0; i < num_planes; i++)
654  dstPtr[i] = dst[i] + dstStride[i] * srcSliceY;
655 
656  if (srcFormat == AV_PIX_FMT_YA8) {
657  switch (dstFormat) {
658  case AV_PIX_FMT_GBRP: conv = gray8aToPlanar8; break;
659  case AV_PIX_FMT_GBRAP: conv = gray8aToPlanar8; break;
660  }
661  } else if (usePal(srcFormat)) {
662  switch (dstFormat) {
663  case AV_PIX_FMT_GBRP: conv = pal8ToPlanar8; break;
664  case AV_PIX_FMT_GBRAP: conv = pal8ToPlanar8; break;
665  }
666  }
667 
668  av_assert1(conv);
669  for (int y = 0; y < srcSliceH; y++) {
670  conv(srcPtr, dstPtr[0], dstPtr[1], dstPtr[2], dstPtr[3], c->opts.src_w,
671  (uint8_t *) c->pal_rgb);
672  srcPtr += srcStride[0];
673  for (int i = 0; i < num_planes; i++)
674  dstPtr[i] += dstStride[i];
675  }
676 
677  return srcSliceH;
678 }
679 
680 static void packed16togbra16(const uint8_t *src, int srcStride,
681  uint16_t *dst[], const int dstStride[], int srcSliceH,
682  int src_alpha, int swap, int shift, int width)
683 {
684  int x, h, i;
685  int dst_alpha = dst[3] != NULL;
686  for (h = 0; h < srcSliceH; h++) {
687  uint16_t *src_line = (uint16_t *)(src + srcStride * h);
688  switch (swap) {
689  case 3:
690  if (src_alpha && dst_alpha) {
691  for (x = 0; x < width; x++) {
692  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
693  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
694  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
695  dst[3][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
696  }
697  } else if (dst_alpha) {
698  for (x = 0; x < width; x++) {
699  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
700  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
701  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
702  dst[3][x] = av_bswap16(0xFFFF >> shift);
703  }
704  } else if (src_alpha) {
705  for (x = 0; x < width; x++) {
706  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
707  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
708  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
709  src_line++;
710  }
711  } else {
712  for (x = 0; x < width; x++) {
713  dst[0][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
714  dst[1][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
715  dst[2][x] = av_bswap16(av_bswap16(*src_line++) >> shift);
716  }
717  }
718  break;
719  case 2:
720  if (src_alpha && dst_alpha) {
721  for (x = 0; x < width; x++) {
722  dst[0][x] = av_bswap16(*src_line++ >> shift);
723  dst[1][x] = av_bswap16(*src_line++ >> shift);
724  dst[2][x] = av_bswap16(*src_line++ >> shift);
725  dst[3][x] = av_bswap16(*src_line++ >> shift);
726  }
727  } else if (dst_alpha) {
728  for (x = 0; x < width; x++) {
729  dst[0][x] = av_bswap16(*src_line++ >> shift);
730  dst[1][x] = av_bswap16(*src_line++ >> shift);
731  dst[2][x] = av_bswap16(*src_line++ >> shift);
732  dst[3][x] = av_bswap16(0xFFFF >> shift);
733  }
734  } else if (src_alpha) {
735  for (x = 0; x < width; x++) {
736  dst[0][x] = av_bswap16(*src_line++ >> shift);
737  dst[1][x] = av_bswap16(*src_line++ >> shift);
738  dst[2][x] = av_bswap16(*src_line++ >> shift);
739  src_line++;
740  }
741  } else {
742  for (x = 0; x < width; x++) {
743  dst[0][x] = av_bswap16(*src_line++ >> shift);
744  dst[1][x] = av_bswap16(*src_line++ >> shift);
745  dst[2][x] = av_bswap16(*src_line++ >> shift);
746  }
747  }
748  break;
749  case 1:
750  if (src_alpha && dst_alpha) {
751  for (x = 0; x < width; x++) {
752  dst[0][x] = av_bswap16(*src_line++) >> shift;
753  dst[1][x] = av_bswap16(*src_line++) >> shift;
754  dst[2][x] = av_bswap16(*src_line++) >> shift;
755  dst[3][x] = av_bswap16(*src_line++) >> shift;
756  }
757  } else if (dst_alpha) {
758  for (x = 0; x < width; x++) {
759  dst[0][x] = av_bswap16(*src_line++) >> shift;
760  dst[1][x] = av_bswap16(*src_line++) >> shift;
761  dst[2][x] = av_bswap16(*src_line++) >> shift;
762  dst[3][x] = 0xFFFF >> shift;
763  }
764  } else if (src_alpha) {
765  for (x = 0; x < width; x++) {
766  dst[0][x] = av_bswap16(*src_line++) >> shift;
767  dst[1][x] = av_bswap16(*src_line++) >> shift;
768  dst[2][x] = av_bswap16(*src_line++) >> shift;
769  src_line++;
770  }
771  } else {
772  for (x = 0; x < width; x++) {
773  dst[0][x] = av_bswap16(*src_line++) >> shift;
774  dst[1][x] = av_bswap16(*src_line++) >> shift;
775  dst[2][x] = av_bswap16(*src_line++) >> shift;
776  }
777  }
778  break;
779  default:
780  if (src_alpha && dst_alpha) {
781  for (x = 0; x < width; x++) {
782  dst[0][x] = *src_line++ >> shift;
783  dst[1][x] = *src_line++ >> shift;
784  dst[2][x] = *src_line++ >> shift;
785  dst[3][x] = *src_line++ >> shift;
786  }
787  } else if (dst_alpha) {
788  for (x = 0; x < width; x++) {
789  dst[0][x] = *src_line++ >> shift;
790  dst[1][x] = *src_line++ >> shift;
791  dst[2][x] = *src_line++ >> shift;
792  dst[3][x] = 0xFFFF >> shift;
793  }
794  } else if (src_alpha) {
795  for (x = 0; x < width; x++) {
796  dst[0][x] = *src_line++ >> shift;
797  dst[1][x] = *src_line++ >> shift;
798  dst[2][x] = *src_line++ >> shift;
799  src_line++;
800  }
801  } else {
802  for (x = 0; x < width; x++) {
803  dst[0][x] = *src_line++ >> shift;
804  dst[1][x] = *src_line++ >> shift;
805  dst[2][x] = *src_line++ >> shift;
806  }
807  }
808  }
809  for (i = 0; i < 4; i++)
810  dst[i] += dstStride[i] >> 1;
811  }
812 }
813 
814 static void packed30togbra10(const uint8_t *src, int srcStride,
815  uint16_t *dst[], const int dstStride[], int srcSliceH,
816  int swap, int bpc, int width)
817 {
818  int x, h, i;
819  int dst_alpha = dst[3] != NULL;
820  int scale_high = bpc - 10, scale_low = 10 - scale_high;
821  uint16_t alpha_val = (1U << bpc) - 1;
822  for (h = 0; h < srcSliceH; h++) {
823  uint32_t *src_line = (uint32_t *)(src + srcStride * h);
824  unsigned component;
825 
826  switch (swap) {
827  case 3:
828  case 2:
829  if (dst_alpha) {
830  for (x = 0; x < width; x++) {
831  unsigned p = AV_RL32(src_line);
832  component = (p >> 20) & 0x3FF;
833  dst[0][x] = av_bswap16(component << scale_high | component >> scale_low);
834  component = (p >> 10) & 0x3FF;
835  dst[1][x] = av_bswap16(component << scale_high | component >> scale_low);
836  component = p & 0x3FF;
837  dst[2][x] = av_bswap16(component << scale_high | component >> scale_low);
838  dst[3][x] = av_bswap16(alpha_val);
839  src_line++;
840  }
841  } else {
842  for (x = 0; x < width; x++) {
843  unsigned p = AV_RL32(src_line);
844  component = (p >> 20) & 0x3FF;
845  dst[0][x] = av_bswap16(component << scale_high | component >> scale_low);
846  component = (p >> 10) & 0x3FF;
847  dst[1][x] = av_bswap16(component << scale_high | component >> scale_low);
848  component = p & 0x3FF;
849  dst[2][x] = av_bswap16(component << scale_high | component >> scale_low);
850  src_line++;
851  }
852  }
853  break;
854  default:
855  if (dst_alpha) {
856  for (x = 0; x < width; x++) {
857  unsigned p = AV_RL32(src_line);
858  component = (p >> 20) & 0x3FF;
859  dst[0][x] = component << scale_high | component >> scale_low;
860  component = (p >> 10) & 0x3FF;
861  dst[1][x] = component << scale_high | component >> scale_low;
862  component = p & 0x3FF;
863  dst[2][x] = component << scale_high | component >> scale_low;
864  dst[3][x] = alpha_val;
865  src_line++;
866  }
867  } else {
868  for (x = 0; x < width; x++) {
869  unsigned p = AV_RL32(src_line);
870  component = (p >> 20) & 0x3FF;
871  dst[0][x] = component << scale_high | component >> scale_low;
872  component = (p >> 10) & 0x3FF;
873  dst[1][x] = component << scale_high | component >> scale_low;
874  component = p & 0x3FF;
875  dst[2][x] = component << scale_high | component >> scale_low;
876  src_line++;
877  }
878  }
879  break;
880  }
881  for (i = 0; i < 4; i++)
882  dst[i] += dstStride[i] >> 1;
883  }
884 }
885 
886 static int Rgb16ToPlanarRgb16Wrapper(SwsInternal *c, const uint8_t *const src[],
887  const int srcStride[], int srcSliceY, int srcSliceH,
888  uint8_t *const dst[], const int dstStride[])
889 {
890  uint16_t *dst2013[] = { (uint16_t *)dst[2], (uint16_t *)dst[0], (uint16_t *)dst[1], (uint16_t *)dst[3] };
891  uint16_t *dst1023[] = { (uint16_t *)dst[1], (uint16_t *)dst[0], (uint16_t *)dst[2], (uint16_t *)dst[3] };
892  int stride2013[] = { dstStride[2], dstStride[0], dstStride[1], dstStride[3] };
893  int stride1023[] = { dstStride[1], dstStride[0], dstStride[2], dstStride[3] };
894  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->opts.src_format);
895  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->opts.dst_format);
896  int bpc = dst_format->comp[0].depth;
897  int alpha = src_format->flags & AV_PIX_FMT_FLAG_ALPHA;
898  int swap = 0;
899  int i;
900 
901  if ( HAVE_BIGENDIAN && !(src_format->flags & AV_PIX_FMT_FLAG_BE) ||
902  !HAVE_BIGENDIAN && src_format->flags & AV_PIX_FMT_FLAG_BE)
903  swap++;
904  if ( HAVE_BIGENDIAN && !(dst_format->flags & AV_PIX_FMT_FLAG_BE) ||
905  !HAVE_BIGENDIAN && dst_format->flags & AV_PIX_FMT_FLAG_BE)
906  swap += 2;
907 
908  if ((dst_format->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) !=
909  (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB) || bpc < 9) {
910  av_log(c, AV_LOG_ERROR, "unsupported conversion to planar RGB %s -> %s\n",
911  src_format->name, dst_format->name);
912  return srcSliceH;
913  }
914 
915  for(i=0; i<4; i++) {
916  dst2013[i] += stride2013[i] * srcSliceY / 2;
917  dst1023[i] += stride1023[i] * srcSliceY / 2;
918  }
919 
920  switch (c->opts.src_format) {
921  case AV_PIX_FMT_RGB48LE:
922  case AV_PIX_FMT_RGB48BE:
923  case AV_PIX_FMT_RGBA64LE:
924  case AV_PIX_FMT_RGBA64BE:
925  packed16togbra16(src[0], srcStride[0],
926  dst2013, stride2013, srcSliceH, alpha, swap,
927  16 - bpc, c->opts.src_w);
928  break;
929  case AV_PIX_FMT_X2RGB10LE:
930  av_assert0(bpc >= 10);
931  packed30togbra10(src[0], srcStride[0],
932  dst2013, stride2013, srcSliceH, swap,
933  bpc, c->opts.src_w);
934  break;
935  case AV_PIX_FMT_BGR48LE:
936  case AV_PIX_FMT_BGR48BE:
937  case AV_PIX_FMT_BGRA64LE:
938  case AV_PIX_FMT_BGRA64BE:
939  packed16togbra16(src[0], srcStride[0],
940  dst1023, stride1023, srcSliceH, alpha, swap,
941  16 - bpc, c->opts.src_w);
942  break;
943  case AV_PIX_FMT_X2BGR10LE:
944  av_assert0(bpc >= 10);
945  packed30togbra10(src[0], srcStride[0],
946  dst1023, stride1023, srcSliceH, swap,
947  bpc, c->opts.src_w);
948  break;
949  default:
950  av_log(c, AV_LOG_ERROR,
951  "unsupported conversion to planar RGB %s -> %s\n",
952  src_format->name, dst_format->name);
953  }
954 
955  return srcSliceH;
956 }
957 
958 static void gbr16ptopacked16(const uint16_t *src[], const int srcStride[],
959  uint8_t *dst, int dstStride, int srcSliceH,
960  int alpha, int swap, int bpp, int width)
961 {
962  int x, h, i;
963  int src_alpha = src[3] != NULL;
964  int scale_high = 16 - bpp, scale_low = (bpp - 8) * 2;
965  for (h = 0; h < srcSliceH; h++) {
966  uint16_t *dest = (uint16_t *)(dst + dstStride * h);
967  uint16_t component;
968 
969  switch(swap) {
970  case 3:
971  if (alpha && !src_alpha) {
972  for (x = 0; x < width; x++) {
973  component = av_bswap16(src[0][x]);
974  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
975  component = av_bswap16(src[1][x]);
976  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
977  component = av_bswap16(src[2][x]);
978  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
979  *dest++ = 0xffff;
980  }
981  } else if (alpha && src_alpha) {
982  for (x = 0; x < width; x++) {
983  component = av_bswap16(src[0][x]);
984  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
985  component = av_bswap16(src[1][x]);
986  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
987  component = av_bswap16(src[2][x]);
988  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
989  component = av_bswap16(src[3][x]);
990  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
991  }
992  } else {
993  for (x = 0; x < width; x++) {
994  component = av_bswap16(src[0][x]);
995  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
996  component = av_bswap16(src[1][x]);
997  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
998  component = av_bswap16(src[2][x]);
999  *dest++ = av_bswap16(component << scale_high | component >> scale_low);
1000  }
1001  }
1002  break;
1003  case 2:
1004  if (alpha && !src_alpha) {
1005  for (x = 0; x < width; x++) {
1006  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
1007  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
1008  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
1009  *dest++ = 0xffff;
1010  }
1011  } else if (alpha && src_alpha) {
1012  for (x = 0; x < width; x++) {
1013  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
1014  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
1015  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
1016  *dest++ = av_bswap16(src[3][x] << scale_high | src[3][x] >> scale_low);
1017  }
1018  } else {
1019  for (x = 0; x < width; x++) {
1020  *dest++ = av_bswap16(src[0][x] << scale_high | src[0][x] >> scale_low);
1021  *dest++ = av_bswap16(src[1][x] << scale_high | src[1][x] >> scale_low);
1022  *dest++ = av_bswap16(src[2][x] << scale_high | src[2][x] >> scale_low);
1023  }
1024  }
1025  break;
1026  case 1:
1027  if (alpha && !src_alpha) {
1028  for (x = 0; x < width; x++) {
1029  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
1030  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
1031  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
1032  *dest++ = 0xffff;
1033  }
1034  } else if (alpha && src_alpha) {
1035  for (x = 0; x < width; x++) {
1036  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
1037  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
1038  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
1039  *dest++ = av_bswap16(src[3][x]) << scale_high | av_bswap16(src[3][x]) >> scale_low;
1040  }
1041  } else {
1042  for (x = 0; x < width; x++) {
1043  *dest++ = av_bswap16(src[0][x]) << scale_high | av_bswap16(src[0][x]) >> scale_low;
1044  *dest++ = av_bswap16(src[1][x]) << scale_high | av_bswap16(src[1][x]) >> scale_low;
1045  *dest++ = av_bswap16(src[2][x]) << scale_high | av_bswap16(src[2][x]) >> scale_low;
1046  }
1047  }
1048  break;
1049  default:
1050  if (alpha && !src_alpha) {
1051  for (x = 0; x < width; x++) {
1052  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
1053  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
1054  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
1055  *dest++ = 0xffff;
1056  }
1057  } else if (alpha && src_alpha) {
1058  for (x = 0; x < width; x++) {
1059  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
1060  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
1061  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
1062  *dest++ = src[3][x] << scale_high | src[3][x] >> scale_low;
1063  }
1064  } else {
1065  for (x = 0; x < width; x++) {
1066  *dest++ = src[0][x] << scale_high | src[0][x] >> scale_low;
1067  *dest++ = src[1][x] << scale_high | src[1][x] >> scale_low;
1068  *dest++ = src[2][x] << scale_high | src[2][x] >> scale_low;
1069  }
1070  }
1071  }
1072  for (i = 0; i < 3 + src_alpha; i++)
1073  src[i] += srcStride[i] >> 1;
1074  }
1075 }
1076 
1077 static void gbr16ptopacked30(const uint16_t *src[], const int srcStride[],
1078  uint8_t *dst, int dstStride, int srcSliceH,
1079  int swap, int bpp, int width)
1080 {
1081  int x, h, i;
1082  int shift = bpp - 10;
1083  av_assert0(bpp >= 0);
1084  for (h = 0; h < srcSliceH; h++) {
1085  uint8_t *dest = dst + dstStride * h;
1086 
1087  switch(swap) {
1088  case 3:
1089  case 1:
1090  for (x = 0; x < width; x++) {
1091  unsigned C0 = av_bswap16(src[0][x]) >> shift;
1092  unsigned C1 = av_bswap16(src[1][x]) >> shift;
1093  unsigned C2 = av_bswap16(src[2][x]) >> shift;
1094  AV_WL32(dest + 4 * x, (3U << 30) + (C0 << 20) + (C1 << 10) + C2);
1095  }
1096  break;
1097  default:
1098  for (x = 0; x < width; x++) {
1099  unsigned C0 = src[0][x] >> shift;
1100  unsigned C1 = src[1][x] >> shift;
1101  unsigned C2 = src[2][x] >> shift;
1102  AV_WL32(dest + 4 * x, (3U << 30) + (C0 << 20) + (C1 << 10) + C2);
1103  }
1104  break;
1105  }
1106  for (i = 0; i < 3; i++)
1107  src[i] += srcStride[i] >> 1;
1108  }
1109 }
1110 
1111 
1112 static int planarRgb16ToRgb16Wrapper(SwsInternal *c, const uint8_t *const src[],
1113  const int srcStride[], int srcSliceY, int srcSliceH,
1114  uint8_t *const dst[], const int dstStride[])
1115 {
1116  const uint16_t *src102[] = { (uint16_t *)src[1], (uint16_t *)src[0], (uint16_t *)src[2], (uint16_t *)src[3] };
1117  const uint16_t *src201[] = { (uint16_t *)src[2], (uint16_t *)src[0], (uint16_t *)src[1], (uint16_t *)src[3] };
1118  int stride102[] = { srcStride[1], srcStride[0], srcStride[2], srcStride[3] };
1119  int stride201[] = { srcStride[2], srcStride[0], srcStride[1], srcStride[3] };
1120  const AVPixFmtDescriptor *src_format = av_pix_fmt_desc_get(c->opts.src_format);
1121  const AVPixFmtDescriptor *dst_format = av_pix_fmt_desc_get(c->opts.dst_format);
1122  int bits_per_sample = src_format->comp[0].depth;
1123  int swap = 0;
1124  if ( HAVE_BIGENDIAN && !(src_format->flags & AV_PIX_FMT_FLAG_BE) ||
1125  !HAVE_BIGENDIAN && src_format->flags & AV_PIX_FMT_FLAG_BE)
1126  swap++;
1127  if ( HAVE_BIGENDIAN && !(dst_format->flags & AV_PIX_FMT_FLAG_BE) ||
1128  !HAVE_BIGENDIAN && dst_format->flags & AV_PIX_FMT_FLAG_BE)
1129  swap += 2;
1130 
1131  if ((src_format->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) !=
1132  (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB) ||
1133  bits_per_sample <= 8) {
1134  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
1135  src_format->name, dst_format->name);
1136  return srcSliceH;
1137  }
1138  switch (c->opts.dst_format) {
1139  case AV_PIX_FMT_BGR48LE:
1140  case AV_PIX_FMT_BGR48BE:
1141  gbr16ptopacked16(src102, stride102,
1142  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1143  srcSliceH, 0, swap, bits_per_sample, c->opts.src_w);
1144  break;
1145  case AV_PIX_FMT_RGB48LE:
1146  case AV_PIX_FMT_RGB48BE:
1147  gbr16ptopacked16(src201, stride201,
1148  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1149  srcSliceH, 0, swap, bits_per_sample, c->opts.src_w);
1150  break;
1151  case AV_PIX_FMT_RGBA64LE:
1152  case AV_PIX_FMT_RGBA64BE:
1153  gbr16ptopacked16(src201, stride201,
1154  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1155  srcSliceH, 1, swap, bits_per_sample, c->opts.src_w);
1156  break;
1157  case AV_PIX_FMT_BGRA64LE:
1158  case AV_PIX_FMT_BGRA64BE:
1159  gbr16ptopacked16(src102, stride102,
1160  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1161  srcSliceH, 1, swap, bits_per_sample, c->opts.src_w);
1162  break;
1163  case AV_PIX_FMT_X2RGB10LE:
1164  gbr16ptopacked30(src201, stride201,
1165  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1166  srcSliceH, swap, bits_per_sample, c->opts.src_w);
1167  break;
1168  case AV_PIX_FMT_X2BGR10LE:
1169  gbr16ptopacked30(src102, stride102,
1170  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1171  srcSliceH, swap, bits_per_sample, c->opts.src_w);
1172  break;
1173  default:
1174  av_log(c, AV_LOG_ERROR,
1175  "unsupported planar RGB conversion %s -> %s\n",
1176  src_format->name, dst_format->name);
1177  }
1178 
1179  return srcSliceH;
1180 }
1181 
1182 static void gbr24ptopacked24(const uint8_t *src[], const int srcStride[],
1183  uint8_t *dst, int dstStride, int srcSliceH,
1184  int width)
1185 {
1186  int x, h, i;
1187  for (h = 0; h < srcSliceH; h++) {
1188  uint8_t *dest = dst + dstStride * h;
1189  for (x = 0; x < width; x++) {
1190  *dest++ = src[0][x];
1191  *dest++ = src[1][x];
1192  *dest++ = src[2][x];
1193  }
1194 
1195  for (i = 0; i < 3; i++)
1196  src[i] += srcStride[i];
1197  }
1198 }
1199 
1200 static void gbr24ptopacked32(const uint8_t *src[], const int srcStride[],
1201  uint8_t *dst, int dstStride, int srcSliceH,
1202  int alpha_first, int width)
1203 {
1204  int x, h, i;
1205  for (h = 0; h < srcSliceH; h++) {
1206  uint8_t *dest = dst + dstStride * h;
1207 
1208  if (alpha_first) {
1209  for (x = 0; x < width; x++) {
1210  *dest++ = 0xff;
1211  *dest++ = src[0][x];
1212  *dest++ = src[1][x];
1213  *dest++ = src[2][x];
1214  }
1215  } else {
1216  for (x = 0; x < width; x++) {
1217  *dest++ = src[0][x];
1218  *dest++ = src[1][x];
1219  *dest++ = src[2][x];
1220  *dest++ = 0xff;
1221  }
1222  }
1223 
1224  for (i = 0; i < 3; i++)
1225  src[i] += srcStride[i];
1226  }
1227 }
1228 
1229 static void gbraptopacked32(const uint8_t *src[], const int srcStride[],
1230  uint8_t *dst, int dstStride, int srcSliceH,
1231  int alpha_first, int width)
1232 {
1233  int x, h, i;
1234  for (h = 0; h < srcSliceH; h++) {
1235  uint8_t *dest = dst + dstStride * h;
1236 
1237  if (alpha_first) {
1238  for (x = 0; x < width; x++) {
1239  *dest++ = src[3][x];
1240  *dest++ = src[0][x];
1241  *dest++ = src[1][x];
1242  *dest++ = src[2][x];
1243  }
1244  } else {
1245  for (x = 0; x < width; x++) {
1246  *dest++ = src[0][x];
1247  *dest++ = src[1][x];
1248  *dest++ = src[2][x];
1249  *dest++ = src[3][x];
1250  }
1251  }
1252 
1253  for (i = 0; i < 4; i++)
1254  src[i] += srcStride[i];
1255  }
1256 }
1257 
1258 static int planarRgbaToRgbWrapper(SwsInternal *c, const uint8_t *const src[],
1259  const int srcStride[], int srcSliceY, int srcSliceH,
1260  uint8_t *const dst[], const int dstStride[])
1261 {
1262  int alpha_first = 0;
1263  const uint8_t *src102[] = { src[1], src[0], src[2], src[3] };
1264  const uint8_t *src201[] = { src[2], src[0], src[1], src[3] };
1265  int stride102[] = { srcStride[1], srcStride[0], srcStride[2], srcStride[3] };
1266  int stride201[] = { srcStride[2], srcStride[0], srcStride[1], srcStride[3] };
1267 
1268  if (c->opts.src_format != AV_PIX_FMT_GBRAP) {
1269  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
1270  av_get_pix_fmt_name(c->opts.src_format),
1271  av_get_pix_fmt_name(c->opts.dst_format));
1272  return srcSliceH;
1273  }
1274 
1275  switch (c->opts.dst_format) {
1276  case AV_PIX_FMT_BGR24:
1277  gbr24ptopacked24(src102, stride102,
1278  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1279  srcSliceH, c->opts.src_w);
1280  break;
1281 
1282  case AV_PIX_FMT_RGB24:
1283  gbr24ptopacked24(src201, stride201,
1284  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1285  srcSliceH, c->opts.src_w);
1286  break;
1287 
1288  case AV_PIX_FMT_ARGB:
1289  alpha_first = 1;
1290  case AV_PIX_FMT_RGBA:
1291  gbraptopacked32(src201, stride201,
1292  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1293  srcSliceH, alpha_first, c->opts.src_w);
1294  break;
1295 
1296  case AV_PIX_FMT_ABGR:
1297  alpha_first = 1;
1298  case AV_PIX_FMT_BGRA:
1299  gbraptopacked32(src102, stride102,
1300  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1301  srcSliceH, alpha_first, c->opts.src_w);
1302  break;
1303 
1304  default:
1305  av_log(c, AV_LOG_ERROR,
1306  "unsupported planar RGB conversion %s -> %s\n",
1307  av_get_pix_fmt_name(c->opts.src_format),
1308  av_get_pix_fmt_name(c->opts.dst_format));
1309  }
1310 
1311  return srcSliceH;
1312 }
1313 
1314 static int planarRgbToRgbWrapper(SwsInternal *c, const uint8_t *const src[],
1315  const int srcStride[], int srcSliceY, int srcSliceH,
1316  uint8_t *const dst[], const int dstStride[])
1317 {
1318  int alpha_first = 0;
1319  const uint8_t *src102[] = { src[1], src[0], src[2] };
1320  const uint8_t *src201[] = { src[2], src[0], src[1] };
1321  int stride102[] = { srcStride[1], srcStride[0], srcStride[2] };
1322  int stride201[] = { srcStride[2], srcStride[0], srcStride[1] };
1323 
1324  if (c->opts.src_format != AV_PIX_FMT_GBRP) {
1325  av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
1326  av_get_pix_fmt_name(c->opts.src_format),
1327  av_get_pix_fmt_name(c->opts.dst_format));
1328  return srcSliceH;
1329  }
1330 
1331  switch (c->opts.dst_format) {
1332  case AV_PIX_FMT_BGR24:
1333  gbr24ptopacked24(src102, stride102,
1334  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1335  srcSliceH, c->opts.src_w);
1336  break;
1337 
1338  case AV_PIX_FMT_RGB24:
1339  gbr24ptopacked24(src201, stride201,
1340  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1341  srcSliceH, c->opts.src_w);
1342  break;
1343 
1344  case AV_PIX_FMT_ARGB:
1345  alpha_first = 1;
1346  case AV_PIX_FMT_RGBA:
1347  gbr24ptopacked32(src201, stride201,
1348  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1349  srcSliceH, alpha_first, c->opts.src_w);
1350  break;
1351 
1352  case AV_PIX_FMT_ABGR:
1353  alpha_first = 1;
1354  case AV_PIX_FMT_BGRA:
1355  gbr24ptopacked32(src102, stride102,
1356  dst[0] + srcSliceY * dstStride[0], dstStride[0],
1357  srcSliceH, alpha_first, c->opts.src_w);
1358  break;
1359 
1360  default:
1361  av_log(c, AV_LOG_ERROR,
1362  "unsupported planar RGB conversion %s -> %s\n",
1363  av_get_pix_fmt_name(c->opts.src_format),
1364  av_get_pix_fmt_name(c->opts.dst_format));
1365  }
1366 
1367  return srcSliceH;
1368 }
1369 
1370 static int planarRgbToplanarRgbWrapper(SwsInternal *c,
1371  const uint8_t *const src[], const int srcStride[],
1372  int srcSliceY, int srcSliceH,
1373  uint8_t *const dst[], const int dstStride[])
1374 {
1375  ff_copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->opts.src_w,
1376  dst[0], dstStride[0]);
1377  ff_copyPlane(src[1], srcStride[1], srcSliceY, srcSliceH, c->opts.src_w,
1378  dst[1], dstStride[1]);
1379  ff_copyPlane(src[2], srcStride[2], srcSliceY, srcSliceH, c->opts.src_w,
1380  dst[2], dstStride[2]);
1381  if (dst[3]) {
1382  if (is16BPS(c->opts.dst_format) || isNBPS(c->opts.dst_format)) {
1383  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->opts.dst_format);
1384  fillPlane16(dst[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 1,
1385  desc_dst->comp[3].depth, isBE(c->opts.dst_format));
1386  } else {
1387  fillPlane(dst[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 255);
1388  }
1389  }
1390 
1391  return srcSliceH;
1392 }
1393 
1394 static void packedtogbr24p(const uint8_t *src, int srcStride,
1395  uint8_t *const dst[], const int dstStride[], int srcSliceH,
1396  int alpha_first, int inc_size, int width)
1397 {
1398  uint8_t *dest[3];
1399  int x, h;
1400 
1401  dest[0] = dst[0];
1402  dest[1] = dst[1];
1403  dest[2] = dst[2];
1404 
1405  if (alpha_first)
1406  src++;
1407 
1408  for (h = 0; h < srcSliceH; h++) {
1409  for (x = 0; x < width; x++) {
1410  dest[0][x] = src[0];
1411  dest[1][x] = src[1];
1412  dest[2][x] = src[2];
1413 
1414  src += inc_size;
1415  }
1416  src += srcStride - width * inc_size;
1417  dest[0] += dstStride[0];
1418  dest[1] += dstStride[1];
1419  dest[2] += dstStride[2];
1420  }
1421 }
1422 
1423 static int rgbToPlanarRgbWrapper(SwsInternal *c, const uint8_t *const src[],
1424  const int srcStride[], int srcSliceY, int srcSliceH,
1425  uint8_t *const dst[], const int dstStride[])
1426 {
1427  int alpha_first = 0;
1428  int stride102[] = { dstStride[1], dstStride[0], dstStride[2] };
1429  int stride201[] = { dstStride[2], dstStride[0], dstStride[1] };
1430  uint8_t *dst102[] = { dst[1] + srcSliceY * dstStride[1],
1431  dst[0] + srcSliceY * dstStride[0],
1432  dst[2] + srcSliceY * dstStride[2] };
1433  uint8_t *dst201[] = { dst[2] + srcSliceY * dstStride[2],
1434  dst[0] + srcSliceY * dstStride[0],
1435  dst[1] + srcSliceY * dstStride[1] };
1436 
1437  switch (c->opts.src_format) {
1438  case AV_PIX_FMT_RGB24:
1439  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
1440  stride201, srcSliceH, alpha_first, 3, c->opts.src_w);
1441  break;
1442  case AV_PIX_FMT_BGR24:
1443  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
1444  stride102, srcSliceH, alpha_first, 3, c->opts.src_w);
1445  break;
1446  case AV_PIX_FMT_ARGB:
1447  alpha_first = 1;
1448  case AV_PIX_FMT_RGBA:
1449  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
1450  stride201, srcSliceH, alpha_first, 4, c->opts.src_w);
1451  break;
1452  case AV_PIX_FMT_ABGR:
1453  alpha_first = 1;
1454  case AV_PIX_FMT_BGRA:
1455  packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
1456  stride102, srcSliceH, alpha_first, 4, c->opts.src_w);
1457  break;
1458  default:
1459  av_log(c, AV_LOG_ERROR,
1460  "unsupported planar RGB conversion %s -> %s\n",
1461  av_get_pix_fmt_name(c->opts.src_format),
1462  av_get_pix_fmt_name(c->opts.dst_format));
1463  }
1464 
1465  return srcSliceH;
1466 }
1467 
1468 static void packed24togbrap(const uint8_t *src, int srcStride,
1469  uint8_t *const dst[], const int dstStride[],
1470  int srcSliceH, int width)
1471 {
1472  uint8_t *dest[4];
1473  int x, h;
1474 
1475  dest[0] = dst[0];
1476  dest[1] = dst[1];
1477  dest[2] = dst[2];
1478  dest[3] = dst[3];
1479 
1480  for (h = 0; h < srcSliceH; h++) {
1481  for (x = 0; x < width; x++) {
1482  dest[0][x] = src[x * 3 + 0];
1483  dest[1][x] = src[x * 3 + 1];
1484  dest[2][x] = src[x * 3 + 2];
1485  dest[3][x] = 0xff;
1486  }
1487  src += srcStride;
1488  dest[0] += dstStride[0];
1489  dest[1] += dstStride[1];
1490  dest[2] += dstStride[2];
1491  dest[3] += dstStride[3];
1492  }
1493 }
1494 
1495 static void packed32togbrap(const uint8_t *src, int srcStride,
1496  uint8_t *const dst[], const int dstStride[],
1497  int srcSliceH, int alpha_first, int width)
1498 {
1499  uint8_t *dest[4];
1500  int x, h;
1501 
1502  dest[0] = dst[0];
1503  dest[1] = dst[1];
1504  dest[2] = dst[2];
1505  dest[3] = dst[3];
1506 
1507  for (h = 0; h < srcSliceH; h++) {
1508  if (alpha_first) {
1509  for (x = 0; x < width; x++) {
1510  dest[0][x] = src[x * 4 + 1];
1511  dest[1][x] = src[x * 4 + 2];
1512  dest[2][x] = src[x * 4 + 3];
1513  dest[3][x] = src[x * 4 + 0];
1514  }
1515  } else {
1516  for (x = 0; x < width; x++) {
1517  dest[0][x] = src[x * 4 + 0];
1518  dest[1][x] = src[x * 4 + 1];
1519  dest[2][x] = src[x * 4 + 2];
1520  dest[3][x] = src[x * 4 + 3];
1521  }
1522  }
1523  src += srcStride;
1524  dest[0] += dstStride[0];
1525  dest[1] += dstStride[1];
1526  dest[2] += dstStride[2];
1527  dest[3] += dstStride[3];
1528  }
1529 }
1530 
1531 static int rgbToPlanarRgbaWrapper(SwsInternal *c, const uint8_t *const src[],
1532  const int srcStride[], int srcSliceY, int srcSliceH,
1533  uint8_t *const dst[], const int dstStride[])
1534 {
1535  int alpha_first = 0;
1536  int stride102[] = { dstStride[1], dstStride[0], dstStride[2], dstStride[3] };
1537  int stride201[] = { dstStride[2], dstStride[0], dstStride[1], dstStride[3] };
1538  uint8_t *dst102[] = { dst[1] + srcSliceY * dstStride[1],
1539  dst[0] + srcSliceY * dstStride[0],
1540  dst[2] + srcSliceY * dstStride[2],
1541  dst[3] + srcSliceY * dstStride[3] };
1542  uint8_t *dst201[] = { dst[2] + srcSliceY * dstStride[2],
1543  dst[0] + srcSliceY * dstStride[0],
1544  dst[1] + srcSliceY * dstStride[1],
1545  dst[3] + srcSliceY * dstStride[3] };
1546 
1547  switch (c->opts.src_format) {
1548  case AV_PIX_FMT_RGB24:
1549  packed24togbrap((const uint8_t *) src[0], srcStride[0], dst201,
1550  stride201, srcSliceH, c->opts.src_w);
1551  break;
1552  case AV_PIX_FMT_BGR24:
1553  packed24togbrap((const uint8_t *) src[0], srcStride[0], dst102,
1554  stride102, srcSliceH, c->opts.src_w);
1555  break;
1556  case AV_PIX_FMT_ARGB:
1557  alpha_first = 1;
1558  case AV_PIX_FMT_RGBA:
1559  packed32togbrap((const uint8_t *) src[0], srcStride[0], dst201,
1560  stride201, srcSliceH, alpha_first, c->opts.src_w);
1561  break;
1562  case AV_PIX_FMT_ABGR:
1563  alpha_first = 1;
1564  case AV_PIX_FMT_BGRA:
1565  packed32togbrap((const uint8_t *) src[0], srcStride[0], dst102,
1566  stride102, srcSliceH, alpha_first, c->opts.src_w);
1567  break;
1568  default:
1569  av_log(c, AV_LOG_ERROR,
1570  "unsupported planar RGB conversion %s -> %s\n",
1571  av_get_pix_fmt_name(c->opts.src_format),
1572  av_get_pix_fmt_name(c->opts.dst_format));
1573  }
1574 
1575  return srcSliceH;
1576 }
1577 
1578 #define BAYER_GBRG
1579 #define BAYER_8
1580 #define BAYER_RENAME(x) bayer_gbrg8_to_##x
1581 #include "bayer_template.c"
1582 
1583 #define BAYER_GBRG
1584 #define BAYER_16LE
1585 #define BAYER_RENAME(x) bayer_gbrg16le_to_##x
1586 #include "bayer_template.c"
1587 
1588 #define BAYER_GBRG
1589 #define BAYER_16BE
1590 #define BAYER_RENAME(x) bayer_gbrg16be_to_##x
1591 #include "bayer_template.c"
1592 
1593 #define BAYER_GRBG
1594 #define BAYER_8
1595 #define BAYER_RENAME(x) bayer_grbg8_to_##x
1596 #include "bayer_template.c"
1597 
1598 #define BAYER_GRBG
1599 #define BAYER_16LE
1600 #define BAYER_RENAME(x) bayer_grbg16le_to_##x
1601 #include "bayer_template.c"
1602 
1603 #define BAYER_GRBG
1604 #define BAYER_16BE
1605 #define BAYER_RENAME(x) bayer_grbg16be_to_##x
1606 #include "bayer_template.c"
1607 
1608 #define BAYER_BGGR
1609 #define BAYER_8
1610 #define BAYER_RENAME(x) bayer_bggr8_to_##x
1611 #include "bayer_template.c"
1612 
1613 #define BAYER_BGGR
1614 #define BAYER_16LE
1615 #define BAYER_RENAME(x) bayer_bggr16le_to_##x
1616 #include "bayer_template.c"
1617 
1618 #define BAYER_BGGR
1619 #define BAYER_16BE
1620 #define BAYER_RENAME(x) bayer_bggr16be_to_##x
1621 #include "bayer_template.c"
1622 
1623 #define BAYER_RGGB
1624 #define BAYER_8
1625 #define BAYER_RENAME(x) bayer_rggb8_to_##x
1626 #include "bayer_template.c"
1627 
1628 #define BAYER_RGGB
1629 #define BAYER_16LE
1630 #define BAYER_RENAME(x) bayer_rggb16le_to_##x
1631 #include "bayer_template.c"
1632 
1633 #define BAYER_RGGB
1634 #define BAYER_16BE
1635 #define BAYER_RENAME(x) bayer_rggb16be_to_##x
1636 #include "bayer_template.c"
1637 
1638 static int bayer_to_rgb24_wrapper(SwsInternal *c, const uint8_t *const src[],
1639  const int srcStride[], int srcSliceY, int srcSliceH,
1640  uint8_t *const dst[], const int dstStride[])
1641 {
1642  uint8_t *dstPtr= dst[0] + srcSliceY * dstStride[0];
1643  const uint8_t *srcPtr= src[0];
1644  int i;
1645  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1646  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1647 
1648  switch(c->opts.src_format) {
1649 #define CASE(pixfmt, prefix) \
1650  case pixfmt: copy = bayer_##prefix##_to_rgb24_copy; \
1651  interpolate = bayer_##prefix##_to_rgb24_interpolate; \
1652  break;
1653  CASE(AV_PIX_FMT_BAYER_BGGR8, bggr8)
1654  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1655  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1656  CASE(AV_PIX_FMT_BAYER_RGGB8, rggb8)
1657  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1658  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1659  CASE(AV_PIX_FMT_BAYER_GBRG8, gbrg8)
1660  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1661  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1662  CASE(AV_PIX_FMT_BAYER_GRBG8, grbg8)
1663  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1664  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1665 #undef CASE
1666  default: return 0;
1667  }
1668 
1669  av_assert0(srcSliceH > 1);
1670 
1671  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1672  srcPtr += 2 * srcStride[0];
1673  dstPtr += 2 * dstStride[0];
1674 
1675  for (i = 2; i < srcSliceH - 2; i += 2) {
1676  interpolate(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1677  srcPtr += 2 * srcStride[0];
1678  dstPtr += 2 * dstStride[0];
1679  }
1680 
1681  if (i + 1 == srcSliceH) {
1682  copy(srcPtr, -srcStride[0], dstPtr, -dstStride[0], c->opts.src_w);
1683  } else if (i < srcSliceH)
1684  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1685  return srcSliceH;
1686 }
1687 
1688 static int bayer_to_rgb48_wrapper(SwsInternal *c, const uint8_t *const src[],
1689  const int srcStride[], int srcSliceY, int srcSliceH,
1690  uint8_t *const dst[], const int dstStride[])
1691 {
1692  uint8_t *dstPtr= dst[0] + srcSliceY * dstStride[0];
1693  const uint8_t *srcPtr= src[0];
1694  int i;
1695  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1696  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int width);
1697 
1698  switch(c->opts.src_format) {
1699 #define CASE(pixfmt, prefix) \
1700  case pixfmt: copy = bayer_##prefix##_to_rgb48_copy; \
1701  interpolate = bayer_##prefix##_to_rgb48_interpolate; \
1702  break;
1703  CASE(AV_PIX_FMT_BAYER_BGGR8, bggr8)
1704  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1705  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1706  CASE(AV_PIX_FMT_BAYER_RGGB8, rggb8)
1707  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1708  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1709  CASE(AV_PIX_FMT_BAYER_GBRG8, gbrg8)
1710  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1711  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1712  CASE(AV_PIX_FMT_BAYER_GRBG8, grbg8)
1713  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1714  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1715 #undef CASE
1716  default: return 0;
1717  }
1718 
1719  av_assert0(srcSliceH > 1);
1720 
1721  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1722  srcPtr += 2 * srcStride[0];
1723  dstPtr += 2 * dstStride[0];
1724 
1725  for (i = 2; i < srcSliceH - 2; i += 2) {
1726  interpolate(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1727  srcPtr += 2 * srcStride[0];
1728  dstPtr += 2 * dstStride[0];
1729  }
1730 
1731  if (i + 1 == srcSliceH) {
1732  copy(srcPtr, -srcStride[0], dstPtr, -dstStride[0], c->opts.src_w);
1733  } else if (i < srcSliceH)
1734  copy(srcPtr, srcStride[0], dstPtr, dstStride[0], c->opts.src_w);
1735  return srcSliceH;
1736 }
1737 
1738 static int bayer_to_yv12_wrapper(SwsInternal *c, const uint8_t *const src[],
1739  const int srcStride[], int srcSliceY, int srcSliceH,
1740  uint8_t *const dst[], const int dstStride[])
1741 {
1742  const uint8_t *srcPtr= src[0];
1743  uint8_t *dstY= dst[0] + srcSliceY * dstStride[0];
1744  uint8_t *dstU= dst[1] + srcSliceY * dstStride[1] / 2;
1745  uint8_t *dstV= dst[2] + srcSliceY * dstStride[2] / 2;
1746  int i;
1747  void (*copy) (const uint8_t *src, int src_stride, uint8_t *dstY, uint8_t *dstU, uint8_t *dstV, int luma_stride, int width, const int32_t *rgb2yuv);
1748  void (*interpolate)(const uint8_t *src, int src_stride, uint8_t *dstY, uint8_t *dstU, uint8_t *dstV, int luma_stride, int width, const int32_t *rgb2yuv);
1749 
1750  switch(c->opts.src_format) {
1751 #define CASE(pixfmt, prefix) \
1752  case pixfmt: copy = bayer_##prefix##_to_yv12_copy; \
1753  interpolate = bayer_##prefix##_to_yv12_interpolate; \
1754  break;
1755  CASE(AV_PIX_FMT_BAYER_BGGR8, bggr8)
1756  CASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)
1757  CASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)
1758  CASE(AV_PIX_FMT_BAYER_RGGB8, rggb8)
1759  CASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)
1760  CASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)
1761  CASE(AV_PIX_FMT_BAYER_GBRG8, gbrg8)
1762  CASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)
1763  CASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)
1764  CASE(AV_PIX_FMT_BAYER_GRBG8, grbg8)
1765  CASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)
1766  CASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)
1767 #undef CASE
1768  default: return 0;
1769  }
1770 
1771  av_assert0(srcSliceH > 1);
1772 
1773  copy(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->opts.src_w, c->input_rgb2yuv_table);
1774  srcPtr += 2 * srcStride[0];
1775  dstY += 2 * dstStride[0];
1776  dstU += dstStride[1];
1777  dstV += dstStride[1];
1778 
1779  for (i = 2; i < srcSliceH - 2; i += 2) {
1780  interpolate(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->opts.src_w, c->input_rgb2yuv_table);
1781  srcPtr += 2 * srcStride[0];
1782  dstY += 2 * dstStride[0];
1783  dstU += dstStride[1];
1784  dstV += dstStride[1];
1785  }
1786 
1787  if (i + 1 == srcSliceH) {
1788  copy(srcPtr, -srcStride[0], dstY, dstU, dstV, -dstStride[0], c->opts.src_w, c->input_rgb2yuv_table);
1789  } else if (i < srcSliceH)
1790  copy(srcPtr, srcStride[0], dstY, dstU, dstV, dstStride[0], c->opts.src_w, c->input_rgb2yuv_table);
1791  return srcSliceH;
1792 }
1793 
1794 #define isRGBA32(x) ( \
1795  (x) == AV_PIX_FMT_ARGB \
1796  || (x) == AV_PIX_FMT_RGBA \
1797  || (x) == AV_PIX_FMT_BGRA \
1798  || (x) == AV_PIX_FMT_ABGR \
1799  )
1800 
1801 #define isRGBA64(x) ( \
1802  (x) == AV_PIX_FMT_RGBA64LE \
1803  || (x) == AV_PIX_FMT_RGBA64BE \
1804  || (x) == AV_PIX_FMT_BGRA64LE \
1805  || (x) == AV_PIX_FMT_BGRA64BE \
1806  )
1807 
1808 #define isRGB48(x) ( \
1809  (x) == AV_PIX_FMT_RGB48LE \
1810  || (x) == AV_PIX_FMT_RGB48BE \
1811  || (x) == AV_PIX_FMT_BGR48LE \
1812  || (x) == AV_PIX_FMT_BGR48BE \
1813  )
1814 
1815 #define isAYUV(x) ( \
1816  (x) == AV_PIX_FMT_AYUV \
1817  || (x) == AV_PIX_FMT_VUYA \
1818  || (x) == AV_PIX_FMT_VUYX \
1819  || (x) == AV_PIX_FMT_UYVA \
1820  )
1821 
1822 #define isX2RGB(x) ( \
1823  (x) == AV_PIX_FMT_X2RGB10LE \
1824  || (x) == AV_PIX_FMT_X2BGR10LE \
1825  )
1826 
1827 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1828 typedef void (* rgbConvFn) (const uint8_t *, uint8_t *, int);
1829 static rgbConvFn findRgbConvFn(SwsInternal *c)
1830 {
1831  const enum AVPixelFormat srcFormat = c->opts.src_format;
1832  const enum AVPixelFormat dstFormat = c->opts.dst_format;
1833  const int srcId = c->srcFormatBpp;
1834  const int dstId = c->dstFormatBpp;
1835  rgbConvFn conv = NULL;
1836 
1837 #define IS_NOT_NE(bpp, desc) \
1838  (((bpp + 7) >> 3) == 2 && \
1839  (!(desc->flags & AV_PIX_FMT_FLAG_BE) != !HAVE_BIGENDIAN))
1840 
1841 #define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
1842 
1843  if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
1844  if ( CONV_IS(ABGR, RGBA)
1845  || CONV_IS(ARGB, BGRA)
1846  || CONV_IS(BGRA, ARGB)
1847  || CONV_IS(RGBA, ABGR)) conv = shuffle_bytes_3210;
1848  else if (CONV_IS(ABGR, ARGB)
1849  || CONV_IS(ARGB, ABGR)) conv = shuffle_bytes_0321;
1850  else if (CONV_IS(ABGR, BGRA)
1851  || CONV_IS(ARGB, RGBA)) conv = shuffle_bytes_1230;
1852  else if (CONV_IS(BGRA, RGBA)
1853  || CONV_IS(RGBA, BGRA)) conv = shuffle_bytes_2103;
1854  else if (CONV_IS(BGRA, ABGR)
1855  || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
1856  } else if (isRGB48(srcFormat) && isRGB48(dstFormat)) {
1857  if (CONV_IS(RGB48LE, BGR48LE)
1858  || CONV_IS(BGR48LE, RGB48LE)
1859  || CONV_IS(RGB48BE, BGR48BE)
1860  || CONV_IS(BGR48BE, RGB48BE)) conv = rgb48tobgr48_nobswap;
1861  else if (CONV_IS(RGB48LE, BGR48BE)
1862  || CONV_IS(BGR48LE, RGB48BE)
1863  || CONV_IS(RGB48BE, BGR48LE)
1864  || CONV_IS(BGR48BE, RGB48LE)) conv = rgb48tobgr48_bswap;
1865  } else if (isRGB48(srcFormat) && isRGBA64(dstFormat)) {
1866  if (CONV_IS(RGB48LE, BGRA64LE)
1867  || CONV_IS(BGR48LE, RGBA64LE)
1868  || CONV_IS(RGB48BE, BGRA64BE)
1869  || CONV_IS(BGR48BE, RGBA64BE)) conv = rgb48tobgr64_nobswap;
1870  else if (CONV_IS(RGB48LE, BGRA64BE)
1871  || CONV_IS(BGR48LE, RGBA64BE)
1872  || CONV_IS(RGB48BE, BGRA64LE)
1873  || CONV_IS(BGR48BE, RGBA64LE)) conv = rgb48tobgr64_bswap;
1874  if (CONV_IS(RGB48LE, RGBA64LE)
1875  || CONV_IS(BGR48LE, BGRA64LE)
1876  || CONV_IS(RGB48BE, RGBA64BE)
1877  || CONV_IS(BGR48BE, BGRA64BE)) conv = rgb48to64_nobswap;
1878  else if (CONV_IS(RGB48LE, RGBA64BE)
1879  || CONV_IS(BGR48LE, BGRA64BE)
1880  || CONV_IS(RGB48BE, RGBA64LE)
1881  || CONV_IS(BGR48BE, BGRA64LE)) conv = rgb48to64_bswap;
1882  } else if (isRGBA64(srcFormat) && isRGB48(dstFormat)) {
1883  if (CONV_IS(RGBA64LE, BGR48LE)
1884  || CONV_IS(BGRA64LE, RGB48LE)
1885  || CONV_IS(RGBA64BE, BGR48BE)
1886  || CONV_IS(BGRA64BE, RGB48BE)) conv = rgb64tobgr48_nobswap;
1887  else if (CONV_IS(RGBA64LE, BGR48BE)
1888  || CONV_IS(BGRA64LE, RGB48BE)
1889  || CONV_IS(RGBA64BE, BGR48LE)
1890  || CONV_IS(BGRA64BE, RGB48LE)) conv = rgb64tobgr48_bswap;
1891  else if (CONV_IS(RGBA64LE, RGB48LE)
1892  || CONV_IS(BGRA64LE, BGR48LE)
1893  || CONV_IS(RGBA64BE, RGB48BE)
1894  || CONV_IS(BGRA64BE, BGR48BE)) conv = rgb64to48_nobswap;
1895  else if (CONV_IS(RGBA64LE, RGB48BE)
1896  || CONV_IS(BGRA64LE, BGR48BE)
1897  || CONV_IS(RGBA64BE, RGB48LE)
1898  || CONV_IS(BGRA64BE, BGR48LE)) conv = rgb64to48_bswap;
1899  } else if (isX2RGB(srcFormat) && isRGB48(dstFormat)) {
1900  if (CONV_IS(X2RGB10LE, RGB48LE)
1901  || CONV_IS(X2BGR10LE, BGR48LE)) conv = HAVE_BIGENDIAN ? x2rgb10to48_bswap
1902  : x2rgb10to48_nobswap;
1903  else if (CONV_IS(X2RGB10LE, RGB48BE)
1904  || CONV_IS(X2BGR10LE, BGR48BE)) conv = HAVE_BIGENDIAN ? x2rgb10to48_nobswap
1905  : x2rgb10to48_bswap;
1906  else if (CONV_IS(X2RGB10LE, BGR48LE)
1907  || CONV_IS(X2BGR10LE, RGB48LE)) conv = HAVE_BIGENDIAN ? x2rgb10tobgr48_bswap
1908  : x2rgb10tobgr48_nobswap;
1909  else if (CONV_IS(X2RGB10LE, BGR48BE)
1910  || CONV_IS(X2BGR10LE, RGB48BE)) conv = HAVE_BIGENDIAN ? x2rgb10tobgr48_nobswap
1911  : x2rgb10tobgr48_bswap;
1912  } else if (isX2RGB(srcFormat) && isRGBA64(dstFormat)) {
1913  if (CONV_IS(X2RGB10LE, RGBA64LE)
1914  || CONV_IS(X2BGR10LE, BGRA64LE)) conv = HAVE_BIGENDIAN ? x2rgb10to64_bswap
1915  : x2rgb10to64_nobswap;
1916  else if (CONV_IS(X2RGB10LE, RGBA64BE)
1917  || CONV_IS(X2BGR10LE, BGRA64BE)) conv = HAVE_BIGENDIAN ? x2rgb10to64_nobswap
1918  : x2rgb10to64_bswap;
1919  else if (CONV_IS(X2RGB10LE, BGRA64LE)
1920  || CONV_IS(X2BGR10LE, RGBA64LE)) conv = HAVE_BIGENDIAN ? x2rgb10tobgr64_bswap
1921  : x2rgb10tobgr64_nobswap;
1922  else if (CONV_IS(X2RGB10LE, BGRA64BE)
1923  || CONV_IS(X2BGR10LE, RGBA64BE)) conv = HAVE_BIGENDIAN ? x2rgb10tobgr64_nobswap
1924  : x2rgb10tobgr64_bswap;
1925  } else if (isAYUV(srcFormat) && isAYUV(dstFormat)) {
1926  /* VUYX only for dst, to avoid copying undefined bytes */
1927  if ( CONV_IS(AYUV, VUYA)
1928  || CONV_IS(AYUV, VUYX)
1929  || CONV_IS(VUYA, AYUV)) conv = shuffle_bytes_3210;
1930  else if (CONV_IS(AYUV, UYVA)) conv = shuffle_bytes_2130;
1931  else if (CONV_IS(VUYA, UYVA)) conv = shuffle_bytes_1203;
1932  else if (CONV_IS(UYVA, AYUV)) conv = shuffle_bytes_3102;
1933  else if (CONV_IS(UYVA, VUYA)
1934  || CONV_IS(UYVA, VUYX)) conv = shuffle_bytes_2013;
1935  } else
1936  /* BGR -> BGR */
1937  if ((isBGRinInt(srcFormat) && isBGRinInt(dstFormat)) ||
1938  (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
1939  switch (srcId | (dstId << 16)) {
1940  case 0x000F000C: conv = rgb12to15; break;
1941  case 0x000F0010: conv = rgb16to15; break;
1942  case 0x000F0018: conv = rgb24to15; break;
1943  case 0x000F0020: conv = rgb32to15; break;
1944  case 0x0010000F: conv = rgb15to16; break;
1945  case 0x00100018: conv = rgb24to16; break;
1946  case 0x00100020: conv = rgb32to16; break;
1947  case 0x0018000F: conv = rgb15to24; break;
1948  case 0x00180010: conv = rgb16to24; break;
1949  case 0x00180020: conv = rgb32to24; break;
1950  case 0x0020000F: conv = rgb15to32; break;
1951  case 0x00200010: conv = rgb16to32; break;
1952  case 0x00200018: conv = rgb24to32; break;
1953  }
1954  } else if ((isBGRinInt(srcFormat) && isRGBinInt(dstFormat)) ||
1955  (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
1956  switch (srcId | (dstId << 16)) {
1957  case 0x000C000C: conv = rgb12tobgr12; break;
1958  case 0x000F000F: conv = rgb15tobgr15; break;
1959  case 0x000F0010: conv = rgb16tobgr15; break;
1960  case 0x000F0018: conv = rgb24tobgr15; break;
1961  case 0x000F0020: conv = rgb32tobgr15; break;
1962  case 0x0010000F: conv = rgb15tobgr16; break;
1963  case 0x00100010: conv = rgb16tobgr16; break;
1964  case 0x00100018: conv = rgb24tobgr16; break;
1965  case 0x00100020: conv = rgb32tobgr16; break;
1966  case 0x0018000F: conv = rgb15tobgr24; break;
1967  case 0x00180010: conv = rgb16tobgr24; break;
1968  case 0x00180018: conv = rgb24tobgr24; break;
1969  case 0x00180020: conv = rgb32tobgr24; break;
1970  case 0x0020000F: conv = rgb15tobgr32; break;
1971  case 0x00200010: conv = rgb16tobgr32; break;
1972  case 0x00200018: conv = rgb24tobgr32; break;
1973  }
1974  }
1975 
1976  if ((dstFormat == AV_PIX_FMT_RGB32_1 || dstFormat == AV_PIX_FMT_BGR32_1) && !isRGBA32(srcFormat) && ALT32_CORR<0)
1977  return NULL;
1978 
1979  // Maintain symmetry between endianness
1980  if (c->opts.flags & SWS_BITEXACT)
1981  if ((dstFormat == AV_PIX_FMT_RGB32 || dstFormat == AV_PIX_FMT_BGR32 ) && !isRGBA32(srcFormat) && ALT32_CORR>0)
1982  return NULL;
1983 
1984  return conv;
1985 }
1986 
1987 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1988 static int rgbToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[],
1989  int srcSliceY, int srcSliceH, uint8_t *const dst[],
1990  const int dstStride[])
1991 
1992 {
1993  const enum AVPixelFormat srcFormat = c->opts.src_format;
1994  const enum AVPixelFormat dstFormat = c->opts.dst_format;
1995  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->opts.src_format);
1996  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->opts.dst_format);
1997  const int srcBpp = (c->srcFormatBpp + 7) >> 3;
1998  const int dstBpp = (c->dstFormatBpp + 7) >> 3;
1999  rgbConvFn conv = findRgbConvFn(c);
2000 
2001  if (!conv) {
2002  av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
2003  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
2004  } else {
2005  const uint8_t *srcPtr = src[0];
2006  uint8_t *dstPtr = dst[0];
2007  int src_bswap = IS_NOT_NE(c->srcFormatBpp, desc_src);
2008  int dst_bswap = IS_NOT_NE(c->dstFormatBpp, desc_dst);
2009 
2010  if ((srcFormat == AV_PIX_FMT_RGB32_1 || srcFormat == AV_PIX_FMT_BGR32_1) &&
2011  !isRGBA32(dstFormat))
2012  srcPtr += ALT32_CORR;
2013 
2014  if ((dstFormat == AV_PIX_FMT_RGB32_1 || dstFormat == AV_PIX_FMT_BGR32_1) &&
2015  !isRGBA32(srcFormat)) {
2016  int i;
2017  av_assert0(ALT32_CORR == 1);
2018  for (i = 0; i < srcSliceH; i++)
2019  dstPtr[dstStride[0] * (srcSliceY + i)] = 255;
2020  dstPtr += ALT32_CORR;
2021  }
2022 
2023  if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
2024  !(srcStride[0] % srcBpp) && !dst_bswap && !src_bswap)
2025  conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
2026  (srcSliceH - 1) * srcStride[0] + c->opts.src_w * srcBpp);
2027  else {
2028  int i, j;
2029  dstPtr += dstStride[0] * srcSliceY;
2030 
2031  for (i = 0; i < srcSliceH; i++) {
2032  if(src_bswap) {
2033  for(j=0; j<c->opts.src_w; j++)
2034  ((uint16_t*)c->formatConvBuffer)[j] = av_bswap16(((uint16_t*)srcPtr)[j]);
2035  conv(c->formatConvBuffer, dstPtr, c->opts.src_w * srcBpp);
2036  }else
2037  conv(srcPtr, dstPtr, c->opts.src_w * srcBpp);
2038  if(dst_bswap)
2039  for(j=0; j<c->opts.src_w; j++)
2040  ((uint16_t*)dstPtr)[j] = av_bswap16(((uint16_t*)dstPtr)[j]);
2041  srcPtr += srcStride[0];
2042  dstPtr += dstStride[0];
2043  }
2044  }
2045  }
2046  return srcSliceH;
2047 }
2048 
2049 static int bgr24ToYv12Wrapper(SwsInternal *c, const uint8_t *const src[],
2050  const int srcStride[], int srcSliceY, int srcSliceH,
2051  uint8_t *const dst[], const int dstStride[])
2052 {
2053  ff_rgb24toyv12(
2054  src[0],
2055  dst[0] + srcSliceY * dstStride[0],
2056  dst[1] + (srcSliceY >> 1) * dstStride[1],
2057  dst[2] + (srcSliceY >> 1) * dstStride[2],
2058  c->opts.src_w, srcSliceH,
2059  dstStride[0], dstStride[1], srcStride[0],
2060  c->input_rgb2yuv_table);
2061  if (dst[3])
2062  fillPlane(dst[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 255);
2063  return srcSliceH;
2064 }
2065 
2066 static int yvu9ToYv12Wrapper(SwsInternal *c, const uint8_t *const src[],
2067  const int srcStride[], int srcSliceY, int srcSliceH,
2068  uint8_t *const dst[], const int dstStride[])
2069 {
2070  ff_copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->opts.src_w,
2071  dst[0], dstStride[0]);
2072 
2073  planar2x(src[1], dst[1] + dstStride[1] * (srcSliceY >> 1), c->chrSrcW,
2074  srcSliceH >> 2, srcStride[1], dstStride[1]);
2075  planar2x(src[2], dst[2] + dstStride[2] * (srcSliceY >> 1), c->chrSrcW,
2076  srcSliceH >> 2, srcStride[2], dstStride[2]);
2077  if (dst[3])
2078  fillPlane(dst[3], dstStride[3], c->opts.src_w, srcSliceH, srcSliceY, 255);
2079  return srcSliceH;
2080 }
2081 
2082 static int uint_y_to_float_y_wrapper(SwsInternal *c, const uint8_t *const src[],
2083  const int srcStride[], int srcSliceY,
2084  int srcSliceH, uint8_t *const dst[], const int dstStride[])
2085 {
2086  int y, x;
2087  ptrdiff_t dstStrideFloat = dstStride[0] >> 2;
2088  const uint8_t *srcPtr = src[0];
2089  float *dstPtr = (float *)(dst[0] + dstStride[0] * srcSliceY);
2090 
2091  for (y = 0; y < srcSliceH; ++y){
2092  for (x = 0; x < c->opts.src_w; ++x){
2093  dstPtr[x] = c->uint2float_lut[srcPtr[x]];
2094  }
2095  srcPtr += srcStride[0];
2096  dstPtr += dstStrideFloat;
2097  }
2098 
2099  return srcSliceH;
2100 }
2101 
2102 static int float_y_to_uint_y_wrapper(SwsInternal *c,
2103  const uint8_t *const src[],
2104  const int srcStride[], int srcSliceY,
2105  int srcSliceH, uint8_t *const dst[],
2106  const int dstStride[])
2107 {
2108  int y, x;
2109  ptrdiff_t srcStrideFloat = srcStride[0] >> 2;
2110  const float *srcPtr = (const float *)src[0];
2111  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
2112 
2113  for (y = 0; y < srcSliceH; ++y){
2114  for (x = 0; x < c->opts.src_w; ++x){
2115  dstPtr[x] = av_clip_uint8(lrintf(255.0f * srcPtr[x]));
2116  }
2117  srcPtr += srcStrideFloat;
2118  dstPtr += dstStride[0];
2119  }
2120 
2121  return srcSliceH;
2122 }
2123 
2124 /* unscaled copy like stuff (assumes nearly identical formats) */
2125 static int packedCopyWrapper(SwsInternal *c, const uint8_t *const src[],
2126  const int srcStride[], int srcSliceY, int srcSliceH,
2127  uint8_t *const dst[], const int dstStride[])
2128 {
2129  if (dstStride[0] == srcStride[0] && srcStride[0] > 0)
2130  memcpy(dst[0] + dstStride[0] * srcSliceY, src[0], srcSliceH * dstStride[0]);
2131  else {
2132  int i;
2133  const uint8_t *srcPtr = src[0];
2134  uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
2135  int length = 0;
2136 
2137  /* universal length finder */
2138  while (length + c->opts.src_w <= FFABS(dstStride[0]) &&
2139  length + c->opts.src_w <= FFABS(srcStride[0]))
2140  length += c->opts.src_w;
2141  av_assert1(length != 0);
2142 
2143  for (i = 0; i < srcSliceH; i++) {
2144  memcpy(dstPtr, srcPtr, length);
2145  srcPtr += srcStride[0];
2146  dstPtr += dstStride[0];
2147  }
2148  }
2149  return srcSliceH;
2150 }
2151 
2152 #define DITHER_COPY(dst, dstStride, src, srcStride, bswap, dbswap)\
2153  unsigned shift= src_depth-dst_depth, tmp;\
2154  unsigned bias = 1 << (shift - 1);\
2155  if (c->opts.dither == SWS_DITHER_NONE) {\
2156  for (i = 0; i < height; i++) {\
2157  for (j = 0; j < length-7; j+=8) {\
2158  tmp = ((bswap(src[j+0]) >> src_shift) + bias)>>shift; dst[j+0] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2159  tmp = ((bswap(src[j+1]) >> src_shift) + bias)>>shift; dst[j+1] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2160  tmp = ((bswap(src[j+2]) >> src_shift) + bias)>>shift; dst[j+2] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2161  tmp = ((bswap(src[j+3]) >> src_shift) + bias)>>shift; dst[j+3] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2162  tmp = ((bswap(src[j+4]) >> src_shift) + bias)>>shift; dst[j+4] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2163  tmp = ((bswap(src[j+5]) >> src_shift) + bias)>>shift; dst[j+5] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2164  tmp = ((bswap(src[j+6]) >> src_shift) + bias)>>shift; dst[j+6] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2165  tmp = ((bswap(src[j+7]) >> src_shift) + bias)>>shift; dst[j+7] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2166  }\
2167  for (; j < length; j++) {\
2168  tmp = (bswap(src[j]) + bias)>>shift; dst[j] = dbswap(tmp - (tmp>>dst_depth) << dst_shift);\
2169  }\
2170  dst += dstStride;\
2171  src += srcStride;\
2172  }\
2173  } else if (shiftonly) {\
2174  for (i = 0; i < height; i++) {\
2175  const uint8_t *dither= dithers[shift-1][i&7];\
2176  for (j = 0; j < length-7; j+=8) {\
2177  tmp = ((bswap(src[j+0]) >> src_shift) + dither[0])>>shift; dst[j+0] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2178  tmp = ((bswap(src[j+1]) >> src_shift) + dither[1])>>shift; dst[j+1] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2179  tmp = ((bswap(src[j+2]) >> src_shift) + dither[2])>>shift; dst[j+2] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2180  tmp = ((bswap(src[j+3]) >> src_shift) + dither[3])>>shift; dst[j+3] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2181  tmp = ((bswap(src[j+4]) >> src_shift) + dither[4])>>shift; dst[j+4] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2182  tmp = ((bswap(src[j+5]) >> src_shift) + dither[5])>>shift; dst[j+5] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2183  tmp = ((bswap(src[j+6]) >> src_shift) + dither[6])>>shift; dst[j+6] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2184  tmp = ((bswap(src[j+7]) >> src_shift) + dither[7])>>shift; dst[j+7] = dbswap((tmp - (tmp>>dst_depth)) << dst_shift);\
2185  }\
2186  for (; j < length; j++) {\
2187  tmp = (bswap(src[j]) + dither[j&7])>>shift; dst[j] = dbswap(tmp - (tmp>>dst_depth) << dst_shift);\
2188  }\
2189  dst += dstStride;\
2190  src += srcStride;\
2191  }\
2192  } else {\
2193  for (i = 0; i < height; i++) {\
2194  const uint8_t *dither= dithers[shift-1][i&7];\
2195  for (j = 0; j < length-7; j+=8) {\
2196  tmp = bswap(src[j+0]) >> src_shift; dst[j+0] = dbswap(((tmp - (tmp>>dst_depth) + dither[0])>>shift) << dst_shift);\
2197  tmp = bswap(src[j+1]) >> src_shift; dst[j+1] = dbswap(((tmp - (tmp>>dst_depth) + dither[1])>>shift) << dst_shift);\
2198  tmp = bswap(src[j+2]) >> src_shift; dst[j+2] = dbswap(((tmp - (tmp>>dst_depth) + dither[2])>>shift) << dst_shift);\
2199  tmp = bswap(src[j+3]) >> src_shift; dst[j+3] = dbswap(((tmp - (tmp>>dst_depth) + dither[3])>>shift) << dst_shift);\
2200  tmp = bswap(src[j+4]) >> src_shift; dst[j+4] = dbswap(((tmp - (tmp>>dst_depth) + dither[4])>>shift) << dst_shift);\
2201  tmp = bswap(src[j+5]) >> src_shift; dst[j+5] = dbswap(((tmp - (tmp>>dst_depth) + dither[5])>>shift) << dst_shift);\
2202  tmp = bswap(src[j+6]) >> src_shift; dst[j+6] = dbswap(((tmp - (tmp>>dst_depth) + dither[6])>>shift) << dst_shift);\
2203  tmp = bswap(src[j+7]) >> src_shift; dst[j+7] = dbswap(((tmp - (tmp>>dst_depth) + dither[7])>>shift) << dst_shift);\
2204  }\
2205  for (; j < length; j++) {\
2206  tmp = bswap(src[j]); dst[j] = dbswap((tmp - (tmp>>dst_depth) + dither[j&7])>>shift);\
2207  }\
2208  dst += dstStride;\
2209  src += srcStride;\
2210  }\
2211  }
2212 
2213 static int planarCopyWrapper(SwsInternal *c, const uint8_t *const src[],
2214  const int srcStride[], int srcSliceY, int srcSliceH,
2215  uint8_t *const dst[], const int dstStride[])
2216 {
2217  const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->opts.src_format);
2218  const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->opts.dst_format);
2219  int plane, i, j;
2220  for (plane = 0; plane < 4 && dst[plane] != NULL; plane++) {
2221  int length = (plane == 0 || plane == 3) ? c->opts.src_w : AV_CEIL_RSHIFT(c->opts.src_w, c->chrDstHSubSample);
2222  int y = (plane == 0 || plane == 3) ? srcSliceY: AV_CEIL_RSHIFT(srcSliceY, c->chrDstVSubSample);
2223  int height = (plane == 0 || plane == 3) ? srcSliceH: AV_CEIL_RSHIFT(srcSliceH, c->chrDstVSubSample);
2224  const uint8_t *srcPtr = src[plane];
2225  uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
2226  int shiftonly = plane == 1 || plane == 2 || (!c->opts.src_range && plane == 0);
2227  if (plane == 1 && isSemiPlanarYUV(c->opts.dst_format))
2228  length *= 2;
2229 
2230  // ignore palette for GRAY8
2231  if (plane == 1 && desc_dst->nb_components < 3) continue;
2232  if (!src[plane] || (plane == 1 && desc_src->nb_components < 3) || (plane == 3 && desc_src->nb_components <= 3)) {
2233  if (is16BPS(c->opts.dst_format) || isNBPS(c->opts.dst_format)) {
2234  fillPlane16(dst[plane], dstStride[plane], length, height, y,
2235  plane == 3, desc_dst->comp[plane].depth,
2236  isBE(c->opts.dst_format));
2237  } else {
2238  fillPlane(dst[plane], dstStride[plane], length, height, y,
2239  (plane == 3) ? 255 : 128);
2240  }
2241  } else {
2242  if(isNBPS(c->opts.src_format) || isNBPS(c->opts.dst_format)
2243  || (is16BPS(c->opts.src_format) != is16BPS(c->opts.dst_format))
2244  ) {
2245  const int src_depth = desc_src->comp[plane].depth;
2246  const int dst_depth = desc_dst->comp[plane].depth;
2247  const int src_shift = desc_src->comp[plane].shift;
2248  const int dst_shift = desc_dst->comp[plane].shift;
2249  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
2250  uint16_t *dstPtr2 = (uint16_t*)dstPtr;
2251 
2252  if (dst_depth == 8) {
2253  av_assert1(src_depth > 8);
2254  if(isBE(c->opts.src_format) == HAVE_BIGENDIAN){
2255  DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, , )
2256  } else {
2257  DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, av_bswap16, )
2258  }
2259  } else if (src_depth == 8) {
2260  for (i = 0; i < height; i++) {
2261  #define COPY816(w)\
2262  if (shiftonly) {\
2263  for (j = 0; j < length; j++)\
2264  w(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) << dst_shift);\
2265  } else {\
2266  for (j = 0; j < length; j++)\
2267  w(&dstPtr2[j], ((srcPtr[j]<<(dst_depth-8)) |\
2268  (srcPtr[j]>>(2*8-dst_depth))) << dst_shift);\
2269  }
2270  if(isBE(c->opts.dst_format)){
2271  COPY816(AV_WB16)
2272  } else {
2273  COPY816(AV_WL16)
2274  }
2275  dstPtr2 += dstStride[plane]/2;
2276  srcPtr += srcStride[plane];
2277  }
2278  } else if (src_depth <= dst_depth) {
2279  unsigned shift = dst_depth - src_depth;
2280  for (i = 0; i < height; i++) {
2281  j = 0;
2282  if(isBE(c->opts.src_format) == HAVE_BIGENDIAN &&
2283  isBE(c->opts.dst_format) == HAVE_BIGENDIAN &&
2284  shiftonly) {
2285 #if HAVE_FAST_64BIT
2286  for (; j < length - 3; j += 4) {
2287  uint64_t v = AV_RN64A(srcPtr2 + j) >> src_shift;
2288  AV_WN64A(dstPtr2 + j, (v << shift) << dst_shift);
2289  }
2290 #else
2291  for (; j < length - 1; j += 2) {
2292  uint32_t v = AV_RN32A(srcPtr2 + j) >> src_shift;
2293  AV_WN32A(dstPtr2 + j, (v << shift) << dst_shift);
2294  }
2295 #endif
2296  }
2297 #define COPY_UP(r,w) \
2298  if(shiftonly){\
2299  for (; j < length; j++){ \
2300  unsigned int v= r(&srcPtr2[j]) >> src_shift;\
2301  w(&dstPtr2[j], (v << shift) << dst_shift);\
2302  }\
2303  }else{\
2304  for (; j < length; j++){ \
2305  unsigned int v= r(&srcPtr2[j]) >> src_shift;\
2306  w(&dstPtr2[j], ((v << shift) | (v>>(2*src_depth-dst_depth))) << dst_shift);\
2307  }\
2308  }
2309  if(isBE(c->opts.src_format)){
2310  if(isBE(c->opts.dst_format)){
2311  COPY_UP(AV_RB16, AV_WB16)
2312  } else {
2313  COPY_UP(AV_RB16, AV_WL16)
2314  }
2315  } else {
2316  if(isBE(c->opts.dst_format)){
2317  COPY_UP(AV_RL16, AV_WB16)
2318  } else {
2319  COPY_UP(AV_RL16, AV_WL16)
2320  }
2321  }
2322  dstPtr2 += dstStride[plane]/2;
2323  srcPtr2 += srcStride[plane]/2;
2324  }
2325  } else { /* src_depth > dst_depth */
2326  if(isBE(c->opts.src_format) == HAVE_BIGENDIAN){
2327  if(isBE(c->opts.dst_format) == HAVE_BIGENDIAN){
2328  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , )
2329  } else {
2330  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , av_bswap16)
2331  }
2332  }else{
2333  if(isBE(c->opts.dst_format) == HAVE_BIGENDIAN){
2334  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, )
2335  } else {
2336  DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, av_bswap16)
2337  }
2338  }
2339  }
2340  } else if (is16BPS(c->opts.src_format) && is16BPS(c->opts.dst_format) &&
2341  isBE(c->opts.src_format) != isBE(c->opts.dst_format)) {
2342 
2343  for (i = 0; i < height; i++) {
2344  for (j = 0; j < length; j++)
2345  ((uint16_t *) dstPtr)[j] = av_bswap16(((const uint16_t *) srcPtr)[j]);
2346  srcPtr += srcStride[plane];
2347  dstPtr += dstStride[plane];
2348  }
2349  } else if (isFloat(c->opts.src_format) && isFloat(c->opts.dst_format) &&
2350  isBE(c->opts.src_format) != isBE(c->opts.dst_format)) { /* swap float plane */
2351  for (i = 0; i < height; i++) {
2352  for (j = 0; j < length; j++)
2353  ((uint32_t *) dstPtr)[j] = av_bswap32(((const uint32_t *) srcPtr)[j]);
2354  srcPtr += srcStride[plane];
2355  dstPtr += dstStride[plane];
2356  }
2357  } else if (dstStride[plane] == srcStride[plane] &&
2358  srcStride[plane] > 0 && srcStride[plane] == length) {
2359  memcpy(dst[plane] + dstStride[plane] * y, src[plane],
2360  height * dstStride[plane]);
2361  } else {
2362  if (is16BPS(c->opts.src_format) && is16BPS(c->opts.dst_format))
2363  length *= 2;
2364  else if (desc_src->comp[0].depth == 1)
2365  length >>= 3; // monowhite/black
2366  for (i = 0; i < height; i++) {
2367  memcpy(dstPtr, srcPtr, length);
2368  srcPtr += srcStride[plane];
2369  dstPtr += dstStride[plane];
2370  }
2371  }
2372  }
2373  }
2374  return srcSliceH;
2375 }
2376 
2377 
2378 #define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt) \
2379  ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) || \
2380  (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))
2381 
2382 
2383 void ff_get_unscaled_swscale(SwsInternal *c)
2384 {
2385  const enum AVPixelFormat srcFormat = c->opts.src_format;
2386  const enum AVPixelFormat dstFormat = c->opts.dst_format;
2387  const int flags = c->opts.flags;
2388  const int dstH = c->opts.dst_h;
2389  const int dstW = c->opts.dst_w;
2390  int needsDither;
2391 
2392  needsDither = isAnyRGB(dstFormat) &&
2393  c->dstFormatBpp < 24 &&
2394  (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
2395 
2396  /* yv12_to_nv12 */
2397  if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) &&
2398  (dstFormat == AV_PIX_FMT_NV12 || dstFormat == AV_PIX_FMT_NV21)) {
2399  c->convert_unscaled = planarToNv12Wrapper;
2400  }
2401  /* yv24_to_nv24 */
2402  if ((srcFormat == AV_PIX_FMT_YUV444P || srcFormat == AV_PIX_FMT_YUVA444P) &&
2403  (dstFormat == AV_PIX_FMT_NV24 || dstFormat == AV_PIX_FMT_NV42)) {
2404  c->convert_unscaled = planarToNv24Wrapper;
2405  }
2406  /* nv12_to_yv12 */
2407  if (dstFormat == AV_PIX_FMT_YUV420P &&
2408  (srcFormat == AV_PIX_FMT_NV12 || srcFormat == AV_PIX_FMT_NV21)) {
2409  c->convert_unscaled = nv12ToPlanarWrapper;
2410  }
2411  /* nv24_to_yv24 */
2412  if (dstFormat == AV_PIX_FMT_YUV444P &&
2413  (srcFormat == AV_PIX_FMT_NV24 || srcFormat == AV_PIX_FMT_NV42)) {
2414  c->convert_unscaled = nv24ToPlanarWrapper;
2415  }
2416  /* yuv2bgr */
2417  if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUV422P ||
2418  srcFormat == AV_PIX_FMT_YUVA420P) && isAnyRGB(dstFormat) &&
2419  !(flags & SWS_ACCURATE_RND) && (c->opts.dither == SWS_DITHER_BAYER || c->opts.dither == SWS_DITHER_AUTO) && !(dstH & 1)) {
2420  c->convert_unscaled = ff_yuv2rgb_get_func_ptr(c);
2421  c->dst_slice_align = 2;
2422  }
2423  /* yuv420p1x_to_p01x */
2424  if ((srcFormat == AV_PIX_FMT_YUV420P10 || srcFormat == AV_PIX_FMT_YUVA420P10 ||
2425  srcFormat == AV_PIX_FMT_YUV420P12 ||
2426  srcFormat == AV_PIX_FMT_YUV420P14 ||
2427  srcFormat == AV_PIX_FMT_YUV420P16 || srcFormat == AV_PIX_FMT_YUVA420P16) &&
2428  (dstFormat == AV_PIX_FMT_P010 || dstFormat == AV_PIX_FMT_P016)) {
2429  c->convert_unscaled = planarToP01xWrapper;
2430  }
2431  /* yuv420p_to_p01xle */
2432  if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) &&
2433  (dstFormat == AV_PIX_FMT_P010LE || dstFormat == AV_PIX_FMT_P016LE)) {
2434  c->convert_unscaled = planar8ToP01xleWrapper;
2435  }
2436 
2437  if (srcFormat == AV_PIX_FMT_YUV410P && !(dstH & 3) &&
2438  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
2439  !(flags & SWS_BITEXACT)) {
2440  c->convert_unscaled = yvu9ToYv12Wrapper;
2441  c->dst_slice_align = 4;
2442  }
2443 
2444  /* bgr24toYV12 */
2445  if (srcFormat == AV_PIX_FMT_BGR24 &&
2446  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
2447  !(flags & SWS_ACCURATE_RND) && !(dstW&1))
2448  c->convert_unscaled = bgr24ToYv12Wrapper;
2449 
2450  /* AYUV/VUYA/UYVA -> AYUV/VUYA/UYVA */
2451  if (isAYUV(srcFormat) && isAYUV(dstFormat) && findRgbConvFn(c))
2452  c->convert_unscaled = rgbToRgbWrapper;
2453 
2454  /* RGB/BGR -> RGB/BGR (no dither needed forms) */
2455  if (isAnyRGB(srcFormat) && isAnyRGB(dstFormat) && findRgbConvFn(c)
2456  && (!needsDither || (c->opts.flags&(SWS_FAST_BILINEAR|SWS_POINT))))
2457  c->convert_unscaled = rgbToRgbWrapper;
2458 
2459  /* RGB to planar RGB */
2460  if ((srcFormat == AV_PIX_FMT_GBRP && dstFormat == AV_PIX_FMT_GBRAP) ||
2461  (srcFormat == AV_PIX_FMT_GBRP10 && dstFormat == AV_PIX_FMT_GBRAP10) ||
2462  (srcFormat == AV_PIX_FMT_GBRP12 && dstFormat == AV_PIX_FMT_GBRAP12) ||
2463  (srcFormat == AV_PIX_FMT_GBRP14 && dstFormat == AV_PIX_FMT_GBRAP14) ||
2464  (srcFormat == AV_PIX_FMT_GBRP16 && dstFormat == AV_PIX_FMT_GBRAP16) ||
2465  (srcFormat == AV_PIX_FMT_GBRAP && dstFormat == AV_PIX_FMT_GBRP) ||
2466  (srcFormat == AV_PIX_FMT_GBRAP10 && dstFormat == AV_PIX_FMT_GBRP10) ||
2467  (srcFormat == AV_PIX_FMT_GBRAP12 && dstFormat == AV_PIX_FMT_GBRP12) ||
2468  (srcFormat == AV_PIX_FMT_GBRAP14 && dstFormat == AV_PIX_FMT_GBRP14) ||
2469  (srcFormat == AV_PIX_FMT_GBRAP16 && dstFormat == AV_PIX_FMT_GBRP16))
2470  c->convert_unscaled = planarRgbToplanarRgbWrapper;
2471 
2472 #define isByteRGB(f) ( \
2473  f == AV_PIX_FMT_RGB32 || \
2474  f == AV_PIX_FMT_RGB32_1 || \
2475  f == AV_PIX_FMT_RGB24 || \
2476  f == AV_PIX_FMT_BGR32 || \
2477  f == AV_PIX_FMT_BGR32_1 || \
2478  f == AV_PIX_FMT_BGR24)
2479 
2480  if (srcFormat == AV_PIX_FMT_GBRP && isPlanar(srcFormat) && isByteRGB(dstFormat))
2481  c->convert_unscaled = planarRgbToRgbWrapper;
2482 
2483  if (srcFormat == AV_PIX_FMT_GBRAP && isByteRGB(dstFormat))
2484  c->convert_unscaled = planarRgbaToRgbWrapper;
2485 
2486  if ((srcFormat == AV_PIX_FMT_RGB48LE || srcFormat == AV_PIX_FMT_RGB48BE ||
2487  srcFormat == AV_PIX_FMT_BGR48LE || srcFormat == AV_PIX_FMT_BGR48BE ||
2488  srcFormat == AV_PIX_FMT_RGBA64LE || srcFormat == AV_PIX_FMT_RGBA64BE ||
2489  srcFormat == AV_PIX_FMT_BGRA64LE || srcFormat == AV_PIX_FMT_BGRA64BE) &&
2490  (dstFormat == AV_PIX_FMT_GBRP9LE || dstFormat == AV_PIX_FMT_GBRP9BE ||
2491  dstFormat == AV_PIX_FMT_GBRP10LE || dstFormat == AV_PIX_FMT_GBRP10BE ||
2492  dstFormat == AV_PIX_FMT_GBRP12LE || dstFormat == AV_PIX_FMT_GBRP12BE ||
2493  dstFormat == AV_PIX_FMT_GBRP14LE || dstFormat == AV_PIX_FMT_GBRP14BE ||
2494  dstFormat == AV_PIX_FMT_GBRP16LE || dstFormat == AV_PIX_FMT_GBRP16BE ||
2495  dstFormat == AV_PIX_FMT_GBRAP10LE || dstFormat == AV_PIX_FMT_GBRAP10BE ||
2496  dstFormat == AV_PIX_FMT_GBRAP12LE || dstFormat == AV_PIX_FMT_GBRAP12BE ||
2497  dstFormat == AV_PIX_FMT_GBRAP14LE || dstFormat == AV_PIX_FMT_GBRAP14BE ||
2498  dstFormat == AV_PIX_FMT_GBRAP16LE || dstFormat == AV_PIX_FMT_GBRAP16BE ))
2499  c->convert_unscaled = Rgb16ToPlanarRgb16Wrapper;
2500 
2501  if (av_pix_fmt_desc_get(dstFormat)->comp[0].depth >= 10 &&
2502  isPlanarRGB(dstFormat) && !isFloat(dstFormat) &&
2503  (srcFormat == AV_PIX_FMT_X2RGB10LE || srcFormat == AV_PIX_FMT_X2BGR10LE))
2504  c->convert_unscaled = Rgb16ToPlanarRgb16Wrapper;
2505 
2506  if ((srcFormat == AV_PIX_FMT_GBRP9LE || srcFormat == AV_PIX_FMT_GBRP9BE ||
2507  srcFormat == AV_PIX_FMT_GBRP16LE || srcFormat == AV_PIX_FMT_GBRP16BE ||
2508  srcFormat == AV_PIX_FMT_GBRP10LE || srcFormat == AV_PIX_FMT_GBRP10BE ||
2509  srcFormat == AV_PIX_FMT_GBRP12LE || srcFormat == AV_PIX_FMT_GBRP12BE ||
2510  srcFormat == AV_PIX_FMT_GBRP14LE || srcFormat == AV_PIX_FMT_GBRP14BE ||
2511  srcFormat == AV_PIX_FMT_GBRAP10LE || srcFormat == AV_PIX_FMT_GBRAP10BE ||
2512  srcFormat == AV_PIX_FMT_GBRAP12LE || srcFormat == AV_PIX_FMT_GBRAP12BE ||
2513  srcFormat == AV_PIX_FMT_GBRAP14LE || srcFormat == AV_PIX_FMT_GBRAP14BE ||
2514  srcFormat == AV_PIX_FMT_GBRAP16LE || srcFormat == AV_PIX_FMT_GBRAP16BE) &&
2515  (dstFormat == AV_PIX_FMT_RGB48LE || dstFormat == AV_PIX_FMT_RGB48BE ||
2516  dstFormat == AV_PIX_FMT_BGR48LE || dstFormat == AV_PIX_FMT_BGR48BE ||
2517  dstFormat == AV_PIX_FMT_RGBA64LE || dstFormat == AV_PIX_FMT_RGBA64BE ||
2518  dstFormat == AV_PIX_FMT_BGRA64LE || dstFormat == AV_PIX_FMT_BGRA64BE))
2519  c->convert_unscaled = planarRgb16ToRgb16Wrapper;
2520 
2521  if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth >= 10 &&
2522  isPlanarRGB(srcFormat) && !isFloat(srcFormat) &&
2523  (dstFormat == AV_PIX_FMT_X2RGB10LE || dstFormat == AV_PIX_FMT_X2BGR10LE))
2524  c->convert_unscaled = planarRgb16ToRgb16Wrapper;
2525 
2526  if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
2527  isPackedRGB(srcFormat) && dstFormat == AV_PIX_FMT_GBRP)
2528  c->convert_unscaled = rgbToPlanarRgbWrapper;
2529 
2530  if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
2531  isPackedRGB(srcFormat) && dstFormat == AV_PIX_FMT_GBRAP)
2532  c->convert_unscaled = rgbToPlanarRgbaWrapper;
2533 
2534  if (isBayer(srcFormat)) {
2535  c->dst_slice_align = 2;
2536  if (dstFormat == AV_PIX_FMT_RGB24)
2537  c->convert_unscaled = bayer_to_rgb24_wrapper;
2538  else if (dstFormat == AV_PIX_FMT_RGB48)
2539  c->convert_unscaled = bayer_to_rgb48_wrapper;
2540  else if (dstFormat == AV_PIX_FMT_YUV420P)
2541  c->convert_unscaled = bayer_to_yv12_wrapper;
2542  else if (!isBayer(dstFormat)) {
2543  av_log(c, AV_LOG_ERROR, "unsupported bayer conversion\n");
2544  av_assert0(0);
2545  }
2546  }
2547 
2548  /* bswap 16 bits per pixel/component packed formats */
2549  if (IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BAYER_BGGR16) ||
2550  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BAYER_RGGB16) ||
2551  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BAYER_GBRG16) ||
2552  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BAYER_GRBG16) ||
2553  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR444) ||
2554  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR48) ||
2555  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR555) ||
2556  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR565) ||
2557  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGRA64) ||
2558  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY9) ||
2559  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY10) ||
2560  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY12) ||
2561  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY14) ||
2562  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY16) ||
2563  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YA16) ||
2564  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_AYUV64) ||
2565  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRP9) ||
2566  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRP10) ||
2567  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRP12) ||
2568  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRP14) ||
2569  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRP16) ||
2570  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP10) ||
2571  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP12) ||
2572  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP14) ||
2573  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP16) ||
2574  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB444) ||
2575  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB48) ||
2576  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB555) ||
2577  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB565) ||
2578  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGBA64) ||
2579  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_XV36) ||
2580  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_XV48) ||
2581  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_XYZ12) ||
2582  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV420P9) ||
2583  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV420P10) ||
2584  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV420P12) ||
2585  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV420P14) ||
2586  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV420P16) ||
2587  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV422P9) ||
2588  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV422P10) ||
2589  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV422P12) ||
2590  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV422P14) ||
2591  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV422P16) ||
2592  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV440P10) ||
2593  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV440P12) ||
2594  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV444P9) ||
2595  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV444P10) ||
2596  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV444P12) ||
2597  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV444P14) ||
2598  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YUV444P16))
2599  c->convert_unscaled = bswap_16bpc;
2600 
2601  /* bswap 32 bits per pixel/component formats */
2602  if (IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRPF32) ||
2603  IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAPF32))
2604  c->convert_unscaled = bswap_32bpc;
2605 
2606  if (usePal(srcFormat)) {
2607  switch (dstFormat) {
2608  case AV_PIX_FMT_GBRP:
2609  case AV_PIX_FMT_GBRAP:
2610  c->convert_unscaled = palToGbrpWrapper;
2611  break;
2612  default:
2613  if (isByteRGB(dstFormat))
2614  c->convert_unscaled = palToRgbWrapper;
2615  break;
2616  }
2617  }
2618 
2619  if (srcFormat == AV_PIX_FMT_YUV422P) {
2620  if (dstFormat == AV_PIX_FMT_YUYV422)
2621  c->convert_unscaled = yuv422pToYuy2Wrapper;
2622  else if (dstFormat == AV_PIX_FMT_UYVY422)
2623  c->convert_unscaled = yuv422pToUyvyWrapper;
2624  }
2625 
2626  /* uint Y to float Y */
2627  if (srcFormat == AV_PIX_FMT_GRAY8 && dstFormat == AV_PIX_FMT_GRAYF32){
2628  c->convert_unscaled = uint_y_to_float_y_wrapper;
2629  }
2630 
2631  /* float Y to uint Y */
2632  if (srcFormat == AV_PIX_FMT_GRAYF32 && dstFormat == AV_PIX_FMT_GRAY8){
2633  c->convert_unscaled = float_y_to_uint_y_wrapper;
2634  }
2635 
2636  /* LQ converters if -sws 0 or -sws 4*/
2637  if (c->opts.flags&(SWS_FAST_BILINEAR|SWS_POINT)) {
2638  /* yv12_to_yuy2 */
2639  if (srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) {
2640  if (dstFormat == AV_PIX_FMT_YUYV422)
2641  c->convert_unscaled = planarToYuy2Wrapper;
2642  else if (dstFormat == AV_PIX_FMT_UYVY422)
2643  c->convert_unscaled = planarToUyvyWrapper;
2644  }
2645  }
2646  if (srcFormat == AV_PIX_FMT_YUYV422 &&
2647  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
2648  c->convert_unscaled = yuyvToYuv420Wrapper;
2649  if (srcFormat == AV_PIX_FMT_UYVY422 &&
2650  (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
2651  c->convert_unscaled = uyvyToYuv420Wrapper;
2652  if (srcFormat == AV_PIX_FMT_YUYV422 && dstFormat == AV_PIX_FMT_YUV422P)
2653  c->convert_unscaled = yuyvToYuv422Wrapper;
2654  if (srcFormat == AV_PIX_FMT_UYVY422 && dstFormat == AV_PIX_FMT_YUV422P)
2655  c->convert_unscaled = uyvyToYuv422Wrapper;
2656  if (dstFormat == AV_PIX_FMT_YUV420P &&
2657  (srcFormat == AV_PIX_FMT_NV24 || srcFormat == AV_PIX_FMT_NV42))
2658  c->convert_unscaled = nv24ToYuv420Wrapper;
2659 
2660 #define isPlanarGray(x) (isGray(x) && (x) != AV_PIX_FMT_YA8 && (x) != AV_PIX_FMT_YA16LE && (x) != AV_PIX_FMT_YA16BE)
2661 
2662  /* simple copy */
2663  if ( srcFormat == dstFormat ||
2664  (srcFormat == AV_PIX_FMT_YUVA420P && dstFormat == AV_PIX_FMT_YUV420P) ||
2665  (srcFormat == AV_PIX_FMT_YUV420P && dstFormat == AV_PIX_FMT_YUVA420P) ||
2666  (isFloat(srcFormat) == isFloat(dstFormat) && isFloat16(srcFormat) == isFloat16(dstFormat)) && ((isPlanarYUV(srcFormat) && isPlanarGray(dstFormat)) ||
2667  (isPlanarYUV(dstFormat) && isPlanarGray(srcFormat)) ||
2668  (isPlanarGray(dstFormat) && isPlanarGray(srcFormat)) ||
2669  (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat) &&
2670  c->chrDstHSubSample == c->chrSrcHSubSample &&
2671  c->chrDstVSubSample == c->chrSrcVSubSample &&
2672  isSemiPlanarYUV(srcFormat) == isSemiPlanarYUV(dstFormat) &&
2673  isSwappedChroma(srcFormat) == isSwappedChroma(dstFormat))))
2674  {
2675  if (isPacked(c->opts.src_format))
2676  c->convert_unscaled = packedCopyWrapper;
2677  else /* Planar YUV or gray */
2678  c->convert_unscaled = planarCopyWrapper;
2679  }
2680 
2681 #if ARCH_PPC
2682  ff_get_unscaled_swscale_ppc(c);
2683 #elif ARCH_ARM
2684  ff_get_unscaled_swscale_arm(c);
2685 #elif ARCH_AARCH64
2686  ff_get_unscaled_swscale_aarch64(c);
2687 #endif
2688 }
2689 
2690 /* Convert the palette to the same packed 32-bit format as the palette */
2691 void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst,
2692  int num_pixels, const uint8_t *palette)
2693 {
2694  int i;
2695 
2696  for (i = 0; i < num_pixels; i++)
2697  ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
2698 }
2699 
2700 /* Palette format: ABCD -> dst format: ABC */
2701 void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst,
2702  int num_pixels, const uint8_t *palette)
2703 {
2704  int i;
2705 
2706  for (i = 0; i < num_pixels; i++) {
2707  //FIXME slow?
2708  dst[0] = palette[src[i] * 4 + 0];
2709  dst[1] = palette[src[i] * 4 + 1];
2710  dst[2] = palette[src[i] * 4 + 2];
2711  dst += 3;
2712  }
2713 }
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:842
flags
const SwsFlags flags[]
Definition: swscale.c:61
rgbToPlanarRgbaWrapper
static int rgbToPlanarRgbaWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1531
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:551
nv24ToPlanarWrapper
static int nv24ToPlanarWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:203
rgb12tobgr12
void rgb12tobgr12(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:325
isX2RGB
#define isX2RGB(x)
Definition: swscale_unscaled.c:1822
gray8aToPlanar8
static void gray8aToPlanar8(const uint8_t *src, uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dstA, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:512
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
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:910
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
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale.h:81
isPacked
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:887
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
ff_get_unscaled_swscale_ppc
av_cold void ff_get_unscaled_swscale_ppc(SwsInternal *c)
Definition: yuv2yuv_altivec.c:187
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
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
C2
#define C2
Definition: mpegaudiodsp_template.c:239
mem_internal.h
packedtogbr24p
static void packedtogbr24p(const uint8_t *src, int srcStride, uint8_t *const dst[], const int dstStride[], int srcSliceH, int alpha_first, int inc_size, int width)
Definition: swscale_unscaled.c:1394
gbr24ptopacked24
static void gbr24ptopacked24(const uint8_t *src[], const int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int width)
Definition: swscale_unscaled.c:1182
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:502
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:65
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:290
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:3341
nv24ToYuv420Wrapper
static int nv24ToYuv420Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:248
src1
const pixel * src1
Definition: h264pred_template.c:420
planarRgbaToRgbWrapper
static int planarRgbaToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1258
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:578
w
uint8_t w
Definition: llviddspenc.c:38
planarToNv12Wrapper
static int planarToNv12Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:142
rgb16tobgr32
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:193
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:573
AVPixFmtDescriptor::name
const char * name
Definition: pixdesc.h:70
SWS_BITEXACT
@ SWS_BITEXACT
Definition: swscale.h:156
CONV_IS
#define CONV_IS(src, dst)
planar8ToP01xleWrapper
static int planar8ToP01xleWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam8[], const int dstStride[])
Definition: swscale_unscaled.c:328
x2rgb10tobgr64_bswap
void x2rgb10tobgr64_bswap(const uint8_t *src, uint8_t *dst, int src_size)
shuffle_bytes_3210
void(* shuffle_bytes_3210)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:58
pal8ToPlanar8
static void pal8ToPlanar8(const uint8_t *src, uint8_t *dst0, uint8_t *dst1, uint8_t *dst2, uint8_t *dstA, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:526
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:73
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:528
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:501
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:117
rgbToPlanarRgbWrapper
static int rgbToPlanarRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1423
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:534
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
planarToP01xWrapper
static int planarToP01xWrapper(SwsInternal *c, const uint8_t *const src8[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam8[], const int dstStride[])
Definition: swscale_unscaled.c:268
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:2701
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:557
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:69
bayer_template.c
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:507
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
x2rgb10tobgr48_nobswap
void x2rgb10tobgr48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:311
yuyvToYuv420Wrapper
static int yuyvToYuv420Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:419
SWS_FAST_BILINEAR
@ SWS_FAST_BILINEAR
Scaler selection options.
Definition: swscale.h:98
isRGBA32
#define isRGBA32(x)
Definition: swscale_unscaled.c:1794
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:727
rgb
Definition: rpzaenc.c:60
bswap_32bpc
static int bswap_32bpc(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:567
planarToUyvyWrapper
static int planarToUyvyWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:383
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:546
shuffle_bytes_2130
void(* shuffle_bytes_2130)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:61
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:1801
C1
#define C1
Definition: mpegaudiodsp_template.c:238
float_y_to_uint_y_wrapper
static int float_y_to_uint_y_wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2102
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:544
palToRgbWrapper
static int palToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:595
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:526
rgb16tobgr16
void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:248
yuv422pToYuy2Wrapper
static int yuv422pToYuy2Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:395
x2rgb10tobgr48_bswap
void x2rgb10tobgr48_bswap(const uint8_t *src, uint8_t *dst, int src_size)
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:741
AV_PIX_FMT_XV48
#define AV_PIX_FMT_XV48
Definition: pixfmt.h:594
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:511
rgb48tobgr64_bswap
void rgb48tobgr64_bswap(const uint8_t *src, uint8_t *dst, int src_size)
DITHER_COPY
#define DITHER_COPY(dst, dstStride, src, srcStride, bswap, dbswap)
Definition: swscale_unscaled.c:2152
bgr24ToYv12Wrapper
static int bgr24ToYv12Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2049
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:531
isRGB48
#define isRGB48(x)
Definition: swscale_unscaled.c:1808
avassert.h
packed32togbrap
static void packed32togbrap(const uint8_t *src, int srcStride, uint8_t *const dst[], const int dstStride[], int srcSliceH, int alpha_first, int width)
Definition: swscale_unscaled.c:1495
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
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
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:540
gbraptopacked32
static void gbraptopacked32(const uint8_t *src[], const int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha_first, int width)
Definition: swscale_unscaled.c:1229
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:548
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
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:550
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:549
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:541
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
Rgb16ToPlanarRgb16Wrapper
static int Rgb16ToPlanarRgb16Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:886
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale.h:82
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:41
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:525
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:539
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:510
isAYUV
#define isAYUV(x)
Definition: swscale_unscaled.c:1815
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:73
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
bayer_to_yv12_wrapper
static int bayer_to_yv12_wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1738
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:565
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:503
uyvyToYuv420Wrapper
static int uyvyToYuv420Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:450
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
conv
static int conv(int samples, float **pcm, char *buf, int channels)
Definition: libvorbisdec.c:135
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:234
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:554
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:508
rgb12to15
void rgb12to15(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:215
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:92
isSemiPlanarYUV
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:773
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
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:547
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:518
shuffle_bytes_3102
void(* shuffle_bytes_3102)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:59
packed30togbra10
static void packed30togbra10(const uint8_t *src, int srcStride, uint16_t *dst[], const int dstStride[], int srcSliceH, int swap, int bpc, int width)
Definition: swscale_unscaled.c:814
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:519
NULL
#define NULL
Definition: coverity.c:32
rgb16to15
void(* rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:50
yvu9ToYv12Wrapper
static int yvu9ToYv12Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2066
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
isFloat16
static av_always_inline int isFloat16(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:871
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
uint_y_to_float_y_wrapper
static int uint_y_to_float_y_wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2082
gray8aToPacked24
static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:498
ff_get_unscaled_swscale_aarch64
void ff_get_unscaled_swscale_aarch64(SwsInternal *c)
Definition: swscale_unscaled.c:218
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
bayer_to_rgb48_wrapper
static int bayer_to_rgb48_wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1688
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
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:530
AV_PIX_FMT_BAYER_GBRG16
#define AV_PIX_FMT_BAYER_GBRG16
Definition: pixfmt.h:556
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:529
rgbConvFn
void(* rgbConvFn)(const uint8_t *, uint8_t *, int)
Definition: swscale_unscaled.c:1828
x2rgb10to64_nobswap
void x2rgb10to64_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
ff_get_unscaled_swscale_arm
void ff_get_unscaled_swscale_arm(SwsInternal *c)
Definition: swscale_unscaled.c:185
COPY816
#define COPY816(w)
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
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:114
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:543
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:304
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)
planarCopyWrapper
static int planarCopyWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2213
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
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
rgb64to48_nobswap
void rgb64to48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:748
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
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
height
#define height
Definition: dsp.h:89
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
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:1052
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:87
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:918
av_bswap32
#define av_bswap32
Definition: bswap.h:47
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:856
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:561
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:533
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:514
SWS_POINT
@ SWS_POINT
nearest neighbor
Definition: swscale.h:102
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:521
x2rgb10tobgr64_nobswap
void x2rgb10tobgr64_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:535
gray8aToPacked32_1
static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
Definition: swscale_unscaled.c:489
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_RN64A
#define AV_RN64A(p)
Definition: intreadwrite.h:526
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:584
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:2378
rgb32to24
void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:155
nv12ToPlanarWrapper
static int nv12ToPlanarWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:162
rgb15tobgr15
void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:314
findRgbConvFn
static rgbConvFn findRgbConvFn(SwsInternal *c)
Definition: swscale_unscaled.c:1829
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:500
isBGRinInt
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:820
yuyvToYuv422Wrapper
static int yuyvToYuv422Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:436
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)
isSwappedChroma
static av_always_inline int isSwappedChroma(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:955
rgb24to16
void(* rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:47
interpolate
static void interpolate(float *out, float v1, float v2, int size)
Definition: twinvq.c:85
bayer_to_rgb24_wrapper
static int bayer_to_rgb24_wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1638
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
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:111
planarToYuy2Wrapper
static int planarToYuy2Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:371
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:582
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:523
AVComponentDescriptor::shift
int shift
Number of least significant bits that must be shifted away to get the value.
Definition: pixdesc.h:52
C0
#define C0
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, const int32_t *rgb2yuv)
Height should be a multiple of 2 and width should be a multiple of 2.
Definition: rgb2rgb.c:85
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:513
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
gbr16ptopacked16
static void gbr16ptopacked16(const uint16_t *src[], const int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha, int swap, int bpp, int width)
Definition: swscale_unscaled.c:958
rgb24to15
void(* rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:48
src2
const pixel * src2
Definition: h264pred_template.c:421
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:545
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:522
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
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:516
planarRgb16ToRgb16Wrapper
static int planarRgb16ToRgb16Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1112
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
yuv422pToUyvyWrapper
static int yuv422pToUyvyWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:407
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:520
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:527
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:864
gbr16ptopacked30
static void gbr16ptopacked30(const uint16_t *src[], const int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int swap, int bpp, int width)
Definition: swscale_unscaled.c:1077
AV_PIX_FMT_P016
#define AV_PIX_FMT_P016
Definition: pixfmt.h:587
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:515
output_pixel
#define output_pixel(p, v)
Definition: swscale_unscaled.c:325
AV_RN32A
#define AV_RN32A(p)
Definition: intreadwrite.h:522
stride
#define stride
Definition: h264pred_template.c:536
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
SwsInternal
Definition: swscale_internal.h:317
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
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
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:95
isPlanarGray
#define isPlanarGray(x)
x2rgb10to48_bswap
void x2rgb10to48_bswap(const uint8_t *src, uint8_t *dst, int src_size)
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:532
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
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
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:108
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:537
AV_WN64A
#define AV_WN64A(p, v)
Definition: intreadwrite.h:538
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:481
uyvyToYuv422Wrapper
static int uyvyToYuv422Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:467
isPackedRGB
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:903
rgb24to32
void rgb24to32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:173
packed16togbra16
static void packed16togbra16(const uint8_t *src, int srcStride, uint16_t *dst[], const int dstStride[], int srcSliceH, int src_alpha, int swap, int shift, int width)
Definition: swscale_unscaled.c:680
rgb24tobgr15
void(* rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:41
shuffle_bytes_2013
void(* shuffle_bytes_2013)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:60
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:562
rgb15tobgr32
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:268
rgb15to16
void(* rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:51
shuffle_bytes_1203
void(* shuffle_bytes_1203)(const uint8_t *src, uint8_t *dst, int src_size)
Definition: rgb2rgb.c:62
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:77
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
x2rgb10to48_nobswap
void x2rgb10to48_nobswap(const uint8_t *src, uint8_t *dst, int src_size)
ALT32_CORR
#define ALT32_CORR
Definition: swscale_internal.h:57
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
src0
const pixel *const src0
Definition: h264pred_template.c:419
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:585
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsInternal *c)
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
planarRgbToplanarRgbWrapper
static int planarRgbToplanarRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1370
avutil.h
AV_PIX_FMT_X2BGR10LE
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:386
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
bswap_16bpc
static int bswap_16bpc(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:540
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
isRGBinInt
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:798
x2rgb10to64_bswap
void x2rgb10to64_bswap(const uint8_t *src, uint8_t *dst, int src_size)
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
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
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsInternal *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:2383
planarToNv24Wrapper
static int planarToNv24Wrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dstParam[], const int dstStride[])
Definition: swscale_unscaled.c:183
AV_PIX_FMT_XV36
#define AV_PIX_FMT_XV36
Definition: pixfmt.h:593
planar2x
void(* planar2x)(const uint8_t *src, uint8_t *dst, int width, int height, int srcStride, int dstStride)
Definition: rgb2rgb.c:90
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
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
planarRgbToRgbWrapper
static int planarRgbToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1314
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
SWS_ACCURATE_RND
@ SWS_ACCURATE_RND
Force bit-exact output.
Definition: swscale.h:155
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:534
h
h
Definition: vp9dsp_template.c:2070
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:538
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:896
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:2691
gbr24ptopacked32
static void gbr24ptopacked32(const uint8_t *src[], const int srcStride[], uint8_t *dst, int dstStride, int srcSliceH, int alpha_first, int width)
Definition: swscale_unscaled.c:1200
width
#define width
Definition: dsp.h:89
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:509
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:555
av_bswap16
#define av_bswap16
Definition: bswap.h:28
packed24togbrap
static void packed24togbrap(const uint8_t *src, int srcStride, uint8_t *const dst[], const int dstStride[], int srcSliceH, int width)
Definition: swscale_unscaled.c:1468
palToGbrpWrapper
static int palToGbrpWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:641
rgbToRgbWrapper
static int rgbToRgbWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:1988
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:536
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:3261
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
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:878
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:258
packedCopyWrapper
static int packedCopyWrapper(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_unscaled.c:2125
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:517
Generated on Sat Jun 28 2025 19:23:47 for FFmpeg by   doxygen 1.8.17