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