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