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