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