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/cpu.h"
44 #include "libavutil/imgutils.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/opt.h"
49 #include "libavutil/pixdesc.h"
50 #include "libavutil/slicethread.h"
51 #include "libavutil/thread.h"
52 #include "libavutil/aarch64/cpu.h"
53 #include "libavutil/ppc/cpu.h"
54 #include "libavutil/x86/asm.h"
55 #include "libavutil/x86/cpu.h"
56 
57 #include "rgb2rgb.h"
58 #include "swscale.h"
59 #include "swscale_internal.h"
60 
61 static SwsVector *sws_getIdentityVec(void);
62 static void sws_addVec(SwsVector *a, SwsVector *b);
63 static void sws_shiftVec(SwsVector *a, int shift);
64 static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level);
65 
66 static void handle_formats(SwsContext *c);
67 
68 typedef struct FormatEntry {
69  uint8_t is_supported_in :1;
70  uint8_t is_supported_out :1;
71  uint8_t is_supported_endianness :1;
72 } FormatEntry;
73 
74 static const FormatEntry format_entries[] = {
75  [AV_PIX_FMT_YUV420P] = { 1, 1 },
76  [AV_PIX_FMT_YUYV422] = { 1, 1 },
77  [AV_PIX_FMT_RGB24] = { 1, 1 },
78  [AV_PIX_FMT_BGR24] = { 1, 1 },
79  [AV_PIX_FMT_YUV422P] = { 1, 1 },
80  [AV_PIX_FMT_YUV444P] = { 1, 1 },
81  [AV_PIX_FMT_YUV410P] = { 1, 1 },
82  [AV_PIX_FMT_YUV411P] = { 1, 1 },
83  [AV_PIX_FMT_GRAY8] = { 1, 1 },
84  [AV_PIX_FMT_MONOWHITE] = { 1, 1 },
85  [AV_PIX_FMT_MONOBLACK] = { 1, 1 },
86  [AV_PIX_FMT_PAL8] = { 1, 0 },
87  [AV_PIX_FMT_YUVJ420P] = { 1, 1 },
88  [AV_PIX_FMT_YUVJ411P] = { 1, 1 },
89  [AV_PIX_FMT_YUVJ422P] = { 1, 1 },
90  [AV_PIX_FMT_YUVJ444P] = { 1, 1 },
91  [AV_PIX_FMT_YVYU422] = { 1, 1 },
92  [AV_PIX_FMT_UYVY422] = { 1, 1 },
93  [AV_PIX_FMT_UYYVYY411] = { 0, 0 },
94  [AV_PIX_FMT_BGR8] = { 1, 1 },
95  [AV_PIX_FMT_BGR4] = { 0, 1 },
96  [AV_PIX_FMT_BGR4_BYTE] = { 1, 1 },
97  [AV_PIX_FMT_RGB8] = { 1, 1 },
98  [AV_PIX_FMT_RGB4] = { 0, 1 },
99  [AV_PIX_FMT_RGB4_BYTE] = { 1, 1 },
100  [AV_PIX_FMT_NV12] = { 1, 1 },
101  [AV_PIX_FMT_NV21] = { 1, 1 },
102  [AV_PIX_FMT_ARGB] = { 1, 1 },
103  [AV_PIX_FMT_RGBA] = { 1, 1 },
104  [AV_PIX_FMT_ABGR] = { 1, 1 },
105  [AV_PIX_FMT_BGRA] = { 1, 1 },
106  [AV_PIX_FMT_0RGB] = { 1, 1 },
107  [AV_PIX_FMT_RGB0] = { 1, 1 },
108  [AV_PIX_FMT_0BGR] = { 1, 1 },
109  [AV_PIX_FMT_BGR0] = { 1, 1 },
110  [AV_PIX_FMT_GRAY9BE] = { 1, 1 },
111  [AV_PIX_FMT_GRAY9LE] = { 1, 1 },
112  [AV_PIX_FMT_GRAY10BE] = { 1, 1 },
113  [AV_PIX_FMT_GRAY10LE] = { 1, 1 },
114  [AV_PIX_FMT_GRAY12BE] = { 1, 1 },
115  [AV_PIX_FMT_GRAY12LE] = { 1, 1 },
116  [AV_PIX_FMT_GRAY14BE] = { 1, 1 },
117  [AV_PIX_FMT_GRAY14LE] = { 1, 1 },
118  [AV_PIX_FMT_GRAY16BE] = { 1, 1 },
119  [AV_PIX_FMT_GRAY16LE] = { 1, 1 },
120  [AV_PIX_FMT_YUV440P] = { 1, 1 },
121  [AV_PIX_FMT_YUVJ440P] = { 1, 1 },
122  [AV_PIX_FMT_YUV440P10LE] = { 1, 1 },
123  [AV_PIX_FMT_YUV440P10BE] = { 1, 1 },
124  [AV_PIX_FMT_YUV440P12LE] = { 1, 1 },
125  [AV_PIX_FMT_YUV440P12BE] = { 1, 1 },
126  [AV_PIX_FMT_YUVA420P] = { 1, 1 },
127  [AV_PIX_FMT_YUVA422P] = { 1, 1 },
128  [AV_PIX_FMT_YUVA444P] = { 1, 1 },
129  [AV_PIX_FMT_YUVA420P9BE] = { 1, 1 },
130  [AV_PIX_FMT_YUVA420P9LE] = { 1, 1 },
131  [AV_PIX_FMT_YUVA422P9BE] = { 1, 1 },
132  [AV_PIX_FMT_YUVA422P9LE] = { 1, 1 },
133  [AV_PIX_FMT_YUVA444P9BE] = { 1, 1 },
134  [AV_PIX_FMT_YUVA444P9LE] = { 1, 1 },
135  [AV_PIX_FMT_YUVA420P10BE]= { 1, 1 },
136  [AV_PIX_FMT_YUVA420P10LE]= { 1, 1 },
137  [AV_PIX_FMT_YUVA422P10BE]= { 1, 1 },
138  [AV_PIX_FMT_YUVA422P10LE]= { 1, 1 },
139  [AV_PIX_FMT_YUVA444P10BE]= { 1, 1 },
140  [AV_PIX_FMT_YUVA444P10LE]= { 1, 1 },
141  [AV_PIX_FMT_YUVA420P16BE]= { 1, 1 },
142  [AV_PIX_FMT_YUVA420P16LE]= { 1, 1 },
143  [AV_PIX_FMT_YUVA422P16BE]= { 1, 1 },
144  [AV_PIX_FMT_YUVA422P16LE]= { 1, 1 },
145  [AV_PIX_FMT_YUVA444P16BE]= { 1, 1 },
146  [AV_PIX_FMT_YUVA444P16LE]= { 1, 1 },
147  [AV_PIX_FMT_RGB48BE] = { 1, 1 },
148  [AV_PIX_FMT_RGB48LE] = { 1, 1 },
149  [AV_PIX_FMT_RGBA64BE] = { 1, 1, 1 },
150  [AV_PIX_FMT_RGBA64LE] = { 1, 1, 1 },
151  [AV_PIX_FMT_RGB565BE] = { 1, 1 },
152  [AV_PIX_FMT_RGB565LE] = { 1, 1 },
153  [AV_PIX_FMT_RGB555BE] = { 1, 1 },
154  [AV_PIX_FMT_RGB555LE] = { 1, 1 },
155  [AV_PIX_FMT_BGR565BE] = { 1, 1 },
156  [AV_PIX_FMT_BGR565LE] = { 1, 1 },
157  [AV_PIX_FMT_BGR555BE] = { 1, 1 },
158  [AV_PIX_FMT_BGR555LE] = { 1, 1 },
159  [AV_PIX_FMT_YUV420P16LE] = { 1, 1 },
160  [AV_PIX_FMT_YUV420P16BE] = { 1, 1 },
161  [AV_PIX_FMT_YUV422P16LE] = { 1, 1 },
162  [AV_PIX_FMT_YUV422P16BE] = { 1, 1 },
163  [AV_PIX_FMT_YUV444P16LE] = { 1, 1 },
164  [AV_PIX_FMT_YUV444P16BE] = { 1, 1 },
165  [AV_PIX_FMT_RGB444LE] = { 1, 1 },
166  [AV_PIX_FMT_RGB444BE] = { 1, 1 },
167  [AV_PIX_FMT_BGR444LE] = { 1, 1 },
168  [AV_PIX_FMT_BGR444BE] = { 1, 1 },
169  [AV_PIX_FMT_YA8] = { 1, 1 },
170  [AV_PIX_FMT_YA16BE] = { 1, 1 },
171  [AV_PIX_FMT_YA16LE] = { 1, 1 },
172  [AV_PIX_FMT_BGR48BE] = { 1, 1 },
173  [AV_PIX_FMT_BGR48LE] = { 1, 1 },
174  [AV_PIX_FMT_BGRA64BE] = { 1, 1, 1 },
175  [AV_PIX_FMT_BGRA64LE] = { 1, 1, 1 },
176  [AV_PIX_FMT_YUV420P9BE] = { 1, 1 },
177  [AV_PIX_FMT_YUV420P9LE] = { 1, 1 },
178  [AV_PIX_FMT_YUV420P10BE] = { 1, 1 },
179  [AV_PIX_FMT_YUV420P10LE] = { 1, 1 },
180  [AV_PIX_FMT_YUV420P12BE] = { 1, 1 },
181  [AV_PIX_FMT_YUV420P12LE] = { 1, 1 },
182  [AV_PIX_FMT_YUV420P14BE] = { 1, 1 },
183  [AV_PIX_FMT_YUV420P14LE] = { 1, 1 },
184  [AV_PIX_FMT_YUV422P9BE] = { 1, 1 },
185  [AV_PIX_FMT_YUV422P9LE] = { 1, 1 },
186  [AV_PIX_FMT_YUV422P10BE] = { 1, 1 },
187  [AV_PIX_FMT_YUV422P10LE] = { 1, 1 },
188  [AV_PIX_FMT_YUV422P12BE] = { 1, 1 },
189  [AV_PIX_FMT_YUV422P12LE] = { 1, 1 },
190  [AV_PIX_FMT_YUV422P14BE] = { 1, 1 },
191  [AV_PIX_FMT_YUV422P14LE] = { 1, 1 },
192  [AV_PIX_FMT_YUV444P9BE] = { 1, 1 },
193  [AV_PIX_FMT_YUV444P9LE] = { 1, 1 },
194  [AV_PIX_FMT_YUV444P10BE] = { 1, 1 },
195  [AV_PIX_FMT_YUV444P10LE] = { 1, 1 },
196  [AV_PIX_FMT_YUV444P12BE] = { 1, 1 },
197  [AV_PIX_FMT_YUV444P12LE] = { 1, 1 },
198  [AV_PIX_FMT_YUV444P14BE] = { 1, 1 },
199  [AV_PIX_FMT_YUV444P14LE] = { 1, 1 },
200  [AV_PIX_FMT_GBRP] = { 1, 1 },
201  [AV_PIX_FMT_GBRP9LE] = { 1, 1 },
202  [AV_PIX_FMT_GBRP9BE] = { 1, 1 },
203  [AV_PIX_FMT_GBRP10LE] = { 1, 1 },
204  [AV_PIX_FMT_GBRP10BE] = { 1, 1 },
205  [AV_PIX_FMT_GBRAP10LE] = { 1, 1 },
206  [AV_PIX_FMT_GBRAP10BE] = { 1, 1 },
207  [AV_PIX_FMT_GBRP12LE] = { 1, 1 },
208  [AV_PIX_FMT_GBRP12BE] = { 1, 1 },
209  [AV_PIX_FMT_GBRAP12LE] = { 1, 1 },
210  [AV_PIX_FMT_GBRAP12BE] = { 1, 1 },
211  [AV_PIX_FMT_GBRP14LE] = { 1, 1 },
212  [AV_PIX_FMT_GBRP14BE] = { 1, 1 },
213  [AV_PIX_FMT_GBRP16LE] = { 1, 1 },
214  [AV_PIX_FMT_GBRP16BE] = { 1, 1 },
215  [AV_PIX_FMT_GBRPF32LE] = { 1, 1 },
216  [AV_PIX_FMT_GBRPF32BE] = { 1, 1 },
217  [AV_PIX_FMT_GBRAPF32LE] = { 1, 1 },
218  [AV_PIX_FMT_GBRAPF32BE] = { 1, 1 },
219  [AV_PIX_FMT_GBRAP] = { 1, 1 },
220  [AV_PIX_FMT_GBRAP16LE] = { 1, 1 },
221  [AV_PIX_FMT_GBRAP16BE] = { 1, 1 },
222  [AV_PIX_FMT_BAYER_BGGR8] = { 1, 0 },
223  [AV_PIX_FMT_BAYER_RGGB8] = { 1, 0 },
224  [AV_PIX_FMT_BAYER_GBRG8] = { 1, 0 },
225  [AV_PIX_FMT_BAYER_GRBG8] = { 1, 0 },
226  [AV_PIX_FMT_BAYER_BGGR16LE] = { 1, 0 },
227  [AV_PIX_FMT_BAYER_BGGR16BE] = { 1, 0 },
228  [AV_PIX_FMT_BAYER_RGGB16LE] = { 1, 0 },
229  [AV_PIX_FMT_BAYER_RGGB16BE] = { 1, 0 },
230  [AV_PIX_FMT_BAYER_GBRG16LE] = { 1, 0 },
231  [AV_PIX_FMT_BAYER_GBRG16BE] = { 1, 0 },
232  [AV_PIX_FMT_BAYER_GRBG16LE] = { 1, 0 },
233  [AV_PIX_FMT_BAYER_GRBG16BE] = { 1, 0 },
234  [AV_PIX_FMT_XYZ12BE] = { 1, 1, 1 },
235  [AV_PIX_FMT_XYZ12LE] = { 1, 1, 1 },
236  [AV_PIX_FMT_AYUV64LE] = { 1, 1},
237  [AV_PIX_FMT_P010LE] = { 1, 1 },
238  [AV_PIX_FMT_P010BE] = { 1, 1 },
239  [AV_PIX_FMT_P016LE] = { 1, 1 },
240  [AV_PIX_FMT_P016BE] = { 1, 1 },
241  [AV_PIX_FMT_GRAYF32LE] = { 1, 1 },
242  [AV_PIX_FMT_GRAYF32BE] = { 1, 1 },
243  [AV_PIX_FMT_YUVA422P12BE] = { 1, 1 },
244  [AV_PIX_FMT_YUVA422P12LE] = { 1, 1 },
245  [AV_PIX_FMT_YUVA444P12BE] = { 1, 1 },
246  [AV_PIX_FMT_YUVA444P12LE] = { 1, 1 },
247  [AV_PIX_FMT_NV24] = { 1, 1 },
248  [AV_PIX_FMT_NV42] = { 1, 1 },
249  [AV_PIX_FMT_Y210LE] = { 1, 0 },
250  [AV_PIX_FMT_X2RGB10LE] = { 1, 1 },
251  [AV_PIX_FMT_X2BGR10LE] = { 1, 1 },
252  [AV_PIX_FMT_P210BE] = { 1, 1 },
253  [AV_PIX_FMT_P210LE] = { 1, 1 },
254  [AV_PIX_FMT_P410BE] = { 1, 1 },
255  [AV_PIX_FMT_P410LE] = { 1, 1 },
256  [AV_PIX_FMT_P216BE] = { 1, 1 },
257  [AV_PIX_FMT_P216LE] = { 1, 1 },
258  [AV_PIX_FMT_P416BE] = { 1, 1 },
259  [AV_PIX_FMT_P416LE] = { 1, 1 },
260  [AV_PIX_FMT_NV16] = { 1, 1 },
261  [AV_PIX_FMT_VUYA] = { 1, 1 },
262 };
263 
264 int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos,
265  int filterSize, int16_t *filter,
266  int dstW)
267 {
268 #if ARCH_X86_64
269  int i, j, k;
270  int cpu_flags = av_get_cpu_flags();
271  // avx2 hscale filter processes 16 pixel blocks.
272  if (!filter || dstW % 16 != 0)
273  return 0;
274  if (EXTERNAL_AVX2_FAST(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_SLOW_GATHER)) {
275  if ((c->srcBpc == 8) && (c->dstBpc <= 14)) {
276  int16_t *filterCopy = NULL;
277  if (filterSize > 4) {
278  if (!FF_ALLOC_TYPED_ARRAY(filterCopy, dstW * filterSize))
279  return AVERROR(ENOMEM);
280  memcpy(filterCopy, filter, dstW * filterSize * sizeof(int16_t));
281  }
282  // Do not swap filterPos for pixels which won't be processed by
283  // the main loop.
284  for (i = 0; i + 8 <= dstW; i += 8) {
285  FFSWAP(int, filterPos[i + 2], filterPos[i + 4]);
286  FFSWAP(int, filterPos[i + 3], filterPos[i + 5]);
287  }
288  if (filterSize > 4) {
289  // 16 pixels are processed at a time.
290  for (i = 0; i + 16 <= dstW; i += 16) {
291  // 4 filter coeffs are processed at a time.
292  for (k = 0; k + 4 <= filterSize; k += 4) {
293  for (j = 0; j < 16; ++j) {
294  int from = (i + j) * filterSize + k;
295  int to = i * filterSize + j * 4 + k * 16;
296  memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t));
297  }
298  }
299  }
300  }
301  av_free(filterCopy);
302  }
303  }
304 #endif
305  return 0;
306 }
307 
308 int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
309 {
310  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
311  format_entries[pix_fmt].is_supported_in : 0;
312 }
313 
314 int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
315 {
316  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
317  format_entries[pix_fmt].is_supported_out : 0;
318 }
319 
320 int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
321 {
322  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
323  format_entries[pix_fmt].is_supported_endianness : 0;
324 }
325 
326 static double getSplineCoeff(double a, double b, double c, double d,
327  double dist)
328 {
329  if (dist <= 1.0)
330  return ((d * dist + c) * dist + b) * dist + a;
331  else
332  return getSplineCoeff(0.0,
333  b + 2.0 * c + 3.0 * d,
334  c + 3.0 * d,
335  -b - 3.0 * c - 6.0 * d,
336  dist - 1.0);
337 }
338 
339 static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
340 {
341  if (pos == -1 || pos <= -513) {
342  pos = (128 << chr_subsample) - 128;
343  }
344  pos += 128; // relative to ideal left edge
345  return pos >> chr_subsample;
346 }
347 
348 typedef struct {
349  int flag; ///< flag associated to the algorithm
350  const char *description; ///< human-readable description
351  int size_factor; ///< size factor used when initing the filters
352 } ScaleAlgorithm;
353 
354 static const ScaleAlgorithm scale_algorithms[] = {
355  { SWS_AREA, "area averaging", 1 /* downscale only, for upscale it is bilinear */ },
356  { SWS_BICUBIC, "bicubic", 4 },
357  { SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 },
358  { SWS_BILINEAR, "bilinear", 2 },
359  { SWS_FAST_BILINEAR, "fast bilinear", -1 },
360  { SWS_GAUSS, "Gaussian", 8 /* infinite ;) */ },
361  { SWS_LANCZOS, "Lanczos", -1 /* custom */ },
362  { SWS_POINT, "nearest neighbor / point", -1 },
363  { SWS_SINC, "sinc", 20 /* infinite ;) */ },
364  { SWS_SPLINE, "bicubic spline", 20 /* infinite :)*/ },
365  { SWS_X, "experimental", 8 },
366 };
367 
368 static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
369  int *outFilterSize, int xInc, int srcW,
370  int dstW, int filterAlign, int one,
371  int flags, int cpu_flags,
372  SwsVector *srcFilter, SwsVector *dstFilter,
373  double param[2], int srcPos, int dstPos)
374 {
375  int i;
376  int filterSize;
377  int filter2Size;
378  int minFilterSize;
379  int64_t *filter = NULL;
380  int64_t *filter2 = NULL;
381  const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8));
382  int ret = -1;
383 
384  emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
385 
386  // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
387  if (!FF_ALLOC_TYPED_ARRAY(*filterPos, dstW + 3))
388  goto nomem;
389 
390  if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled
391  int i;
392  filterSize = 1;
393  if (!FF_ALLOCZ_TYPED_ARRAY(filter, dstW * filterSize))
394  goto nomem;
395 
396  for (i = 0; i < dstW; i++) {
397  filter[i * filterSize] = fone;
398  (*filterPos)[i] = i;
399  }
400  } else if (flags & SWS_POINT) { // lame looking point sampling mode
401  int i;
402  int64_t xDstInSrc;
403  filterSize = 1;
404  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
405  goto nomem;
406 
407  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
408  for (i = 0; i < dstW; i++) {
409  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
410 
411  (*filterPos)[i] = xx;
412  filter[i] = fone;
413  xDstInSrc += xInc;
414  }
415  } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||
416  (flags & SWS_FAST_BILINEAR)) { // bilinear upscale
417  int i;
418  int64_t xDstInSrc;
419  filterSize = 2;
420  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
421  goto nomem;
422 
423  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
424  for (i = 0; i < dstW; i++) {
425  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
426  int j;
427 
428  (*filterPos)[i] = xx;
429  // bilinear upscale / linear interpolate / area averaging
430  for (j = 0; j < filterSize; j++) {
431  int64_t coeff = fone - FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
432  if (coeff < 0)
433  coeff = 0;
434  filter[i * filterSize + j] = coeff;
435  xx++;
436  }
437  xDstInSrc += xInc;
438  }
439  } else {
440  int64_t xDstInSrc;
441  int sizeFactor = -1;
442 
443  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
444  if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
445  sizeFactor = scale_algorithms[i].size_factor;
446  break;
447  }
448  }
449  if (flags & SWS_LANCZOS)
450  sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;
451  av_assert0(sizeFactor > 0);
452 
453  if (xInc <= 1 << 16)
454  filterSize = 1 + sizeFactor; // upscale
455  else
456  filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
457 
458  filterSize = FFMIN(filterSize, srcW - 2);
459  filterSize = FFMAX(filterSize, 1);
460 
461  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
462  goto nomem;
463  xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
464  for (i = 0; i < dstW; i++) {
465  int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
466  int j;
467  (*filterPos)[i] = xx;
468  for (j = 0; j < filterSize; j++) {
469  int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
470  double floatd;
471  int64_t coeff;
472 
473  if (xInc > 1 << 16)
474  d = d * dstW / srcW;
475  floatd = d * (1.0 / (1 << 30));
476 
477  if (flags & SWS_BICUBIC) {
478  int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24);
479  int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);
480 
481  if (d >= 1LL << 31) {
482  coeff = 0.0;
483  } else {
484  int64_t dd = (d * d) >> 30;
485  int64_t ddd = (dd * d) >> 30;
486 
487  if (d < 1LL << 30)
488  coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
489  (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
490  (6 * (1 << 24) - 2 * B) * (1 << 30);
491  else
492  coeff = (-B - 6 * C) * ddd +
493  (6 * B + 30 * C) * dd +
494  (-12 * B - 48 * C) * d +
495  (8 * B + 24 * C) * (1 << 30);
496  }
497  coeff /= (1LL<<54)/fone;
498  } else if (flags & SWS_X) {
499  double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
500  double c;
501 
502  if (floatd < 1.0)
503  c = cos(floatd * M_PI);
504  else
505  c = -1.0;
506  if (c < 0.0)
507  c = -pow(-c, A);
508  else
509  c = pow(c, A);
510  coeff = (c * 0.5 + 0.5) * fone;
511  } else if (flags & SWS_AREA) {
512  int64_t d2 = d - (1 << 29);
513  if (d2 * xInc < -(1LL << (29 + 16)))
514  coeff = 1.0 * (1LL << (30 + 16));
515  else if (d2 * xInc < (1LL << (29 + 16)))
516  coeff = -d2 * xInc + (1LL << (29 + 16));
517  else
518  coeff = 0.0;
519  coeff *= fone >> (30 + 16);
520  } else if (flags & SWS_GAUSS) {
521  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
522  coeff = exp2(-p * floatd * floatd) * fone;
523  } else if (flags & SWS_SINC) {
524  coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
525  } else if (flags & SWS_LANCZOS) {
526  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
527  coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) /
528  (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
529  if (floatd > p)
530  coeff = 0;
531  } else if (flags & SWS_BILINEAR) {
532  coeff = (1 << 30) - d;
533  if (coeff < 0)
534  coeff = 0;
535  coeff *= fone >> 30;
536  } else if (flags & SWS_SPLINE) {
537  double p = -2.196152422706632;
538  coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone;
539  } else {
540  av_assert0(0);
541  }
542 
543  filter[i * filterSize + j] = coeff;
544  xx++;
545  }
546  xDstInSrc += 2 * xInc;
547  }
548  }
549 
550  /* apply src & dst Filter to filter -> filter2
551  * av_free(filter);
552  */
553  av_assert0(filterSize > 0);
554  filter2Size = filterSize;
555  if (srcFilter)
556  filter2Size += srcFilter->length - 1;
557  if (dstFilter)
558  filter2Size += dstFilter->length - 1;
559  av_assert0(filter2Size > 0);
560  if (!FF_ALLOCZ_TYPED_ARRAY(filter2, dstW * filter2Size))
561  goto nomem;
562  for (i = 0; i < dstW; i++) {
563  int j, k;
564 
565  if (srcFilter) {
566  for (k = 0; k < srcFilter->length; k++) {
567  for (j = 0; j < filterSize; j++)
568  filter2[i * filter2Size + k + j] +=
569  srcFilter->coeff[k] * filter[i * filterSize + j];
570  }
571  } else {
572  for (j = 0; j < filterSize; j++)
573  filter2[i * filter2Size + j] = filter[i * filterSize + j];
574  }
575  // FIXME dstFilter
576 
577  (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
578  }
579  av_freep(&filter);
580 
581  /* try to reduce the filter-size (step1 find size and shift left) */
582  // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
583  minFilterSize = 0;
584  for (i = dstW - 1; i >= 0; i--) {
585  int min = filter2Size;
586  int j;
587  int64_t cutOff = 0.0;
588 
589  /* get rid of near zero elements on the left by shifting left */
590  for (j = 0; j < filter2Size; j++) {
591  int k;
592  cutOff += FFABS(filter2[i * filter2Size]);
593 
594  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
595  break;
596 
597  /* preserve monotonicity because the core can't handle the
598  * filter otherwise */
599  if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
600  break;
601 
602  // move filter coefficients left
603  for (k = 1; k < filter2Size; k++)
604  filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
605  filter2[i * filter2Size + k - 1] = 0;
606  (*filterPos)[i]++;
607  }
608 
609  cutOff = 0;
610  /* count near zeros on the right */
611  for (j = filter2Size - 1; j > 0; j--) {
612  cutOff += FFABS(filter2[i * filter2Size + j]);
613 
614  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
615  break;
616  min--;
617  }
618 
619  if (min > minFilterSize)
620  minFilterSize = min;
621  }
622 
623  if (PPC_ALTIVEC(cpu_flags)) {
624  // we can handle the special case 4, so we don't want to go the full 8
625  if (minFilterSize < 5)
626  filterAlign = 4;
627 
628  /* We really don't want to waste our time doing useless computation, so
629  * fall back on the scalar C code for very small filters.
630  * Vectorizing is worth it only if you have a decent-sized vector. */
631  if (minFilterSize < 3)
632  filterAlign = 1;
633  }
634 
635  if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
636  // special case for unscaled vertical filtering
637  if (minFilterSize == 1 && filterAlign == 2)
638  filterAlign = 1;
639  }
640 
641  av_assert0(minFilterSize > 0);
642  filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
643  av_assert0(filterSize > 0);
644  filter = av_malloc_array(dstW, filterSize * sizeof(*filter));
645  if (!filter)
646  goto nomem;
647  if (filterSize >= MAX_FILTER_SIZE * 16 /
648  ((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16)) {
649  ret = RETCODE_USE_CASCADE;
650  goto fail;
651  }
652  *outFilterSize = filterSize;
653 
654  if (flags & SWS_PRINT_INFO)
655  av_log(NULL, AV_LOG_VERBOSE,
656  "SwScaler: reducing / aligning filtersize %d -> %d\n",
657  filter2Size, filterSize);
658  /* try to reduce the filter-size (step2 reduce it) */
659  for (i = 0; i < dstW; i++) {
660  int j;
661 
662  for (j = 0; j < filterSize; j++) {
663  if (j >= filter2Size)
664  filter[i * filterSize + j] = 0;
665  else
666  filter[i * filterSize + j] = filter2[i * filter2Size + j];
667  if ((flags & SWS_BITEXACT) && j >= minFilterSize)
668  filter[i * filterSize + j] = 0;
669  }
670  }
671 
672  // FIXME try to align filterPos if possible
673 
674  // fix borders
675  for (i = 0; i < dstW; i++) {
676  int j;
677  if ((*filterPos)[i] < 0) {
678  // move filter coefficients left to compensate for filterPos
679  for (j = 1; j < filterSize; j++) {
680  int left = FFMAX(j + (*filterPos)[i], 0);
681  filter[i * filterSize + left] += filter[i * filterSize + j];
682  filter[i * filterSize + j] = 0;
683  }
684  (*filterPos)[i]= 0;
685  }
686 
687  if ((*filterPos)[i] + filterSize > srcW) {
688  int shift = (*filterPos)[i] + FFMIN(filterSize - srcW, 0);
689  int64_t acc = 0;
690 
691  for (j = filterSize - 1; j >= 0; j--) {
692  if ((*filterPos)[i] + j >= srcW) {
693  acc += filter[i * filterSize + j];
694  filter[i * filterSize + j] = 0;
695  }
696  }
697  for (j = filterSize - 1; j >= 0; j--) {
698  if (j < shift) {
699  filter[i * filterSize + j] = 0;
700  } else {
701  filter[i * filterSize + j] = filter[i * filterSize + j - shift];
702  }
703  }
704 
705  (*filterPos)[i]-= shift;
706  filter[i * filterSize + srcW - 1 - (*filterPos)[i]] += acc;
707  }
708  av_assert0((*filterPos)[i] >= 0);
709  av_assert0((*filterPos)[i] < srcW);
710  if ((*filterPos)[i] + filterSize > srcW) {
711  for (j = 0; j < filterSize; j++) {
712  av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
713  }
714  }
715  }
716 
717  // Note the +1 is for the MMX scaler which reads over the end
718  /* align at 16 for AltiVec (needed by hScale_altivec_real) */
719  if (!FF_ALLOCZ_TYPED_ARRAY(*outFilter, *outFilterSize * (dstW + 3)))
720  goto nomem;
721 
722  /* normalize & store in outFilter */
723  for (i = 0; i < dstW; i++) {
724  int j;
725  int64_t error = 0;
726  int64_t sum = 0;
727 
728  for (j = 0; j < filterSize; j++) {
729  sum += filter[i * filterSize + j];
730  }
731  sum = (sum + one / 2) / one;
732  if (!sum) {
733  av_log(NULL, AV_LOG_WARNING, "SwScaler: zero vector in scaling\n");
734  sum = 1;
735  }
736  for (j = 0; j < *outFilterSize; j++) {
737  int64_t v = filter[i * filterSize + j] + error;
738  int intV = ROUNDED_DIV(v, sum);
739  (*outFilter)[i * (*outFilterSize) + j] = intV;
740  error = v - intV * sum;
741  }
742  }
743 
744  (*filterPos)[dstW + 0] =
745  (*filterPos)[dstW + 1] =
746  (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1]; /* the MMX/SSE scaler will
747  * read over the end */
748  for (i = 0; i < *outFilterSize; i++) {
749  int k = (dstW - 1) * (*outFilterSize) + i;
750  (*outFilter)[k + 1 * (*outFilterSize)] =
751  (*outFilter)[k + 2 * (*outFilterSize)] =
752  (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
753  }
754 
755  ret = 0;
756  goto done;
757 nomem:
758  ret = AVERROR(ENOMEM);
759 fail:
760  if(ret < 0)
761  av_log(NULL, ret == RETCODE_USE_CASCADE ? AV_LOG_DEBUG : AV_LOG_ERROR, "sws: initFilter failed\n");
762 done:
763  av_free(filter);
764  av_free(filter2);
765  return ret;
766 }
767 
768 static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
769 {
770  int64_t W, V, Z, Cy, Cu, Cv;
771  int64_t vr = table[0];
772  int64_t ub = table[1];
773  int64_t ug = -table[2];
774  int64_t vg = -table[3];
775  int64_t ONE = 65536;
776  int64_t cy = ONE;
777  uint8_t *p = (uint8_t*)c->input_rgb2yuv_table;
778  int i;
779  static const int8_t map[] = {
780  BY_IDX, GY_IDX, -1 , BY_IDX, BY_IDX, GY_IDX, -1 , BY_IDX,
781  RY_IDX, -1 , GY_IDX, RY_IDX, RY_IDX, -1 , GY_IDX, RY_IDX,
782  RY_IDX, GY_IDX, -1 , RY_IDX, RY_IDX, GY_IDX, -1 , RY_IDX,
783  BY_IDX, -1 , GY_IDX, BY_IDX, BY_IDX, -1 , GY_IDX, BY_IDX,
784  BU_IDX, GU_IDX, -1 , BU_IDX, BU_IDX, GU_IDX, -1 , BU_IDX,
785  RU_IDX, -1 , GU_IDX, RU_IDX, RU_IDX, -1 , GU_IDX, RU_IDX,
786  RU_IDX, GU_IDX, -1 , RU_IDX, RU_IDX, GU_IDX, -1 , RU_IDX,
787  BU_IDX, -1 , GU_IDX, BU_IDX, BU_IDX, -1 , GU_IDX, BU_IDX,
788  BV_IDX, GV_IDX, -1 , BV_IDX, BV_IDX, GV_IDX, -1 , BV_IDX,
789  RV_IDX, -1 , GV_IDX, RV_IDX, RV_IDX, -1 , GV_IDX, RV_IDX,
790  RV_IDX, GV_IDX, -1 , RV_IDX, RV_IDX, GV_IDX, -1 , RV_IDX,
791  BV_IDX, -1 , GV_IDX, BV_IDX, BV_IDX, -1 , GV_IDX, BV_IDX,
792  RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX,
793  BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX,
794  GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 ,
795  -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX,
796  RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX,
797  BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX,
798  GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 ,
799  -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX,
800  RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX,
801  BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX,
802  GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 ,
803  -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, //23
804  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //24
805  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //25
806  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //26
807  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //27
808  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //28
809  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //29
810  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //30
811  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //31
812  BY_IDX, GY_IDX, RY_IDX, -1 , -1 , -1 , -1 , -1 , //32
813  BU_IDX, GU_IDX, RU_IDX, -1 , -1 , -1 , -1 , -1 , //33
814  BV_IDX, GV_IDX, RV_IDX, -1 , -1 , -1 , -1 , -1 , //34
815  };
816 
817  dstRange = 0; //FIXME range = 1 is handled elsewhere
818 
819  if (!dstRange) {
820  cy = cy * 255 / 219;
821  } else {
822  vr = vr * 224 / 255;
823  ub = ub * 224 / 255;
824  ug = ug * 224 / 255;
825  vg = vg * 224 / 255;
826  }
827  W = ROUNDED_DIV(ONE*ONE*ug, ub);
828  V = ROUNDED_DIV(ONE*ONE*vg, vr);
829  Z = ONE*ONE-W-V;
830 
831  Cy = ROUNDED_DIV(cy*Z, ONE);
832  Cu = ROUNDED_DIV(ub*Z, ONE);
833  Cv = ROUNDED_DIV(vr*Z, ONE);
834 
835  c->input_rgb2yuv_table[RY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cy);
836  c->input_rgb2yuv_table[GY_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cy);
837  c->input_rgb2yuv_table[BY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cy);
838 
839  c->input_rgb2yuv_table[RU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cu);
840  c->input_rgb2yuv_table[GU_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cu);
841  c->input_rgb2yuv_table[BU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(Z+W) , Cu);
842 
843  c->input_rgb2yuv_table[RV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(V+Z) , Cv);
844  c->input_rgb2yuv_table[GV_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cv);
845  c->input_rgb2yuv_table[BV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cv);
846 
847  if(/*!dstRange && */!memcmp(table, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sizeof(ff_yuv2rgb_coeffs[SWS_CS_DEFAULT]))) {
848  c->input_rgb2yuv_table[BY_IDX] = ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
849  c->input_rgb2yuv_table[BV_IDX] = (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
850  c->input_rgb2yuv_table[BU_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
851  c->input_rgb2yuv_table[GY_IDX] = ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
852  c->input_rgb2yuv_table[GV_IDX] = (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
853  c->input_rgb2yuv_table[GU_IDX] = (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
854  c->input_rgb2yuv_table[RY_IDX] = ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
855  c->input_rgb2yuv_table[RV_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
856  c->input_rgb2yuv_table[RU_IDX] = (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
857  }
858  for(i=0; i<FF_ARRAY_ELEMS(map); i++)
859  AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ? c->input_rgb2yuv_table[map[i]] : 0);
860 }
861 
862 static void fill_xyztables(struct SwsContext *c)
863 {
864  int i;
865  double xyzgamma = XYZ_GAMMA;
866  double rgbgamma = 1.0 / RGB_GAMMA;
867  double xyzgammainv = 1.0 / XYZ_GAMMA;
868  double rgbgammainv = RGB_GAMMA;
869  static const int16_t xyz2rgb_matrix[3][4] = {
870  {13270, -6295, -2041},
871  {-3969, 7682, 170},
872  { 228, -835, 4329} };
873  static const int16_t rgb2xyz_matrix[3][4] = {
874  {1689, 1464, 739},
875  { 871, 2929, 296},
876  { 79, 488, 3891} };
877  static int16_t xyzgamma_tab[4096], rgbgamma_tab[4096], xyzgammainv_tab[4096], rgbgammainv_tab[4096];
878 
879  memcpy(c->xyz2rgb_matrix, xyz2rgb_matrix, sizeof(c->xyz2rgb_matrix));
880  memcpy(c->rgb2xyz_matrix, rgb2xyz_matrix, sizeof(c->rgb2xyz_matrix));
881  c->xyzgamma = xyzgamma_tab;
882  c->rgbgamma = rgbgamma_tab;
883  c->xyzgammainv = xyzgammainv_tab;
884  c->rgbgammainv = rgbgammainv_tab;
885 
886  if (rgbgamma_tab[4095])
887  return;
888 
889  /* set gamma vectors */
890  for (i = 0; i < 4096; i++) {
891  xyzgamma_tab[i] = lrint(pow(i / 4095.0, xyzgamma) * 4095.0);
892  rgbgamma_tab[i] = lrint(pow(i / 4095.0, rgbgamma) * 4095.0);
893  xyzgammainv_tab[i] = lrint(pow(i / 4095.0, xyzgammainv) * 4095.0);
894  rgbgammainv_tab[i] = lrint(pow(i / 4095.0, rgbgammainv) * 4095.0);
895  }
896 }
897 
898 static int range_override_needed(enum AVPixelFormat format)
899 {
900  return !isYUV(format) && !isGray(format);
901 }
902 
903 int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4],
904  int srcRange, const int table[4], int dstRange,
905  int brightness, int contrast, int saturation)
906 {
907  const AVPixFmtDescriptor *desc_dst;
908  const AVPixFmtDescriptor *desc_src;
909  int need_reinit = 0;
910 
911  if (c->nb_slice_ctx) {
912  int parent_ret = 0;
913  for (int i = 0; i < c->nb_slice_ctx; i++) {
914  int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table,
915  srcRange, table, dstRange,
916  brightness, contrast, saturation);
917  if (ret < 0)
918  parent_ret = ret;
919  }
920 
921  return parent_ret;
922  }
923 
924  handle_formats(c);
925  desc_dst = av_pix_fmt_desc_get(c->dstFormat);
926  desc_src = av_pix_fmt_desc_get(c->srcFormat);
927 
928  if(range_override_needed(c->dstFormat))
929  dstRange = 0;
930  if(range_override_needed(c->srcFormat))
931  srcRange = 0;
932 
933  if (c->srcRange != srcRange ||
934  c->dstRange != dstRange ||
935  c->brightness != brightness ||
936  c->contrast != contrast ||
937  c->saturation != saturation ||
938  memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
939  memcmp(c->dstColorspaceTable, table, sizeof(int) * 4)
940  )
941  need_reinit = 1;
942 
943  memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
944  memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
945 
946 
947 
948  c->brightness = brightness;
949  c->contrast = contrast;
950  c->saturation = saturation;
951  c->srcRange = srcRange;
952  c->dstRange = dstRange;
953 
954  //The srcBpc check is possibly wrong but we seem to lack a definitive reference to test this
955  //and what we have in ticket 2939 looks better with this check
956  if (need_reinit && (c->srcBpc == 8 || !isYUV(c->srcFormat)))
957  ff_sws_init_range_convert(c);
958 
959  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
960  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
961 
962  if (c->cascaded_context[c->cascaded_mainindex])
963  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
964 
965  if (!need_reinit)
966  return 0;
967 
968  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
969  if (!c->cascaded_context[0] &&
970  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
971  c->srcW && c->srcH && c->dstW && c->dstH) {
972  enum AVPixelFormat tmp_format;
973  int tmp_width, tmp_height;
974  int srcW = c->srcW;
975  int srcH = c->srcH;
976  int dstW = c->dstW;
977  int dstH = c->dstH;
978  int ret;
979  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
980 
981  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
982  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
983  tmp_format = AV_PIX_FMT_BGRA64;
984  } else {
985  tmp_format = AV_PIX_FMT_BGR48;
986  }
987  } else {
988  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
989  tmp_format = AV_PIX_FMT_BGRA;
990  } else {
991  tmp_format = AV_PIX_FMT_BGR24;
992  }
993  }
994 
995  if (srcW*srcH > dstW*dstH) {
996  tmp_width = dstW;
997  tmp_height = dstH;
998  } else {
999  tmp_width = srcW;
1000  tmp_height = srcH;
1001  }
1002 
1003  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1004  tmp_width, tmp_height, tmp_format, 64);
1005  if (ret < 0)
1006  return ret;
1007 
1008  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
1009  tmp_width, tmp_height, tmp_format,
1010  c->flags, c->param);
1011  if (!c->cascaded_context[0])
1012  return -1;
1013 
1014  c->cascaded_context[0]->alphablend = c->alphablend;
1015  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1016  if (ret < 0)
1017  return ret;
1018  //we set both src and dst depending on that the RGB side will be ignored
1019  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
1020  srcRange, table, dstRange,
1021  brightness, contrast, saturation);
1022 
1023  c->cascaded_context[1] = sws_alloc_set_opts(tmp_width, tmp_height, tmp_format,
1024  dstW, dstH, c->dstFormat,
1025  c->flags, c->param);
1026  if (!c->cascaded_context[1])
1027  return -1;
1028  c->cascaded_context[1]->srcRange = srcRange;
1029  c->cascaded_context[1]->dstRange = dstRange;
1030  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1031  if (ret < 0)
1032  return ret;
1033  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
1034  srcRange, table, dstRange,
1035  0, 1 << 16, 1 << 16);
1036  return 0;
1037  }
1038  //We do not support this combination currently, we need to cascade more contexts to compensate
1039  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
1040  return -1; //AVERROR_PATCHWELCOME;
1041  return 0;
1042  }
1043 
1044  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1045  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1046  contrast, saturation);
1047  // FIXME factorize
1048 
1049 #if ARCH_PPC
1050  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1051  contrast, saturation);
1052 #endif
1053  }
1054 
1055  fill_rgb2yuv_table(c, table, dstRange);
1056 
1057  return 0;
1058 }
1059 
1060 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1061  int *srcRange, int **table, int *dstRange,
1062  int *brightness, int *contrast, int *saturation)
1063 {
1064  if (!c )
1065  return -1;
1066 
1067  if (c->nb_slice_ctx) {
1068  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1069  table, dstRange, brightness, contrast,
1070  saturation);
1071  }
1072 
1073  *inv_table = c->srcColorspaceTable;
1074  *table = c->dstColorspaceTable;
1075  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1076  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1077  *brightness = c->brightness;
1078  *contrast = c->contrast;
1079  *saturation = c->saturation;
1080 
1081  return 0;
1082 }
1083 
1084 static int handle_jpeg(enum AVPixelFormat *format)
1085 {
1086  switch (*format) {
1087  case AV_PIX_FMT_YUVJ420P:
1088  *format = AV_PIX_FMT_YUV420P;
1089  return 1;
1090  case AV_PIX_FMT_YUVJ411P:
1091  *format = AV_PIX_FMT_YUV411P;
1092  return 1;
1093  case AV_PIX_FMT_YUVJ422P:
1094  *format = AV_PIX_FMT_YUV422P;
1095  return 1;
1096  case AV_PIX_FMT_YUVJ444P:
1097  *format = AV_PIX_FMT_YUV444P;
1098  return 1;
1099  case AV_PIX_FMT_YUVJ440P:
1100  *format = AV_PIX_FMT_YUV440P;
1101  return 1;
1102  case AV_PIX_FMT_GRAY8:
1103  case AV_PIX_FMT_YA8:
1104  case AV_PIX_FMT_GRAY9LE:
1105  case AV_PIX_FMT_GRAY9BE:
1106  case AV_PIX_FMT_GRAY10LE:
1107  case AV_PIX_FMT_GRAY10BE:
1108  case AV_PIX_FMT_GRAY12LE:
1109  case AV_PIX_FMT_GRAY12BE:
1110  case AV_PIX_FMT_GRAY14LE:
1111  case AV_PIX_FMT_GRAY14BE:
1112  case AV_PIX_FMT_GRAY16LE:
1113  case AV_PIX_FMT_GRAY16BE:
1114  case AV_PIX_FMT_YA16BE:
1115  case AV_PIX_FMT_YA16LE:
1116  return 1;
1117  default:
1118  return 0;
1119  }
1120 }
1121 
1122 static int handle_0alpha(enum AVPixelFormat *format)
1123 {
1124  switch (*format) {
1125  case AV_PIX_FMT_0BGR : *format = AV_PIX_FMT_ABGR ; return 1;
1126  case AV_PIX_FMT_BGR0 : *format = AV_PIX_FMT_BGRA ; return 4;
1127  case AV_PIX_FMT_0RGB : *format = AV_PIX_FMT_ARGB ; return 1;
1128  case AV_PIX_FMT_RGB0 : *format = AV_PIX_FMT_RGBA ; return 4;
1129  default: return 0;
1130  }
1131 }
1132 
1133 static int handle_xyz(enum AVPixelFormat *format)
1134 {
1135  switch (*format) {
1136  case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1;
1137  case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1;
1138  default: return 0;
1139  }
1140 }
1141 
1142 static void handle_formats(SwsContext *c)
1143 {
1144  c->src0Alpha |= handle_0alpha(&c->srcFormat);
1145  c->dst0Alpha |= handle_0alpha(&c->dstFormat);
1146  c->srcXYZ |= handle_xyz(&c->srcFormat);
1147  c->dstXYZ |= handle_xyz(&c->dstFormat);
1148  if (c->srcXYZ || c->dstXYZ)
1149  fill_xyztables(c);
1150 }
1151 
1152 SwsContext *sws_alloc_context(void)
1153 {
1154  SwsContext *c = av_mallocz(sizeof(SwsContext));
1155 
1156  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1157 
1158  if (c) {
1159  c->av_class = &ff_sws_context_class;
1160  av_opt_set_defaults(c);
1161  atomic_init(&c->stride_unaligned_warned, 0);
1162  atomic_init(&c->data_unaligned_warned, 0);
1163  }
1164 
1165  return c;
1166 }
1167 
1168 static uint16_t * alloc_gamma_tbl(double e)
1169 {
1170  int i = 0;
1171  uint16_t * tbl;
1172  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1173  if (!tbl)
1174  return NULL;
1175 
1176  for (i = 0; i < 65536; ++i) {
1177  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1178  }
1179  return tbl;
1180 }
1181 
1182 static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
1183 {
1184  switch(fmt) {
1185  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1186  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1187  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1188  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1189  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1190 
1191  case AV_PIX_FMT_YUVA420P: return AV_PIX_FMT_YUV420P;
1192  case AV_PIX_FMT_YUVA422P: return AV_PIX_FMT_YUV422P;
1193  case AV_PIX_FMT_YUVA444P: return AV_PIX_FMT_YUV444P;
1194 
1195  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1196 
1197  case AV_PIX_FMT_GBRAP10LE: return AV_PIX_FMT_GBRP10;
1198  case AV_PIX_FMT_GBRAP10BE: return AV_PIX_FMT_GBRP10;
1199 
1200  case AV_PIX_FMT_GBRAP12LE: return AV_PIX_FMT_GBRP12;
1201  case AV_PIX_FMT_GBRAP12BE: return AV_PIX_FMT_GBRP12;
1202 
1203  case AV_PIX_FMT_GBRAP16LE: return AV_PIX_FMT_GBRP16;
1204  case AV_PIX_FMT_GBRAP16BE: return AV_PIX_FMT_GBRP16;
1205 
1206  case AV_PIX_FMT_RGBA64LE: return AV_PIX_FMT_RGB48;
1207  case AV_PIX_FMT_RGBA64BE: return AV_PIX_FMT_RGB48;
1208  case AV_PIX_FMT_BGRA64LE: return AV_PIX_FMT_BGR48;
1209  case AV_PIX_FMT_BGRA64BE: return AV_PIX_FMT_BGR48;
1210 
1211  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1212  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1213 
1214  case AV_PIX_FMT_YUVA420P9BE: return AV_PIX_FMT_YUV420P9;
1215  case AV_PIX_FMT_YUVA422P9BE: return AV_PIX_FMT_YUV422P9;
1216  case AV_PIX_FMT_YUVA444P9BE: return AV_PIX_FMT_YUV444P9;
1217  case AV_PIX_FMT_YUVA420P9LE: return AV_PIX_FMT_YUV420P9;
1218  case AV_PIX_FMT_YUVA422P9LE: return AV_PIX_FMT_YUV422P9;
1219  case AV_PIX_FMT_YUVA444P9LE: return AV_PIX_FMT_YUV444P9;
1220  case AV_PIX_FMT_YUVA420P10BE: return AV_PIX_FMT_YUV420P10;
1221  case AV_PIX_FMT_YUVA422P10BE: return AV_PIX_FMT_YUV422P10;
1222  case AV_PIX_FMT_YUVA444P10BE: return AV_PIX_FMT_YUV444P10;
1223  case AV_PIX_FMT_YUVA420P10LE: return AV_PIX_FMT_YUV420P10;
1224  case AV_PIX_FMT_YUVA422P10LE: return AV_PIX_FMT_YUV422P10;
1225  case AV_PIX_FMT_YUVA444P10LE: return AV_PIX_FMT_YUV444P10;
1226  case AV_PIX_FMT_YUVA420P16BE: return AV_PIX_FMT_YUV420P16;
1227  case AV_PIX_FMT_YUVA422P16BE: return AV_PIX_FMT_YUV422P16;
1228  case AV_PIX_FMT_YUVA444P16BE: return AV_PIX_FMT_YUV444P16;
1229  case AV_PIX_FMT_YUVA420P16LE: return AV_PIX_FMT_YUV420P16;
1230  case AV_PIX_FMT_YUVA422P16LE: return AV_PIX_FMT_YUV422P16;
1231  case AV_PIX_FMT_YUVA444P16LE: return AV_PIX_FMT_YUV444P16;
1232 
1233 // case AV_PIX_FMT_AYUV64LE:
1234 // case AV_PIX_FMT_AYUV64BE:
1235 // case AV_PIX_FMT_PAL8:
1236  default: return AV_PIX_FMT_NONE;
1237  }
1238 }
1239 
1240 static int context_init_threaded(SwsContext *c,
1241  SwsFilter *src_filter, SwsFilter *dst_filter)
1242 {
1243  int ret;
1244 
1245  ret = avpriv_slicethread_create(&c->slicethread, (void*)c,
1246  ff_sws_slice_worker, NULL, c->nb_threads);
1247  if (ret == AVERROR(ENOSYS)) {
1248  c->nb_threads = 1;
1249  return 0;
1250  } else if (ret < 0)
1251  return ret;
1252 
1253  c->nb_threads = ret;
1254 
1255  c->slice_ctx = av_calloc(c->nb_threads, sizeof(*c->slice_ctx));
1256  c->slice_err = av_calloc(c->nb_threads, sizeof(*c->slice_err));
1257  if (!c->slice_ctx || !c->slice_err)
1258  return AVERROR(ENOMEM);
1259 
1260  for (int i = 0; i < c->nb_threads; i++) {
1261  c->slice_ctx[i] = sws_alloc_context();
1262  if (!c->slice_ctx[i])
1263  return AVERROR(ENOMEM);
1264 
1265  c->slice_ctx[i]->parent = c;
1266 
1267  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
1268  if (ret < 0)
1269  return ret;
1270 
1271  c->slice_ctx[i]->nb_threads = 1;
1272 
1273  ret = sws_init_context(c->slice_ctx[i], src_filter, dst_filter);
1274  if (ret < 0)
1275  return ret;
1276 
1277  c->nb_slice_ctx++;
1278 
1279  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
1280  av_log(c, AV_LOG_VERBOSE,
1281  "Error-diffusion dither is in use, scaling will be single-threaded.");
1282  break;
1283  }
1284  }
1285 
1286  c->frame_src = av_frame_alloc();
1287  c->frame_dst = av_frame_alloc();
1288  if (!c->frame_src || !c->frame_dst)
1289  return AVERROR(ENOMEM);
1290 
1291  return 0;
1292 }
1293 
1294 av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
1295  SwsFilter *dstFilter)
1296 {
1297  int i;
1298  int usesVFilter, usesHFilter;
1299  int unscaled;
1300  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1301  int srcW = c->srcW;
1302  int srcH = c->srcH;
1303  int dstW = c->dstW;
1304  int dstH = c->dstH;
1305  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1306  int flags, cpu_flags;
1307  enum AVPixelFormat srcFormat = c->srcFormat;
1308  enum AVPixelFormat dstFormat = c->dstFormat;
1309  const AVPixFmtDescriptor *desc_src;
1310  const AVPixFmtDescriptor *desc_dst;
1311  int ret = 0;
1312  enum AVPixelFormat tmpFmt;
1313  static const float float_mult = 1.0f / 255.0f;
1314  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1315 
1316  if (c->nb_threads != 1) {
1317  ret = context_init_threaded(c, srcFilter, dstFilter);
1318  if (ret < 0 || c->nb_threads > 1)
1319  return ret;
1320  // threading disabled in this build, init as single-threaded
1321  }
1322 
1323  cpu_flags = av_get_cpu_flags();
1324  flags = c->flags;
1325  emms_c();
1326  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1327  return AVERROR_UNKNOWN;
1328 
1329  unscaled = (srcW == dstW && srcH == dstH);
1330 
1331  c->srcRange |= handle_jpeg(&c->srcFormat);
1332  c->dstRange |= handle_jpeg(&c->dstFormat);
1333 
1334  if(srcFormat!=c->srcFormat || dstFormat!=c->dstFormat)
1335  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1336 
1337  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1338  sws_setColorspaceDetails(c, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->srcRange,
1339  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1340  c->dstRange, 0, 1 << 16, 1 << 16);
1341 
1342  handle_formats(c);
1343  srcFormat = c->srcFormat;
1344  dstFormat = c->dstFormat;
1345  desc_src = av_pix_fmt_desc_get(srcFormat);
1346  desc_dst = av_pix_fmt_desc_get(dstFormat);
1347 
1348  // If the source has no alpha then disable alpha blendaway
1349  if (c->src0Alpha)
1350  c->alphablend = SWS_ALPHA_BLEND_NONE;
1351 
1352  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1353  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1354  if (!sws_isSupportedInput(srcFormat)) {
1355  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1356  av_get_pix_fmt_name(srcFormat));
1357  return AVERROR(EINVAL);
1358  }
1359  if (!sws_isSupportedOutput(dstFormat)) {
1360  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1361  av_get_pix_fmt_name(dstFormat));
1362  return AVERROR(EINVAL);
1363  }
1364  }
1365  av_assert2(desc_src && desc_dst);
1366 
1367  i = flags & (SWS_POINT |
1368  SWS_AREA |
1369  SWS_BILINEAR |
1370  SWS_FAST_BILINEAR |
1371  SWS_BICUBIC |
1372  SWS_X |
1373  SWS_GAUSS |
1374  SWS_LANCZOS |
1375  SWS_SINC |
1376  SWS_SPLINE |
1377  SWS_BICUBLIN);
1378 
1379  /* provide a default scaler if not set by caller */
1380  if (!i) {
1381  if (dstW < srcW && dstH < srcH)
1382  flags |= SWS_BICUBIC;
1383  else if (dstW > srcW && dstH > srcH)
1384  flags |= SWS_BICUBIC;
1385  else
1386  flags |= SWS_BICUBIC;
1387  c->flags = flags;
1388  } else if (i & (i - 1)) {
1389  av_log(c, AV_LOG_ERROR,
1390  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1391  return AVERROR(EINVAL);
1392  }
1393  /* sanity check */
1394  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1395  /* FIXME check if these are enough and try to lower them after
1396  * fixing the relevant parts of the code */
1397  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1398  srcW, srcH, dstW, dstH);
1399  return AVERROR(EINVAL);
1400  }
1401  if (flags & SWS_FAST_BILINEAR) {
1402  if (srcW < 8 || dstW < 8) {
1403  flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR;
1404  c->flags = flags;
1405  }
1406  }
1407 
1408  if (!dstFilter)
1409  dstFilter = &dummyFilter;
1410  if (!srcFilter)
1411  srcFilter = &dummyFilter;
1412 
1413  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1414  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1415  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1416  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1417  c->vRounder = 4 * 0x0001000100010001ULL;
1418 
1419  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1420  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1421  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1422  (dstFilter->chrV && dstFilter->chrV->length > 1);
1423  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1424  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1425  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1426  (dstFilter->chrH && dstFilter->chrH->length > 1);
1427 
1428  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1429  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1430 
1431  c->dst_slice_align = 1 << c->chrDstVSubSample;
1432 
1433  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1434  if (dstW&1) {
1435  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1436  flags |= SWS_FULL_CHR_H_INT;
1437  c->flags = flags;
1438  }
1439 
1440  if ( c->chrSrcHSubSample == 0
1441  && c->chrSrcVSubSample == 0
1442  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1443  && !(c->flags & SWS_FAST_BILINEAR)
1444  ) {
1445  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1446  flags |= SWS_FULL_CHR_H_INT;
1447  c->flags = flags;
1448  }
1449  }
1450 
1451  if (c->dither == SWS_DITHER_AUTO) {
1452  if (flags & SWS_ERROR_DIFFUSION)
1453  c->dither = SWS_DITHER_ED;
1454  }
1455 
1456  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1457  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1458  dstFormat == AV_PIX_FMT_BGR8 ||
1459  dstFormat == AV_PIX_FMT_RGB8) {
1460  if (c->dither == SWS_DITHER_AUTO)
1461  c->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1462  if (!(flags & SWS_FULL_CHR_H_INT)) {
1463  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1464  av_log(c, AV_LOG_DEBUG,
1465  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1466  av_get_pix_fmt_name(dstFormat));
1467  flags |= SWS_FULL_CHR_H_INT;
1468  c->flags = flags;
1469  }
1470  }
1471  if (flags & SWS_FULL_CHR_H_INT) {
1472  if (c->dither == SWS_DITHER_BAYER) {
1473  av_log(c, AV_LOG_DEBUG,
1474  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1475  av_get_pix_fmt_name(dstFormat));
1476  c->dither = SWS_DITHER_ED;
1477  }
1478  }
1479  }
1480  if (isPlanarRGB(dstFormat)) {
1481  if (!(flags & SWS_FULL_CHR_H_INT)) {
1482  av_log(c, AV_LOG_DEBUG,
1483  "%s output is not supported with half chroma resolution, switching to full\n",
1484  av_get_pix_fmt_name(dstFormat));
1485  flags |= SWS_FULL_CHR_H_INT;
1486  c->flags = flags;
1487  }
1488  }
1489 
1490  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1491  * chroma interpolation */
1492  if (flags & SWS_FULL_CHR_H_INT &&
1493  isAnyRGB(dstFormat) &&
1494  !isPlanarRGB(dstFormat) &&
1495  dstFormat != AV_PIX_FMT_RGBA64LE &&
1496  dstFormat != AV_PIX_FMT_RGBA64BE &&
1497  dstFormat != AV_PIX_FMT_BGRA64LE &&
1498  dstFormat != AV_PIX_FMT_BGRA64BE &&
1499  dstFormat != AV_PIX_FMT_RGB48LE &&
1500  dstFormat != AV_PIX_FMT_RGB48BE &&
1501  dstFormat != AV_PIX_FMT_BGR48LE &&
1502  dstFormat != AV_PIX_FMT_BGR48BE &&
1503  dstFormat != AV_PIX_FMT_RGBA &&
1504  dstFormat != AV_PIX_FMT_ARGB &&
1505  dstFormat != AV_PIX_FMT_BGRA &&
1506  dstFormat != AV_PIX_FMT_ABGR &&
1507  dstFormat != AV_PIX_FMT_RGB24 &&
1508  dstFormat != AV_PIX_FMT_BGR24 &&
1509  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1510  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1511  dstFormat != AV_PIX_FMT_BGR8 &&
1512  dstFormat != AV_PIX_FMT_RGB8
1513  ) {
1514  av_log(c, AV_LOG_WARNING,
1515  "full chroma interpolation for destination format '%s' not yet implemented\n",
1516  av_get_pix_fmt_name(dstFormat));
1517  flags &= ~SWS_FULL_CHR_H_INT;
1518  c->flags = flags;
1519  }
1520  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1521  c->chrDstHSubSample = 1;
1522 
1523  // drop some chroma lines if the user wants it
1524  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1525  SWS_SRC_V_CHR_DROP_SHIFT;
1526  c->chrSrcVSubSample += c->vChrDrop;
1527 
1528  /* drop every other pixel for chroma calculation unless user
1529  * wants full chroma */
1530  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1531  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1532  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1533  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1534  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1535  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1536  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1537  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1538  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1539  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1540  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1541  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1542  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1543  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1544  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1545  (flags & SWS_FAST_BILINEAR)))
1546  c->chrSrcHSubSample = 1;
1547 
1548  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1549  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1550  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1551  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1552  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1553 
1554  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1555  goto nomem;
1556 
1557  c->frame_src = av_frame_alloc();
1558  c->frame_dst = av_frame_alloc();
1559  if (!c->frame_src || !c->frame_dst)
1560  goto nomem;
1561 
1562  c->srcBpc = desc_src->comp[0].depth;
1563  if (c->srcBpc < 8)
1564  c->srcBpc = 8;
1565  c->dstBpc = desc_dst->comp[0].depth;
1566  if (c->dstBpc < 8)
1567  c->dstBpc = 8;
1568  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1569  c->srcBpc = 16;
1570  if (c->dstBpc == 16)
1571  dst_stride <<= 1;
1572 
1573  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1574  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1575  c->chrDstW >= c->chrSrcW &&
1576  (srcW & 15) == 0;
1577  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1578 
1579  && (flags & SWS_FAST_BILINEAR)) {
1580  if (flags & SWS_PRINT_INFO)
1581  av_log(c, AV_LOG_INFO,
1582  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1583  }
1584  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1585  c->canMMXEXTBeUsed = 0;
1586  } else
1587  c->canMMXEXTBeUsed = 0;
1588 
1589  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1590  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1591 
1592  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1593  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1594  * correct scaling.
1595  * n-2 is the last chrominance sample available.
1596  * This is not perfect, but no one should notice the difference, the more
1597  * correct variant would be like the vertical one, but that would require
1598  * some special code for the first and last pixel */
1599  if (flags & SWS_FAST_BILINEAR) {
1600  if (c->canMMXEXTBeUsed) {
1601  c->lumXInc += 20;
1602  c->chrXInc += 20;
1603  }
1604  // we don't use the x86 asm scaler if MMX is available
1605  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1606  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1607  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1608  }
1609  }
1610 
1611  // hardcoded for now
1612  c->gamma_value = 2.2;
1613  tmpFmt = AV_PIX_FMT_RGBA64LE;
1614 
1615 
1616  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1617  SwsContext *c2;
1618  c->cascaded_context[0] = NULL;
1619 
1620  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1621  srcW, srcH, tmpFmt, 64);
1622  if (ret < 0)
1623  return ret;
1624 
1625  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1626  srcW, srcH, tmpFmt,
1627  flags, NULL, NULL, c->param);
1628  if (!c->cascaded_context[0]) {
1629  return AVERROR(ENOMEM);
1630  }
1631 
1632  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1633  dstW, dstH, tmpFmt,
1634  flags, srcFilter, dstFilter, c->param);
1635 
1636  if (!c->cascaded_context[1])
1637  return AVERROR(ENOMEM);
1638 
1639  c2 = c->cascaded_context[1];
1640  c2->is_internal_gamma = 1;
1641  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1642  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1643  if (!c2->gamma || !c2->inv_gamma)
1644  return AVERROR(ENOMEM);
1645 
1646  // is_internal_flag is set after creating the context
1647  // to properly create the gamma convert FilterDescriptor
1648  // we have to re-initialize it
1649  ff_free_filters(c2);
1650  if ((ret = ff_init_filters(c2)) < 0) {
1651  sws_freeContext(c2);
1652  c->cascaded_context[1] = NULL;
1653  return ret;
1654  }
1655 
1656  c->cascaded_context[2] = NULL;
1657  if (dstFormat != tmpFmt) {
1658  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1659  dstW, dstH, tmpFmt, 64);
1660  if (ret < 0)
1661  return ret;
1662 
1663  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1664  dstW, dstH, dstFormat,
1665  flags, NULL, NULL, c->param);
1666  if (!c->cascaded_context[2])
1667  return AVERROR(ENOMEM);
1668  }
1669  return 0;
1670  }
1671 
1672  if (isBayer(srcFormat)) {
1673  if (!unscaled ||
1674  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1675  dstFormat != AV_PIX_FMT_RGB48)) {
1676  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1677 
1678  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1679  srcW, srcH, tmpFormat, 64);
1680  if (ret < 0)
1681  return ret;
1682 
1683  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1684  srcW, srcH, tmpFormat,
1685  flags, srcFilter, NULL, c->param);
1686  if (!c->cascaded_context[0])
1687  return AVERROR(ENOMEM);
1688 
1689  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1690  dstW, dstH, dstFormat,
1691  flags, NULL, dstFilter, c->param);
1692  if (!c->cascaded_context[1])
1693  return AVERROR(ENOMEM);
1694  return 0;
1695  }
1696  }
1697 
1698  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1699  for (i = 0; i < 256; ++i){
1700  c->uint2float_lut[i] = (float)i * float_mult;
1701  }
1702  }
1703 
1704  // float will be converted to uint16_t
1705  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1706  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1707  dstFormat != AV_PIX_FMT_GRAY8))){
1708  c->srcBpc = 16;
1709  }
1710 
1711  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1712  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1713 
1714  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1715  if (!unscaled ||
1716  dstFormat != tmpFormat ||
1717  usesHFilter || usesVFilter ||
1718  c->srcRange != c->dstRange
1719  ) {
1720  c->cascaded_mainindex = 1;
1721  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1722  srcW, srcH, tmpFormat, 64);
1723  if (ret < 0)
1724  return ret;
1725 
1726  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
1727  srcW, srcH, tmpFormat,
1728  flags, c->param);
1729  if (!c->cascaded_context[0])
1730  return AVERROR(EINVAL);
1731  c->cascaded_context[0]->alphablend = c->alphablend;
1732  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1733  if (ret < 0)
1734  return ret;
1735 
1736  c->cascaded_context[1] = sws_alloc_set_opts(srcW, srcH, tmpFormat,
1737  dstW, dstH, dstFormat,
1738  flags, c->param);
1739  if (!c->cascaded_context[1])
1740  return AVERROR(EINVAL);
1741 
1742  c->cascaded_context[1]->srcRange = c->srcRange;
1743  c->cascaded_context[1]->dstRange = c->dstRange;
1744  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1745  if (ret < 0)
1746  return ret;
1747 
1748  return 0;
1749  }
1750  }
1751  }
1752 
1753 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1754 #define USE_MMAP 1
1755 #else
1756 #define USE_MMAP 0
1757 #endif
1758 
1759  /* precalculate horizontal scaler filter coefficients */
1760  {
1761 #if HAVE_MMXEXT_INLINE
1762 // can't downscale !!!
1763  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1764  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1765  NULL, NULL, 8);
1766  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1767  NULL, NULL, NULL, 4);
1768 
1769 #if USE_MMAP
1770  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1771  PROT_READ | PROT_WRITE,
1772  MAP_PRIVATE | MAP_ANONYMOUS,
1773  -1, 0);
1774  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1775  PROT_READ | PROT_WRITE,
1776  MAP_PRIVATE | MAP_ANONYMOUS,
1777  -1, 0);
1778 #elif HAVE_VIRTUALALLOC
1779  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1780  c->lumMmxextFilterCodeSize,
1781  MEM_COMMIT,
1782  PAGE_EXECUTE_READWRITE);
1783  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1784  c->chrMmxextFilterCodeSize,
1785  MEM_COMMIT,
1786  PAGE_EXECUTE_READWRITE);
1787 #else
1788  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1789  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1790 #endif
1791 
1792 #ifdef MAP_ANONYMOUS
1793  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1794 #else
1795  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1796 #endif
1797  {
1798  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1799  return AVERROR(ENOMEM);
1800  }
1801 
1802  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1803  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1804  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1805  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1806  goto nomem;
1807 
1808  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1809  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1810  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1811  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1812 
1813 #if USE_MMAP
1814  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1815  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1816  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1817  ret = AVERROR(EINVAL);
1818  goto fail;
1819  }
1820 #endif
1821  } else
1822 #endif /* HAVE_MMXEXT_INLINE */
1823  {
1824  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1825  PPC_ALTIVEC(cpu_flags) ? 8 :
1826  have_neon(cpu_flags) ? 4 : 1;
1827 
1828  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1829  &c->hLumFilterSize, c->lumXInc,
1830  srcW, dstW, filterAlign, 1 << 14,
1831  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1832  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1833  c->param,
1834  get_local_pos(c, 0, 0, 0),
1835  get_local_pos(c, 0, 0, 0))) < 0)
1836  goto fail;
1837  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1838  goto nomem;
1839  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1840  &c->hChrFilterSize, c->chrXInc,
1841  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1842  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1843  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1844  c->param,
1845  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1846  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1847  goto fail;
1848  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1849  goto nomem;
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:809
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:87
A
#define A(x)
Definition: vpx_arith.h:28
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:2771
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:289
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
Definition: yuv2rgb.c:774
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_PIX_FMT_BAYER_GBRG16LE
@ AV_PIX_FMT_BAYER_GBRG16LE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:258
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:139
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:870
cpu.h
AV_PIX_FMT_P416BE
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
Definition: pixfmt.h:367
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:79
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:513
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:1459
libm.h
fill_xyztables
static void fill_xyztables(struct SwsContext *c)
Definition: utils.c:862
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale_internal.h:71
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:2675
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:93
MAX_FILTER_SIZE
#define MAX_FILTER_SIZE
Definition: af_dynaudnorm.c:34
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale_internal.h:73
EXTERNAL_AVX2_FAST
#define EXTERNAL_AVX2_FAST(flags)
Definition: cpu.h:79
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
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:445
alphaless_fmt
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
Definition: utils.c:1182
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:1122
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:270
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:313
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:442
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:310
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
b
#define b
Definition: input.c:34
table
static const uint16_t table[]
Definition: prosumer.c:206
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:446
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:277
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:447
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:408
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:2627
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:101
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
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:52
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:290
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:333
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:30
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:271
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:280
SWS_FAST_BILINEAR
#define SWS_FAST_BILINEAR
Definition: swscale.h:65
handle_jpeg
static int handle_jpeg(enum AVPixelFormat *format)
Definition: utils.c:1084
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:694
FormatEntry
Definition: utils.c:68
SWS_BITEXACT
#define SWS_BITEXACT
Definition: swscale.h:91
SWS_BICUBLIN
#define SWS_BICUBLIN
Definition: swscale.h:71
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:238
fail
#define fail()
Definition: checkasm.h:131
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:464
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:424
Range::len
unsigned int len
Definition: swscale_internal.h:87
ONE
@ ONE
Definition: vc1_parser.c:47
ub
#define ub(width, name)
Definition: cbs_h2645.c:264
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:406
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:308
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:2703
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:708
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:392
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:69
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:58
AV_PIX_FMT_VUYA
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4, 32bpp, VUYAVUYA...
Definition: pixfmt.h:370
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:104
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:411
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:71
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:179
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:368
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:330
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:420
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:72
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:94
float
float
Definition: af_crystalizer.c:122
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:505
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:256
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:368
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:421
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
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:359
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
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:88
SwsVector::length
int length
number of coefficients in the vector
Definition: swscale.h:118
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:293
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:339
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:405
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:419
scale_algorithms
static const ScaleAlgorithm scale_algorithms[]
Definition: utils.c:354
ScaleAlgorithm::flag
int flag
flag associated to the algorithm
Definition: utils.c:349
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:74
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:440
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:440
NAN
#define NAN
Definition: mathematics.h:64
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:329
W
@ W
Definition: vf_addroi.c:26
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:64
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:532
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:1168
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:427
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:69
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:177
SWS_SRC_V_CHR_DROP_SHIFT
#define SWS_SRC_V_CHR_DROP_SHIFT
Definition: swscale.h:78
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:312
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:279
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:399
NULL
#define NULL
Definition: coverity.c:32
SWS_SINC
#define SWS_SINC
Definition: swscale.h:73
RETCODE_USE_CASCADE
#define RETCODE_USE_CASCADE
Definition: swscale_internal.h:64
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:358
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:336
RangeList
Definition: swscale_internal.h:90
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:48
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:337
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:92
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1152
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:351
fill_rgb2yuv_table
static void fill_rgb2yuv_table(SwsContext *c, const int table[4], int dstRange)
Definition: utils.c:768
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:409
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:267
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:978
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:117
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:1142
range_override_needed
static int range_override_needed(enum AVPixelFormat format)
Definition: utils.c:898
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:903
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:88
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:176
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Definition: swscale_internal.h:463
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:624
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
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:353
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: swscale.h:80
SWS_X
#define SWS_X
Definition: swscale.h:68
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:1214
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:126
f
f
Definition: af_crystalizer.c:122
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:439
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:269
ff_sws_init_scale
void ff_sws_init_scale(SwsContext *c)
Definition: swscale.c:589
PPC_ALTIVEC
#define PPC_ALTIVEC(flags)
Definition: cpu.h:25
SwsVector
Definition: swscale.h:116
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:823
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
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SWS_FULL_CHR_H_INT
#define SWS_FULL_CHR_H_INT
Definition: swscale.h:86
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:394
AV_PIX_FMT_GRAY12LE
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:288
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:401
SwsContext::srcH
int srcH
Height of source luma/alpha planes.
Definition: swscale_internal.h:321
asm.h
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:722
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:160
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:148
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:191
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:122
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:72
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:283
SwsFilter::lumV
SwsVector * lumV
Definition: swscale.h:124
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
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:308
SWS_ACCURATE_RND
#define SWS_ACCURATE_RND
Definition: swscale.h:90
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:362
SWS_SPLINE
#define SWS_SPLINE
Definition: swscale.h:75
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:441
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:1133
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:338
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:403
SwsContext::srcW
int srcW
Width of source luma/alpha planes.
Definition: swscale_internal.h:320
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:320
DITHER1XBPP
#define DITHER1XBPP
Definition: swscale_internal.h:46
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:1240
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:269
FormatEntry::is_supported_in
uint8_t is_supported_in
Definition: utils.c:69
SWS_LANCZOS
#define SWS_LANCZOS
Definition: swscale.h:74
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:425
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GRAY9BE
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:307
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:340
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:326
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:314
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:264
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:400
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:311
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:341
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:407
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:831
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:91
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:102
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:287
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
XYZ_GAMMA
#define XYZ_GAMMA
Definition: swscale_internal.h:544
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:361
verbose
int verbose
Definition: checkasm.c:292
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:292
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:332
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:1060
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:1294
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:70
sws_freeContext
void sws_freeContext(SwsContext *c)
Free the swscaler context swsContext.
Definition: utils.c:2383
ScaleAlgorithm
Definition: utils.c:348
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
ff_shuffle_filter_coefficients
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
Definition: utils.c:264
RGB_GAMMA
#define RGB_GAMMA
Definition: swscale_internal.h:545
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, little-endian
Definition: pixfmt.h:365
ScaleAlgorithm::description
const char * description
human-readable description
Definition: utils.c:350
INLINE_MMXEXT
#define INLINE_MMXEXT(flags)
Definition: cpu.h:88
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:88
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:82
DITHER32_INT
#define DITHER32_INT
Definition: swscale_internal.h:497
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
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:355
isBayer16BPS
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:816
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:276
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:444
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:351
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1885
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AV_PIX_FMT_P216BE
@ AV_PIX_FMT_P216BE
interleaved chroma YUV 4:2:2, 32bpp, big-endian
Definition: pixfmt.h:364
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:330
SwsFilter::lumH
SwsVector * lumH
Definition: swscale.h:123
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:70
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:329
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:268
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:155
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:252
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:27
SwsContext::src_h_chr_pos
int src_h_chr_pos
Definition: swscale_internal.h:462
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:282
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:443
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:66
cpu.h
INLINE_AMD3DNOW
#define INLINE_AMD3DNOW(flags)
Definition: cpu.h:85
SwsContext::dst_v_chr_pos
int dst_v_chr_pos
Definition: swscale_internal.h:465
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:335
SWS_AREA
#define SWS_AREA
Definition: swscale.h:70
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale_internal.h:74
int
int
Definition: ffmpeg_filter.c:155
SwsContext
Definition: swscale_internal.h:298
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:125
SWS_SRC_V_CHR_DROP_MASK
#define SWS_SRC_V_CHR_DROP_MASK
Definition: swscale.h:77
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:322
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:61
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:67
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
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:2595
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:92
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:341
Generated on Tue Aug 9 2022 19:21:16 for FFmpeg by   doxygen 1.8.17