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_LOONGARCH64
1084  ff_sws_init_range_convert_loongarch(c);
1085 #endif
1086  }
1087 
1088  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1089  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1090 
1091  if (c->cascaded_context[c->cascaded_mainindex])
1092  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
1093 
1094  if (!need_reinit)
1095  return 0;
1096 
1097  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
1098  if (!c->cascaded_context[0] &&
1099  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
1100  c->srcW && c->srcH && c->dstW && c->dstH) {
1101  enum AVPixelFormat tmp_format;
1102  int tmp_width, tmp_height;
1103  int srcW = c->srcW;
1104  int srcH = c->srcH;
1105  int dstW = c->dstW;
1106  int dstH = c->dstH;
1107  int ret;
1108  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
1109 
1110  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
1111  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1112  tmp_format = AV_PIX_FMT_BGRA64;
1113  } else {
1114  tmp_format = AV_PIX_FMT_BGR48;
1115  }
1116  } else {
1117  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1118  tmp_format = AV_PIX_FMT_BGRA;
1119  } else {
1120  tmp_format = AV_PIX_FMT_BGR24;
1121  }
1122  }
1123 
1124  if (srcW*srcH > dstW*dstH) {
1125  tmp_width = dstW;
1126  tmp_height = dstH;
1127  } else {
1128  tmp_width = srcW;
1129  tmp_height = srcH;
1130  }
1131 
1132  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1133  tmp_width, tmp_height, tmp_format, 64);
1134  if (ret < 0)
1135  return ret;
1136 
1137  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, c->srcFormat,
1138  tmp_width, tmp_height, tmp_format,
1139  c->flags, c->param);
1140  if (!c->cascaded_context[0])
1141  return -1;
1142 
1143  c->cascaded_context[0]->alphablend = c->alphablend;
1144  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1145  if (ret < 0)
1146  return ret;
1147  //we set both src and dst depending on that the RGB side will be ignored
1148  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
1149  srcRange, table, dstRange,
1150  brightness, contrast, saturation);
1151 
1152  c->cascaded_context[1] = alloc_set_opts(tmp_width, tmp_height, tmp_format,
1153  dstW, dstH, c->dstFormat,
1154  c->flags, c->param);
1155  if (!c->cascaded_context[1])
1156  return -1;
1157  c->cascaded_context[1]->srcRange = srcRange;
1158  c->cascaded_context[1]->dstRange = dstRange;
1159  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1160  if (ret < 0)
1161  return ret;
1162  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
1163  srcRange, table, dstRange,
1164  0, 1 << 16, 1 << 16);
1165  return 0;
1166  }
1167  //We do not support this combination currently, we need to cascade more contexts to compensate
1168  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
1169  return -1; //AVERROR_PATCHWELCOME;
1170  return 0;
1171  }
1172 
1173  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1174  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1175  contrast, saturation);
1176  // FIXME factorize
1177 
1178 #if ARCH_PPC
1179  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1180  contrast, saturation);
1181 #endif
1182  }
1183 
1184  fill_rgb2yuv_table(c, table, dstRange);
1185 
1186  return 0;
1187 }
1188 
1189 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1190  int *srcRange, int **table, int *dstRange,
1191  int *brightness, int *contrast, int *saturation)
1192 {
1193  if (!c )
1194  return -1;
1195 
1196  if (c->nb_slice_ctx) {
1197  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1198  table, dstRange, brightness, contrast,
1199  saturation);
1200  }
1201 
1202  *inv_table = c->srcColorspaceTable;
1203  *table = c->dstColorspaceTable;
1204  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1205  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1206  *brightness = c->brightness;
1207  *contrast = c->contrast;
1208  *saturation = c->saturation;
1209 
1210  return 0;
1211 }
1212 
1213 SwsContext *sws_alloc_context(void)
1214 {
1215  SwsContext *c = av_mallocz(sizeof(SwsContext));
1216 
1217  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1218 
1219  if (c) {
1220  c->av_class = &ff_sws_context_class;
1221  av_opt_set_defaults(c);
1222  atomic_init(&c->stride_unaligned_warned, 0);
1223  atomic_init(&c->data_unaligned_warned, 0);
1224  }
1225 
1226  return c;
1227 }
1228 
1229 static uint16_t * alloc_gamma_tbl(double e)
1230 {
1231  int i = 0;
1232  uint16_t * tbl;
1233  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1234  if (!tbl)
1235  return NULL;
1236 
1237  for (i = 0; i < 65536; ++i) {
1238  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1239  }
1240  return tbl;
1241 }
1242 
1243 static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
1244 {
1245  switch(fmt) {
1246  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1247  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1248  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1249  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1250  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1251 
1252  case AV_PIX_FMT_YUVA420P: return AV_PIX_FMT_YUV420P;
1253  case AV_PIX_FMT_YUVA422P: return AV_PIX_FMT_YUV422P;
1254  case AV_PIX_FMT_YUVA444P: return AV_PIX_FMT_YUV444P;
1255 
1256  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1257 
1258  case AV_PIX_FMT_GBRAP10LE: return AV_PIX_FMT_GBRP10;
1259  case AV_PIX_FMT_GBRAP10BE: return AV_PIX_FMT_GBRP10;
1260 
1261  case AV_PIX_FMT_GBRAP12LE: return AV_PIX_FMT_GBRP12;
1262  case AV_PIX_FMT_GBRAP12BE: return AV_PIX_FMT_GBRP12;
1263 
1264  case AV_PIX_FMT_GBRAP14LE: return AV_PIX_FMT_GBRP14;
1265  case AV_PIX_FMT_GBRAP14BE: return AV_PIX_FMT_GBRP14;
1266 
1267  case AV_PIX_FMT_GBRAP16LE: return AV_PIX_FMT_GBRP16;
1268  case AV_PIX_FMT_GBRAP16BE: return AV_PIX_FMT_GBRP16;
1269 
1270  case AV_PIX_FMT_RGBA64LE: return AV_PIX_FMT_RGB48;
1271  case AV_PIX_FMT_RGBA64BE: return AV_PIX_FMT_RGB48;
1272  case AV_PIX_FMT_BGRA64LE: return AV_PIX_FMT_BGR48;
1273  case AV_PIX_FMT_BGRA64BE: return AV_PIX_FMT_BGR48;
1274 
1275  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1276  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1277 
1278  case AV_PIX_FMT_YUVA420P9BE: return AV_PIX_FMT_YUV420P9;
1279  case AV_PIX_FMT_YUVA422P9BE: return AV_PIX_FMT_YUV422P9;
1280  case AV_PIX_FMT_YUVA444P9BE: return AV_PIX_FMT_YUV444P9;
1281  case AV_PIX_FMT_YUVA420P9LE: return AV_PIX_FMT_YUV420P9;
1282  case AV_PIX_FMT_YUVA422P9LE: return AV_PIX_FMT_YUV422P9;
1283  case AV_PIX_FMT_YUVA444P9LE: return AV_PIX_FMT_YUV444P9;
1284  case AV_PIX_FMT_YUVA420P10BE: return AV_PIX_FMT_YUV420P10;
1285  case AV_PIX_FMT_YUVA422P10BE: return AV_PIX_FMT_YUV422P10;
1286  case AV_PIX_FMT_YUVA444P10BE: return AV_PIX_FMT_YUV444P10;
1287  case AV_PIX_FMT_YUVA420P10LE: return AV_PIX_FMT_YUV420P10;
1288  case AV_PIX_FMT_YUVA422P10LE: return AV_PIX_FMT_YUV422P10;
1289  case AV_PIX_FMT_YUVA444P10LE: return AV_PIX_FMT_YUV444P10;
1290  case AV_PIX_FMT_YUVA420P16BE: return AV_PIX_FMT_YUV420P16;
1291  case AV_PIX_FMT_YUVA422P16BE: return AV_PIX_FMT_YUV422P16;
1292  case AV_PIX_FMT_YUVA444P16BE: return AV_PIX_FMT_YUV444P16;
1293  case AV_PIX_FMT_YUVA420P16LE: return AV_PIX_FMT_YUV420P16;
1294  case AV_PIX_FMT_YUVA422P16LE: return AV_PIX_FMT_YUV422P16;
1295  case AV_PIX_FMT_YUVA444P16LE: return AV_PIX_FMT_YUV444P16;
1296 
1297 // case AV_PIX_FMT_AYUV64LE:
1298 // case AV_PIX_FMT_AYUV64BE:
1299 // case AV_PIX_FMT_PAL8:
1300  default: return AV_PIX_FMT_NONE;
1301  }
1302 }
1303 
1304 static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter,
1305  SwsFilter *dstFilter);
1306 
1307 static av_cold int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter,
1308  SwsFilter *dstFilter)
1309 {
1310  int i;
1311  int usesVFilter, usesHFilter;
1312  int unscaled;
1313  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1314  int srcW = c->srcW;
1315  int srcH = c->srcH;
1316  int dstW = c->dstW;
1317  int dstH = c->dstH;
1318  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1319  int flags, cpu_flags;
1320  enum AVPixelFormat srcFormat, dstFormat;
1321  const AVPixFmtDescriptor *desc_src;
1322  const AVPixFmtDescriptor *desc_dst;
1323  int ret = 0;
1324  enum AVPixelFormat tmpFmt;
1325  static const float float_mult = 1.0f / 255.0f;
1326 
1327  cpu_flags = av_get_cpu_flags();
1328  flags = c->flags;
1329  emms_c();
1330 
1331  unscaled = (srcW == dstW && srcH == dstH);
1332 
1333  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1334  sws_setColorspaceDetails(c, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->srcRange,
1335  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1336  c->dstRange, 0, 1 << 16, 1 << 16);
1337 
1338  handle_formats(c);
1339  srcFormat = c->srcFormat;
1340  dstFormat = c->dstFormat;
1341  desc_src = av_pix_fmt_desc_get(srcFormat);
1342  desc_dst = av_pix_fmt_desc_get(dstFormat);
1343 
1344  // If the source has no alpha then disable alpha blendaway
1345  if (c->src0Alpha)
1346  c->alphablend = SWS_ALPHA_BLEND_NONE;
1347 
1348  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1349  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1350  if (!sws_isSupportedInput(srcFormat)) {
1351  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1352  av_get_pix_fmt_name(srcFormat));
1353  return AVERROR(EINVAL);
1354  }
1355  if (!sws_isSupportedOutput(dstFormat)) {
1356  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1357  av_get_pix_fmt_name(dstFormat));
1358  return AVERROR(EINVAL);
1359  }
1360  }
1361  av_assert2(desc_src && desc_dst);
1362 
1363  i = flags & (SWS_POINT |
1364  SWS_AREA |
1365  SWS_BILINEAR |
1366  SWS_FAST_BILINEAR |
1367  SWS_BICUBIC |
1368  SWS_X |
1369  SWS_GAUSS |
1370  SWS_LANCZOS |
1371  SWS_SINC |
1372  SWS_SPLINE |
1373  SWS_BICUBLIN);
1374 
1375  /* provide a default scaler if not set by caller */
1376  if (!i) {
1377  if (dstW < srcW && dstH < srcH)
1378  flags |= SWS_BICUBIC;
1379  else if (dstW > srcW && dstH > srcH)
1380  flags |= SWS_BICUBIC;
1381  else
1382  flags |= SWS_BICUBIC;
1383  c->flags = flags;
1384  } else if (i & (i - 1)) {
1385  av_log(c, AV_LOG_ERROR,
1386  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1387  return AVERROR(EINVAL);
1388  }
1389  /* sanity check */
1390  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1391  /* FIXME check if these are enough and try to lower them after
1392  * fixing the relevant parts of the code */
1393  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1394  srcW, srcH, dstW, dstH);
1395  return AVERROR(EINVAL);
1396  }
1397  if (flags & SWS_FAST_BILINEAR) {
1398  if (srcW < 8 || dstW < 8) {
1399  flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR;
1400  c->flags = flags;
1401  }
1402  }
1403 
1404  if (!dstFilter)
1405  dstFilter = &dummyFilter;
1406  if (!srcFilter)
1407  srcFilter = &dummyFilter;
1408 
1409  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1410  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1411  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1412  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1413  c->vRounder = 4 * 0x0001000100010001ULL;
1414 
1415  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1416  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1417  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1418  (dstFilter->chrV && dstFilter->chrV->length > 1);
1419  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1420  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1421  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1422  (dstFilter->chrH && dstFilter->chrH->length > 1);
1423 
1424  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1425  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1426 
1427  c->dst_slice_align = 1 << c->chrDstVSubSample;
1428 
1429  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1430  if (dstW&1) {
1431  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1432  flags |= SWS_FULL_CHR_H_INT;
1433  c->flags = flags;
1434  }
1435 
1436  if ( c->chrSrcHSubSample == 0
1437  && c->chrSrcVSubSample == 0
1438  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1439  && !(c->flags & SWS_FAST_BILINEAR)
1440  ) {
1441  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1442  flags |= SWS_FULL_CHR_H_INT;
1443  c->flags = flags;
1444  }
1445  }
1446 
1447  if (c->dither == SWS_DITHER_AUTO) {
1448  if (flags & SWS_ERROR_DIFFUSION)
1449  c->dither = SWS_DITHER_ED;
1450  }
1451 
1452  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1453  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1454  dstFormat == AV_PIX_FMT_BGR8 ||
1455  dstFormat == AV_PIX_FMT_RGB8) {
1456  if (c->dither == SWS_DITHER_AUTO)
1457  c->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1458  if (!(flags & SWS_FULL_CHR_H_INT)) {
1459  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1460  av_log(c, AV_LOG_DEBUG,
1461  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1462  av_get_pix_fmt_name(dstFormat));
1463  flags |= SWS_FULL_CHR_H_INT;
1464  c->flags = flags;
1465  }
1466  }
1467  if (flags & SWS_FULL_CHR_H_INT) {
1468  if (c->dither == SWS_DITHER_BAYER) {
1469  av_log(c, AV_LOG_DEBUG,
1470  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1471  av_get_pix_fmt_name(dstFormat));
1472  c->dither = SWS_DITHER_ED;
1473  }
1474  }
1475  }
1476  if (isPlanarRGB(dstFormat)) {
1477  if (!(flags & SWS_FULL_CHR_H_INT)) {
1478  av_log(c, AV_LOG_DEBUG,
1479  "%s output is not supported with half chroma resolution, switching to full\n",
1480  av_get_pix_fmt_name(dstFormat));
1481  flags |= SWS_FULL_CHR_H_INT;
1482  c->flags = flags;
1483  }
1484  }
1485 
1486  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1487  * chroma interpolation */
1488  if (flags & SWS_FULL_CHR_H_INT &&
1489  isAnyRGB(dstFormat) &&
1490  !isPlanarRGB(dstFormat) &&
1491  dstFormat != AV_PIX_FMT_RGBA64LE &&
1492  dstFormat != AV_PIX_FMT_RGBA64BE &&
1493  dstFormat != AV_PIX_FMT_BGRA64LE &&
1494  dstFormat != AV_PIX_FMT_BGRA64BE &&
1495  dstFormat != AV_PIX_FMT_RGB48LE &&
1496  dstFormat != AV_PIX_FMT_RGB48BE &&
1497  dstFormat != AV_PIX_FMT_BGR48LE &&
1498  dstFormat != AV_PIX_FMT_BGR48BE &&
1499  dstFormat != AV_PIX_FMT_RGBA &&
1500  dstFormat != AV_PIX_FMT_ARGB &&
1501  dstFormat != AV_PIX_FMT_BGRA &&
1502  dstFormat != AV_PIX_FMT_ABGR &&
1503  dstFormat != AV_PIX_FMT_RGB24 &&
1504  dstFormat != AV_PIX_FMT_BGR24 &&
1505  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1506  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1507  dstFormat != AV_PIX_FMT_BGR8 &&
1508  dstFormat != AV_PIX_FMT_RGB8
1509  ) {
1510  av_log(c, AV_LOG_WARNING,
1511  "full chroma interpolation for destination format '%s' not yet implemented\n",
1512  av_get_pix_fmt_name(dstFormat));
1513  flags &= ~SWS_FULL_CHR_H_INT;
1514  c->flags = flags;
1515  }
1516  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1517  c->chrDstHSubSample = 1;
1518 
1519  // drop some chroma lines if the user wants it
1520  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1521  SWS_SRC_V_CHR_DROP_SHIFT;
1522  c->chrSrcVSubSample += c->vChrDrop;
1523 
1524  /* drop every other pixel for chroma calculation unless user
1525  * wants full chroma */
1526  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1527  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1528  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1529  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1530  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1531  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1532  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1533  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1534  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1535  srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE &&
1536  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1537  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1538  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1539  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1540  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1541  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1542  (flags & SWS_FAST_BILINEAR)))
1543  c->chrSrcHSubSample = 1;
1544 
1545  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1546  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1547  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1548  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1549  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1550 
1551  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1552  goto nomem;
1553 
1554  c->srcBpc = desc_src->comp[0].depth;
1555  if (c->srcBpc < 8)
1556  c->srcBpc = 8;
1557  c->dstBpc = desc_dst->comp[0].depth;
1558  if (c->dstBpc < 8)
1559  c->dstBpc = 8;
1560  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1561  c->srcBpc = 16;
1562  if (c->dstBpc == 16)
1563  dst_stride <<= 1;
1564 
1565  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1566  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1567  c->chrDstW >= c->chrSrcW &&
1568  (srcW & 15) == 0;
1569  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1570 
1571  && (flags & SWS_FAST_BILINEAR)) {
1572  if (flags & SWS_PRINT_INFO)
1573  av_log(c, AV_LOG_INFO,
1574  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1575  }
1576  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1577  c->canMMXEXTBeUsed = 0;
1578  } else
1579  c->canMMXEXTBeUsed = 0;
1580 
1581  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1582  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1583 
1584  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1585  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1586  * correct scaling.
1587  * n-2 is the last chrominance sample available.
1588  * This is not perfect, but no one should notice the difference, the more
1589  * correct variant would be like the vertical one, but that would require
1590  * some special code for the first and last pixel */
1591  if (flags & SWS_FAST_BILINEAR) {
1592  if (c->canMMXEXTBeUsed) {
1593  c->lumXInc += 20;
1594  c->chrXInc += 20;
1595  }
1596  // we don't use the x86 asm scaler if MMX is available
1597  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1598  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1599  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1600  }
1601  }
1602 
1603  // hardcoded for now
1604  c->gamma_value = 2.2;
1605  tmpFmt = AV_PIX_FMT_RGBA64LE;
1606 
1607 
1608  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1609  SwsContext *c2;
1610  c->cascaded_context[0] = NULL;
1611 
1612  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1613  srcW, srcH, tmpFmt, 64);
1614  if (ret < 0)
1615  return ret;
1616 
1617  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1618  srcW, srcH, tmpFmt,
1619  flags, NULL, NULL, c->param);
1620  if (!c->cascaded_context[0]) {
1621  return AVERROR(ENOMEM);
1622  }
1623 
1624  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1625  dstW, dstH, tmpFmt,
1626  flags, srcFilter, dstFilter, c->param);
1627 
1628  if (!c->cascaded_context[1])
1629  return AVERROR(ENOMEM);
1630 
1631  c2 = c->cascaded_context[1];
1632  c2->is_internal_gamma = 1;
1633  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1634  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1635  if (!c2->gamma || !c2->inv_gamma)
1636  return AVERROR(ENOMEM);
1637 
1638  // is_internal_flag is set after creating the context
1639  // to properly create the gamma convert FilterDescriptor
1640  // we have to re-initialize it
1641  ff_free_filters(c2);
1642  if ((ret = ff_init_filters(c2)) < 0) {
1643  sws_freeContext(c2);
1644  c->cascaded_context[1] = NULL;
1645  return ret;
1646  }
1647 
1648  c->cascaded_context[2] = NULL;
1649  if (dstFormat != tmpFmt) {
1650  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1651  dstW, dstH, tmpFmt, 64);
1652  if (ret < 0)
1653  return ret;
1654 
1655  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1656  dstW, dstH, dstFormat,
1657  flags, NULL, NULL, c->param);
1658  if (!c->cascaded_context[2])
1659  return AVERROR(ENOMEM);
1660  }
1661  return 0;
1662  }
1663 
1664  if (isBayer(srcFormat)) {
1665  if (!unscaled ||
1666  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1667  dstFormat != AV_PIX_FMT_RGB48)) {
1668  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1669 
1670  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1671  srcW, srcH, tmpFormat, 64);
1672  if (ret < 0)
1673  return ret;
1674 
1675  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1676  srcW, srcH, tmpFormat,
1677  flags, srcFilter, NULL, c->param);
1678  if (!c->cascaded_context[0])
1679  return AVERROR(ENOMEM);
1680 
1681  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1682  dstW, dstH, dstFormat,
1683  flags, NULL, dstFilter, c->param);
1684  if (!c->cascaded_context[1])
1685  return AVERROR(ENOMEM);
1686  return 0;
1687  }
1688  }
1689 
1690  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1691  for (i = 0; i < 256; ++i){
1692  c->uint2float_lut[i] = (float)i * float_mult;
1693  }
1694  }
1695 
1696  // float will be converted to uint16_t
1697  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1698  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1699  dstFormat != AV_PIX_FMT_GRAY8))){
1700  c->srcBpc = 16;
1701  }
1702 
1703  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1704  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1705 
1706  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1707  if (!unscaled ||
1708  dstFormat != tmpFormat ||
1709  usesHFilter || usesVFilter ||
1710  c->srcRange != c->dstRange
1711  ) {
1712  c->cascaded_mainindex = 1;
1713  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1714  srcW, srcH, tmpFormat, 64);
1715  if (ret < 0)
1716  return ret;
1717 
1718  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1719  srcW, srcH, tmpFormat,
1720  flags, c->param);
1721  if (!c->cascaded_context[0])
1722  return AVERROR(EINVAL);
1723  c->cascaded_context[0]->alphablend = c->alphablend;
1724  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1725  if (ret < 0)
1726  return ret;
1727 
1728  c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1729  dstW, dstH, dstFormat,
1730  flags, c->param);
1731  if (!c->cascaded_context[1])
1732  return AVERROR(EINVAL);
1733 
1734  c->cascaded_context[1]->srcRange = c->srcRange;
1735  c->cascaded_context[1]->dstRange = c->dstRange;
1736  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1737  if (ret < 0)
1738  return ret;
1739 
1740  return 0;
1741  }
1742  }
1743  }
1744 
1745  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1746  if (unscaled && !usesHFilter && !usesVFilter &&
1747  c->alphablend != SWS_ALPHA_BLEND_NONE &&
1748  isALPHA(srcFormat) &&
1749  (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
1750  alphaless_fmt(srcFormat) == dstFormat
1751  ) {
1752  c->convert_unscaled = ff_sws_alphablendaway;
1753 
1754  if (flags & SWS_PRINT_INFO)
1755  av_log(c, AV_LOG_INFO,
1756  "using alpha blendaway %s -> %s special converter\n",
1757  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1758  return 0;
1759  }
1760 
1761  /* unscaled special cases */
1762  if (unscaled && !usesHFilter && !usesVFilter &&
1763  (c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
1764  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1765 
1766  ff_get_unscaled_swscale(c);
1767 
1768  if (c->convert_unscaled) {
1769  if (flags & SWS_PRINT_INFO)
1770  av_log(c, AV_LOG_INFO,
1771  "using unscaled %s -> %s special converter\n",
1772  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1773  return 0;
1774  }
1775  }
1776 
1777 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1778 #define USE_MMAP 1
1779 #else
1780 #define USE_MMAP 0
1781 #endif
1782 
1783  /* precalculate horizontal scaler filter coefficients */
1784  {
1785 #if HAVE_MMXEXT_INLINE
1786 // can't downscale !!!
1787  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1788  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1789  NULL, NULL, 8);
1790  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1791  NULL, NULL, NULL, 4);
1792 
1793 #if USE_MMAP
1794  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1795  PROT_READ | PROT_WRITE,
1796  MAP_PRIVATE | MAP_ANONYMOUS,
1797  -1, 0);
1798  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1799  PROT_READ | PROT_WRITE,
1800  MAP_PRIVATE | MAP_ANONYMOUS,
1801  -1, 0);
1802 #elif HAVE_VIRTUALALLOC
1803  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1804  c->lumMmxextFilterCodeSize,
1805  MEM_COMMIT,
1806  PAGE_EXECUTE_READWRITE);
1807  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1808  c->chrMmxextFilterCodeSize,
1809  MEM_COMMIT,
1810  PAGE_EXECUTE_READWRITE);
1811 #else
1812  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1813  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1814 #endif
1815 
1816 #ifdef MAP_ANONYMOUS
1817  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1818 #else
1819  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1820 #endif
1821  {
1822  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1823  return AVERROR(ENOMEM);
1824  }
1825 
1826  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1827  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1828  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1829  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1830  goto nomem;
1831 
1832  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1833  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1834  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1835  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1836 
1837 #if USE_MMAP
1838  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1839  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1840  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1841  ret = AVERROR(EINVAL);
1842  goto fail;
1843  }
1844 #endif
1845  } else
1846 #endif /* HAVE_MMXEXT_INLINE */
1847  {
1848  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1849  PPC_ALTIVEC(cpu_flags) ? 8 :
1850  have_neon(cpu_flags) ? 4 :
1851  have_lsx(cpu_flags) ? 8 :
1852  have_lasx(cpu_flags) ? 8 : 1;
1853 
1854  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1855  &c->hLumFilterSize, c->lumXInc,
1856  srcW, dstW, filterAlign, 1 << 14,
1857  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1858  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1859  c->param,
1860  get_local_pos(c, 0, 0, 0),
1861  get_local_pos(c, 0, 0, 0))) < 0)
1862  goto fail;
1863  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1864  goto nomem;
1865  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1866  &c->hChrFilterSize, c->chrXInc,
1867  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1868  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1869  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1870  c->param,
1871  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1872  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1873  goto fail;
1874  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1875  goto nomem;
1876  }
1877  } // initialize horizontal stuff
1878 
1879  /* precalculate vertical scaler filter coefficients */
1880  {
1881  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1882  PPC_ALTIVEC(cpu_flags) ? 8 :
1883  have_neon(cpu_flags) ? 2 : 1;
1884 
1885  if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1886  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1887  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1888  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1889  c->param,
1890  get_local_pos(c, 0, 0, 1),
1891  get_local_pos(c, 0, 0, 1))) < 0)
1892  goto fail;
1893  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1894  c->chrYInc, c->chrSrcH, c->chrDstH,
1895  filterAlign, (1 << 12),
1896  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1897  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1898  c->param,
1899  get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
1900  get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
1901 
1902  goto fail;
1903 
1904 #if HAVE_ALTIVEC
1905  if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->dstH) ||
1906  !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1907  goto nomem;
1908 
1909  for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
1910  int j;
1911  short *p = (short *)&c->vYCoeffsBank[i];
1912  for (j = 0; j < 8; j++)
1913  p[j] = c->vLumFilter[i];
1914  }
1915 
1916  for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
1917  int j;
1918  short *p = (short *)&c->vCCoeffsBank[i];
1919  for (j = 0; j < 8; j++)
1920  p[j] = c->vChrFilter[i];
1921  }
1922 #endif
1923  }
1924 
1925  for (i = 0; i < 4; i++)
1926  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->dstW + 3))
1927  goto nomem;
1928 
1929  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;
1930 
1931  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1932  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1933  c->uv_offx2 = dst_stride + 16;
1934 
1935  av_assert0(c->chrDstH <= dstH);
1936 
1937  if (flags & SWS_PRINT_INFO) {
1938  const char *scaler = NULL, *cpucaps;
1939 
1940  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1941  if (flags & scale_algorithms[i].flag) {
1942  scaler = scale_algorithms[i].description;
1943  break;
1944  }
1945  }
1946  if (!scaler)
1947  scaler = "ehh flags invalid?!";
1948  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1949  scaler,
1950  av_get_pix_fmt_name(srcFormat),
1951 #ifdef DITHER1XBPP
1952  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1953  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1954  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1955  "dithered " : "",
1956 #else
1957  "",
1958 #endif
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->slice_ctx[i]->parent = c;
2046 
2047  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
2048  if (ret < 0)
2049  return ret;
2050 
2051  c->slice_ctx[i]->nb_threads = 1;
2052 
2053  ret = sws_init_single_context(c->slice_ctx[i], src_filter, dst_filter);
2054  if (ret < 0)
2055  return ret;
2056 
2057  c->nb_slice_ctx++;
2058 
2059  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
2060  av_log(c, AV_LOG_VERBOSE,
2061  "Error-diffusion dither is in use, scaling will be single-threaded.");
2062  break;
2063  }
2064  }
2065 
2066  return 0;
2067 }
2068 
2069 av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
2070  SwsFilter *dstFilter)
2071 {
2072  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
2073  enum AVPixelFormat src_format, dst_format;
2074  int ret;
2075 
2076  c->frame_src = av_frame_alloc();
2077  c->frame_dst = av_frame_alloc();
2078  if (!c->frame_src || !c->frame_dst)
2079  return AVERROR(ENOMEM);
2080 
2081  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
2082  return AVERROR_UNKNOWN;
2083 
2084  src_format = c->srcFormat;
2085  dst_format = c->dstFormat;
2086  c->srcRange |= handle_jpeg(&c->srcFormat);
2087  c->dstRange |= handle_jpeg(&c->dstFormat);
2088 
2089  if (src_format != c->srcFormat || dst_format != c->dstFormat)
2090  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
2091 
2092  if (c->nb_threads != 1) {
2093  ret = context_init_threaded(c, srcFilter, dstFilter);
2094  if (ret < 0 || c->nb_threads > 1)
2095  return ret;
2096  // threading disabled in this build, init as single-threaded
2097  }
2098 
2099  return sws_init_single_context(c, srcFilter, dstFilter);
2100 }
2101 
2102 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
2103  int dstW, int dstH, enum AVPixelFormat dstFormat,
2104  int flags, SwsFilter *srcFilter,
2105  SwsFilter *dstFilter, const double *param)
2106 {
2107  SwsContext *c;
2108 
2109  c = alloc_set_opts(srcW, srcH, srcFormat,
2110  dstW, dstH, dstFormat,
2111  flags, param);
2112  if (!c)
2113  return NULL;
2114 
2115  if (sws_init_context(c, srcFilter, dstFilter) < 0) {
2116  sws_freeContext(c);
2117  return NULL;
2118  }
2119 
2120  return c;
2121 }
2122 
2123 static int isnan_vec(SwsVector *a)
2124 {
2125  int i;
2126  for (i=0; i<a->length; i++)
2127  if (isnan(a->coeff[i]))
2128  return 1;
2129  return 0;
2130 }
2131 
2132 static void makenan_vec(SwsVector *a)
2133 {
2134  int i;
2135  for (i=0; i<a->length; i++)
2136  a->coeff[i] = NAN;
2137 }
2138 
2139 SwsVector *sws_allocVec(int length)
2140 {
2141  SwsVector *vec;
2142 
2143  if(length <= 0 || length > INT_MAX/ sizeof(double))
2144  return NULL;
2145 
2146  vec = av_malloc(sizeof(SwsVector));
2147  if (!vec)
2148  return NULL;
2149  vec->length = length;
2150  vec->coeff = av_malloc(sizeof(double) * length);
2151  if (!vec->coeff)
2152  av_freep(&vec);
2153  return vec;
2154 }
2155 
2156 SwsVector *sws_getGaussianVec(double variance, double quality)
2157 {
2158  const int length = (int)(variance * quality + 0.5) | 1;
2159  int i;
2160  double middle = (length - 1) * 0.5;
2161  SwsVector *vec;
2162 
2163  if(variance < 0 || quality < 0)
2164  return NULL;
2165 
2166  vec = sws_allocVec(length);
2167 
2168  if (!vec)
2169  return NULL;
2170 
2171  for (i = 0; i < length; i++) {
2172  double dist = i - middle;
2173  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2174  sqrt(2 * variance * M_PI);
2175  }
2176 
2177  sws_normalizeVec(vec, 1.0);
2178 
2179  return vec;
2180 }
2181 
2182 /**
2183  * Allocate and return a vector with length coefficients, all
2184  * with the same value c.
2185  */
2186 static
2187 SwsVector *sws_getConstVec(double c, int length)
2188 {
2189  int i;
2190  SwsVector *vec = sws_allocVec(length);
2191 
2192  if (!vec)
2193  return NULL;
2194 
2195  for (i = 0; i < length; i++)
2196  vec->coeff[i] = c;
2197 
2198  return vec;
2199 }
2200 
2201 /**
2202  * Allocate and return a vector with just one coefficient, with
2203  * value 1.0.
2204  */
2205 static
2206 SwsVector *sws_getIdentityVec(void)
2207 {
2208  return sws_getConstVec(1.0, 1);
2209 }
2210 
2211 static double sws_dcVec(SwsVector *a)
2212 {
2213  int i;
2214  double sum = 0;
2215 
2216  for (i = 0; i < a->length; i++)
2217  sum += a->coeff[i];
2218 
2219  return sum;
2220 }
2221 
2222 void sws_scaleVec(SwsVector *a, double scalar)
2223 {
2224  int i;
2225 
2226  for (i = 0; i < a->length; i++)
2227  a->coeff[i] *= scalar;
2228 }
2229 
2230 void sws_normalizeVec(SwsVector *a, double height)
2231 {
2232  sws_scaleVec(a, height / sws_dcVec(a));
2233 }
2234 
2235 static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
2236 {
2237  int length = FFMAX(a->length, b->length);
2238  int i;
2239  SwsVector *vec = sws_getConstVec(0.0, length);
2240 
2241  if (!vec)
2242  return NULL;
2243 
2244  for (i = 0; i < a->length; i++)
2245  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2246  for (i = 0; i < b->length; i++)
2247  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2248 
2249  return vec;
2250 }
2251 
2252 /* shift left / or right if "shift" is negative */
2253 static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
2254 {
2255  int length = a->length + FFABS(shift) * 2;
2256  int i;
2257  SwsVector *vec = sws_getConstVec(0.0, length);
2258 
2259  if (!vec)
2260  return NULL;
2261 
2262  for (i = 0; i < a->length; i++) {
2263  vec->coeff[i + (length - 1) / 2 -
2264  (a->length - 1) / 2 - shift] = a->coeff[i];
2265  }
2266 
2267  return vec;
2268 }
2269 
2270 static
2271 void sws_shiftVec(SwsVector *a, int shift)
2272 {
2273  SwsVector *shifted = sws_getShiftedVec(a, shift);
2274  if (!shifted) {
2275  makenan_vec(a);
2276  return;
2277  }
2278  av_free(a->coeff);
2279  a->coeff = shifted->coeff;
2280  a->length = shifted->length;
2281  av_free(shifted);
2282 }
2283 
2284 static
2285 void sws_addVec(SwsVector *a, SwsVector *b)
2286 {
2287  SwsVector *sum = sws_sumVec(a, b);
2288  if (!sum) {
2289  makenan_vec(a);
2290  return;
2291  }
2292  av_free(a->coeff);
2293  a->coeff = sum->coeff;
2294  a->length = sum->length;
2295  av_free(sum);
2296 }
2297 
2298 /**
2299  * Print with av_log() a textual representation of the vector a
2300  * if log_level <= av_log_level.
2301  */
2302 static
2303 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2304 {
2305  int i;
2306  double max = 0;
2307  double min = 0;
2308  double range;
2309 
2310  for (i = 0; i < a->length; i++)
2311  if (a->coeff[i] > max)
2312  max = a->coeff[i];
2313 
2314  for (i = 0; i < a->length; i++)
2315  if (a->coeff[i] < min)
2316  min = a->coeff[i];
2317 
2318  range = max - min;
2319 
2320  for (i = 0; i < a->length; i++) {
2321  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2322  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2323  for (; x > 0; x--)
2324  av_log(log_ctx, log_level, " ");
2325  av_log(log_ctx, log_level, "|\n");
2326  }
2327 }
2328 
2329 void sws_freeVec(SwsVector *a)
2330 {
2331  if (!a)
2332  return;
2333  av_freep(&a->coeff);
2334  a->length = 0;
2335  av_free(a);
2336 }
2337 
2338 void sws_freeFilter(SwsFilter *filter)
2339 {
2340  if (!filter)
2341  return;
2342 
2343  sws_freeVec(filter->lumH);
2344  sws_freeVec(filter->lumV);
2345  sws_freeVec(filter->chrH);
2346  sws_freeVec(filter->chrV);
2347  av_free(filter);
2348 }
2349 
2350 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2351  float lumaSharpen, float chromaSharpen,
2352  float chromaHShift, float chromaVShift,
2353  int verbose)
2354 {
2355  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2356  if (!filter)
2357  return NULL;
2358 
2359  if (lumaGBlur != 0.0) {
2360  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2361  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2362  } else {
2363  filter->lumH = sws_getIdentityVec();
2364  filter->lumV = sws_getIdentityVec();
2365  }
2366 
2367  if (chromaGBlur != 0.0) {
2368  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2369  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2370  } else {
2371  filter->chrH = sws_getIdentityVec();
2372  filter->chrV = sws_getIdentityVec();
2373  }
2374 
2375  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2376  goto fail;
2377 
2378  if (chromaSharpen != 0.0) {
2379  SwsVector *id = sws_getIdentityVec();
2380  if (!id)
2381  goto fail;
2382  sws_scaleVec(filter->chrH, -chromaSharpen);
2383  sws_scaleVec(filter->chrV, -chromaSharpen);
2384  sws_addVec(filter->chrH, id);
2385  sws_addVec(filter->chrV, id);
2386  sws_freeVec(id);
2387  }
2388 
2389  if (lumaSharpen != 0.0) {
2390  SwsVector *id = sws_getIdentityVec();
2391  if (!id)
2392  goto fail;
2393  sws_scaleVec(filter->lumH, -lumaSharpen);
2394  sws_scaleVec(filter->lumV, -lumaSharpen);
2395  sws_addVec(filter->lumH, id);
2396  sws_addVec(filter->lumV, id);
2397  sws_freeVec(id);
2398  }
2399 
2400  if (chromaHShift != 0.0)
2401  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2402 
2403  if (chromaVShift != 0.0)
2404  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2405 
2406  sws_normalizeVec(filter->chrH, 1.0);
2407  sws_normalizeVec(filter->chrV, 1.0);
2408  sws_normalizeVec(filter->lumH, 1.0);
2409  sws_normalizeVec(filter->lumV, 1.0);
2410 
2411  if (isnan_vec(filter->chrH) ||
2412  isnan_vec(filter->chrV) ||
2413  isnan_vec(filter->lumH) ||
2414  isnan_vec(filter->lumV))
2415  goto fail;
2416 
2417  if (verbose)
2418  sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
2419  if (verbose)
2420  sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
2421 
2422  return filter;
2423 
2424 fail:
2425  sws_freeVec(filter->lumH);
2426  sws_freeVec(filter->lumV);
2427  sws_freeVec(filter->chrH);
2428  sws_freeVec(filter->chrV);
2429  av_freep(&filter);
2430  return NULL;
2431 }
2432 
2433 void sws_freeContext(SwsContext *c)
2434 {
2435  int i;
2436  if (!c)
2437  return;
2438 
2439  for (i = 0; i < c->nb_slice_ctx; i++)
2440  sws_freeContext(c->slice_ctx[i]);
2441  av_freep(&c->slice_ctx);
2442  av_freep(&c->slice_err);
2443 
2444  avpriv_slicethread_free(&c->slicethread);
2445 
2446  for (i = 0; i < 4; i++)
2447  av_freep(&c->dither_error[i]);
2448 
2449  av_frame_free(&c->frame_src);
2450  av_frame_free(&c->frame_dst);
2451 
2452  av_freep(&c->src_ranges.ranges);
2453 
2454  av_freep(&c->vLumFilter);
2455  av_freep(&c->vChrFilter);
2456  av_freep(&c->hLumFilter);
2457  av_freep(&c->hChrFilter);
2458 #if HAVE_ALTIVEC
2459  av_freep(&c->vYCoeffsBank);
2460  av_freep(&c->vCCoeffsBank);
2461 #endif
2462 
2463  av_freep(&c->vLumFilterPos);
2464  av_freep(&c->vChrFilterPos);
2465  av_freep(&c->hLumFilterPos);
2466  av_freep(&c->hChrFilterPos);
2467 
2468 #if HAVE_MMX_INLINE
2469 #if USE_MMAP
2470  if (c->lumMmxextFilterCode)
2471  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2472  if (c->chrMmxextFilterCode)
2473  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2474 #elif HAVE_VIRTUALALLOC
2475  if (c->lumMmxextFilterCode)
2476  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2477  if (c->chrMmxextFilterCode)
2478  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2479 #else
2480  av_free(c->lumMmxextFilterCode);
2481  av_free(c->chrMmxextFilterCode);
2482 #endif
2483  c->lumMmxextFilterCode = NULL;
2484  c->chrMmxextFilterCode = NULL;
2485 #endif /* HAVE_MMX_INLINE */
2486 
2487  av_freep(&c->yuvTable);
2488  av_freep(&c->formatConvBuffer);
2489 
2490  sws_freeContext(c->cascaded_context[0]);
2491  sws_freeContext(c->cascaded_context[1]);
2492  sws_freeContext(c->cascaded_context[2]);
2493  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2494  av_freep(&c->cascaded_tmp[0]);
2495  av_freep(&c->cascaded1_tmp[0]);
2496 
2497  av_freep(&c->gamma);
2498  av_freep(&c->inv_gamma);
2499 
2500  av_freep(&c->rgb0_scratch);
2501  av_freep(&c->xyz_scratch);
2502 
2503  ff_free_filters(c);
2504 
2505  av_free(c);
2506 }
2507 
2508 struct SwsContext *sws_getCachedContext(struct SwsContext *context, int srcW,
2509  int srcH, enum AVPixelFormat srcFormat,
2510  int dstW, int dstH,
2511  enum AVPixelFormat dstFormat, int flags,
2512  SwsFilter *srcFilter,
2513  SwsFilter *dstFilter,
2514  const double *param)
2515 {
2516  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2517  SWS_PARAM_DEFAULT };
2518  int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
2519  src_v_chr_pos = -513, dst_v_chr_pos = -513;
2520 
2521  if (!param)
2522  param = default_param;
2523 
2524  if (context &&
2525  (context->srcW != srcW ||
2526  context->srcH != srcH ||
2527  context->srcFormat != srcFormat ||
2528  context->dstW != dstW ||
2529  context->dstH != dstH ||
2530  context->dstFormat != dstFormat ||
2531  context->flags != flags ||
2532  context->param[0] != param[0] ||
2533  context->param[1] != param[1])) {
2534 
2535  av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
2536  av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
2537  av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
2538  av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
2539  sws_freeContext(context);
2540  context = NULL;
2541  }
2542 
2543  if (!context) {
2544  if (!(context = sws_alloc_context()))
2545  return NULL;
2546  context->srcW = srcW;
2547  context->srcH = srcH;
2548  context->srcFormat = srcFormat;
2549  context->dstW = dstW;
2550  context->dstH = dstH;
2551  context->dstFormat = dstFormat;
2552  context->flags = flags;
2553  context->param[0] = param[0];
2554  context->param[1] = param[1];
2555 
2556  av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
2557  av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
2558  av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
2559  av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
2560 
2561  if (sws_init_context(context, srcFilter, dstFilter) < 0) {
2562  sws_freeContext(context);
2563  return NULL;
2564  }
2565  }
2566  return context;
2567 }
2568 
2569 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2570 {
2571  Range *tmp;
2572  unsigned int idx;
2573 
2574  /* find the first existing range after the new one */
2575  for (idx = 0; idx < rl->nb_ranges; idx++)
2576  if (rl->ranges[idx].start > start)
2577  break;
2578 
2579  /* check for overlap */
2580  if (idx > 0) {
2581  Range *prev = &rl->ranges[idx - 1];
2582  if (prev->start + prev->len > start)
2583  return AVERROR(EINVAL);
2584  }
2585  if (idx < rl->nb_ranges) {
2586  Range *next = &rl->ranges[idx];
2587  if (start + len > next->start)
2588  return AVERROR(EINVAL);
2589  }
2590 
2591  tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated,
2592  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2593  if (!tmp)
2594  return AVERROR(ENOMEM);
2595  rl->ranges = tmp;
2596 
2597  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2598  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2599  rl->ranges[idx].start = start;
2600  rl->ranges[idx].len = len;
2601  rl->nb_ranges++;
2602 
2603  /* merge ranges */
2604  if (idx > 0) {
2605  Range *prev = &rl->ranges[idx - 1];
2606  Range *cur = &rl->ranges[idx];
2607  if (prev->start + prev->len == cur->start) {
2608  prev->len += cur->len;
2609  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2610  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2611  rl->nb_ranges--;
2612  idx--;
2613  }
2614  }
2615  if (idx < rl->nb_ranges - 1) {
2616  Range *cur = &rl->ranges[idx];
2617  Range *next = &rl->ranges[idx + 1];
2618  if (cur->start + cur->len == next->start) {
2619  cur->len += next->len;
2620  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2621  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2622  rl->nb_ranges--;
2623  }
2624  }
2625 
2626  return 0;
2627 }
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:2508
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)
Definition: yuv2rgb.c:775
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:1640
cpu.h
AV_PIX_FMT_P416BE
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
Definition: pixfmt.h:398
acc
int acc
Definition: yuv2rgb.c:553
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:82
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:2206
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:516
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:74
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
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h:96
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:160
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale_internal.h:76
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:448
alphaless_fmt
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
Definition: utils.c:1243
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:445
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:205
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:449
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:450
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
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
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
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:103
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:2253
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:52
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:2329
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:1307
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:2123
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:91
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:240
fail
#define fail()
Definition: checkasm.h:179
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:467
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
Range::len
unsigned int len
Definition: swscale_internal.h:90
ONE
@ ONE
Definition: vc1_parser.c:48
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:58
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:148
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:333
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:75
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:94
emms_c
#define emms_c()
Definition: emms.h:63
float
float
Definition: af_crystalizer.c:121
ff_range_add
int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
Definition: utils.c:2569
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:2303
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:59
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
Definition: swscale.h:88
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:118
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:2139
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:2156
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:511
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:443
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:332
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:73
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:1229
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:72
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:1974
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:67
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:2350
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:93
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:57
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:95
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1213
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:2132
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
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
sws_addVec
static void sws_addVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2285
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1205
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:117
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:466
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:2222
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:2187
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:791
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:2110
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:1219
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:126
f
f
Definition: af_crystalizer.c:121
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:442
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:116
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:2102
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
Definition: swscale.h:86
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:324
asm.h
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:2557
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:122
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:410
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:124
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:90
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:444
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:466
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:323
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
DITHER1XBPP
#define DITHER1XBPP
Definition: swscale_internal.h:49
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:2271
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_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
W
@ W
Definition: vf_addroi.c:27
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:2338
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:843
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:94
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:102
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:547
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:345
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:1189
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:2069
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:29
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:2433
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:548
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:500
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:447
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:123
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:73
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:2235
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
d
d
Definition: ffmpeg_filter.c:424
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:474
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:254
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:465
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:446
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:468
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:77
int
int
Definition: ffmpeg_filter.c:424
SwsContext
Definition: swscale_internal.h:301
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:125
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:2211
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:325
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:2230
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:64
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:92
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:344
Generated on Thu Apr 18 2024 19:21:54 for FFmpeg by   doxygen 1.8.17