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