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