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