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