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