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