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 {
72  av_assert0(LIBSWSCALE_VERSION_MICRO >= 100);
73  return LIBSWSCALE_VERSION_INT;
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;
90  uint8_t is_supported_endianness :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 
273 int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
274 {
275  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
276  format_entries[pix_fmt].is_supported_in : 0;
277 }
278 
279 int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
280 {
281  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
282  format_entries[pix_fmt].is_supported_out : 0;
283 }
284 
285 int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
286 {
287  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
288  format_entries[pix_fmt].is_supported_endianness : 0;
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
317 } ScaleAlgorithm;
318 
319 static const ScaleAlgorithm scale_algorithms[] = {
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)) {
614  ret = RETCODE_USE_CASCADE;
615  goto fail;
616  }
617  *outFilterSize = filterSize;
618 
619  if (flags & SWS_PRINT_INFO)
620  av_log(NULL, AV_LOG_VERBOSE,
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,
757  RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX,
758  BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_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,
761  RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX,
762  BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_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,
765  RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX,
766  BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_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 
863 static int range_override_needed(enum AVPixelFormat format)
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  for (int i = 0; i < c->nb_slice_ctx; i++) {
878  int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table,
879  srcRange, table, dstRange,
880  brightness, contrast, saturation);
881  if (ret < 0)
882  return ret;
883  }
884 
885  return 0;
886  }
887 
888  handle_formats(c);
889  desc_dst = av_pix_fmt_desc_get(c->dstFormat);
890  desc_src = av_pix_fmt_desc_get(c->srcFormat);
891 
892  if(range_override_needed(c->dstFormat))
893  dstRange = 0;
894  if(range_override_needed(c->srcFormat))
895  srcRange = 0;
896 
897  if (c->srcRange != srcRange ||
898  c->dstRange != dstRange ||
899  c->brightness != brightness ||
900  c->contrast != contrast ||
901  c->saturation != saturation ||
902  memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
903  memcmp(c->dstColorspaceTable, table, sizeof(int) * 4)
904  )
905  need_reinit = 1;
906 
907  memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
908  memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
909 
910 
911 
912  c->brightness = brightness;
913  c->contrast = contrast;
914  c->saturation = saturation;
915  c->srcRange = srcRange;
916  c->dstRange = dstRange;
917 
918  //The srcBpc check is possibly wrong but we seem to lack a definitive reference to test this
919  //and what we have in ticket 2939 looks better with this check
920  if (need_reinit && (c->srcBpc == 8 || !isYUV(c->srcFormat)))
921  ff_sws_init_range_convert(c);
922 
923  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
924  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
925 
926  if (c->cascaded_context[c->cascaded_mainindex])
927  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
928 
929  if (!need_reinit)
930  return 0;
931 
932  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
933  if (!c->cascaded_context[0] &&
934  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
935  c->srcW && c->srcH && c->dstW && c->dstH) {
936  enum AVPixelFormat tmp_format;
937  int tmp_width, tmp_height;
938  int srcW = c->srcW;
939  int srcH = c->srcH;
940  int dstW = c->dstW;
941  int dstH = c->dstH;
942  int ret;
943  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
944 
945  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
946  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
947  tmp_format = AV_PIX_FMT_BGRA64;
948  } else {
949  tmp_format = AV_PIX_FMT_BGR48;
950  }
951  } else {
952  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
953  tmp_format = AV_PIX_FMT_BGRA;
954  } else {
955  tmp_format = AV_PIX_FMT_BGR24;
956  }
957  }
958 
959  if (srcW*srcH > dstW*dstH) {
960  tmp_width = dstW;
961  tmp_height = dstH;
962  } else {
963  tmp_width = srcW;
964  tmp_height = srcH;
965  }
966 
967  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
968  tmp_width, tmp_height, tmp_format, 64);
969  if (ret < 0)
970  return ret;
971 
972  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
973  tmp_width, tmp_height, tmp_format,
974  c->flags, c->param);
975  if (!c->cascaded_context[0])
976  return -1;
977 
978  c->cascaded_context[0]->alphablend = c->alphablend;
979  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
980  if (ret < 0)
981  return ret;
982  //we set both src and dst depending on that the RGB side will be ignored
983  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
984  srcRange, table, dstRange,
985  brightness, contrast, saturation);
986 
987  c->cascaded_context[1] = sws_getContext(tmp_width, tmp_height, tmp_format,
988  dstW, dstH, c->dstFormat,
989  c->flags, NULL, NULL, c->param);
990  if (!c->cascaded_context[1])
991  return -1;
992  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
993  srcRange, table, dstRange,
994  0, 1 << 16, 1 << 16);
995  return 0;
996  }
997  return -1;
998  }
999 
1000  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1001  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1002  contrast, saturation);
1003  // FIXME factorize
1004 
1005  if (ARCH_PPC)
1006  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1007  contrast, saturation);
1008  }
1009 
1010  fill_rgb2yuv_table(c, table, dstRange);
1011 
1012  return 0;
1013 }
1014 
1015 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1016  int *srcRange, int **table, int *dstRange,
1017  int *brightness, int *contrast, int *saturation)
1018 {
1019  if (!c )
1020  return -1;
1021 
1022  if (c->nb_slice_ctx) {
1023  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1024  table, dstRange, brightness, contrast,
1025  saturation);
1026  }
1027 
1028  *inv_table = c->srcColorspaceTable;
1029  *table = c->dstColorspaceTable;
1030  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1031  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1032  *brightness = c->brightness;
1033  *contrast = c->contrast;
1034  *saturation = c->saturation;
1035 
1036  return 0;
1037 }
1038 
1039 static int handle_jpeg(enum AVPixelFormat *format)
1040 {
1041  switch (*format) {
1042  case AV_PIX_FMT_YUVJ420P:
1043  *format = AV_PIX_FMT_YUV420P;
1044  return 1;
1045  case AV_PIX_FMT_YUVJ411P:
1046  *format = AV_PIX_FMT_YUV411P;
1047  return 1;
1048  case AV_PIX_FMT_YUVJ422P:
1049  *format = AV_PIX_FMT_YUV422P;
1050  return 1;
1051  case AV_PIX_FMT_YUVJ444P:
1052  *format = AV_PIX_FMT_YUV444P;
1053  return 1;
1054  case AV_PIX_FMT_YUVJ440P:
1055  *format = AV_PIX_FMT_YUV440P;
1056  return 1;
1057  case AV_PIX_FMT_GRAY8:
1058  case AV_PIX_FMT_YA8:
1059  case AV_PIX_FMT_GRAY9LE:
1060  case AV_PIX_FMT_GRAY9BE:
1061  case AV_PIX_FMT_GRAY10LE:
1062  case AV_PIX_FMT_GRAY10BE:
1063  case AV_PIX_FMT_GRAY12LE:
1064  case AV_PIX_FMT_GRAY12BE:
1065  case AV_PIX_FMT_GRAY14LE:
1066  case AV_PIX_FMT_GRAY14BE:
1067  case AV_PIX_FMT_GRAY16LE:
1068  case AV_PIX_FMT_GRAY16BE:
1069  case AV_PIX_FMT_YA16BE:
1070  case AV_PIX_FMT_YA16LE:
1071  return 1;
1072  default:
1073  return 0;
1074  }
1075 }
1076 
1077 static int handle_0alpha(enum AVPixelFormat *format)
1078 {
1079  switch (*format) {
1080  case AV_PIX_FMT_0BGR : *format = AV_PIX_FMT_ABGR ; return 1;
1081  case AV_PIX_FMT_BGR0 : *format = AV_PIX_FMT_BGRA ; return 4;
1082  case AV_PIX_FMT_0RGB : *format = AV_PIX_FMT_ARGB ; return 1;
1083  case AV_PIX_FMT_RGB0 : *format = AV_PIX_FMT_RGBA ; return 4;
1084  default: return 0;
1085  }
1086 }
1087 
1088 static int handle_xyz(enum AVPixelFormat *format)
1089 {
1090  switch (*format) {
1091  case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1;
1092  case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1;
1093  default: return 0;
1094  }
1095 }
1096 
1097 static void handle_formats(SwsContext *c)
1098 {
1099  c->src0Alpha |= handle_0alpha(&c->srcFormat);
1100  c->dst0Alpha |= handle_0alpha(&c->dstFormat);
1101  c->srcXYZ |= handle_xyz(&c->srcFormat);
1102  c->dstXYZ |= handle_xyz(&c->dstFormat);
1103  if (c->srcXYZ || c->dstXYZ)
1104  fill_xyztables(c);
1105 }
1106 
1107 SwsContext *sws_alloc_context(void)
1108 {
1109  SwsContext *c = av_mallocz(sizeof(SwsContext));
1110 
1111  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1112 
1113  if (c) {
1114  c->av_class = &ff_sws_context_class;
1115  av_opt_set_defaults(c);
1116  atomic_init(&c->stride_unaligned_warned, 0);
1117  atomic_init(&c->data_unaligned_warned, 0);
1118  }
1119 
1120  return c;
1121 }
1122 
1123 static uint16_t * alloc_gamma_tbl(double e)
1124 {
1125  int i = 0;
1126  uint16_t * tbl;
1127  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1128  if (!tbl)
1129  return NULL;
1130 
1131  for (i = 0; i < 65536; ++i) {
1132  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1133  }
1134  return tbl;
1135 }
1136 
1137 static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
1138 {
1139  switch(fmt) {
1140  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1141  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1142  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1143  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1144  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1145 
1146  case AV_PIX_FMT_YUVA420P: return AV_PIX_FMT_YUV420P;
1147  case AV_PIX_FMT_YUVA422P: return AV_PIX_FMT_YUV422P;
1148  case AV_PIX_FMT_YUVA444P: return AV_PIX_FMT_YUV444P;
1149 
1150  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1151 
1152  case AV_PIX_FMT_GBRAP10LE: return AV_PIX_FMT_GBRP10;
1153  case AV_PIX_FMT_GBRAP10BE: return AV_PIX_FMT_GBRP10;
1154 
1155  case AV_PIX_FMT_GBRAP12LE: return AV_PIX_FMT_GBRP12;
1156  case AV_PIX_FMT_GBRAP12BE: return AV_PIX_FMT_GBRP12;
1157 
1158  case AV_PIX_FMT_GBRAP16LE: return AV_PIX_FMT_GBRP16;
1159  case AV_PIX_FMT_GBRAP16BE: return AV_PIX_FMT_GBRP16;
1160 
1161  case AV_PIX_FMT_RGBA64LE: return AV_PIX_FMT_RGB48;
1162  case AV_PIX_FMT_RGBA64BE: return AV_PIX_FMT_RGB48;
1163  case AV_PIX_FMT_BGRA64LE: return AV_PIX_FMT_BGR48;
1164  case AV_PIX_FMT_BGRA64BE: return AV_PIX_FMT_BGR48;
1165 
1166  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1167  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1168 
1169  case AV_PIX_FMT_YUVA420P9BE: return AV_PIX_FMT_YUV420P9;
1170  case AV_PIX_FMT_YUVA422P9BE: return AV_PIX_FMT_YUV422P9;
1171  case AV_PIX_FMT_YUVA444P9BE: return AV_PIX_FMT_YUV444P9;
1172  case AV_PIX_FMT_YUVA420P9LE: return AV_PIX_FMT_YUV420P9;
1173  case AV_PIX_FMT_YUVA422P9LE: return AV_PIX_FMT_YUV422P9;
1174  case AV_PIX_FMT_YUVA444P9LE: return AV_PIX_FMT_YUV444P9;
1175  case AV_PIX_FMT_YUVA420P10BE: return AV_PIX_FMT_YUV420P10;
1176  case AV_PIX_FMT_YUVA422P10BE: return AV_PIX_FMT_YUV422P10;
1177  case AV_PIX_FMT_YUVA444P10BE: return AV_PIX_FMT_YUV444P10;
1178  case AV_PIX_FMT_YUVA420P10LE: return AV_PIX_FMT_YUV420P10;
1179  case AV_PIX_FMT_YUVA422P10LE: return AV_PIX_FMT_YUV422P10;
1180  case AV_PIX_FMT_YUVA444P10LE: return AV_PIX_FMT_YUV444P10;
1181  case AV_PIX_FMT_YUVA420P16BE: return AV_PIX_FMT_YUV420P16;
1182  case AV_PIX_FMT_YUVA422P16BE: return AV_PIX_FMT_YUV422P16;
1183  case AV_PIX_FMT_YUVA444P16BE: return AV_PIX_FMT_YUV444P16;
1184  case AV_PIX_FMT_YUVA420P16LE: return AV_PIX_FMT_YUV420P16;
1185  case AV_PIX_FMT_YUVA422P16LE: return AV_PIX_FMT_YUV422P16;
1186  case AV_PIX_FMT_YUVA444P16LE: return AV_PIX_FMT_YUV444P16;
1187 
1188 // case AV_PIX_FMT_AYUV64LE:
1189 // case AV_PIX_FMT_AYUV64BE:
1190 // case AV_PIX_FMT_PAL8:
1191  default: return AV_PIX_FMT_NONE;
1192  }
1193 }
1194 
1195 static int context_init_threaded(SwsContext *c,
1196  SwsFilter *src_filter, SwsFilter *dst_filter)
1197 {
1198  int ret;
1199 
1200  ret = avpriv_slicethread_create(&c->slicethread, (void*)c,
1201  ff_sws_slice_worker, NULL, c->nb_threads);
1202  if (ret == AVERROR(ENOSYS)) {
1203  c->nb_threads = 1;
1204  return 0;
1205  } else if (ret < 0)
1206  return ret;
1207 
1208  c->nb_threads = ret;
1209 
1210  c->slice_ctx = av_calloc(c->nb_threads, sizeof(*c->slice_ctx));
1211  c->slice_err = av_calloc(c->nb_threads, sizeof(*c->slice_err));
1212  if (!c->slice_ctx || !c->slice_err)
1213  return AVERROR(ENOMEM);
1214 
1215  for (int i = 0; i < c->nb_threads; i++) {
1216  c->slice_ctx[i] = sws_alloc_context();
1217  if (!c->slice_ctx[i])
1218  return AVERROR(ENOMEM);
1219 
1220  c->slice_ctx[i]->parent = c;
1221 
1222  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
1223  if (ret < 0)
1224  return ret;
1225 
1226  c->slice_ctx[i]->nb_threads = 1;
1227 
1228  ret = sws_init_context(c->slice_ctx[i], src_filter, dst_filter);
1229  if (ret < 0)
1230  return ret;
1231 
1232  c->nb_slice_ctx++;
1233 
1234  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
1235  av_log(c, AV_LOG_VERBOSE,
1236  "Error-diffusion dither is in use, scaling will be single-threaded.");
1237  break;
1238  }
1239  }
1240 
1241  c->frame_src = av_frame_alloc();
1242  c->frame_dst = av_frame_alloc();
1243  if (!c->frame_src || !c->frame_dst)
1244  return AVERROR(ENOMEM);
1245 
1246  return 0;
1247 }
1248 
1249 av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
1250  SwsFilter *dstFilter)
1251 {
1252  int i;
1253  int usesVFilter, usesHFilter;
1254  int unscaled;
1255  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1256  int srcW = c->srcW;
1257  int srcH = c->srcH;
1258  int dstW = c->dstW;
1259  int dstH = c->dstH;
1260  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1261  int flags, cpu_flags;
1262  enum AVPixelFormat srcFormat = c->srcFormat;
1263  enum AVPixelFormat dstFormat = c->dstFormat;
1264  const AVPixFmtDescriptor *desc_src;
1265  const AVPixFmtDescriptor *desc_dst;
1266  int ret = 0;
1267  enum AVPixelFormat tmpFmt;
1268  static const float float_mult = 1.0f / 255.0f;
1269  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1270 
1271  if (c->nb_threads != 1) {
1272  ret = context_init_threaded(c, srcFilter, dstFilter);
1273  if (ret < 0 || c->nb_threads > 1)
1274  return ret;
1275  // threading disabled in this build, init as single-threaded
1276  }
1277 
1278  cpu_flags = av_get_cpu_flags();
1279  flags = c->flags;
1280  emms_c();
1281  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1282  return AVERROR_UNKNOWN;
1283 
1284  unscaled = (srcW == dstW && srcH == dstH);
1285 
1286  c->srcRange |= handle_jpeg(&c->srcFormat);
1287  c->dstRange |= handle_jpeg(&c->dstFormat);
1288 
1289  if(srcFormat!=c->srcFormat || dstFormat!=c->dstFormat)
1290  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1291 
1292  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1293  sws_setColorspaceDetails(c, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->srcRange,
1294  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1295  c->dstRange, 0, 1 << 16, 1 << 16);
1296 
1297  handle_formats(c);
1298  srcFormat = c->srcFormat;
1299  dstFormat = c->dstFormat;
1300  desc_src = av_pix_fmt_desc_get(srcFormat);
1301  desc_dst = av_pix_fmt_desc_get(dstFormat);
1302 
1303  // If the source has no alpha then disable alpha blendaway
1304  if (c->src0Alpha)
1305  c->alphablend = SWS_ALPHA_BLEND_NONE;
1306 
1307  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1308  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1309  if (!sws_isSupportedInput(srcFormat)) {
1310  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1311  av_get_pix_fmt_name(srcFormat));
1312  return AVERROR(EINVAL);
1313  }
1314  if (!sws_isSupportedOutput(dstFormat)) {
1315  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1316  av_get_pix_fmt_name(dstFormat));
1317  return AVERROR(EINVAL);
1318  }
1319  }
1320  av_assert2(desc_src && desc_dst);
1321 
1322  i = flags & (SWS_POINT |
1323  SWS_AREA |
1324  SWS_BILINEAR |
1325  SWS_FAST_BILINEAR |
1326  SWS_BICUBIC |
1327  SWS_X |
1328  SWS_GAUSS |
1329  SWS_LANCZOS |
1330  SWS_SINC |
1331  SWS_SPLINE |
1332  SWS_BICUBLIN);
1333 
1334  /* provide a default scaler if not set by caller */
1335  if (!i) {
1336  if (dstW < srcW && dstH < srcH)
1337  flags |= SWS_BICUBIC;
1338  else if (dstW > srcW && dstH > srcH)
1339  flags |= SWS_BICUBIC;
1340  else
1341  flags |= SWS_BICUBIC;
1342  c->flags = flags;
1343  } else if (i & (i - 1)) {
1344  av_log(c, AV_LOG_ERROR,
1345  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1346  return AVERROR(EINVAL);
1347  }
1348  /* sanity check */
1349  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1350  /* FIXME check if these are enough and try to lower them after
1351  * fixing the relevant parts of the code */
1352  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1353  srcW, srcH, dstW, dstH);
1354  return AVERROR(EINVAL);
1355  }
1356  if (flags & SWS_FAST_BILINEAR) {
1357  if (srcW < 8 || dstW < 8) {
1358  flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR;
1359  c->flags = flags;
1360  }
1361  }
1362 
1363  if (!dstFilter)
1364  dstFilter = &dummyFilter;
1365  if (!srcFilter)
1366  srcFilter = &dummyFilter;
1367 
1368  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1369  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1370  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1371  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1372  c->vRounder = 4 * 0x0001000100010001ULL;
1373 
1374  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1375  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1376  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1377  (dstFilter->chrV && dstFilter->chrV->length > 1);
1378  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1379  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1380  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1381  (dstFilter->chrH && dstFilter->chrH->length > 1);
1382 
1383  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1384  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1385 
1386  c->dst_slice_align = 1 << c->chrDstVSubSample;
1387 
1388  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1389  if (dstW&1) {
1390  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1391  flags |= SWS_FULL_CHR_H_INT;
1392  c->flags = flags;
1393  }
1394 
1395  if ( c->chrSrcHSubSample == 0
1396  && c->chrSrcVSubSample == 0
1397  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1398  && !(c->flags & SWS_FAST_BILINEAR)
1399  ) {
1400  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1401  flags |= SWS_FULL_CHR_H_INT;
1402  c->flags = flags;
1403  }
1404  }
1405 
1406  if (c->dither == SWS_DITHER_AUTO) {
1407  if (flags & SWS_ERROR_DIFFUSION)
1408  c->dither = SWS_DITHER_ED;
1409  }
1410 
1411  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1412  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1413  dstFormat == AV_PIX_FMT_BGR8 ||
1414  dstFormat == AV_PIX_FMT_RGB8) {
1415  if (c->dither == SWS_DITHER_AUTO)
1416  c->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1417  if (!(flags & SWS_FULL_CHR_H_INT)) {
1418  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1419  av_log(c, AV_LOG_DEBUG,
1420  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1421  av_get_pix_fmt_name(dstFormat));
1422  flags |= SWS_FULL_CHR_H_INT;
1423  c->flags = flags;
1424  }
1425  }
1426  if (flags & SWS_FULL_CHR_H_INT) {
1427  if (c->dither == SWS_DITHER_BAYER) {
1428  av_log(c, AV_LOG_DEBUG,
1429  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1430  av_get_pix_fmt_name(dstFormat));
1431  c->dither = SWS_DITHER_ED;
1432  }
1433  }
1434  }
1435  if (isPlanarRGB(dstFormat)) {
1436  if (!(flags & SWS_FULL_CHR_H_INT)) {
1437  av_log(c, AV_LOG_DEBUG,
1438  "%s output is not supported with half chroma resolution, switching to full\n",
1439  av_get_pix_fmt_name(dstFormat));
1440  flags |= SWS_FULL_CHR_H_INT;
1441  c->flags = flags;
1442  }
1443  }
1444 
1445  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1446  * chroma interpolation */
1447  if (flags & SWS_FULL_CHR_H_INT &&
1448  isAnyRGB(dstFormat) &&
1449  !isPlanarRGB(dstFormat) &&
1450  dstFormat != AV_PIX_FMT_RGBA64LE &&
1451  dstFormat != AV_PIX_FMT_RGBA64BE &&
1452  dstFormat != AV_PIX_FMT_BGRA64LE &&
1453  dstFormat != AV_PIX_FMT_BGRA64BE &&
1454  dstFormat != AV_PIX_FMT_RGB48LE &&
1455  dstFormat != AV_PIX_FMT_RGB48BE &&
1456  dstFormat != AV_PIX_FMT_BGR48LE &&
1457  dstFormat != AV_PIX_FMT_BGR48BE &&
1458  dstFormat != AV_PIX_FMT_RGBA &&
1459  dstFormat != AV_PIX_FMT_ARGB &&
1460  dstFormat != AV_PIX_FMT_BGRA &&
1461  dstFormat != AV_PIX_FMT_ABGR &&
1462  dstFormat != AV_PIX_FMT_RGB24 &&
1463  dstFormat != AV_PIX_FMT_BGR24 &&
1464  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1465  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1466  dstFormat != AV_PIX_FMT_BGR8 &&
1467  dstFormat != AV_PIX_FMT_RGB8
1468  ) {
1469  av_log(c, AV_LOG_WARNING,
1470  "full chroma interpolation for destination format '%s' not yet implemented\n",
1471  av_get_pix_fmt_name(dstFormat));
1472  flags &= ~SWS_FULL_CHR_H_INT;
1473  c->flags = flags;
1474  }
1475  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1476  c->chrDstHSubSample = 1;
1477 
1478  // drop some chroma lines if the user wants it
1479  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1480  SWS_SRC_V_CHR_DROP_SHIFT;
1481  c->chrSrcVSubSample += c->vChrDrop;
1482 
1483  /* drop every other pixel for chroma calculation unless user
1484  * wants full chroma */
1485  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1486  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1487  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1488  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1489  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1490  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1491  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1492  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1493  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1494  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1495  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1496  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1497  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1498  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1499  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1500  (flags & SWS_FAST_BILINEAR)))
1501  c->chrSrcHSubSample = 1;
1502 
1503  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1504  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1505  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1506  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1507  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1508 
1509  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1510  goto nomem;
1511 
1512  c->frame_src = av_frame_alloc();
1513  c->frame_dst = av_frame_alloc();
1514  if (!c->frame_src || !c->frame_dst)
1515  goto nomem;
1516 
1517  c->srcBpc = desc_src->comp[0].depth;
1518  if (c->srcBpc < 8)
1519  c->srcBpc = 8;
1520  c->dstBpc = desc_dst->comp[0].depth;
1521  if (c->dstBpc < 8)
1522  c->dstBpc = 8;
1523  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1524  c->srcBpc = 16;
1525  if (c->dstBpc == 16)
1526  dst_stride <<= 1;
1527 
1528  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1529  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1530  c->chrDstW >= c->chrSrcW &&
1531  (srcW & 15) == 0;
1532  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1533 
1534  && (flags & SWS_FAST_BILINEAR)) {
1535  if (flags & SWS_PRINT_INFO)
1536  av_log(c, AV_LOG_INFO,
1537  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1538  }
1539  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1540  c->canMMXEXTBeUsed = 0;
1541  } else
1542  c->canMMXEXTBeUsed = 0;
1543 
1544  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1545  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1546 
1547  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1548  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1549  * correct scaling.
1550  * n-2 is the last chrominance sample available.
1551  * This is not perfect, but no one should notice the difference, the more
1552  * correct variant would be like the vertical one, but that would require
1553  * some special code for the first and last pixel */
1554  if (flags & SWS_FAST_BILINEAR) {
1555  if (c->canMMXEXTBeUsed) {
1556  c->lumXInc += 20;
1557  c->chrXInc += 20;
1558  }
1559  // we don't use the x86 asm scaler if MMX is available
1560  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1561  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1562  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1563  }
1564  }
1565 
1566  // hardcoded for now
1567  c->gamma_value = 2.2;
1568  tmpFmt = AV_PIX_FMT_RGBA64LE;
1569 
1570 
1571  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1572  SwsContext *c2;
1573  c->cascaded_context[0] = NULL;
1574 
1575  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1576  srcW, srcH, tmpFmt, 64);
1577  if (ret < 0)
1578  return ret;
1579 
1580  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1581  srcW, srcH, tmpFmt,
1582  flags, NULL, NULL, c->param);
1583  if (!c->cascaded_context[0]) {
1584  return AVERROR(ENOMEM);
1585  }
1586 
1587  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1588  dstW, dstH, tmpFmt,
1589  flags, srcFilter, dstFilter, c->param);
1590 
1591  if (!c->cascaded_context[1])
1592  return AVERROR(ENOMEM);
1593 
1594  c2 = c->cascaded_context[1];
1595  c2->is_internal_gamma = 1;
1596  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1597  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1598  if (!c2->gamma || !c2->inv_gamma)
1599  return AVERROR(ENOMEM);
1600 
1601  // is_internal_flag is set after creating the context
1602  // to properly create the gamma convert FilterDescriptor
1603  // we have to re-initialize it
1604  ff_free_filters(c2);
1605  if ((ret = ff_init_filters(c2)) < 0) {
1606  sws_freeContext(c2);
1607  c->cascaded_context[1] = NULL;
1608  return ret;
1609  }
1610 
1611  c->cascaded_context[2] = NULL;
1612  if (dstFormat != tmpFmt) {
1613  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1614  dstW, dstH, tmpFmt, 64);
1615  if (ret < 0)
1616  return ret;
1617 
1618  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1619  dstW, dstH, dstFormat,
1620  flags, NULL, NULL, c->param);
1621  if (!c->cascaded_context[2])
1622  return AVERROR(ENOMEM);
1623  }
1624  return 0;
1625  }
1626 
1627  if (isBayer(srcFormat)) {
1628  if (!unscaled ||
1629  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1630  dstFormat != AV_PIX_FMT_RGB48)) {
1631  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1632 
1633  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1634  srcW, srcH, tmpFormat, 64);
1635  if (ret < 0)
1636  return ret;
1637 
1638  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1639  srcW, srcH, tmpFormat,
1640  flags, srcFilter, NULL, c->param);
1641  if (!c->cascaded_context[0])
1642  return AVERROR(ENOMEM);
1643 
1644  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1645  dstW, dstH, dstFormat,
1646  flags, NULL, dstFilter, c->param);
1647  if (!c->cascaded_context[1])
1648  return AVERROR(ENOMEM);
1649  return 0;
1650  }
1651  }
1652 
1653  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1654  for (i = 0; i < 256; ++i){
1655  c->uint2float_lut[i] = (float)i * float_mult;
1656  }
1657  }
1658 
1659  // float will be converted to uint16_t
1660  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1661  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1662  dstFormat != AV_PIX_FMT_GRAY8))){
1663  c->srcBpc = 16;
1664  }
1665 
1666  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1667  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1668 
1669  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1670  if (!unscaled ||
1671  dstFormat != tmpFormat ||
1672  usesHFilter || usesVFilter ||
1673  c->srcRange != c->dstRange
1674  ) {
1675  c->cascaded_mainindex = 1;
1676  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1677  srcW, srcH, tmpFormat, 64);
1678  if (ret < 0)
1679  return ret;
1680 
1681  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
1682  srcW, srcH, tmpFormat,
1683  flags, c->param);
1684  if (!c->cascaded_context[0])
1685  return AVERROR(EINVAL);
1686  c->cascaded_context[0]->alphablend = c->alphablend;
1687  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1688  if (ret < 0)
1689  return ret;
1690 
1691  c->cascaded_context[1] = sws_alloc_set_opts(srcW, srcH, tmpFormat,
1692  dstW, dstH, dstFormat,
1693  flags, c->param);
1694  if (!c->cascaded_context[1])
1695  return AVERROR(EINVAL);
1696 
1697  c->cascaded_context[1]->srcRange = c->srcRange;
1698  c->cascaded_context[1]->dstRange = c->dstRange;
1699  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1700  if (ret < 0)
1701  return ret;
1702 
1703  return 0;
1704  }
1705  }
1706  }
1707 
1708 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1709 #define USE_MMAP 1
1710 #else
1711 #define USE_MMAP 0
1712 #endif
1713 
1714  /* precalculate horizontal scaler filter coefficients */
1715  {
1716 #if HAVE_MMXEXT_INLINE
1717 // can't downscale !!!
1718  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1719  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1720  NULL, NULL, 8);
1721  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1722  NULL, NULL, NULL, 4);
1723 
1724 #if USE_MMAP
1725  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1726  PROT_READ | PROT_WRITE,
1727  MAP_PRIVATE | MAP_ANONYMOUS,
1728  -1, 0);
1729  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1730  PROT_READ | PROT_WRITE,
1731  MAP_PRIVATE | MAP_ANONYMOUS,
1732  -1, 0);
1733 #elif HAVE_VIRTUALALLOC
1734  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1735  c->lumMmxextFilterCodeSize,
1736  MEM_COMMIT,
1737  PAGE_EXECUTE_READWRITE);
1738  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1739  c->chrMmxextFilterCodeSize,
1740  MEM_COMMIT,
1741  PAGE_EXECUTE_READWRITE);
1742 #else
1743  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1744  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1745 #endif
1746 
1747 #ifdef MAP_ANONYMOUS
1748  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1749 #else
1750  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1751 #endif
1752  {
1753  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1754  return AVERROR(ENOMEM);
1755  }
1756 
1757  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1758  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1759  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1760  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1761  goto nomem;
1762 
1763  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1764  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1765  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1766  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1767 
1768 #if USE_MMAP
1769  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1770  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1771  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1772  ret = AVERROR(EINVAL);
1773  goto fail;
1774  }
1775 #endif
1776  } else
1777 #endif /* HAVE_MMXEXT_INLINE */
1778  {
1779  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1780  PPC_ALTIVEC(cpu_flags) ? 8 :
1781  have_neon(cpu_flags) ? 8 : 1;
1782 
1783  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1784  &c->hLumFilterSize, c->lumXInc,
1785  srcW, dstW, filterAlign, 1 << 14,
1786  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1787  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1788  c->param,
1789  get_local_pos(c, 0, 0, 0),
1790  get_local_pos(c, 0, 0, 0))) < 0)
1791  goto fail;
1792  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1793  &c->hChrFilterSize, c->chrXInc,
1794  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1795  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1796  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1797  c->param,
1798  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1799  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1800  goto fail;
1801  }
1802  } // initialize horizontal stuff
1803 
1804  /* precalculate vertical scaler filter coefficients */
1805  {
1806  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1807  PPC_ALTIVEC(cpu_flags) ? 8 :
1808  have_neon(cpu_flags) ? 2 : 1;
1809 
1810  if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1811  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1812  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1813  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1814  c->param,
1815  get_local_pos(c, 0, 0, 1),
1816  get_local_pos(c, 0, 0, 1))) < 0)
1817  goto fail;
1818  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1819  c->chrYInc, c->chrSrcH, c->chrDstH,
1820  filterAlign, (1 << 12),
1821  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1822  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1823  c->param,
1824  get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
1825  get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
1826 
1827  goto fail;
1828 
1829 #if HAVE_ALTIVEC
1830  if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->dstH) ||
1831  !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1832  goto nomem;
1833 
1834  for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
1835  int j;
1836  short *p = (short *)&c->vYCoeffsBank[i];
1837  for (j = 0; j < 8; j++)
1838  p[j] = c->vLumFilter[i];
1839  }
1840 
1841  for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
1842  int j;
1843  short *p = (short *)&c->vCCoeffsBank[i];
1844  for (j = 0; j < 8; j++)
1845  p[j] = c->vChrFilter[i];
1846  }
1847 #endif
1848  }
1849 
1850  for (i = 0; i < 4; i++)
1851  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->dstW + 2))
1852  goto nomem;
1853 
1854  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;
1855 
1856  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1857  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1858  c->uv_offx2 = dst_stride + 16;
1859 
1860  av_assert0(c->chrDstH <= dstH);
1861 
1862  if (flags & SWS_PRINT_INFO) {
1863  const char *scaler = NULL, *cpucaps;
1864 
1865  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1866  if (flags & scale_algorithms[i].flag) {
1867  scaler = scale_algorithms[i].description;
1868  break;
1869  }
1870  }
1871  if (!scaler)
1872  scaler = "ehh flags invalid?!";
1873  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1874  scaler,
1875  av_get_pix_fmt_name(srcFormat),
1876 #ifdef DITHER1XBPP
1877  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1878  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1879  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1880  "dithered " : "",
1881 #else
1882  "",
1883 #endif
1884  av_get_pix_fmt_name(dstFormat));
1885 
1886  if (INLINE_MMXEXT(cpu_flags))
1887  cpucaps = "MMXEXT";
1888  else if (INLINE_AMD3DNOW(cpu_flags))
1889  cpucaps = "3DNOW";
1890  else if (INLINE_MMX(cpu_flags))
1891  cpucaps = "MMX";
1892  else if (PPC_ALTIVEC(cpu_flags))
1893  cpucaps = "AltiVec";
1894  else
1895  cpucaps = "C";
1896 
1897  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1898 
1899  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1900  av_log(c, AV_LOG_DEBUG,
1901  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1902  c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
1903  av_log(c, AV_LOG_DEBUG,
1904  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1905  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1906  c->chrXInc, c->chrYInc);
1907  }
1908 
1909  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1910  if (unscaled && !usesHFilter && !usesVFilter &&
1911  c->alphablend != SWS_ALPHA_BLEND_NONE &&
1912  isALPHA(srcFormat) &&
1913  (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
1914  alphaless_fmt(srcFormat) == dstFormat
1915  ) {
1916  c->convert_unscaled = ff_sws_alphablendaway;
1917 
1918  if (flags & SWS_PRINT_INFO)
1919  av_log(c, AV_LOG_INFO,
1920  "using alpha blendaway %s -> %s special converter\n",
1921  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1922  return 0;
1923  }
1924 
1925  /* unscaled special cases */
1926  if (unscaled && !usesHFilter && !usesVFilter &&
1927  (c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
1928  isFloat(srcFormat) || isFloat(dstFormat))){
1929  ff_get_unscaled_swscale(c);
1930 
1931  if (c->convert_unscaled) {
1932  if (flags & SWS_PRINT_INFO)
1933  av_log(c, AV_LOG_INFO,
1934  "using unscaled %s -> %s special converter\n",
1935  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1936  return 0;
1937  }
1938  }
1939 
1940  ff_sws_init_scale(c);
1941 
1942  return ff_init_filters(c);
1943 nomem:
1944  ret = AVERROR(ENOMEM);
1945 fail: // FIXME replace things by appropriate error codes
1946  if (ret == RETCODE_USE_CASCADE) {
1947  int tmpW = sqrt(srcW * (int64_t)dstW);
1948  int tmpH = sqrt(srcH * (int64_t)dstH);
1949  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1950 
1951  if (isALPHA(srcFormat))
1952  tmpFormat = AV_PIX_FMT_YUVA420P;
1953 
1954  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1955  return AVERROR(EINVAL);
1956 
1957  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1958  tmpW, tmpH, tmpFormat, 64);
1959  if (ret < 0)
1960  return ret;
1961 
1962  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1963  tmpW, tmpH, tmpFormat,
1964  flags, srcFilter, NULL, c->param);
1965  if (!c->cascaded_context[0])
1966  return AVERROR(ENOMEM);
1967 
1968  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
1969  dstW, dstH, dstFormat,
1970  flags, NULL, dstFilter, c->param);
1971  if (!c->cascaded_context[1])
1972  return AVERROR(ENOMEM);
1973  return 0;
1974  }
1975  return ret;
1976 }
1977 
1978 SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
1979  int dstW, int dstH, enum AVPixelFormat dstFormat,
1980  int flags, const double *param)
1981 {
1982  SwsContext *c;
1983 
1984  if (!(c = sws_alloc_context()))
1985  return NULL;
1986 
1987  c->flags = flags;
1988  c->srcW = srcW;
1989  c->srcH = srcH;
1990  c->dstW = dstW;
1991  c->dstH = dstH;
1992  c->srcFormat = srcFormat;
1993  c->dstFormat = dstFormat;
1994 
1995  if (param) {
1996  c->param[0] = param[0];
1997  c->param[1] = param[1];
1998  }
1999 
2000  return c;
2001 }
2002 
2003 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
2004  int dstW, int dstH, enum AVPixelFormat dstFormat,
2005  int flags, SwsFilter *srcFilter,
2006  SwsFilter *dstFilter, const double *param)
2007 {
2008  SwsContext *c;
2009 
2010  c = sws_alloc_set_opts(srcW, srcH, srcFormat,
2011  dstW, dstH, dstFormat,
2012  flags, param);
2013  if (!c)
2014  return NULL;
2015 
2016  if (sws_init_context(c, srcFilter, dstFilter) < 0) {
2017  sws_freeContext(c);
2018  return NULL;
2019  }
2020 
2021  return c;
2022 }
2023 
2024 static int isnan_vec(SwsVector *a)
2025 {
2026  int i;
2027  for (i=0; i<a->length; i++)
2028  if (isnan(a->coeff[i]))
2029  return 1;
2030  return 0;
2031 }
2032 
2033 static void makenan_vec(SwsVector *a)
2034 {
2035  int i;
2036  for (i=0; i<a->length; i++)
2037  a->coeff[i] = NAN;
2038 }
2039 
2040 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2041  float lumaSharpen, float chromaSharpen,
2042  float chromaHShift, float chromaVShift,
2043  int verbose)
2044 {
2045  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2046  if (!filter)
2047  return NULL;
2048 
2049  if (lumaGBlur != 0.0) {
2050  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2051  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2052  } else {
2053  filter->lumH = sws_getIdentityVec();
2054  filter->lumV = sws_getIdentityVec();
2055  }
2056 
2057  if (chromaGBlur != 0.0) {
2058  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2059  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2060  } else {
2061  filter->chrH = sws_getIdentityVec();
2062  filter->chrV = sws_getIdentityVec();
2063  }
2064 
2065  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2066  goto fail;
2067 
2068  if (chromaSharpen != 0.0) {
2069  SwsVector *id = sws_getIdentityVec();
2070  if (!id)
2071  goto fail;
2072  sws_scaleVec(filter->chrH, -chromaSharpen);
2073  sws_scaleVec(filter->chrV, -chromaSharpen);
2074  sws_addVec(filter->chrH, id);
2075  sws_addVec(filter->chrV, id);
2076  sws_freeVec(id);
2077  }
2078 
2079  if (lumaSharpen != 0.0) {
2080  SwsVector *id = sws_getIdentityVec();
2081  if (!id)
2082  goto fail;
2083  sws_scaleVec(filter->lumH, -lumaSharpen);
2084  sws_scaleVec(filter->lumV, -lumaSharpen);
2085  sws_addVec(filter->lumH, id);
2086  sws_addVec(filter->lumV, id);
2087  sws_freeVec(id);
2088  }
2089 
2090  if (chromaHShift != 0.0)
2091  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2092 
2093  if (chromaVShift != 0.0)
2094  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2095 
2096  sws_normalizeVec(filter->chrH, 1.0);
2097  sws_normalizeVec(filter->chrV, 1.0);
2098  sws_normalizeVec(filter->lumH, 1.0);
2099  sws_normalizeVec(filter->lumV, 1.0);
2100 
2101  if (isnan_vec(filter->chrH) ||
2102  isnan_vec(filter->chrV) ||
2103  isnan_vec(filter->lumH) ||
2104  isnan_vec(filter->lumV))
2105  goto fail;
2106 
2107  if (verbose)
2108  sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
2109  if (verbose)
2110  sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
2111 
2112  return filter;
2113 
2114 fail:
2115  sws_freeVec(filter->lumH);
2116  sws_freeVec(filter->lumV);
2117  sws_freeVec(filter->chrH);
2118  sws_freeVec(filter->chrV);
2119  av_freep(&filter);
2120  return NULL;
2121 }
2122 
2123 SwsVector *sws_allocVec(int length)
2124 {
2125  SwsVector *vec;
2126 
2127  if(length <= 0 || length > INT_MAX/ sizeof(double))
2128  return NULL;
2129 
2130  vec = av_malloc(sizeof(SwsVector));
2131  if (!vec)
2132  return NULL;
2133  vec->length = length;
2134  vec->coeff = av_malloc(sizeof(double) * length);
2135  if (!vec->coeff)
2136  av_freep(&vec);
2137  return vec;
2138 }
2139 
2140 SwsVector *sws_getGaussianVec(double variance, double quality)
2141 {
2142  const int length = (int)(variance * quality + 0.5) | 1;
2143  int i;
2144  double middle = (length - 1) * 0.5;
2145  SwsVector *vec;
2146 
2147  if(variance < 0 || quality < 0)
2148  return NULL;
2149 
2150  vec = sws_allocVec(length);
2151 
2152  if (!vec)
2153  return NULL;
2154 
2155  for (i = 0; i < length; i++) {
2156  double dist = i - middle;
2157  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2158  sqrt(2 * variance * M_PI);
2159  }
2160 
2161  sws_normalizeVec(vec, 1.0);
2162 
2163  return vec;
2164 }
2165 
2166 /**
2167  * Allocate and return a vector with length coefficients, all
2168  * with the same value c.
2169  */
2170 static
2171 SwsVector *sws_getConstVec(double c, int length)
2172 {
2173  int i;
2174  SwsVector *vec = sws_allocVec(length);
2175 
2176  if (!vec)
2177  return NULL;
2178 
2179  for (i = 0; i < length; i++)
2180  vec->coeff[i] = c;
2181 
2182  return vec;
2183 }
2184 
2185 /**
2186  * Allocate and return a vector with just one coefficient, with
2187  * value 1.0.
2188  */
2189 static
2190 SwsVector *sws_getIdentityVec(void)
2191 {
2192  return sws_getConstVec(1.0, 1);
2193 }
2194 
2195 static double sws_dcVec(SwsVector *a)
2196 {
2197  int i;
2198  double sum = 0;
2199 
2200  for (i = 0; i < a->length; i++)
2201  sum += a->coeff[i];
2202 
2203  return sum;
2204 }
2205 
2206 void sws_scaleVec(SwsVector *a, double scalar)
2207 {
2208  int i;
2209 
2210  for (i = 0; i < a->length; i++)
2211  a->coeff[i] *= scalar;
2212 }
2213 
2214 void sws_normalizeVec(SwsVector *a, double height)
2215 {
2216  sws_scaleVec(a, height / sws_dcVec(a));
2217 }
2218 
2219 static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
2220 {
2221  int length = FFMAX(a->length, b->length);
2222  int i;
2223  SwsVector *vec = sws_getConstVec(0.0, length);
2224 
2225  if (!vec)
2226  return NULL;
2227 
2228  for (i = 0; i < a->length; i++)
2229  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2230  for (i = 0; i < b->length; i++)
2231  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2232 
2233  return vec;
2234 }
2235 
2236 /* shift left / or right if "shift" is negative */
2237 static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
2238 {
2239  int length = a->length + FFABS(shift) * 2;
2240  int i;
2241  SwsVector *vec = sws_getConstVec(0.0, length);
2242 
2243  if (!vec)
2244  return NULL;
2245 
2246  for (i = 0; i < a->length; i++) {
2247  vec->coeff[i + (length - 1) / 2 -
2248  (a->length - 1) / 2 - shift] = a->coeff[i];
2249  }
2250 
2251  return vec;
2252 }
2253 
2254 static
2255 void sws_shiftVec(SwsVector *a, int shift)
2256 {
2257  SwsVector *shifted = sws_getShiftedVec(a, shift);
2258  if (!shifted) {
2259  makenan_vec(a);
2260  return;
2261  }
2262  av_free(a->coeff);
2263  a->coeff = shifted->coeff;
2264  a->length = shifted->length;
2265  av_free(shifted);
2266 }
2267 
2268 static
2269 void sws_addVec(SwsVector *a, SwsVector *b)
2270 {
2271  SwsVector *sum = sws_sumVec(a, b);
2272  if (!sum) {
2273  makenan_vec(a);
2274  return;
2275  }
2276  av_free(a->coeff);
2277  a->coeff = sum->coeff;
2278  a->length = sum->length;
2279  av_free(sum);
2280 }
2281 
2282 /**
2283  * Print with av_log() a textual representation of the vector a
2284  * if log_level <= av_log_level.
2285  */
2286 static
2287 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2288 {
2289  int i;
2290  double max = 0;
2291  double min = 0;
2292  double range;
2293 
2294  for (i = 0; i < a->length; i++)
2295  if (a->coeff[i] > max)
2296  max = a->coeff[i];
2297 
2298  for (i = 0; i < a->length; i++)
2299  if (a->coeff[i] < min)
2300  min = a->coeff[i];
2301 
2302  range = max - min;
2303 
2304  for (i = 0; i < a->length; i++) {
2305  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2306  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2307  for (; x > 0; x--)
2308  av_log(log_ctx, log_level, " ");
2309  av_log(log_ctx, log_level, "|\n");
2310  }
2311 }
2312 
2313 void sws_freeVec(SwsVector *a)
2314 {
2315  if (!a)
2316  return;
2317  av_freep(&a->coeff);
2318  a->length = 0;
2319  av_free(a);
2320 }
2321 
2322 void sws_freeFilter(SwsFilter *filter)
2323 {
2324  if (!filter)
2325  return;
2326 
2327  sws_freeVec(filter->lumH);
2328  sws_freeVec(filter->lumV);
2329  sws_freeVec(filter->chrH);
2330  sws_freeVec(filter->chrV);
2331  av_free(filter);
2332 }
2333 
2334 void sws_freeContext(SwsContext *c)
2335 {
2336  int i;
2337  if (!c)
2338  return;
2339 
2340  for (i = 0; i < c->nb_slice_ctx; i++)
2341  sws_freeContext(c->slice_ctx[i]);
2342  av_freep(&c->slice_ctx);
2343  av_freep(&c->slice_err);
2344 
2345  avpriv_slicethread_free(&c->slicethread);
2346 
2347  for (i = 0; i < 4; i++)
2348  av_freep(&c->dither_error[i]);
2349 
2350  av_frame_free(&c->frame_src);
2351  av_frame_free(&c->frame_dst);
2352 
2353  av_freep(&c->src_ranges.ranges);
2354 
2355  av_freep(&c->vLumFilter);
2356  av_freep(&c->vChrFilter);
2357  av_freep(&c->hLumFilter);
2358  av_freep(&c->hChrFilter);
2359 #if HAVE_ALTIVEC
2360  av_freep(&c->vYCoeffsBank);
2361  av_freep(&c->vCCoeffsBank);
2362 #endif
2363 
2364  av_freep(&c->vLumFilterPos);
2365  av_freep(&c->vChrFilterPos);
2366  av_freep(&c->hLumFilterPos);
2367  av_freep(&c->hChrFilterPos);
2368 
2369 #if HAVE_MMX_INLINE
2370 #if USE_MMAP
2371  if (c->lumMmxextFilterCode)
2372  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2373  if (c->chrMmxextFilterCode)
2374  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2375 #elif HAVE_VIRTUALALLOC
2376  if (c->lumMmxextFilterCode)
2377  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2378  if (c->chrMmxextFilterCode)
2379  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2380 #else
2381  av_free(c->lumMmxextFilterCode);
2382  av_free(c->chrMmxextFilterCode);
2383 #endif
2384  c->lumMmxextFilterCode = NULL;
2385  c->chrMmxextFilterCode = NULL;
2386 #endif /* HAVE_MMX_INLINE */
2387 
2388  av_freep(&c->yuvTable);
2389  av_freep(&c->formatConvBuffer);
2390 
2391  sws_freeContext(c->cascaded_context[0]);
2392  sws_freeContext(c->cascaded_context[1]);
2393  sws_freeContext(c->cascaded_context[2]);
2394  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2395  av_freep(&c->cascaded_tmp[0]);
2396  av_freep(&c->cascaded1_tmp[0]);
2397 
2398  av_freep(&c->gamma);
2399  av_freep(&c->inv_gamma);
2400 
2401  av_freep(&c->rgb0_scratch);
2402  av_freep(&c->xyz_scratch);
2403 
2404  ff_free_filters(c);
2405 
2406  av_free(c);
2407 }
2408 
2409 struct SwsContext *sws_getCachedContext(struct SwsContext *context, int srcW,
2410  int srcH, enum AVPixelFormat srcFormat,
2411  int dstW, int dstH,
2412  enum AVPixelFormat dstFormat, int flags,
2413  SwsFilter *srcFilter,
2414  SwsFilter *dstFilter,
2415  const double *param)
2416 {
2417  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2418  SWS_PARAM_DEFAULT };
2419  int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
2420  src_v_chr_pos = -513, dst_v_chr_pos = -513;
2421 
2422  if (!param)
2423  param = default_param;
2424 
2425  if (context &&
2426  (context->srcW != srcW ||
2427  context->srcH != srcH ||
2428  context->srcFormat != srcFormat ||
2429  context->dstW != dstW ||
2430  context->dstH != dstH ||
2431  context->dstFormat != dstFormat ||
2432  context->flags != flags ||
2433  context->param[0] != param[0] ||
2434  context->param[1] != param[1])) {
2435 
2436  av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
2437  av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
2438  av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
2439  av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
2440  sws_freeContext(context);
2441  context = NULL;
2442  }
2443 
2444  if (!context) {
2445  if (!(context = sws_alloc_context()))
2446  return NULL;
2447  context->srcW = srcW;
2448  context->srcH = srcH;
2449  context->srcFormat = srcFormat;
2450  context->dstW = dstW;
2451  context->dstH = dstH;
2452  context->dstFormat = dstFormat;
2453  context->flags = flags;
2454  context->param[0] = param[0];
2455  context->param[1] = param[1];
2456 
2457  av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
2458  av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
2459  av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
2460  av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
2461 
2462  if (sws_init_context(context, srcFilter, dstFilter) < 0) {
2463  sws_freeContext(context);
2464  return NULL;
2465  }
2466  }
2467  return context;
2468 }
2469 
2470 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2471 {
2472  Range *tmp;
2473  unsigned int idx;
2474 
2475  /* find the first existing range after the new one */
2476  for (idx = 0; idx < rl->nb_ranges; idx++)
2477  if (rl->ranges[idx].start > start)
2478  break;
2479 
2480  /* check for overlap */
2481  if (idx > 0) {
2482  Range *prev = &rl->ranges[idx - 1];
2483  if (prev->start + prev->len > start)
2484  return AVERROR(EINVAL);
2485  }
2486  if (idx < rl->nb_ranges) {
2487  Range *next = &rl->ranges[idx];
2488  if (start + len > next->start)
2489  return AVERROR(EINVAL);
2490  }
2491 
2492  tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated,
2493  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2494  if (!tmp)
2495  return AVERROR(ENOMEM);
2496  rl->ranges = tmp;
2497 
2498  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2499  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2500  rl->ranges[idx].start = start;
2501  rl->ranges[idx].len = len;
2502  rl->nb_ranges++;
2503 
2504  /* merge ranges */
2505  if (idx > 0) {
2506  Range *prev = &rl->ranges[idx - 1];
2507  Range *cur = &rl->ranges[idx];
2508  if (prev->start + prev->len == cur->start) {
2509  prev->len += cur->len;
2510  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2511  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2512  rl->nb_ranges--;
2513  idx--;
2514  }
2515  }
2516  if (idx < rl->nb_ranges - 1) {
2517  Range *cur = &rl->ranges[idx];
2518  Range *next = &rl->ranges[idx + 1];
2519  if (cur->start + cur->len == next->start) {
2520  cur->len += next->len;
2521  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2522  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2523  rl->nb_ranges--;
2524  }
2525  }
2526 
2527  return 0;
2528 }
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:2409
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:1137
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:1077
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:2190
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:2237
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:2313
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:2024
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:1039
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:2470
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:2287
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:2123
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:2140
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:1123
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:2040
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:1107
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:2033
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:2269
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:1097
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:2206
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:2171
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:2003
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:1088
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:1195
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2255
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:2322
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)
Definition: utils.c:1015
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:1249
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:2334
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:1978
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:2219
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:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
SwsContext::src_h_chr_pos
int src_h_chr_pos
Definition: swscale_internal.h: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:2195
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:2214
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
Generated on Sat Oct 23 2021 19:21:38 for FFmpeg by   doxygen 1.8.17