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