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