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