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