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