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