FFmpeg
utils.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of 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 "config.h"
22 
23 #define _DEFAULT_SOURCE
24 #define _SVID_SOURCE // needed for MAP_ANONYMOUS
25 #define _DARWIN_C_SOURCE // needed for MAP_ANON
26 #include <inttypes.h>
27 #include <math.h>
28 #include <stdio.h>
29 #include <string.h>
30 #if HAVE_MMAP
31 #include <sys/mman.h>
32 #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
33 #define MAP_ANONYMOUS MAP_ANON
34 #endif
35 #endif
36 #if HAVE_VIRTUALALLOC
37 #define WIN32_LEAN_AND_MEAN
38 #include <windows.h>
39 #endif
40 
41 #include "libavutil/attributes.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/cpu.h"
44 #include "libavutil/imgutils.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/opt.h"
49 #include "libavutil/pixdesc.h"
50 #include "libavutil/slicethread.h"
51 #include "libavutil/thread.h"
52 #include "libavutil/aarch64/cpu.h"
53 #include "libavutil/ppc/cpu.h"
54 #include "libavutil/x86/asm.h"
55 #include "libavutil/x86/cpu.h"
56 
57 #include "rgb2rgb.h"
58 #include "swscale.h"
59 #include "swscale_internal.h"
60 
61 static SwsVector *sws_getIdentityVec(void);
62 static void sws_addVec(SwsVector *a, SwsVector *b);
63 static void sws_shiftVec(SwsVector *a, int shift);
64 static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);
65 
66 static void handle_formats(SwsContext *c);
67 
68 typedef struct FormatEntry {
69  uint8_t is_supported_in :1;
70  uint8_t is_supported_out :1;
72 } FormatEntry;
73 
74 static const FormatEntry format_entries[] = {
75  [AV_PIX_FMT_YUV420P] = { 1, 1 },
76  [AV_PIX_FMT_YUYV422] = { 1, 1 },
77  [AV_PIX_FMT_RGB24] = { 1, 1 },
78  [AV_PIX_FMT_BGR24] = { 1, 1 },
79  [AV_PIX_FMT_YUV422P] = { 1, 1 },
80  [AV_PIX_FMT_YUV444P] = { 1, 1 },
81  [AV_PIX_FMT_YUV410P] = { 1, 1 },
82  [AV_PIX_FMT_YUV411P] = { 1, 1 },
83  [AV_PIX_FMT_GRAY8] = { 1, 1 },
84  [AV_PIX_FMT_MONOWHITE] = { 1, 1 },
85  [AV_PIX_FMT_MONOBLACK] = { 1, 1 },
86  [AV_PIX_FMT_PAL8] = { 1, 0 },
87  [AV_PIX_FMT_YUVJ420P] = { 1, 1 },
88  [AV_PIX_FMT_YUVJ411P] = { 1, 1 },
89  [AV_PIX_FMT_YUVJ422P] = { 1, 1 },
90  [AV_PIX_FMT_YUVJ444P] = { 1, 1 },
91  [AV_PIX_FMT_YVYU422] = { 1, 1 },
92  [AV_PIX_FMT_UYVY422] = { 1, 1 },
93  [AV_PIX_FMT_UYYVYY411] = { 0, 0 },
94  [AV_PIX_FMT_BGR8] = { 1, 1 },
95  [AV_PIX_FMT_BGR4] = { 0, 1 },
96  [AV_PIX_FMT_BGR4_BYTE] = { 1, 1 },
97  [AV_PIX_FMT_RGB8] = { 1, 1 },
98  [AV_PIX_FMT_RGB4] = { 0, 1 },
99  [AV_PIX_FMT_RGB4_BYTE] = { 1, 1 },
100  [AV_PIX_FMT_NV12] = { 1, 1 },
101  [AV_PIX_FMT_NV21] = { 1, 1 },
102  [AV_PIX_FMT_ARGB] = { 1, 1 },
103  [AV_PIX_FMT_RGBA] = { 1, 1 },
104  [AV_PIX_FMT_ABGR] = { 1, 1 },
105  [AV_PIX_FMT_BGRA] = { 1, 1 },
106  [AV_PIX_FMT_0RGB] = { 1, 1 },
107  [AV_PIX_FMT_RGB0] = { 1, 1 },
108  [AV_PIX_FMT_0BGR] = { 1, 1 },
109  [AV_PIX_FMT_BGR0] = { 1, 1 },
110  [AV_PIX_FMT_GRAY9BE] = { 1, 1 },
111  [AV_PIX_FMT_GRAY9LE] = { 1, 1 },
112  [AV_PIX_FMT_GRAY10BE] = { 1, 1 },
113  [AV_PIX_FMT_GRAY10LE] = { 1, 1 },
114  [AV_PIX_FMT_GRAY12BE] = { 1, 1 },
115  [AV_PIX_FMT_GRAY12LE] = { 1, 1 },
116  [AV_PIX_FMT_GRAY14BE] = { 1, 1 },
117  [AV_PIX_FMT_GRAY14LE] = { 1, 1 },
118  [AV_PIX_FMT_GRAY16BE] = { 1, 1 },
119  [AV_PIX_FMT_GRAY16LE] = { 1, 1 },
120  [AV_PIX_FMT_YUV440P] = { 1, 1 },
121  [AV_PIX_FMT_YUVJ440P] = { 1, 1 },
122  [AV_PIX_FMT_YUV440P10LE] = { 1, 1 },
123  [AV_PIX_FMT_YUV440P10BE] = { 1, 1 },
124  [AV_PIX_FMT_YUV440P12LE] = { 1, 1 },
125  [AV_PIX_FMT_YUV440P12BE] = { 1, 1 },
126  [AV_PIX_FMT_YUVA420P] = { 1, 1 },
127  [AV_PIX_FMT_YUVA422P] = { 1, 1 },
128  [AV_PIX_FMT_YUVA444P] = { 1, 1 },
129  [AV_PIX_FMT_YUVA420P9BE] = { 1, 1 },
130  [AV_PIX_FMT_YUVA420P9LE] = { 1, 1 },
131  [AV_PIX_FMT_YUVA422P9BE] = { 1, 1 },
132  [AV_PIX_FMT_YUVA422P9LE] = { 1, 1 },
133  [AV_PIX_FMT_YUVA444P9BE] = { 1, 1 },
134  [AV_PIX_FMT_YUVA444P9LE] = { 1, 1 },
135  [AV_PIX_FMT_YUVA420P10BE]= { 1, 1 },
136  [AV_PIX_FMT_YUVA420P10LE]= { 1, 1 },
137  [AV_PIX_FMT_YUVA422P10BE]= { 1, 1 },
138  [AV_PIX_FMT_YUVA422P10LE]= { 1, 1 },
139  [AV_PIX_FMT_YUVA444P10BE]= { 1, 1 },
140  [AV_PIX_FMT_YUVA444P10LE]= { 1, 1 },
141  [AV_PIX_FMT_YUVA420P16BE]= { 1, 1 },
142  [AV_PIX_FMT_YUVA420P16LE]= { 1, 1 },
143  [AV_PIX_FMT_YUVA422P16BE]= { 1, 1 },
144  [AV_PIX_FMT_YUVA422P16LE]= { 1, 1 },
145  [AV_PIX_FMT_YUVA444P16BE]= { 1, 1 },
146  [AV_PIX_FMT_YUVA444P16LE]= { 1, 1 },
147  [AV_PIX_FMT_RGB48BE] = { 1, 1 },
148  [AV_PIX_FMT_RGB48LE] = { 1, 1 },
149  [AV_PIX_FMT_RGBA64BE] = { 1, 1, 1 },
150  [AV_PIX_FMT_RGBA64LE] = { 1, 1, 1 },
151  [AV_PIX_FMT_RGB565BE] = { 1, 1 },
152  [AV_PIX_FMT_RGB565LE] = { 1, 1 },
153  [AV_PIX_FMT_RGB555BE] = { 1, 1 },
154  [AV_PIX_FMT_RGB555LE] = { 1, 1 },
155  [AV_PIX_FMT_BGR565BE] = { 1, 1 },
156  [AV_PIX_FMT_BGR565LE] = { 1, 1 },
157  [AV_PIX_FMT_BGR555BE] = { 1, 1 },
158  [AV_PIX_FMT_BGR555LE] = { 1, 1 },
159  [AV_PIX_FMT_YUV420P16LE] = { 1, 1 },
160  [AV_PIX_FMT_YUV420P16BE] = { 1, 1 },
161  [AV_PIX_FMT_YUV422P16LE] = { 1, 1 },
162  [AV_PIX_FMT_YUV422P16BE] = { 1, 1 },
163  [AV_PIX_FMT_YUV444P16LE] = { 1, 1 },
164  [AV_PIX_FMT_YUV444P16BE] = { 1, 1 },
165  [AV_PIX_FMT_RGB444LE] = { 1, 1 },
166  [AV_PIX_FMT_RGB444BE] = { 1, 1 },
167  [AV_PIX_FMT_BGR444LE] = { 1, 1 },
168  [AV_PIX_FMT_BGR444BE] = { 1, 1 },
169  [AV_PIX_FMT_YA8] = { 1, 1 },
170  [AV_PIX_FMT_YA16BE] = { 1, 1 },
171  [AV_PIX_FMT_YA16LE] = { 1, 1 },
172  [AV_PIX_FMT_BGR48BE] = { 1, 1 },
173  [AV_PIX_FMT_BGR48LE] = { 1, 1 },
174  [AV_PIX_FMT_BGRA64BE] = { 1, 1, 1 },
175  [AV_PIX_FMT_BGRA64LE] = { 1, 1, 1 },
176  [AV_PIX_FMT_YUV420P9BE] = { 1, 1 },
177  [AV_PIX_FMT_YUV420P9LE] = { 1, 1 },
178  [AV_PIX_FMT_YUV420P10BE] = { 1, 1 },
179  [AV_PIX_FMT_YUV420P10LE] = { 1, 1 },
180  [AV_PIX_FMT_YUV420P12BE] = { 1, 1 },
181  [AV_PIX_FMT_YUV420P12LE] = { 1, 1 },
182  [AV_PIX_FMT_YUV420P14BE] = { 1, 1 },
183  [AV_PIX_FMT_YUV420P14LE] = { 1, 1 },
184  [AV_PIX_FMT_YUV422P9BE] = { 1, 1 },
185  [AV_PIX_FMT_YUV422P9LE] = { 1, 1 },
186  [AV_PIX_FMT_YUV422P10BE] = { 1, 1 },
187  [AV_PIX_FMT_YUV422P10LE] = { 1, 1 },
188  [AV_PIX_FMT_YUV422P12BE] = { 1, 1 },
189  [AV_PIX_FMT_YUV422P12LE] = { 1, 1 },
190  [AV_PIX_FMT_YUV422P14BE] = { 1, 1 },
191  [AV_PIX_FMT_YUV422P14LE] = { 1, 1 },
192  [AV_PIX_FMT_YUV444P9BE] = { 1, 1 },
193  [AV_PIX_FMT_YUV444P9LE] = { 1, 1 },
194  [AV_PIX_FMT_YUV444P10BE] = { 1, 1 },
195  [AV_PIX_FMT_YUV444P10LE] = { 1, 1 },
196  [AV_PIX_FMT_YUV444P12BE] = { 1, 1 },
197  [AV_PIX_FMT_YUV444P12LE] = { 1, 1 },
198  [AV_PIX_FMT_YUV444P14BE] = { 1, 1 },
199  [AV_PIX_FMT_YUV444P14LE] = { 1, 1 },
200  [AV_PIX_FMT_GBRP] = { 1, 1 },
201  [AV_PIX_FMT_GBRP9LE] = { 1, 1 },
202  [AV_PIX_FMT_GBRP9BE] = { 1, 1 },
203  [AV_PIX_FMT_GBRP10LE] = { 1, 1 },
204  [AV_PIX_FMT_GBRP10BE] = { 1, 1 },
205  [AV_PIX_FMT_GBRAP10LE] = { 1, 1 },
206  [AV_PIX_FMT_GBRAP10BE] = { 1, 1 },
207  [AV_PIX_FMT_GBRP12LE] = { 1, 1 },
208  [AV_PIX_FMT_GBRP12BE] = { 1, 1 },
209  [AV_PIX_FMT_GBRAP12LE] = { 1, 1 },
210  [AV_PIX_FMT_GBRAP12BE] = { 1, 1 },
211  [AV_PIX_FMT_GBRP14LE] = { 1, 1 },
212  [AV_PIX_FMT_GBRP14BE] = { 1, 1 },
213  [AV_PIX_FMT_GBRP16LE] = { 1, 1 },
214  [AV_PIX_FMT_GBRP16BE] = { 1, 1 },
215  [AV_PIX_FMT_GBRPF32LE] = { 1, 1 },
216  [AV_PIX_FMT_GBRPF32BE] = { 1, 1 },
217  [AV_PIX_FMT_GBRAPF32LE] = { 1, 1 },
218  [AV_PIX_FMT_GBRAPF32BE] = { 1, 1 },
219  [AV_PIX_FMT_GBRAP] = { 1, 1 },
220  [AV_PIX_FMT_GBRAP16LE] = { 1, 1 },
221  [AV_PIX_FMT_GBRAP16BE] = { 1, 1 },
222  [AV_PIX_FMT_BAYER_BGGR8] = { 1, 0 },
223  [AV_PIX_FMT_BAYER_RGGB8] = { 1, 0 },
224  [AV_PIX_FMT_BAYER_GBRG8] = { 1, 0 },
225  [AV_PIX_FMT_BAYER_GRBG8] = { 1, 0 },
226  [AV_PIX_FMT_BAYER_BGGR16LE] = { 1, 0 },
227  [AV_PIX_FMT_BAYER_BGGR16BE] = { 1, 0 },
228  [AV_PIX_FMT_BAYER_RGGB16LE] = { 1, 0 },
229  [AV_PIX_FMT_BAYER_RGGB16BE] = { 1, 0 },
230  [AV_PIX_FMT_BAYER_GBRG16LE] = { 1, 0 },
231  [AV_PIX_FMT_BAYER_GBRG16BE] = { 1, 0 },
232  [AV_PIX_FMT_BAYER_GRBG16LE] = { 1, 0 },
233  [AV_PIX_FMT_BAYER_GRBG16BE] = { 1, 0 },
234  [AV_PIX_FMT_XYZ12BE] = { 1, 1, 1 },
235  [AV_PIX_FMT_XYZ12LE] = { 1, 1, 1 },
236  [AV_PIX_FMT_AYUV64LE] = { 1, 1},
237  [AV_PIX_FMT_P010LE] = { 1, 1 },
238  [AV_PIX_FMT_P010BE] = { 1, 1 },
239  [AV_PIX_FMT_P016LE] = { 1, 1 },
240  [AV_PIX_FMT_P016BE] = { 1, 1 },
241  [AV_PIX_FMT_GRAYF32LE] = { 1, 1 },
242  [AV_PIX_FMT_GRAYF32BE] = { 1, 1 },
243  [AV_PIX_FMT_YUVA422P12BE] = { 1, 1 },
244  [AV_PIX_FMT_YUVA422P12LE] = { 1, 1 },
245  [AV_PIX_FMT_YUVA444P12BE] = { 1, 1 },
246  [AV_PIX_FMT_YUVA444P12LE] = { 1, 1 },
247  [AV_PIX_FMT_NV24] = { 1, 1 },
248  [AV_PIX_FMT_NV42] = { 1, 1 },
249  [AV_PIX_FMT_Y210LE] = { 1, 0 },
250  [AV_PIX_FMT_X2RGB10LE] = { 1, 1 },
251  [AV_PIX_FMT_X2BGR10LE] = { 1, 1 },
252  [AV_PIX_FMT_P210BE] = { 1, 1 },
253  [AV_PIX_FMT_P210LE] = { 1, 1 },
254  [AV_PIX_FMT_P410BE] = { 1, 1 },
255  [AV_PIX_FMT_P410LE] = { 1, 1 },
256  [AV_PIX_FMT_P216BE] = { 1, 1 },
257  [AV_PIX_FMT_P216LE] = { 1, 1 },
258  [AV_PIX_FMT_P416BE] = { 1, 1 },
259  [AV_PIX_FMT_P416LE] = { 1, 1 },
260 };
261 
263  int filterSize, int16_t *filter,
264  int dstW)
265 {
266 #if ARCH_X86_64
267  int i, j, k;
268  int cpu_flags = av_get_cpu_flags();
269  // avx2 hscale filter processes 16 pixel blocks.
270  if (!filter || dstW % 16 != 0)
271  return 0;
273  if ((c->srcBpc == 8) && (c->dstBpc <= 14)) {
274  int16_t *filterCopy = NULL;
275  if (filterSize > 4) {
276  if (!FF_ALLOC_TYPED_ARRAY(filterCopy, dstW * filterSize))
277  return AVERROR(ENOMEM);
278  memcpy(filterCopy, filter, dstW * filterSize * sizeof(int16_t));
279  }
280  // Do not swap filterPos for pixels which won't be processed by
281  // the main loop.
282  for (i = 0; i + 8 <= dstW; i += 8) {
283  FFSWAP(int, filterPos[i + 2], filterPos[i + 4]);
284  FFSWAP(int, filterPos[i + 3], filterPos[i + 5]);
285  }
286  if (filterSize > 4) {
287  // 16 pixels are processed at a time.
288  for (i = 0; i + 16 <= dstW; i += 16) {
289  // 4 filter coeffs are processed at a time.
290  for (k = 0; k + 4 <= filterSize; k += 4) {
291  for (j = 0; j < 16; ++j) {
292  int from = (i + j) * filterSize + k;
293  int to = i * filterSize + j * 4 + k * 16;
294  memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t));
295  }
296  }
297  }
298  }
299  av_free(filterCopy);
300  }
301  }
302 #endif
303  return 0;
304 }
305 
307 {
308  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
310 }
311 
313 {
314  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
316 }
317 
319 {
320  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
322 }
323 
324 static double getSplineCoeff(double a, double b, double c, double d,
325  double dist)
326 {
327  if (dist <= 1.0)
328  return ((d * dist + c) * dist + b) * dist + a;
329  else
330  return getSplineCoeff(0.0,
331  b + 2.0 * c + 3.0 * d,
332  c + 3.0 * d,
333  -b - 3.0 * c - 6.0 * d,
334  dist - 1.0);
335 }
336 
337 static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
338 {
339  if (pos == -1 || pos <= -513) {
340  pos = (128 << chr_subsample) - 128;
341  }
342  pos += 128; // relative to ideal left edge
343  return pos >> chr_subsample;
344 }
345 
346 typedef struct {
347  int flag; ///< flag associated to the algorithm
348  const char *description; ///< human-readable description
349  int size_factor; ///< size factor used when initing the filters
351 
353  { SWS_AREA, "area averaging", 1 /* downscale only, for upscale it is bilinear */ },
354  { SWS_BICUBIC, "bicubic", 4 },
355  { SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 },
356  { SWS_BILINEAR, "bilinear", 2 },
357  { SWS_FAST_BILINEAR, "fast bilinear", -1 },
358  { SWS_GAUSS, "Gaussian", 8 /* infinite ;) */ },
359  { SWS_LANCZOS, "Lanczos", -1 /* custom */ },
360  { SWS_POINT, "nearest neighbor / point", -1 },
361  { SWS_SINC, "sinc", 20 /* infinite ;) */ },
362  { SWS_SPLINE, "bicubic spline", 20 /* infinite :)*/ },
363  { SWS_X, "experimental", 8 },
364 };
365 
366 static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
367  int *outFilterSize, int xInc, int srcW,
368  int dstW, int filterAlign, int one,
369  int flags, int cpu_flags,
370  SwsVector *srcFilter, SwsVector *dstFilter,
371  double param[2], int srcPos, int dstPos)
372 {
373  int i;
374  int filterSize;
375  int filter2Size;
376  int minFilterSize;
377  int64_t *filter = NULL;
378  int64_t *filter2 = NULL;
379  const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8));
380  int ret = -1;
381 
382  emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
383 
384  // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
385  if (!FF_ALLOC_TYPED_ARRAY(*filterPos, dstW + 3))
386  goto nomem;
387 
388  if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled
389  int i;
390  filterSize = 1;
391  if (!FF_ALLOCZ_TYPED_ARRAY(filter, dstW * filterSize))
392  goto nomem;
393 
394  for (i = 0; i < dstW; i++) {
395  filter[i * filterSize] = fone;
396  (*filterPos)[i] = i;
397  }
398  } else if (flags & SWS_POINT) { // lame looking point sampling mode
399  int i;
400  int64_t xDstInSrc;
401  filterSize = 1;
402  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
403  goto nomem;
404 
405  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
406  for (i = 0; i < dstW; i++) {
407  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
408 
409  (*filterPos)[i] = xx;
410  filter[i] = fone;
411  xDstInSrc += xInc;
412  }
413  } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||
414  (flags & SWS_FAST_BILINEAR)) { // bilinear upscale
415  int i;
416  int64_t xDstInSrc;
417  filterSize = 2;
418  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
419  goto nomem;
420 
421  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
422  for (i = 0; i < dstW; i++) {
423  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
424  int j;
425 
426  (*filterPos)[i] = xx;
427  // bilinear upscale / linear interpolate / area averaging
428  for (j = 0; j < filterSize; j++) {
429  int64_t coeff = fone - FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
430  if (coeff < 0)
431  coeff = 0;
432  filter[i * filterSize + j] = coeff;
433  xx++;
434  }
435  xDstInSrc += xInc;
436  }
437  } else {
438  int64_t xDstInSrc;
439  int sizeFactor = -1;
440 
441  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
442  if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
443  sizeFactor = scale_algorithms[i].size_factor;
444  break;
445  }
446  }
447  if (flags & SWS_LANCZOS)
448  sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;
449  av_assert0(sizeFactor > 0);
450 
451  if (xInc <= 1 << 16)
452  filterSize = 1 + sizeFactor; // upscale
453  else
454  filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
455 
456  filterSize = FFMIN(filterSize, srcW - 2);
457  filterSize = FFMAX(filterSize, 1);
458 
459  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
460  goto nomem;
461  xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
462  for (i = 0; i < dstW; i++) {
463  int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
464  int j;
465  (*filterPos)[i] = xx;
466  for (j = 0; j < filterSize; j++) {
467  int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
468  double floatd;
469  int64_t coeff;
470 
471  if (xInc > 1 << 16)
472  d = d * dstW / srcW;
473  floatd = d * (1.0 / (1 << 30));
474 
475  if (flags & SWS_BICUBIC) {
476  int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24);
477  int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);
478 
479  if (d >= 1LL << 31) {
480  coeff = 0.0;
481  } else {
482  int64_t dd = (d * d) >> 30;
483  int64_t ddd = (dd * d) >> 30;
484 
485  if (d < 1LL << 30)
486  coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
487  (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
488  (6 * (1 << 24) - 2 * B) * (1 << 30);
489  else
490  coeff = (-B - 6 * C) * ddd +
491  (6 * B + 30 * C) * dd +
492  (-12 * B - 48 * C) * d +
493  (8 * B + 24 * C) * (1 << 30);
494  }
495  coeff /= (1LL<<54)/fone;
496  } else if (flags & SWS_X) {
497  double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
498  double c;
499 
500  if (floatd < 1.0)
501  c = cos(floatd * M_PI);
502  else
503  c = -1.0;
504  if (c < 0.0)
505  c = -pow(-c, A);
506  else
507  c = pow(c, A);
508  coeff = (c * 0.5 + 0.5) * fone;
509  } else if (flags & SWS_AREA) {
510  int64_t d2 = d - (1 << 29);
511  if (d2 * xInc < -(1LL << (29 + 16)))
512  coeff = 1.0 * (1LL << (30 + 16));
513  else if (d2 * xInc < (1LL << (29 + 16)))
514  coeff = -d2 * xInc + (1LL << (29 + 16));
515  else
516  coeff = 0.0;
517  coeff *= fone >> (30 + 16);
518  } else if (flags & SWS_GAUSS) {
519  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
520  coeff = exp2(-p * floatd * floatd) * fone;
521  } else if (flags & SWS_SINC) {
522  coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
523  } else if (flags & SWS_LANCZOS) {
524  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
525  coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) /
526  (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
527  if (floatd > p)
528  coeff = 0;
529  } else if (flags & SWS_BILINEAR) {
530  coeff = (1 << 30) - d;
531  if (coeff < 0)
532  coeff = 0;
533  coeff *= fone >> 30;
534  } else if (flags & SWS_SPLINE) {
535  double p = -2.196152422706632;
536  coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone;
537  } else {
538  av_assert0(0);
539  }
540 
541  filter[i * filterSize + j] = coeff;
542  xx++;
543  }
544  xDstInSrc += 2 * xInc;
545  }
546  }
547 
548  /* apply src & dst Filter to filter -> filter2
549  * av_free(filter);
550  */
551  av_assert0(filterSize > 0);
552  filter2Size = filterSize;
553  if (srcFilter)
554  filter2Size += srcFilter->length - 1;
555  if (dstFilter)
556  filter2Size += dstFilter->length - 1;
557  av_assert0(filter2Size > 0);
558  if (!FF_ALLOCZ_TYPED_ARRAY(filter2, dstW * filter2Size))
559  goto nomem;
560  for (i = 0; i < dstW; i++) {
561  int j, k;
562 
563  if (srcFilter) {
564  for (k = 0; k < srcFilter->length; k++) {
565  for (j = 0; j < filterSize; j++)
566  filter2[i * filter2Size + k + j] +=
567  srcFilter->coeff[k] * filter[i * filterSize + j];
568  }
569  } else {
570  for (j = 0; j < filterSize; j++)
571  filter2[i * filter2Size + j] = filter[i * filterSize + j];
572  }
573  // FIXME dstFilter
574 
575  (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
576  }
577  av_freep(&filter);
578 
579  /* try to reduce the filter-size (step1 find size and shift left) */
580  // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
581  minFilterSize = 0;
582  for (i = dstW - 1; i >= 0; i--) {
583  int min = filter2Size;
584  int j;
585  int64_t cutOff = 0.0;
586 
587  /* get rid of near zero elements on the left by shifting left */
588  for (j = 0; j < filter2Size; j++) {
589  int k;
590  cutOff += FFABS(filter2[i * filter2Size]);
591 
592  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
593  break;
594 
595  /* preserve monotonicity because the core can't handle the
596  * filter otherwise */
597  if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
598  break;
599 
600  // move filter coefficients left
601  for (k = 1; k < filter2Size; k++)
602  filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
603  filter2[i * filter2Size + k - 1] = 0;
604  (*filterPos)[i]++;
605  }
606 
607  cutOff = 0;
608  /* count near zeros on the right */
609  for (j = filter2Size - 1; j > 0; j--) {
610  cutOff += FFABS(filter2[i * filter2Size + j]);
611 
612  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
613  break;
614  min--;
615  }
616 
617  if (min > minFilterSize)
618  minFilterSize = min;
619  }
620 
621  if (PPC_ALTIVEC(cpu_flags)) {
622  // we can handle the special case 4, so we don't want to go the full 8
623  if (minFilterSize < 5)
624  filterAlign = 4;
625 
626  /* We really don't want to waste our time doing useless computation, so
627  * fall back on the scalar C code for very small filters.
628  * Vectorizing is worth it only if you have a decent-sized vector. */
629  if (minFilterSize < 3)
630  filterAlign = 1;
631  }
632 
633  if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
634  // special case for unscaled vertical filtering
635  if (minFilterSize == 1 && filterAlign == 2)
636  filterAlign = 1;
637  }
638 
639  av_assert0(minFilterSize > 0);
640  filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
641  av_assert0(filterSize > 0);
642  filter = av_malloc_array(dstW, filterSize * sizeof(*filter));
643  if (!filter)
644  goto nomem;
645  if (filterSize >= MAX_FILTER_SIZE * 16 /
646  ((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16)) {
648  goto fail;
649  }
650  *outFilterSize = filterSize;
651 
652  if (flags & SWS_PRINT_INFO)
654  "SwScaler: reducing / aligning filtersize %d -> %d\n",
655  filter2Size, filterSize);
656  /* try to reduce the filter-size (step2 reduce it) */
657  for (i = 0; i < dstW; i++) {
658  int j;
659 
660  for (j = 0; j < filterSize; j++) {
661  if (j >= filter2Size)
662  filter[i * filterSize + j] = 0;
663  else
664  filter[i * filterSize + j] = filter2[i * filter2Size + j];
665  if ((flags & SWS_BITEXACT) && j >= minFilterSize)
666  filter[i * filterSize + j] = 0;
667  }
668  }
669 
670  // FIXME try to align filterPos if possible
671 
672  // fix borders
673  for (i = 0; i < dstW; i++) {
674  int j;
675  if ((*filterPos)[i] < 0) {
676  // move filter coefficients left to compensate for filterPos
677  for (j = 1; j < filterSize; j++) {
678  int left = FFMAX(j + (*filterPos)[i], 0);
679  filter[i * filterSize + left] += filter[i * filterSize + j];
680  filter[i * filterSize + j] = 0;
681  }
682  (*filterPos)[i]= 0;
683  }
684 
685  if ((*filterPos)[i] + filterSize > srcW) {
686  int shift = (*filterPos)[i] + FFMIN(filterSize - srcW, 0);
687  int64_t acc = 0;
688 
689  for (j = filterSize - 1; j >= 0; j--) {
690  if ((*filterPos)[i] + j >= srcW) {
691  acc += filter[i * filterSize + j];
692  filter[i * filterSize + j] = 0;
693  }
694  }
695  for (j = filterSize - 1; j >= 0; j--) {
696  if (j < shift) {
697  filter[i * filterSize + j] = 0;
698  } else {
699  filter[i * filterSize + j] = filter[i * filterSize + j - shift];
700  }
701  }
702 
703  (*filterPos)[i]-= shift;
704  filter[i * filterSize + srcW - 1 - (*filterPos)[i]] += acc;
705  }
706  av_assert0((*filterPos)[i] >= 0);
707  av_assert0((*filterPos)[i] < srcW);
708  if ((*filterPos)[i] + filterSize > srcW) {
709  for (j = 0; j < filterSize; j++) {
710  av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
711  }
712  }
713  }
714 
715  // Note the +1 is for the MMX scaler which reads over the end
716  /* align at 16 for AltiVec (needed by hScale_altivec_real) */
717  if (!FF_ALLOCZ_TYPED_ARRAY(*outFilter, *outFilterSize * (dstW + 3)))
718  goto nomem;
719 
720  /* normalize & store in outFilter */
721  for (i = 0; i < dstW; i++) {
722  int j;
723  int64_t error = 0;
724  int64_t sum = 0;
725 
726  for (j = 0; j < filterSize; j++) {
727  sum += filter[i * filterSize + j];
728  }
729  sum = (sum + one / 2) / one;
730  if (!sum) {
731  av_log(NULL, AV_LOG_WARNING, "SwScaler: zero vector in scaling\n");
732  sum = 1;
733  }
734  for (j = 0; j < *outFilterSize; j++) {
735  int64_t v = filter[i * filterSize + j] + error;
736  int intV = ROUNDED_DIV(v, sum);
737  (*outFilter)[i * (*outFilterSize) + j] = intV;
738  error = v - intV * sum;
739  }
740  }
741 
742  (*filterPos)[dstW + 0] =
743  (*filterPos)[dstW + 1] =
744  (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1]; /* the MMX/SSE scaler will
745  * read over the end */
746  for (i = 0; i < *outFilterSize; i++) {
747  int k = (dstW - 1) * (*outFilterSize) + i;
748  (*outFilter)[k + 1 * (*outFilterSize)] =
749  (*outFilter)[k + 2 * (*outFilterSize)] =
750  (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
751  }
752 
753  ret = 0;
754  goto done;
755 nomem:
756  ret = AVERROR(ENOMEM);
757 fail:
758  if(ret < 0)
759  av_log(NULL, ret == RETCODE_USE_CASCADE ? AV_LOG_DEBUG : AV_LOG_ERROR, "sws: initFilter failed\n");
760 done:
761  av_free(filter);
762  av_free(filter2);
763  return ret;
764 }
765 
766 static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
767 {
768  int64_t W, V, Z, Cy, Cu, Cv;
769  int64_t vr = table[0];
770  int64_t ub = table[1];
771  int64_t ug = -table[2];
772  int64_t vg = -table[3];
773  int64_t ONE = 65536;
774  int64_t cy = ONE;
775  uint8_t *p = (uint8_t*)c->input_rgb2yuv_table;
776  int i;
777  static const int8_t map[] = {
778  BY_IDX, GY_IDX, -1 , BY_IDX, BY_IDX, GY_IDX, -1 , BY_IDX,
779  RY_IDX, -1 , GY_IDX, RY_IDX, RY_IDX, -1 , GY_IDX, RY_IDX,
780  RY_IDX, GY_IDX, -1 , RY_IDX, RY_IDX, GY_IDX, -1 , RY_IDX,
781  BY_IDX, -1 , GY_IDX, BY_IDX, BY_IDX, -1 , GY_IDX, BY_IDX,
782  BU_IDX, GU_IDX, -1 , BU_IDX, BU_IDX, GU_IDX, -1 , BU_IDX,
783  RU_IDX, -1 , GU_IDX, RU_IDX, RU_IDX, -1 , GU_IDX, RU_IDX,
784  RU_IDX, GU_IDX, -1 , RU_IDX, RU_IDX, GU_IDX, -1 , RU_IDX,
785  BU_IDX, -1 , GU_IDX, BU_IDX, BU_IDX, -1 , GU_IDX, BU_IDX,
786  BV_IDX, GV_IDX, -1 , BV_IDX, BV_IDX, GV_IDX, -1 , BV_IDX,
787  RV_IDX, -1 , GV_IDX, RV_IDX, RV_IDX, -1 , GV_IDX, RV_IDX,
788  RV_IDX, GV_IDX, -1 , RV_IDX, RV_IDX, GV_IDX, -1 , RV_IDX,
789  BV_IDX, -1 , GV_IDX, BV_IDX, BV_IDX, -1 , GV_IDX, BV_IDX,
792  GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 ,
793  -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX,
796  GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 ,
797  -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX,
800  GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 ,
801  -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, //23
802  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //24
803  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //25
804  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //26
805  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //27
806  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //28
807  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //29
808  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //30
809  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //31
810  BY_IDX, GY_IDX, RY_IDX, -1 , -1 , -1 , -1 , -1 , //32
811  BU_IDX, GU_IDX, RU_IDX, -1 , -1 , -1 , -1 , -1 , //33
812  BV_IDX, GV_IDX, RV_IDX, -1 , -1 , -1 , -1 , -1 , //34
813  };
814 
815  dstRange = 0; //FIXME range = 1 is handled elsewhere
816 
817  if (!dstRange) {
818  cy = cy * 255 / 219;
819  } else {
820  vr = vr * 224 / 255;
821  ub = ub * 224 / 255;
822  ug = ug * 224 / 255;
823  vg = vg * 224 / 255;
824  }
825  W = ROUNDED_DIV(ONE*ONE*ug, ub);
826  V = ROUNDED_DIV(ONE*ONE*vg, vr);
827  Z = ONE*ONE-W-V;
828 
829  Cy = ROUNDED_DIV(cy*Z, ONE);
830  Cu = ROUNDED_DIV(ub*Z, ONE);
831  Cv = ROUNDED_DIV(vr*Z, ONE);
832 
833  c->input_rgb2yuv_table[RY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cy);
834  c->input_rgb2yuv_table[GY_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cy);
835  c->input_rgb2yuv_table[BY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cy);
836 
837  c->input_rgb2yuv_table[RU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cu);
838  c->input_rgb2yuv_table[GU_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cu);
839  c->input_rgb2yuv_table[BU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(Z+W) , Cu);
840 
841  c->input_rgb2yuv_table[RV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(V+Z) , Cv);
842  c->input_rgb2yuv_table[GV_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cv);
843  c->input_rgb2yuv_table[BV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cv);
844 
845  if(/*!dstRange && */!memcmp(table, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sizeof(ff_yuv2rgb_coeffs[SWS_CS_DEFAULT]))) {
846  c->input_rgb2yuv_table[BY_IDX] = ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
847  c->input_rgb2yuv_table[BV_IDX] = (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
848  c->input_rgb2yuv_table[BU_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
849  c->input_rgb2yuv_table[GY_IDX] = ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
850  c->input_rgb2yuv_table[GV_IDX] = (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
851  c->input_rgb2yuv_table[GU_IDX] = (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
852  c->input_rgb2yuv_table[RY_IDX] = ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
853  c->input_rgb2yuv_table[RV_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
854  c->input_rgb2yuv_table[RU_IDX] = (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
855  }
856  for(i=0; i<FF_ARRAY_ELEMS(map); i++)
857  AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ? c->input_rgb2yuv_table[map[i]] : 0);
858 }
859 
860 static void fill_xyztables(struct SwsContext *c)
861 {
862  int i;
863  double xyzgamma = XYZ_GAMMA;
864  double rgbgamma = 1.0 / RGB_GAMMA;
865  double xyzgammainv = 1.0 / XYZ_GAMMA;
866  double rgbgammainv = RGB_GAMMA;
867  static const int16_t xyz2rgb_matrix[3][4] = {
868  {13270, -6295, -2041},
869  {-3969, 7682, 170},
870  { 228, -835, 4329} };
871  static const int16_t rgb2xyz_matrix[3][4] = {
872  {1689, 1464, 739},
873  { 871, 2929, 296},
874  { 79, 488, 3891} };
875  static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
876 
877  memcpy(c->xyz2rgb_matrix, xyz2rgb_matrix, sizeof(c->xyz2rgb_matrix));
878  memcpy(c->rgb2xyz_matrix, rgb2xyz_matrix, sizeof(c->rgb2xyz_matrix));
879  c->xyzgamma = xyzgamma_tab;
880  c->rgbgamma = rgbgamma_tab;
881  c->xyzgammainv = xyzgammainv_tab;
882  c->rgbgammainv = rgbgammainv_tab;
883 
884  if (rgbgamma_tab[4095])
885  return;
886 
887  /* set gamma vectors */
888  for (i = 0; i < 4096; i++) {
889  xyzgamma_tab[i] = lrint(pow(i / 4095.0, xyzgamma) * 4095.0);
890  rgbgamma_tab[i] = lrint(pow(i / 4095.0, rgbgamma) * 4095.0);
891  xyzgammainv_tab[i] = lrint(pow(i / 4095.0, xyzgammainv) * 4095.0);
892  rgbgammainv_tab[i] = lrint(pow(i / 4095.0, rgbgammainv) * 4095.0);
893  }
894 }
895 
897 {
898  return !isYUV(format) && !isGray(format);
899 }
900 
901 int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4],
902  int srcRange, const int table[4], int dstRange,
903  int brightness, int contrast, int saturation)
904 {
905  const AVPixFmtDescriptor *desc_dst;
906  const AVPixFmtDescriptor *desc_src;
907  int need_reinit = 0;
908 
909  if (c->nb_slice_ctx) {
910  int parent_ret = 0;
911  for (int i = 0; i < c->nb_slice_ctx; i++) {
912  int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table,
913  srcRange, table, dstRange,
914  brightness, contrast, saturation);
915  if (ret < 0)
916  parent_ret = ret;
917  }
918 
919  return parent_ret;
920  }
921 
922  handle_formats(c);
923  desc_dst = av_pix_fmt_desc_get(c->dstFormat);
924  desc_src = av_pix_fmt_desc_get(c->srcFormat);
925 
926  if(range_override_needed(c->dstFormat))
927  dstRange = 0;
928  if(range_override_needed(c->srcFormat))
929  srcRange = 0;
930 
931  if (c->srcRange != srcRange ||
932  c->dstRange != dstRange ||
933  c->brightness != brightness ||
934  c->contrast != contrast ||
935  c->saturation != saturation ||
936  memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
937  memcmp(c->dstColorspaceTable, table, sizeof(int) * 4)
938  )
939  need_reinit = 1;
940 
941  memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
942  memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
943 
944 
945 
946  c->brightness = brightness;
947  c->contrast = contrast;
948  c->saturation = saturation;
949  c->srcRange = srcRange;
950  c->dstRange = dstRange;
951 
952  //The srcBpc check is possibly wrong but we seem to lack a definitive reference to test this
953  //and what we have in ticket 2939 looks better with this check
954  if (need_reinit && (c->srcBpc == 8 || !isYUV(c->srcFormat)))
956 
957  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
958  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
959 
960  if (c->cascaded_context[c->cascaded_mainindex])
961  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
962 
963  if (!need_reinit)
964  return 0;
965 
966  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
967  if (!c->cascaded_context[0] &&
968  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
969  c->srcW && c->srcH && c->dstW && c->dstH) {
970  enum AVPixelFormat tmp_format;
971  int tmp_width, tmp_height;
972  int srcW = c->srcW;
973  int srcH = c->srcH;
974  int dstW = c->dstW;
975  int dstH = c->dstH;
976  int ret;
977  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
978 
979  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
980  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
981  tmp_format = AV_PIX_FMT_BGRA64;
982  } else {
983  tmp_format = AV_PIX_FMT_BGR48;
984  }
985  } else {
986  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
987  tmp_format = AV_PIX_FMT_BGRA;
988  } else {
989  tmp_format = AV_PIX_FMT_BGR24;
990  }
991  }
992 
993  if (srcW*srcH > dstW*dstH) {
994  tmp_width = dstW;
995  tmp_height = dstH;
996  } else {
997  tmp_width = srcW;
998  tmp_height = srcH;
999  }
1000 
1001  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1002  tmp_width, tmp_height, tmp_format, 64);
1003  if (ret < 0)
1004  return ret;
1005 
1006  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
1007  tmp_width, tmp_height, tmp_format,
1008  c->flags, c->param);
1009  if (!c->cascaded_context[0])
1010  return -1;
1011 
1012  c->cascaded_context[0]->alphablend = c->alphablend;
1013  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1014  if (ret < 0)
1015  return ret;
1016  //we set both src and dst depending on that the RGB side will be ignored
1017  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
1018  srcRange, table, dstRange,
1019  brightness, contrast, saturation);
1020 
1021  c->cascaded_context[1] = sws_alloc_set_opts(tmp_width, tmp_height, tmp_format,
1022  dstW, dstH, c->dstFormat,
1023  c->flags, c->param);
1024  if (!c->cascaded_context[1])
1025  return -1;
1026  c->cascaded_context[1]->srcRange = srcRange;
1027  c->cascaded_context[1]->dstRange = dstRange;
1028  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1029  if (ret < 0)
1030  return ret;
1031  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
1032  srcRange, table, dstRange,
1033  0, 1 << 16, 1 << 16);
1034  return 0;
1035  }
1036  //We do not support this combination currently, we need to cascade more contexts to compensate
1037  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
1038  return -1; //AVERROR_PATCHWELCOME;
1039  return 0;
1040  }
1041 
1042  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1043  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1044  contrast, saturation);
1045  // FIXME factorize
1046 
1047  if (ARCH_PPC)
1048  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1049  contrast, saturation);
1050  }
1051 
1052  fill_rgb2yuv_table(c, table, dstRange);
1053 
1054  return 0;
1055 }
1056 
1057 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1058  int *srcRange, int **table, int *dstRange,
1059  int *brightness, int *contrast, int *saturation)
1060 {
1061  if (!c )
1062  return -1;
1063 
1064  if (c->nb_slice_ctx) {
1065  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1066  table, dstRange, brightness, contrast,
1067  saturation);
1068  }
1069 
1070  *inv_table = c->srcColorspaceTable;
1071  *table = c->dstColorspaceTable;
1072  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1073  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1074  *brightness = c->brightness;
1075  *contrast = c->contrast;
1076  *saturation = c->saturation;
1077 
1078  return 0;
1079 }
1080 
1082 {
1083  switch (*format) {
1084  case AV_PIX_FMT_YUVJ420P:
1086  return 1;
1087  case AV_PIX_FMT_YUVJ411P:
1089  return 1;
1090  case AV_PIX_FMT_YUVJ422P:
1092  return 1;
1093  case AV_PIX_FMT_YUVJ444P:
1095  return 1;
1096  case AV_PIX_FMT_YUVJ440P:
1098  return 1;
1099  case AV_PIX_FMT_GRAY8:
1100  case AV_PIX_FMT_YA8:
1101  case AV_PIX_FMT_GRAY9LE:
1102  case AV_PIX_FMT_GRAY9BE:
1103  case AV_PIX_FMT_GRAY10LE:
1104  case AV_PIX_FMT_GRAY10BE:
1105  case AV_PIX_FMT_GRAY12LE:
1106  case AV_PIX_FMT_GRAY12BE:
1107  case AV_PIX_FMT_GRAY14LE:
1108  case AV_PIX_FMT_GRAY14BE:
1109  case AV_PIX_FMT_GRAY16LE:
1110  case AV_PIX_FMT_GRAY16BE:
1111  case AV_PIX_FMT_YA16BE:
1112  case AV_PIX_FMT_YA16LE:
1113  return 1;
1114  default:
1115  return 0;
1116  }
1117 }
1118 
1120 {
1121  switch (*format) {
1122  case AV_PIX_FMT_0BGR : *format = AV_PIX_FMT_ABGR ; return 1;
1123  case AV_PIX_FMT_BGR0 : *format = AV_PIX_FMT_BGRA ; return 4;
1124  case AV_PIX_FMT_0RGB : *format = AV_PIX_FMT_ARGB ; return 1;
1125  case AV_PIX_FMT_RGB0 : *format = AV_PIX_FMT_RGBA ; return 4;
1126  default: return 0;
1127  }
1128 }
1129 
1131 {
1132  switch (*format) {
1133  case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1;
1134  case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1;
1135  default: return 0;
1136  }
1137 }
1138 
1140 {
1141  c->src0Alpha |= handle_0alpha(&c->srcFormat);
1142  c->dst0Alpha |= handle_0alpha(&c->dstFormat);
1143  c->srcXYZ |= handle_xyz(&c->srcFormat);
1144  c->dstXYZ |= handle_xyz(&c->dstFormat);
1145  if (c->srcXYZ || c->dstXYZ)
1146  fill_xyztables(c);
1147 }
1148 
1150 {
1151  SwsContext *c = av_mallocz(sizeof(SwsContext));
1152 
1153  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1154 
1155  if (c) {
1156  c->av_class = &ff_sws_context_class;
1158  atomic_init(&c->stride_unaligned_warned, 0);
1159  atomic_init(&c->data_unaligned_warned, 0);
1160  }
1161 
1162  return c;
1163 }
1164 
1165 static uint16_t * alloc_gamma_tbl(double e)
1166 {
1167  int i = 0;
1168  uint16_t * tbl;
1169  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1170  if (!tbl)
1171  return NULL;
1172 
1173  for (i = 0; i < 65536; ++i) {
1174  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1175  }
1176  return tbl;
1177 }
1178 
1180 {
1181  switch(fmt) {
1182  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1183  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1184  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1185  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1186  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1187 
1191 
1192  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1193 
1196 
1199 
1202 
1207 
1208  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1209  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1210 
1229 
1230 // case AV_PIX_FMT_AYUV64LE:
1231 // case AV_PIX_FMT_AYUV64BE:
1232 // case AV_PIX_FMT_PAL8:
1233  default: return AV_PIX_FMT_NONE;
1234  }
1235 }
1236 
1238  SwsFilter *src_filter, SwsFilter *dst_filter)
1239 {
1240  int ret;
1241 
1242  ret = avpriv_slicethread_create(&c->slicethread, (void*)c,
1243  ff_sws_slice_worker, NULL, c->nb_threads);
1244  if (ret == AVERROR(ENOSYS)) {
1245  c->nb_threads = 1;
1246  return 0;
1247  } else if (ret < 0)
1248  return ret;
1249 
1250  c->nb_threads = ret;
1251 
1252  c->slice_ctx = av_calloc(c->nb_threads, sizeof(*c->slice_ctx));
1253  c->slice_err = av_calloc(c->nb_threads, sizeof(*c->slice_err));
1254  if (!c->slice_ctx || !c->slice_err)
1255  return AVERROR(ENOMEM);
1256 
1257  for (int i = 0; i < c->nb_threads; i++) {
1258  c->slice_ctx[i] = sws_alloc_context();
1259  if (!c->slice_ctx[i])
1260  return AVERROR(ENOMEM);
1261 
1262  c->slice_ctx[i]->parent = c;
1263 
1264  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
1265  if (ret < 0)
1266  return ret;
1267 
1268  c->slice_ctx[i]->nb_threads = 1;
1269 
1270  ret = sws_init_context(c->slice_ctx[i], src_filter, dst_filter);
1271  if (ret < 0)
1272  return ret;
1273 
1274  c->nb_slice_ctx++;
1275 
1276  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
1278  "Error-diffusion dither is in use, scaling will be single-threaded.");
1279  break;
1280  }
1281  }
1282 
1283  c->frame_src = av_frame_alloc();
1284  c->frame_dst = av_frame_alloc();
1285  if (!c->frame_src || !c->frame_dst)
1286  return AVERROR(ENOMEM);
1287 
1288  return 0;
1289 }
1290 
1292  SwsFilter *dstFilter)
1293 {
1294  int i;
1295  int usesVFilter, usesHFilter;
1296  int unscaled;
1297  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1298  int srcW = c->srcW;
1299  int srcH = c->srcH;
1300  int dstW = c->dstW;
1301  int dstH = c->dstH;
1302  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1303  int flags, cpu_flags;
1304  enum AVPixelFormat srcFormat = c->srcFormat;
1305  enum AVPixelFormat dstFormat = c->dstFormat;
1306  const AVPixFmtDescriptor *desc_src;
1307  const AVPixFmtDescriptor *desc_dst;
1308  int ret = 0;
1309  enum AVPixelFormat tmpFmt;
1310  static const float float_mult = 1.0f / 255.0f;
1311  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1312 
1313  if (c->nb_threads != 1) {
1314  ret = context_init_threaded(c, srcFilter, dstFilter);
1315  if (ret < 0 || c->nb_threads > 1)
1316  return ret;
1317  // threading disabled in this build, init as single-threaded
1318  }
1319 
1321  flags = c->flags;
1322  emms_c();
1323  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1324  return AVERROR_UNKNOWN;
1325 
1326  unscaled = (srcW == dstW && srcH == dstH);
1327 
1328  c->srcRange |= handle_jpeg(&c->srcFormat);
1329  c->dstRange |= handle_jpeg(&c->dstFormat);
1330 
1331  if(srcFormat!=c->srcFormat || dstFormat!=c->dstFormat)
1332  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1333 
1334  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1337  c->dstRange, 0, 1 << 16, 1 << 16);
1338 
1339  handle_formats(c);
1340  srcFormat = c->srcFormat;
1341  dstFormat = c->dstFormat;
1342  desc_src = av_pix_fmt_desc_get(srcFormat);
1343  desc_dst = av_pix_fmt_desc_get(dstFormat);
1344 
1345  // If the source has no alpha then disable alpha blendaway
1346  if (c->src0Alpha)
1347  c->alphablend = SWS_ALPHA_BLEND_NONE;
1348 
1349  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1350  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1351  if (!sws_isSupportedInput(srcFormat)) {
1352  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1353  av_get_pix_fmt_name(srcFormat));
1354  return AVERROR(EINVAL);
1355  }
1356  if (!sws_isSupportedOutput(dstFormat)) {
1357  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1358  av_get_pix_fmt_name(dstFormat));
1359  return AVERROR(EINVAL);
1360  }
1361  }
1362  av_assert2(desc_src && desc_dst);
1363 
1364  i = flags & (SWS_POINT |
1365  SWS_AREA |
1366  SWS_BILINEAR |
1368  SWS_BICUBIC |
1369  SWS_X |
1370  SWS_GAUSS |
1371  SWS_LANCZOS |
1372  SWS_SINC |
1373  SWS_SPLINE |
1374  SWS_BICUBLIN);
1375 
1376  /* provide a default scaler if not set by caller */
1377  if (!i) {
1378  if (dstW < srcW && dstH < srcH)
1379  flags |= SWS_BICUBIC;
1380  else if (dstW > srcW && dstH > srcH)
1381  flags |= SWS_BICUBIC;
1382  else
1383  flags |= SWS_BICUBIC;
1384  c->flags = flags;
1385  } else if (i & (i - 1)) {
1387  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1388  return AVERROR(EINVAL);
1389  }
1390  /* sanity check */
1391  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1392  /* FIXME check if these are enough and try to lower them after
1393  * fixing the relevant parts of the code */
1394  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1395  srcW, srcH, dstW, dstH);
1396  return AVERROR(EINVAL);
1397  }
1398  if (flags & SWS_FAST_BILINEAR) {
1399  if (srcW < 8 || dstW < 8) {
1401  c->flags = flags;
1402  }
1403  }
1404 
1405  if (!dstFilter)
1406  dstFilter = &dummyFilter;
1407  if (!srcFilter)
1408  srcFilter = &dummyFilter;
1409 
1410  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1411  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1412  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1413  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1414  c->vRounder = 4 * 0x0001000100010001ULL;
1415 
1416  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1417  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1418  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1419  (dstFilter->chrV && dstFilter->chrV->length > 1);
1420  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1421  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1422  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1423  (dstFilter->chrH && dstFilter->chrH->length > 1);
1424 
1425  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1426  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1427 
1428  c->dst_slice_align = 1 << c->chrDstVSubSample;
1429 
1430  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1431  if (dstW&1) {
1432  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1434  c->flags = flags;
1435  }
1436 
1437  if ( c->chrSrcHSubSample == 0
1438  && c->chrSrcVSubSample == 0
1439  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1440  && !(c->flags & SWS_FAST_BILINEAR)
1441  ) {
1442  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1444  c->flags = flags;
1445  }
1446  }
1447 
1448  if (c->dither == SWS_DITHER_AUTO) {
1449  if (flags & SWS_ERROR_DIFFUSION)
1450  c->dither = SWS_DITHER_ED;
1451  }
1452 
1453  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1454  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1455  dstFormat == AV_PIX_FMT_BGR8 ||
1456  dstFormat == AV_PIX_FMT_RGB8) {
1457  if (c->dither == SWS_DITHER_AUTO)
1459  if (!(flags & SWS_FULL_CHR_H_INT)) {
1460  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1462  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1463  av_get_pix_fmt_name(dstFormat));
1465  c->flags = flags;
1466  }
1467  }
1468  if (flags & SWS_FULL_CHR_H_INT) {
1469  if (c->dither == SWS_DITHER_BAYER) {
1471  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1472  av_get_pix_fmt_name(dstFormat));
1473  c->dither = SWS_DITHER_ED;
1474  }
1475  }
1476  }
1477  if (isPlanarRGB(dstFormat)) {
1478  if (!(flags & SWS_FULL_CHR_H_INT)) {
1480  "%s output is not supported with half chroma resolution, switching to full\n",
1481  av_get_pix_fmt_name(dstFormat));
1483  c->flags = flags;
1484  }
1485  }
1486 
1487  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1488  * chroma interpolation */
1489  if (flags & SWS_FULL_CHR_H_INT &&
1490  isAnyRGB(dstFormat) &&
1491  !isPlanarRGB(dstFormat) &&
1492  dstFormat != AV_PIX_FMT_RGBA64LE &&
1493  dstFormat != AV_PIX_FMT_RGBA64BE &&
1494  dstFormat != AV_PIX_FMT_BGRA64LE &&
1495  dstFormat != AV_PIX_FMT_BGRA64BE &&
1496  dstFormat != AV_PIX_FMT_RGB48LE &&
1497  dstFormat != AV_PIX_FMT_RGB48BE &&
1498  dstFormat != AV_PIX_FMT_BGR48LE &&
1499  dstFormat != AV_PIX_FMT_BGR48BE &&
1500  dstFormat != AV_PIX_FMT_RGBA &&
1501  dstFormat != AV_PIX_FMT_ARGB &&
1502  dstFormat != AV_PIX_FMT_BGRA &&
1503  dstFormat != AV_PIX_FMT_ABGR &&
1504  dstFormat != AV_PIX_FMT_RGB24 &&
1505  dstFormat != AV_PIX_FMT_BGR24 &&
1506  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1507  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1508  dstFormat != AV_PIX_FMT_BGR8 &&
1509  dstFormat != AV_PIX_FMT_RGB8
1510  ) {
1512  "full chroma interpolation for destination format '%s' not yet implemented\n",
1513  av_get_pix_fmt_name(dstFormat));
1515  c->flags = flags;
1516  }
1517  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1518  c->chrDstHSubSample = 1;
1519 
1520  // drop some chroma lines if the user wants it
1521  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1523  c->chrSrcVSubSample += c->vChrDrop;
1524 
1525  /* drop every other pixel for chroma calculation unless user
1526  * wants full chroma */
1527  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1528  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1529  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1530  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1531  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1532  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1533  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1534  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1535  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1536  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1537  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1538  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1539  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1540  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1541  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1542  (flags & SWS_FAST_BILINEAR)))
1543  c->chrSrcHSubSample = 1;
1544 
1545  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1546  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1547  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1548  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1549  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1550 
1551  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1552  goto nomem;
1553 
1554  c->frame_src = av_frame_alloc();
1555  c->frame_dst = av_frame_alloc();
1556  if (!c->frame_src || !c->frame_dst)
1557  goto nomem;
1558 
1559  c->srcBpc = desc_src->comp[0].depth;
1560  if (c->srcBpc < 8)
1561  c->srcBpc = 8;
1562  c->dstBpc = desc_dst->comp[0].depth;
1563  if (c->dstBpc < 8)
1564  c->dstBpc = 8;
1565  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1566  c->srcBpc = 16;
1567  if (c->dstBpc == 16)
1568  dst_stride <<= 1;
1569 
1570  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1571  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1572  c->chrDstW >= c->chrSrcW &&
1573  (srcW & 15) == 0;
1574  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1575 
1576  && (flags & SWS_FAST_BILINEAR)) {
1577  if (flags & SWS_PRINT_INFO)
1578  av_log(c, AV_LOG_INFO,
1579  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1580  }
1581  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1582  c->canMMXEXTBeUsed = 0;
1583  } else
1584  c->canMMXEXTBeUsed = 0;
1585 
1586  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1587  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1588 
1589  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1590  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1591  * correct scaling.
1592  * n-2 is the last chrominance sample available.
1593  * This is not perfect, but no one should notice the difference, the more
1594  * correct variant would be like the vertical one, but that would require
1595  * some special code for the first and last pixel */
1596  if (flags & SWS_FAST_BILINEAR) {
1597  if (c->canMMXEXTBeUsed) {
1598  c->lumXInc += 20;
1599  c->chrXInc += 20;
1600  }
1601  // we don't use the x86 asm scaler if MMX is available
1602  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1603  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1604  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1605  }
1606  }
1607 
1608  // hardcoded for now
1609  c->gamma_value = 2.2;
1610  tmpFmt = AV_PIX_FMT_RGBA64LE;
1611 
1612 
1613  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1614  SwsContext *c2;
1615  c->cascaded_context[0] = NULL;
1616 
1617  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1618  srcW, srcH, tmpFmt, 64);
1619  if (ret < 0)
1620  return ret;
1621 
1622  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1623  srcW, srcH, tmpFmt,
1624  flags, NULL, NULL, c->param);
1625  if (!c->cascaded_context[0]) {
1626  return AVERROR(ENOMEM);
1627  }
1628 
1629  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1630  dstW, dstH, tmpFmt,
1631  flags, srcFilter, dstFilter, c->param);
1632 
1633  if (!c->cascaded_context[1])
1634  return AVERROR(ENOMEM);
1635 
1636  c2 = c->cascaded_context[1];
1637  c2->is_internal_gamma = 1;
1638  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1639  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1640  if (!c2->gamma || !c2->inv_gamma)
1641  return AVERROR(ENOMEM);
1642 
1643  // is_internal_flag is set after creating the context
1644  // to properly create the gamma convert FilterDescriptor
1645  // we have to re-initialize it
1647  if ((ret = ff_init_filters(c2)) < 0) {
1649  c->cascaded_context[1] = NULL;
1650  return ret;
1651  }
1652 
1653  c->cascaded_context[2] = NULL;
1654  if (dstFormat != tmpFmt) {
1655  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1656  dstW, dstH, tmpFmt, 64);
1657  if (ret < 0)
1658  return ret;
1659 
1660  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1661  dstW, dstH, dstFormat,
1662  flags, NULL, NULL, c->param);
1663  if (!c->cascaded_context[2])
1664  return AVERROR(ENOMEM);
1665  }
1666  return 0;
1667  }
1668 
1669  if (isBayer(srcFormat)) {
1670  if (!unscaled ||
1671  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1672  dstFormat != AV_PIX_FMT_RGB48)) {
1673  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1674 
1675  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1676  srcW, srcH, tmpFormat, 64);
1677  if (ret < 0)
1678  return ret;
1679 
1680  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1681  srcW, srcH, tmpFormat,
1682  flags, srcFilter, NULL, c->param);
1683  if (!c->cascaded_context[0])
1684  return AVERROR(ENOMEM);
1685 
1686  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1687  dstW, dstH, dstFormat,
1688  flags, NULL, dstFilter, c->param);
1689  if (!c->cascaded_context[1])
1690  return AVERROR(ENOMEM);
1691  return 0;
1692  }
1693  }
1694 
1695  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1696  for (i = 0; i < 256; ++i){
1697  c->uint2float_lut[i] = (float)i * float_mult;
1698  }
1699  }
1700 
1701  // float will be converted to uint16_t
1702  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1703  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1704  dstFormat != AV_PIX_FMT_GRAY8))){
1705  c->srcBpc = 16;
1706  }
1707 
1708  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1709  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1710 
1711  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1712  if (!unscaled ||
1713  dstFormat != tmpFormat ||
1714  usesHFilter || usesVFilter ||
1715  c->srcRange != c->dstRange
1716  ) {
1717  c->cascaded_mainindex = 1;
1718  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1719  srcW, srcH, tmpFormat, 64);
1720  if (ret < 0)
1721  return ret;
1722 
1723  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
1724  srcW, srcH, tmpFormat,
1725  flags, c->param);
1726  if (!c->cascaded_context[0])
1727  return AVERROR(EINVAL);
1728  c->cascaded_context[0]->alphablend = c->alphablend;
1729  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1730  if (ret < 0)
1731  return ret;
1732 
1733  c->cascaded_context[1] = sws_alloc_set_opts(srcW, srcH, tmpFormat,
1734  dstW, dstH, dstFormat,
1735  flags, c->param);
1736  if (!c->cascaded_context[1])
1737  return AVERROR(EINVAL);
1738 
1739  c->cascaded_context[1]->srcRange = c->srcRange;
1740  c->cascaded_context[1]->dstRange = c->dstRange;
1741  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1742  if (ret < 0)
1743  return ret;
1744 
1745  return 0;
1746  }
1747  }
1748  }
1749 
1750 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1751 #define USE_MMAP 1
1752 #else
1753 #define USE_MMAP 0
1754 #endif
1755 
1756  /* precalculate horizontal scaler filter coefficients */
1757  {
1758 #if HAVE_MMXEXT_INLINE
1759 // can't downscale !!!
1760  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1761  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1762  NULL, NULL, 8);
1763  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1764  NULL, NULL, NULL, 4);
1765 
1766 #if USE_MMAP
1767  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1768  PROT_READ | PROT_WRITE,
1769  MAP_PRIVATE | MAP_ANONYMOUS,
1770  -1, 0);
1771  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1772  PROT_READ | PROT_WRITE,
1773  MAP_PRIVATE | MAP_ANONYMOUS,
1774  -1, 0);
1775 #elif HAVE_VIRTUALALLOC
1776  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1777  c->lumMmxextFilterCodeSize,
1778  MEM_COMMIT,
1779  PAGE_EXECUTE_READWRITE);
1780  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1781  c->chrMmxextFilterCodeSize,
1782  MEM_COMMIT,
1783  PAGE_EXECUTE_READWRITE);
1784 #else
1785  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1786  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1787 #endif
1788 
1789 #ifdef MAP_ANONYMOUS
1790  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1791 #else
1792  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1793 #endif
1794  {
1795  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1796  return AVERROR(ENOMEM);
1797  }
1798 
1799  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1800  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1801  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1802  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1803  goto nomem;
1804 
1805  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1806  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1807  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1808  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1809 
1810 #if USE_MMAP
1811  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1812  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1813  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1814  ret = AVERROR(EINVAL);
1815  goto fail;
1816  }
1817 #endif
1818  } else
1819 #endif /* HAVE_MMXEXT_INLINE */
1820  {
1821  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1822  PPC_ALTIVEC(cpu_flags) ? 8 :
1823  have_neon(cpu_flags) ? 8 : 1;
1824 
1825  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1826  &c->hLumFilterSize, c->lumXInc,
1827  srcW, dstW, filterAlign, 1 << 14,
1829  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1830  c->param,
1831  get_local_pos(c, 0, 0, 0),
1832  get_local_pos(c, 0, 0, 0))) < 0)
1833  goto fail;
1834  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1835  goto nomem;
1836  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1837  &c->hChrFilterSize, c->chrXInc,
1838  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1840  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1841  c->param,
1842  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1843  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1844  goto fail;
1845  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1846  goto nomem;
1847  }
1848  } // initialize horizontal stuff
1849 
1850  /* precalculate vertical scaler filter coefficients */
1851  {
1852  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1853  PPC_ALTIVEC(cpu_flags) ? 8 :
1854  have_neon(cpu_flags) ? 2 : 1;
1855 
1856  if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1857  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1859  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1860  c->param,
1861  get_local_pos(c, 0, 0, 1),
1862  get_local_pos(c, 0, 0, 1))) < 0)
1863  goto fail;
1864  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1865  c->chrYInc, c->chrSrcH, c->chrDstH,
1866  filterAlign, (1 << 12),
1868  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1869  c->param,
1870  get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
1871  get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
1872 
1873  goto fail;
1874 
1875 #if HAVE_ALTIVEC
1876  if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->dstH) ||
1877  !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1878  goto nomem;
1879 
1880  for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
1881  int j;
1882  short *p = (short *)&c->vYCoeffsBank[i];
1883  for (j = 0; j < 8; j++)
1884  p[j] = c->vLumFilter[i];
1885  }
1886 
1887  for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
1888  int j;
1889  short *p = (short *)&c->vCCoeffsBank[i];
1890  for (j = 0; j < 8; j++)
1891  p[j] = c->vChrFilter[i];
1892  }
1893 #endif
1894  }
1895 
1896  for (i = 0; i < 4; i++)
1897  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->dstW + 2))
1898  goto nomem;
1899 
1900  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;
1901 
1902  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1903  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1904  c->uv_offx2 = dst_stride + 16;
1905 
1906  av_assert0(c->chrDstH <= dstH);
1907 
1908  if (flags & SWS_PRINT_INFO) {
1909  const char *scaler = NULL, *cpucaps;
1910 
1911  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1912  if (flags & scale_algorithms[i].flag) {
1913  scaler = scale_algorithms[i].description;
1914  break;
1915  }
1916  }
1917  if (!scaler)
1918  scaler = "ehh flags invalid?!";
1919  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1920  scaler,
1921  av_get_pix_fmt_name(srcFormat),
1922 #ifdef DITHER1XBPP
1923  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1924  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1925  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1926  "dithered " : "",
1927 #else
1928  "",
1929 #endif
1930  av_get_pix_fmt_name(dstFormat));
1931 
1932  if (INLINE_MMXEXT(cpu_flags))
1933  cpucaps = "MMXEXT";
1934  else if (INLINE_AMD3DNOW(cpu_flags))
1935  cpucaps = "3DNOW";
1936  else if (INLINE_MMX(cpu_flags))
1937  cpucaps = "MMX";
1938  else if (PPC_ALTIVEC(cpu_flags))
1939  cpucaps = "AltiVec";
1940  else
1941  cpucaps = "C";
1942 
1943  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1944 
1945  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1947  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1948  c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
1950  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1951  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1952  c->chrXInc, c->chrYInc);
1953  }
1954 
1955  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1956  if (unscaled && !usesHFilter && !usesVFilter &&
1957  c->alphablend != SWS_ALPHA_BLEND_NONE &&
1958  isALPHA(srcFormat) &&
1959  (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
1960  alphaless_fmt(srcFormat) == dstFormat
1961  ) {
1962  c->convert_unscaled = ff_sws_alphablendaway;
1963 
1964  if (flags & SWS_PRINT_INFO)
1965  av_log(c, AV_LOG_INFO,
1966  "using alpha blendaway %s -> %s special converter\n",
1967  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1968  return 0;
1969  }
1970 
1971  /* unscaled special cases */
1972  if (unscaled && !usesHFilter && !usesVFilter &&
1973  (c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
1974  isFloat(srcFormat) || isFloat(dstFormat))){
1976 
1977  if (c->convert_unscaled) {
1978  if (flags & SWS_PRINT_INFO)
1979  av_log(c, AV_LOG_INFO,
1980  "using unscaled %s -> %s special converter\n",
1981  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1982  return 0;
1983  }
1984  }
1985 
1987 
1988  return ff_init_filters(c);
1989 nomem:
1990  ret = AVERROR(ENOMEM);
1991 fail: // FIXME replace things by appropriate error codes
1992  if (ret == RETCODE_USE_CASCADE) {
1993  int tmpW = sqrt(srcW * (int64_t)dstW);
1994  int tmpH = sqrt(srcH * (int64_t)dstH);
1995  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1996 
1997  if (isALPHA(srcFormat))
1998  tmpFormat = AV_PIX_FMT_YUVA420P;
1999 
2000  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
2001  return AVERROR(EINVAL);
2002 
2003  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
2004  tmpW, tmpH, tmpFormat, 64);
2005  if (ret < 0)
2006  return ret;
2007 
2008  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
2009  tmpW, tmpH, tmpFormat,
2010  flags, srcFilter, NULL, c->param);
2011  if (!c->cascaded_context[0])
2012  return AVERROR(ENOMEM);
2013 
2014  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
2015  dstW, dstH, dstFormat,
2016  flags, NULL, dstFilter, c->param);
2017  if (!c->cascaded_context[1])
2018  return AVERROR(ENOMEM);
2019  return 0;
2020  }
2021  return ret;
2022 }
2023 
2024 SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
2025  int dstW, int dstH, enum AVPixelFormat dstFormat,
2026  int flags, const double *param)
2027 {
2028  SwsContext *c;
2029 
2030  if (!(c = sws_alloc_context()))
2031  return NULL;
2032 
2033  c->flags = flags;
2034  c->srcW = srcW;
2035  c->srcH = srcH;
2036  c->dstW = dstW;
2037  c->dstH = dstH;
2038  c->srcFormat = srcFormat;
2039  c->dstFormat = dstFormat;
2040 
2041  if (param) {
2042  c->param[0] = param[0];
2043  c->param[1] = param[1];
2044  }
2045 
2046  return c;
2047 }
2048 
2049 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
2050  int dstW, int dstH, enum AVPixelFormat dstFormat,
2051  int flags, SwsFilter *srcFilter,
2052  SwsFilter *dstFilter, const double *param)
2053 {
2054  SwsContext *c;
2055 
2056  c = sws_alloc_set_opts(srcW, srcH, srcFormat,
2057  dstW, dstH, dstFormat,
2058  flags, param);
2059  if (!c)
2060  return NULL;
2061 
2062  if (sws_init_context(c, srcFilter, dstFilter) < 0) {
2063  sws_freeContext(c);
2064  return NULL;
2065  }
2066 
2067  return c;
2068 }
2069 
2070 static int isnan_vec(SwsVector *a)
2071 {
2072  int i;
2073  for (i=0; i<a->length; i++)
2074  if (isnan(a->coeff[i]))
2075  return 1;
2076  return 0;
2077 }
2078 
2079 static void makenan_vec(SwsVector *a)
2080 {
2081  int i;
2082  for (i=0; i<a->length; i++)
2083  a->coeff[i] = NAN;
2084 }
2085 
2086 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2087  float lumaSharpen, float chromaSharpen,
2088  float chromaHShift, float chromaVShift,
2089  int verbose)
2090 {
2091  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2092  if (!filter)
2093  return NULL;
2094 
2095  if (lumaGBlur != 0.0) {
2096  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2097  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2098  } else {
2099  filter->lumH = sws_getIdentityVec();
2100  filter->lumV = sws_getIdentityVec();
2101  }
2102 
2103  if (chromaGBlur != 0.0) {
2104  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2105  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2106  } else {
2107  filter->chrH = sws_getIdentityVec();
2108  filter->chrV = sws_getIdentityVec();
2109  }
2110 
2111  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2112  goto fail;
2113 
2114  if (chromaSharpen != 0.0) {
2115  SwsVector *id = sws_getIdentityVec();
2116  if (!id)
2117  goto fail;
2118  sws_scaleVec(filter->chrH, -chromaSharpen);
2119  sws_scaleVec(filter->chrV, -chromaSharpen);
2120  sws_addVec(filter->chrH, id);
2121  sws_addVec(filter->chrV, id);
2122  sws_freeVec(id);
2123  }
2124 
2125  if (lumaSharpen != 0.0) {
2126  SwsVector *id = sws_getIdentityVec();
2127  if (!id)
2128  goto fail;
2129  sws_scaleVec(filter->lumH, -lumaSharpen);
2130  sws_scaleVec(filter->lumV, -lumaSharpen);
2131  sws_addVec(filter->lumH, id);
2132  sws_addVec(filter->lumV, id);
2133  sws_freeVec(id);
2134  }
2135 
2136  if (chromaHShift != 0.0)
2137  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2138 
2139  if (chromaVShift != 0.0)
2140  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2141 
2142  sws_normalizeVec(filter->chrH, 1.0);
2143  sws_normalizeVec(filter->chrV, 1.0);
2144  sws_normalizeVec(filter->lumH, 1.0);
2145  sws_normalizeVec(filter->lumV, 1.0);
2146 
2147  if (isnan_vec(filter->chrH) ||
2148  isnan_vec(filter->chrV) ||
2149  isnan_vec(filter->lumH) ||
2150  isnan_vec(filter->lumV))
2151  goto fail;
2152 
2153  if (verbose)
2155  if (verbose)
2157 
2158  return filter;
2159 
2160 fail:
2161  sws_freeVec(filter->lumH);
2162  sws_freeVec(filter->lumV);
2163  sws_freeVec(filter->chrH);
2164  sws_freeVec(filter->chrV);
2165  av_freep(&filter);
2166  return NULL;
2167 }
2168 
2170 {
2171  SwsVector *vec;
2172 
2173  if(length <= 0 || length > INT_MAX/ sizeof(double))
2174  return NULL;
2175 
2176  vec = av_malloc(sizeof(SwsVector));
2177  if (!vec)
2178  return NULL;
2179  vec->length = length;
2180  vec->coeff = av_malloc(sizeof(double) * length);
2181  if (!vec->coeff)
2182  av_freep(&vec);
2183  return vec;
2184 }
2185 
2186 SwsVector *sws_getGaussianVec(double variance, double quality)
2187 {
2188  const int length = (int)(variance * quality + 0.5) | 1;
2189  int i;
2190  double middle = (length - 1) * 0.5;
2191  SwsVector *vec;
2192 
2193  if(variance < 0 || quality < 0)
2194  return NULL;
2195 
2196  vec = sws_allocVec(length);
2197 
2198  if (!vec)
2199  return NULL;
2200 
2201  for (i = 0; i < length; i++) {
2202  double dist = i - middle;
2203  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2204  sqrt(2 * variance * M_PI);
2205  }
2206 
2207  sws_normalizeVec(vec, 1.0);
2208 
2209  return vec;
2210 }
2211 
2212 /**
2213  * Allocate and return a vector with length coefficients, all
2214  * with the same value c.
2215  */
2216 static
2217 SwsVector *sws_getConstVec(double c, int length)
2218 {
2219  int i;
2220  SwsVector *vec = sws_allocVec(length);
2221 
2222  if (!vec)
2223  return NULL;
2224 
2225  for (i = 0; i < length; i++)
2226  vec->coeff[i] = c;
2227 
2228  return vec;
2229 }
2230 
2231 /**
2232  * Allocate and return a vector with just one coefficient, with
2233  * value 1.0.
2234  */
2235 static
2237 {
2238  return sws_getConstVec(1.0, 1);
2239 }
2240 
2241 static double sws_dcVec(SwsVector *a)
2242 {
2243  int i;
2244  double sum = 0;
2245 
2246  for (i = 0; i < a->length; i++)
2247  sum += a->coeff[i];
2248 
2249  return sum;
2250 }
2251 
2252 void sws_scaleVec(SwsVector *a, double scalar)
2253 {
2254  int i;
2255 
2256  for (i = 0; i < a->length; i++)
2257  a->coeff[i] *= scalar;
2258 }
2259 
2261 {
2263 }
2264 
2266 {
2267  int length = FFMAX(a->length, b->length);
2268  int i;
2269  SwsVector *vec = sws_getConstVec(0.0, length);
2270 
2271  if (!vec)
2272  return NULL;
2273 
2274  for (i = 0; i < a->length; i++)
2275  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2276  for (i = 0; i < b->length; i++)
2277  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2278 
2279  return vec;
2280 }
2281 
2282 /* shift left / or right if "shift" is negative */
2284 {
2285  int length = a->length + FFABS(shift) * 2;
2286  int i;
2287  SwsVector *vec = sws_getConstVec(0.0, length);
2288 
2289  if (!vec)
2290  return NULL;
2291 
2292  for (i = 0; i < a->length; i++) {
2293  vec->coeff[i + (length - 1) / 2 -
2294  (a->length - 1) / 2 - shift] = a->coeff[i];
2295  }
2296 
2297  return vec;
2298 }
2299 
2300 static
2302 {
2303  SwsVector *shifted = sws_getShiftedVec(a, shift);
2304  if (!shifted) {
2305  makenan_vec(a);
2306  return;
2307  }
2308  av_free(a->coeff);
2309  a->coeff = shifted->coeff;
2310  a->length = shifted->length;
2311  av_free(shifted);
2312 }
2313 
2314 static
2316 {
2317  SwsVector *sum = sws_sumVec(a, b);
2318  if (!sum) {
2319  makenan_vec(a);
2320  return;
2321  }
2322  av_free(a->coeff);
2323  a->coeff = sum->coeff;
2324  a->length = sum->length;
2325  av_free(sum);
2326 }
2327 
2328 /**
2329  * Print with av_log() a textual representation of the vector a
2330  * if log_level <= av_log_level.
2331  */
2332 static
2333 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2334 {
2335  int i;
2336  double max = 0;
2337  double min = 0;
2338  double range;
2339 
2340  for (i = 0; i < a->length; i++)
2341  if (a->coeff[i] > max)
2342  max = a->coeff[i];
2343 
2344  for (i = 0; i < a->length; i++)
2345  if (a->coeff[i] < min)
2346  min = a->coeff[i];
2347 
2348  range = max - min;
2349 
2350  for (i = 0; i < a->length; i++) {
2351  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2352  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2353  for (; x > 0; x--)
2354  av_log(log_ctx, log_level, " ");
2355  av_log(log_ctx, log_level, "|\n");
2356  }
2357 }
2358 
2360 {
2361  if (!a)
2362  return;
2363  av_freep(&a->coeff);
2364  a->length = 0;
2365  av_free(a);
2366 }
2367 
2369 {
2370  if (!filter)
2371  return;
2372 
2373  sws_freeVec(filter->lumH);
2374  sws_freeVec(filter->lumV);
2375  sws_freeVec(filter->chrH);
2376  sws_freeVec(filter->chrV);
2377  av_free(filter);
2378 }
2379 
2381 {
2382  int i;
2383  if (!c)
2384  return;
2385 
2386  for (i = 0; i < c->nb_slice_ctx; i++)
2387  sws_freeContext(c->slice_ctx[i]);
2388  av_freep(&c->slice_ctx);
2389  av_freep(&c->slice_err);
2390 
2391  avpriv_slicethread_free(&c->slicethread);
2392 
2393  for (i = 0; i < 4; i++)
2394  av_freep(&c->dither_error[i]);
2395 
2396  av_frame_free(&c->frame_src);
2397  av_frame_free(&c->frame_dst);
2398 
2399  av_freep(&c->src_ranges.ranges);
2400 
2401  av_freep(&c->vLumFilter);
2402  av_freep(&c->vChrFilter);
2403  av_freep(&c->hLumFilter);
2404  av_freep(&c->hChrFilter);
2405 #if HAVE_ALTIVEC
2406  av_freep(&c->vYCoeffsBank);
2407  av_freep(&c->vCCoeffsBank);
2408 #endif
2409 
2410  av_freep(&c->vLumFilterPos);
2411  av_freep(&c->vChrFilterPos);
2412  av_freep(&c->hLumFilterPos);
2413  av_freep(&c->hChrFilterPos);
2414 
2415 #if HAVE_MMX_INLINE
2416 #if USE_MMAP
2417  if (c->lumMmxextFilterCode)
2418  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2419  if (c->chrMmxextFilterCode)
2420  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2421 #elif HAVE_VIRTUALALLOC
2422  if (c->lumMmxextFilterCode)
2423  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2424  if (c->chrMmxextFilterCode)
2425  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2426 #else
2427  av_free(c->lumMmxextFilterCode);
2428  av_free(c->chrMmxextFilterCode);
2429 #endif
2430  c->lumMmxextFilterCode = NULL;
2431  c->chrMmxextFilterCode = NULL;
2432 #endif /* HAVE_MMX_INLINE */
2433 
2434  av_freep(&c->yuvTable);
2435  av_freep(&c->formatConvBuffer);
2436 
2437  sws_freeContext(c->cascaded_context[0]);
2438  sws_freeContext(c->cascaded_context[1]);
2439  sws_freeContext(c->cascaded_context[2]);
2440  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2441  av_freep(&c->cascaded_tmp[0]);
2442  av_freep(&c->cascaded1_tmp[0]);
2443 
2444  av_freep(&c->gamma);
2445  av_freep(&c->inv_gamma);
2446 
2447  av_freep(&c->rgb0_scratch);
2448  av_freep(&c->xyz_scratch);
2449 
2450  ff_free_filters(c);
2451 
2452  av_free(c);
2453 }
2454 
2456  int srcH, enum AVPixelFormat srcFormat,
2457  int dstW, int dstH,
2458  enum AVPixelFormat dstFormat, int flags,
2459  SwsFilter *srcFilter,
2460  SwsFilter *dstFilter,
2461  const double *param)
2462 {
2463  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2465  int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
2466  src_v_chr_pos = -513, dst_v_chr_pos = -513;
2467 
2468  if (!param)
2469  param = default_param;
2470 
2471  if (context &&
2472  (context->srcW != srcW ||
2473  context->srcH != srcH ||
2474  context->srcFormat != srcFormat ||
2475  context->dstW != dstW ||
2476  context->dstH != dstH ||
2477  context->dstFormat != dstFormat ||
2478  context->flags != flags ||
2479  context->param[0] != param[0] ||
2480  context->param[1] != param[1])) {
2481 
2482  av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
2483  av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
2484  av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
2485  av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
2487  context = NULL;
2488  }
2489 
2490  if (!context) {
2491  if (!(context = sws_alloc_context()))
2492  return NULL;
2493  context->srcW = srcW;
2494  context->srcH = srcH;
2495  context->srcFormat = srcFormat;
2496  context->dstW = dstW;
2497  context->dstH = dstH;
2498  context->dstFormat = dstFormat;
2499  context->flags = flags;
2500  context->param[0] = param[0];
2501  context->param[1] = param[1];
2502 
2503  av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
2504  av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
2505  av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
2506  av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
2507 
2508  if (sws_init_context(context, srcFilter, dstFilter) < 0) {
2510  return NULL;
2511  }
2512  }
2513  return context;
2514 }
2515 
2516 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2517 {
2518  Range *tmp;
2519  unsigned int idx;
2520 
2521  /* find the first existing range after the new one */
2522  for (idx = 0; idx < rl->nb_ranges; idx++)
2523  if (rl->ranges[idx].start > start)
2524  break;
2525 
2526  /* check for overlap */
2527  if (idx > 0) {
2528  Range *prev = &rl->ranges[idx - 1];
2529  if (prev->start + prev->len > start)
2530  return AVERROR(EINVAL);
2531  }
2532  if (idx < rl->nb_ranges) {
2533  Range *next = &rl->ranges[idx];
2534  if (start + len > next->start)
2535  return AVERROR(EINVAL);
2536  }
2537 
2539  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2540  if (!tmp)
2541  return AVERROR(ENOMEM);
2542  rl->ranges = tmp;
2543 
2544  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2545  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2546  rl->ranges[idx].start = start;
2547  rl->ranges[idx].len = len;
2548  rl->nb_ranges++;
2549 
2550  /* merge ranges */
2551  if (idx > 0) {
2552  Range *prev = &rl->ranges[idx - 1];
2553  Range *cur = &rl->ranges[idx];
2554  if (prev->start + prev->len == cur->start) {
2555  prev->len += cur->len;
2556  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2557  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2558  rl->nb_ranges--;
2559  idx--;
2560  }
2561  }
2562  if (idx < rl->nb_ranges - 1) {
2563  Range *cur = &rl->ranges[idx];
2564  Range *next = &rl->ranges[idx + 1];
2565  if (cur->start + cur->len == next->start) {
2566  cur->len += next->len;
2567  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2568  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2569  rl->nb_ranges--;
2570  }
2571  }
2572 
2573  return 0;
2574 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:809
sws_getCachedContext
struct SwsContext * sws_getCachedContext(struct SwsContext *context, int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Check if context can be reused, otherwise reallocate a new one.
Definition: utils.c:2455
INLINE_MMX
#define INLINE_MMX(flags)
Definition: cpu.h:87
AV_PIX_FMT_XYZ12LE
@ AV_PIX_FMT_XYZ12LE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as lit...
Definition: pixfmt.h:189
av_pix_fmt_swap_endianness
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
Definition: pixdesc.c:2758
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:147
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_PIX_FMT_GRAY10BE
@ AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
Definition: pixfmt.h:289
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
Definition: yuv2rgb.c:773
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_PIX_FMT_BAYER_GBRG16LE
@ AV_PIX_FMT_BAYER_GBRG16LE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:258
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:139
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:870
cpu.h
AV_PIX_FMT_P416BE
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
Definition: pixfmt.h:367
acc
int acc
Definition: yuv2rgb.c:554
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:133
SWS_ALPHA_BLEND_NONE
@ SWS_ALPHA_BLEND_NONE
Definition: swscale_internal.h:79
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:197
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:513
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1458
libm.h
fill_xyztables
static void fill_xyztables(struct SwsContext *c)
Definition: utils.c:860
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale_internal.h:71
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:129
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:164
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:162
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:239
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h:93
MAX_FILTER_SIZE
#define MAX_FILTER_SIZE
Definition: af_dynaudnorm.c:34
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale_internal.h:73
EXTERNAL_AVX2_FAST
#define EXTERNAL_AVX2_FAST(flags)
Definition: cpu.h:79
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:178
pixdesc.h
RV_IDX
#define RV_IDX
Definition: swscale_internal.h:445
alphaless_fmt
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
Definition: utils.c:1179
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
handle_0alpha
static int handle_0alpha(enum AVPixelFormat *format)
Definition: utils.c:1119
AV_PIX_FMT_YUV440P12BE
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:270
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:313
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:442
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:310
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
b
#define b
Definition: input.c:34
table
static const uint16_t table[]
Definition: prosumer.c:206
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:446
AV_PIX_FMT_P010BE
@ AV_PIX_FMT_P010BE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:277
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
sws_getIdentityVec
static SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
Definition: utils.c:2236
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:447
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:234
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:406
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:121
isGray
#define isGray(x)
Definition: swscale.c:40
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:246
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2614
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:100
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:156
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:172
sws_getShiftedVec
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
Definition: utils.c:2283
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_PIX_FMT_BAYER_GRBG16BE
@ AV_PIX_FMT_BAYER_GRBG16BE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:261
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:52
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:290
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:333
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
sws_freeVec
void sws_freeVec(SwsVector *a)
Definition: utils.c:2359
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_PIX_FMT_AYUV64LE
@ AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:271
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:125
AV_PIX_FMT_BAYER_GBRG16BE
@ AV_PIX_FMT_BAYER_GBRG16BE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:259
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:2070
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:280
A
#define A(x)
Definition: vp56_arith.h:28
SWS_FAST_BILINEAR
#define SWS_FAST_BILINEAR
Definition: swscale.h:65
handle_jpeg
static int handle_jpeg(enum AVPixelFormat *format)
Definition: utils.c:1081
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:694
FormatEntry
Definition: utils.c:68
SWS_BITEXACT
#define SWS_BITEXACT
Definition: swscale.h:91
SWS_BICUBLIN
#define SWS_BICUBLIN
Definition: swscale.h:71
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:233
avpriv_slicethread_create
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
Definition: slicethread.c:238
fail
#define fail()
Definition: checkasm.h:130
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:464
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:422
Range::len
unsigned int len
Definition: swscale_internal.h:87
ONE
@ ONE
Definition: vc1_parser.c:47
ub
#define ub(width, name)
Definition: cbs_h2645.c:266
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:404
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:308
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2690
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:708
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:96
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:390
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:184
SWS_POINT
#define SWS_POINT
Definition: swscale.h:69
AV_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:154
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:149
AV_CPU_FLAG_SLOW_GATHER
#define AV_CPU_FLAG_SLOW_GATHER
CPU has slow gathers.
Definition: cpu.h:58
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:241
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:409
ff_init_filters
int ff_init_filters(SwsContext *c)
Definition: slice.c:248
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:248
FormatEntry::is_supported_endianness
uint8_t is_supported_endianness
Definition: utils.c:71
AV_PIX_FMT_YUV422P12BE
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:236
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:243
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
lrint
#define lrint
Definition: tablegen.h:53
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_PIX_FMT_BAYER_RGGB16BE
@ AV_PIX_FMT_BAYER_RGGB16BE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:257
initFilter
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[2], int srcPos, int dstPos)
Definition: utils.c:366
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
SwsContext::srcFormat
enum AVPixelFormat srcFormat
Source pixel format.
Definition: swscale_internal.h:330
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:418
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:72
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
SWS_MAX_REDUCE_CUTOFF
#define SWS_MAX_REDUCE_CUTOFF
Definition: swscale.h:94
float
float
Definition: af_crystalizer.c:122
ff_range_add
int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
Definition: utils.c:2516
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:206
sws_printVec2
static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
Print with av_log() a textual representation of the vector a if log_level <= av_log_level.
Definition: utils.c:2333
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:505
intreadwrite.h
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: alphablend.c:23
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:165
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_P416LE
@ AV_PIX_FMT_P416LE
interleaved chroma YUV 4:4:4, 48bpp, little-endian
Definition: pixfmt.h:368
AV_PIX_FMT_BAYER_RGGB16LE
@ AV_PIX_FMT_BAYER_RGGB16LE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:256
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:419
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
height
static int height
Definition: utils.c:158
AV_PIX_FMT_P210LE
@ AV_PIX_FMT_P210LE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:359
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AV_PIX_FMT_BAYER_BGGR8
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
Definition: pixfmt.h:250
SWS_FULL_CHR_H_INP
#define SWS_FULL_CHR_H_INP
Definition: swscale.h:88
SwsVector::length
int length
number of coefficients in the vector
Definition: swscale.h:118
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:2169
AV_PIX_FMT_P016BE
@ AV_PIX_FMT_P016BE
like NV12, with 16bpp per component, big-endian
Definition: pixfmt.h:293
from
const char * from
Definition: jacosubdec.c:66
to
const char * to
Definition: webvttdec.c:35
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:245
get_local_pos
static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
Definition: utils.c:337
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:403
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:180
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:417
scale_algorithms
static const ScaleAlgorithm scale_algorithms[]
Definition: utils.c:352
ScaleAlgorithm::flag
int flag
flag associated to the algorithm
Definition: utils.c:347
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:87
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
format_entries
static const FormatEntry format_entries[]
Definition: utils.c:74
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:163
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
sws_getGaussianVec
SwsVector * sws_getGaussianVec(double variance, double quality)
Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality,...
Definition: utils.c:2186
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:438
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:440
NAN
#define NAN
Definition: mathematics.h:64
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
SwsContext::dstFormat
enum AVPixelFormat dstFormat
Destination pixel format.
Definition: swscale_internal.h:329
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:155
AV_PIX_FMT_BAYER_RGGB8
@ AV_PIX_FMT_BAYER_RGGB8
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
Definition: pixfmt.h:251
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:177
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:532
AV_PIX_FMT_BAYER_GRBG16LE
@ AV_PIX_FMT_BAYER_GRBG16LE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:260
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:152
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:150
alloc_gamma_tbl
static uint16_t * alloc_gamma_tbl(double e)
Definition: utils.c:1165
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:425
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:123
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale_internal.h:69
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:1974
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
SWS_SRC_V_CHR_DROP_SHIFT
#define SWS_SRC_V_CHR_DROP_SHIFT
Definition: swscale.h:78
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:312
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:279
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:397
NULL
#define NULL
Definition: coverity.c:32
SWS_SINC
#define SWS_SINC
Definition: swscale.h:73
RETCODE_USE_CASCADE
#define RETCODE_USE_CASCADE
Definition: swscale_internal.h:64
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
AV_PIX_FMT_P210BE
@ AV_PIX_FMT_P210BE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
Definition: pixfmt.h:358
isnan
#define isnan(x)
Definition: libm.h:340
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
AV_PIX_FMT_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:203
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
sws_getDefaultFilter
SwsFilter * sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
Definition: utils.c:2086
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:76
AV_PIX_FMT_YUVA422P12LE
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:336
RangeList
Definition: swscale_internal.h:90
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:48
V
#define V
Definition: avdct.c:30
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:196
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:337
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:92
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1149
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:2079
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:173
AV_PIX_FMT_Y210LE
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:351
fill_rgb2yuv_table
static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
Definition: utils.c:766
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:181
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:230
ff_sws_rgb2rgb_init
av_cold void ff_sws_rgb2rgb_init(void)
Definition: rgb2rgb.c:137
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:84
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:407
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:267
sws_addVec
static void sws_addVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2315
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:978
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:117
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
handle_formats
static void handle_formats(SwsContext *c)
Definition: utils.c:1139
range_override_needed
static int range_override_needed(enum AVPixelFormat format)
Definition: utils.c:896
sws_setColorspaceDetails
int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
Definition: utils.c:901
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:169
ff_sws_context_class
const AVClass ff_sws_context_class
Definition: options.c:88
exp
int8_t exp
Definition: eval.c:72
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
AVOnce
#define AVOnce
Definition: thread.h:176
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Definition: swscale_internal.h:463
Range
Definition: vf_colorbalance.c:38
sws_scaleVec
void sws_scaleVec(SwsVector *a, double scalar)
Scale all the coefficients of a by the scalar value.
Definition: utils.c:2252
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
sws_getConstVec
static SwsVector * sws_getConstVec(double c, int length)
Allocate and return a vector with length coefficients, all with the same value c.
Definition: utils.c:2217
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:624
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:235
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:242
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
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:353
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: swscale.h:80
SWS_X
#define SWS_X
Definition: swscale.h:68
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:146
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c:1213
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:126
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:68
RY_IDX
#define RY_IDX
Definition: swscale_internal.h:439
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:269
ff_sws_init_scale
void ff_sws_init_scale(SwsContext *c)
Definition: swscale.c:589
PPC_ALTIVEC
#define PPC_ALTIVEC(flags)
Definition: cpu.h:25
SwsVector
Definition: swscale.h:116
sws_getContext
SwsContext * sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:2049
AV_PIX_FMT_BAYER_BGGR16LE
@ AV_PIX_FMT_BAYER_BGGR16LE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:254
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:232
cpu.h
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:151
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:823
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:130
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SWS_FULL_CHR_H_INT
#define SWS_FULL_CHR_H_INT
Definition: swscale.h:86
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:238
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:202
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:392
AV_PIX_FMT_GRAY12LE
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:288
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:399
SwsContext::srcH
int srcH
Height of source luma/alpha planes.
Definition: swscale_internal.h:321
asm.h
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:722
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:160
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:148
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:132
have_neon
#define have_neon(flags)
Definition: cpu.h:26
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:161
SwsFilter
Definition: swscale.h:122
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
SWS_GAUSS
#define SWS_GAUSS
Definition: swscale.h:72
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:283
SwsFilter::lumV
SwsVector * lumV
Definition: swscale.h:124
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
attributes.h
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:228
sws_isSupportedInput
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported input format, 0 otherwise.
Definition: utils.c:306
SWS_ACCURATE_RND
#define SWS_ACCURATE_RND
Definition: swscale.h:90
AV_PIX_FMT_P410LE
@ AV_PIX_FMT_P410LE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
Definition: pixfmt.h:362
SWS_SPLINE
#define SWS_SPLINE
Definition: swscale.h:75
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:175
M_PI
#define M_PI
Definition: mathematics.h:52
slicethread.h
isALPHA
#define isALPHA(x)
Definition: swscale.c:51
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
BY_IDX
#define BY_IDX
Definition: swscale_internal.h:441
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:198
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:176
flag
#define flag(name)
Definition: cbs_av1.c:553
handle_xyz
static int handle_xyz(enum AVPixelFormat *format)
Definition: utils.c:1130
AV_PIX_FMT_YUVA444P12LE
@ AV_PIX_FMT_YUVA444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:338
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:170
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:401
SwsContext::srcW
int srcW
Width of source luma/alpha planes.
Definition: swscale_internal.h:320
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
sws_isSupportedEndiannessConversion
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: utils.c:318
DITHER1XBPP
#define DITHER1XBPP
Definition: swscale_internal.h:46
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
ff_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:48
context_init_threaded
static int context_init_threaded(SwsContext *c, SwsFilter *src_filter, SwsFilter *dst_filter)
Definition: utils.c:1237
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2301
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
FormatEntry::is_supported_in
uint8_t is_supported_in
Definition: utils.c:69
SWS_LANCZOS
#define SWS_LANCZOS
Definition: swscale.h:74
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:423
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GRAY9BE
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:307
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:340
ff_free_filters
int ff_free_filters(SwsContext *c)
Definition: slice.c:382
AV_PIX_FMT_BAYER_GBRG8
@ AV_PIX_FMT_BAYER_GBRG8
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
Definition: pixfmt.h:252
exp2
#define exp2(x)
Definition: libm.h:288
getSplineCoeff
static double getSplineCoeff(double a, double b, double c, double d, double dist)
Definition: utils.c:324
sws_isSupportedOutput
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported output format, 0 otherwise.
Definition: utils.c:312
swscale_internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
AV_PIX_FMT_XYZ12BE
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
Definition: pixfmt.h:190
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:398
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:126
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:311
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:341
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:405
sws_freeFilter
void sws_freeFilter(SwsFilter *filter)
Definition: utils.c:2368
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:831
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:91
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:102
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:207
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AV_PIX_FMT_GRAY12BE
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:287
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:200
ret
ret
Definition: filter_design.txt:187
XYZ_GAMMA
#define XYZ_GAMMA
Definition: swscale_internal.h:544
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:229
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AV_PIX_FMT_BAYER_BGGR16BE
@ AV_PIX_FMT_BAYER_BGGR16BE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:255
AV_PIX_FMT_P410BE
@ AV_PIX_FMT_P410BE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
Definition: pixfmt.h:361
verbose
int verbose
Definition: checkasm.c:289
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:292
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:332
pos
unsigned int pos
Definition: spdifenc.c:412
sws_getColorspaceDetails
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
if LIBSWSCALE_VERSION_MAJOR > 6
Definition: utils.c:1057
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
sws_init_context
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:1291
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:244
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:240
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:29
B
#define B
Definition: huffyuvdsp.h:32
c2
static const uint64_t c2
Definition: murmur3.c:52
FormatEntry::is_supported_out
uint8_t is_supported_out
Definition: utils.c:70
sws_freeContext
void sws_freeContext(SwsContext *c)
Free the swscaler context swsContext.
Definition: utils.c:2380
ScaleAlgorithm
Definition: utils.c:346
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:153
ff_shuffle_filter_coefficients
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
Definition: utils.c:262
RGB_GAMMA
#define RGB_GAMMA
Definition: swscale_internal.h:545
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AV_PIX_FMT_P216LE
@ AV_PIX_FMT_P216LE
interleaved chroma YUV 4:2:2, 32bpp, little-endian
Definition: pixfmt.h:365
ScaleAlgorithm::description
const char * description
human-readable description
Definition: utils.c:348
INLINE_MMXEXT
#define INLINE_MMXEXT(flags)
Definition: cpu.h:88
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:174
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
Range::start
AVRational start
Definition: vf_pseudocolor.c:104
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:122
shift
static int shift(int a, int b)
Definition: sonic.c:88
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:124
SWS_PRINT_INFO
#define SWS_PRINT_INFO
Definition: swscale.h:82
DITHER32_INT
#define DITHER32_INT
Definition: swscale_internal.h:497
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
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:355
isBayer16BPS
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:816
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AV_PIX_FMT_P010LE
@ AV_PIX_FMT_P010LE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:276
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:444
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:179
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:113
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
ScaleAlgorithm::size_factor
int size_factor
size factor used when initing the filters
Definition: utils.c:349
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1884
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AV_PIX_FMT_P216BE
@ AV_PIX_FMT_P216BE
interleaved chroma YUV 4:2:2, 32bpp, big-endian
Definition: pixfmt.h:364
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
sws_alloc_set_opts
SwsContext * sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:2024
AV_PIX_FMT_GRAY14LE
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:330
SwsFilter::lumH
SwsVector * lumH
Definition: swscale.h:123
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:70
sws_sumVec
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2265
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
AV_PIX_FMT_GRAY14BE
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:329
X86_MMX
#define X86_MMX(flags)
Definition: cpu.h:30
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:182
AV_PIX_FMT_YUV440P10BE
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:268
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:157
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:183
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:247
d
d
Definition: ffmpeg_filter.c:153
ff_yuv2rgb_init_tables_ppc
av_cold void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
Definition: yuv2rgb_altivec.c:598
cpu.h
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:227
avpriv_slicethread_free
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
Definition: slicethread.c:252
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SwsContext::src_h_chr_pos
int src_h_chr_pos
Definition: swscale_internal.h:462
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:282
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:443
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:185
SWS_BILINEAR
#define SWS_BILINEAR
Definition: swscale.h:66
cpu.h
INLINE_AMD3DNOW
#define INLINE_AMD3DNOW(flags)
Definition: cpu.h:85
SwsContext::dst_v_chr_pos
int dst_v_chr_pos
Definition: swscale_internal.h:465
AV_PIX_FMT_YUVA422P12BE
@ AV_PIX_FMT_YUVA422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:335
SWS_AREA
#define SWS_AREA
Definition: swscale.h:70
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale_internal.h:74
int
int
Definition: ffmpeg_filter.c:153
SwsContext
Definition: swscale_internal.h:298
W
@ W
Definition: vf_addroi.c:26
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:131
SwsFilter::chrH
SwsVector * chrH
Definition: swscale.h:125
SWS_SRC_V_CHR_DROP_MASK
#define SWS_SRC_V_CHR_DROP_MASK
Definition: swscale.h:77
sws_dcVec
static double sws_dcVec(SwsVector *a)
Definition: utils.c:2241
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:322
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:237
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
sws_normalizeVec
void sws_normalizeVec(SwsVector *a, double height)
Scale all the coefficients of a so that their sum equals height.
Definition: utils.c:2260
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:168
APCK_SIZE
#define APCK_SIZE
Definition: swscale_internal.h:61
AV_PIX_FMT_BAYER_GRBG8
@ AV_PIX_FMT_BAYER_GRBG8
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
Definition: pixfmt.h:253
rgb2rgb.h
SWS_BICUBIC
#define SWS_BICUBIC
Definition: swscale.h:67
swscale.h
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
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:2582
AV_PIX_FMT_UYYVYY411
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:82
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:138
SWS_ERROR_DIFFUSION
#define SWS_ERROR_DIFFUSION
Definition: swscale.h:92
min
float min
Definition: vorbis_enc_data.h:429
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:171
SwsContext::param
double param[2]
Input parameters for scaling algorithms that need them.
Definition: swscale_internal.h:341