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