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