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"
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;
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 {
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 
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;
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 
359 {
360  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
362 }
363 
365 {
366  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
368 }
369 
371 {
372  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
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
403 
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 
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)) {
709  goto fail;
710  }
711  *outFilterSize = filterSize;
712 
713  if (flags & SWS_PRINT_INFO)
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,
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,
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,
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 
958 {
959  switch (*format) {
960  case AV_PIX_FMT_YUVJ420P:
962  return 1;
963  case AV_PIX_FMT_YUVJ411P:
965  return 1;
966  case AV_PIX_FMT_YUVJ422P:
968  return 1;
969  case AV_PIX_FMT_YUVJ444P:
971  return 1;
972  case AV_PIX_FMT_YUVJ440P:
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 
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 
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 
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 
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) {
1083 #if ARCH_AARCH64
1085 #elif ARCH_LOONGARCH64
1087 #elif ARCH_X86
1089 #endif
1090  }
1091 
1092  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1093  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1094 
1095  if (c->cascaded_context[c->cascaded_mainindex])
1096  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
1097 
1098  if (!need_reinit)
1099  return 0;
1100 
1101  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
1102  if (!c->cascaded_context[0] &&
1103  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
1104  c->srcW && c->srcH && c->dstW && c->dstH) {
1105  enum AVPixelFormat tmp_format;
1106  int tmp_width, tmp_height;
1107  int srcW = c->srcW;
1108  int srcH = c->srcH;
1109  int dstW = c->dstW;
1110  int dstH = c->dstH;
1111  int ret;
1112  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
1113 
1114  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
1115  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1116  tmp_format = AV_PIX_FMT_BGRA64;
1117  } else {
1118  tmp_format = AV_PIX_FMT_BGR48;
1119  }
1120  } else {
1121  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1122  tmp_format = AV_PIX_FMT_BGRA;
1123  } else {
1124  tmp_format = AV_PIX_FMT_BGR24;
1125  }
1126  }
1127 
1128  if (srcW*srcH > dstW*dstH) {
1129  tmp_width = dstW;
1130  tmp_height = dstH;
1131  } else {
1132  tmp_width = srcW;
1133  tmp_height = srcH;
1134  }
1135 
1136  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1137  tmp_width, tmp_height, tmp_format, 64);
1138  if (ret < 0)
1139  return ret;
1140 
1141  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, c->srcFormat,
1142  tmp_width, tmp_height, tmp_format,
1143  c->flags, c->param);
1144  if (!c->cascaded_context[0])
1145  return -1;
1146 
1147  c->cascaded_context[0]->alphablend = c->alphablend;
1148  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1149  if (ret < 0)
1150  return ret;
1151  //we set both src and dst depending on that the RGB side will be ignored
1152  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
1153  srcRange, table, dstRange,
1154  brightness, contrast, saturation);
1155 
1156  c->cascaded_context[1] = alloc_set_opts(tmp_width, tmp_height, tmp_format,
1157  dstW, dstH, c->dstFormat,
1158  c->flags, c->param);
1159  if (!c->cascaded_context[1])
1160  return -1;
1161  c->cascaded_context[1]->srcRange = srcRange;
1162  c->cascaded_context[1]->dstRange = dstRange;
1163  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1164  if (ret < 0)
1165  return ret;
1166  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
1167  srcRange, table, dstRange,
1168  0, 1 << 16, 1 << 16);
1169  return 0;
1170  }
1171  //We do not support this combination currently, we need to cascade more contexts to compensate
1172  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
1173  return -1; //AVERROR_PATCHWELCOME;
1174  return 0;
1175  }
1176 
1177  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1178  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1179  contrast, saturation);
1180  // FIXME factorize
1181 
1182 #if ARCH_PPC
1183  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1184  contrast, saturation);
1185 #endif
1186  }
1187 
1188  fill_rgb2yuv_table(c, table, dstRange);
1189 
1190  return 0;
1191 }
1192 
1193 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1194  int *srcRange, int **table, int *dstRange,
1195  int *brightness, int *contrast, int *saturation)
1196 {
1197  if (!c )
1198  return -1;
1199 
1200  if (c->nb_slice_ctx) {
1201  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1202  table, dstRange, brightness, contrast,
1203  saturation);
1204  }
1205 
1206  *inv_table = c->srcColorspaceTable;
1207  *table = c->dstColorspaceTable;
1208  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1209  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1210  *brightness = c->brightness;
1211  *contrast = c->contrast;
1212  *saturation = c->saturation;
1213 
1214  return 0;
1215 }
1216 
1218 {
1219  SwsContext *c = av_mallocz(sizeof(SwsContext));
1220 
1221  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1222 
1223  if (c) {
1224  c->av_class = &ff_sws_context_class;
1226  atomic_init(&c->stride_unaligned_warned, 0);
1227  atomic_init(&c->data_unaligned_warned, 0);
1228  }
1229 
1230  return c;
1231 }
1232 
1233 static uint16_t * alloc_gamma_tbl(double e)
1234 {
1235  int i = 0;
1236  uint16_t * tbl;
1237  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1238  if (!tbl)
1239  return NULL;
1240 
1241  for (i = 0; i < 65536; ++i) {
1242  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1243  }
1244  return tbl;
1245 }
1246 
1248 {
1249  switch(fmt) {
1250  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1251  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1252  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1253  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1254  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1255 
1259 
1260  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1261 
1264 
1267 
1270 
1273 
1278 
1279  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1280  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1281 
1300 
1301 // case AV_PIX_FMT_AYUV64LE:
1302 // case AV_PIX_FMT_AYUV64BE:
1303 // case AV_PIX_FMT_PAL8:
1304  default: return AV_PIX_FMT_NONE;
1305  }
1306 }
1307 
1308 static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter,
1309  SwsFilter *dstFilter);
1310 
1312  SwsFilter *dstFilter)
1313 {
1314  int i;
1315  int usesVFilter, usesHFilter;
1316  int unscaled;
1317  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1318  int srcW = c->srcW;
1319  int srcH = c->srcH;
1320  int dstW = c->dstW;
1321  int dstH = c->dstH;
1322  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1323  int flags, cpu_flags;
1324  enum AVPixelFormat srcFormat, dstFormat;
1325  const AVPixFmtDescriptor *desc_src;
1326  const AVPixFmtDescriptor *desc_dst;
1327  int ret = 0;
1328  enum AVPixelFormat tmpFmt;
1329  static const float float_mult = 1.0f / 255.0f;
1330 
1332  flags = c->flags;
1333  emms_c();
1334 
1335  unscaled = (srcW == dstW && srcH == dstH);
1336 
1337  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1340  c->dstRange, 0, 1 << 16, 1 << 16);
1341 
1342  handle_formats(c);
1343  srcFormat = c->srcFormat;
1344  dstFormat = c->dstFormat;
1345  desc_src = av_pix_fmt_desc_get(srcFormat);
1346  desc_dst = av_pix_fmt_desc_get(dstFormat);
1347 
1348  // If the source has no alpha then disable alpha blendaway
1349  if (c->src0Alpha)
1350  c->alphablend = SWS_ALPHA_BLEND_NONE;
1351 
1352  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1353  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1354  if (!sws_isSupportedInput(srcFormat)) {
1355  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1356  av_get_pix_fmt_name(srcFormat));
1357  return AVERROR(EINVAL);
1358  }
1359  if (!sws_isSupportedOutput(dstFormat)) {
1360  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1361  av_get_pix_fmt_name(dstFormat));
1362  return AVERROR(EINVAL);
1363  }
1364  }
1365  av_assert2(desc_src && desc_dst);
1366 
1367  i = flags & (SWS_POINT |
1368  SWS_AREA |
1369  SWS_BILINEAR |
1371  SWS_BICUBIC |
1372  SWS_X |
1373  SWS_GAUSS |
1374  SWS_LANCZOS |
1375  SWS_SINC |
1376  SWS_SPLINE |
1377  SWS_BICUBLIN);
1378 
1379  /* provide a default scaler if not set by caller */
1380  if (!i) {
1381  if (dstW < srcW && dstH < srcH)
1382  flags |= SWS_BICUBIC;
1383  else if (dstW > srcW && dstH > srcH)
1384  flags |= SWS_BICUBIC;
1385  else
1386  flags |= SWS_BICUBIC;
1387  c->flags = flags;
1388  } else if (i & (i - 1)) {
1390  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1391  return AVERROR(EINVAL);
1392  }
1393  /* sanity check */
1394  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1395  /* FIXME check if these are enough and try to lower them after
1396  * fixing the relevant parts of the code */
1397  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1398  srcW, srcH, dstW, dstH);
1399  return AVERROR(EINVAL);
1400  }
1401  if (flags & SWS_FAST_BILINEAR) {
1402  if (srcW < 8 || dstW < 8) {
1404  c->flags = flags;
1405  }
1406  }
1407 
1408  if (!dstFilter)
1409  dstFilter = &dummyFilter;
1410  if (!srcFilter)
1411  srcFilter = &dummyFilter;
1412 
1413  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1414  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1415  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1416  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1417  c->vRounder = 4 * 0x0001000100010001ULL;
1418 
1419  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1420  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1421  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1422  (dstFilter->chrV && dstFilter->chrV->length > 1);
1423  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1424  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1425  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1426  (dstFilter->chrH && dstFilter->chrH->length > 1);
1427 
1428  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1429  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1430 
1431  c->dst_slice_align = 1 << c->chrDstVSubSample;
1432 
1433  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1434  if (dstW&1) {
1435  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1437  c->flags = flags;
1438  }
1439 
1440  if ( c->chrSrcHSubSample == 0
1441  && c->chrSrcVSubSample == 0
1442  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1443  && !(c->flags & SWS_FAST_BILINEAR)
1444  ) {
1445  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1447  c->flags = flags;
1448  }
1449  }
1450 
1451  if (c->dither == SWS_DITHER_AUTO) {
1452  if (flags & SWS_ERROR_DIFFUSION)
1453  c->dither = SWS_DITHER_ED;
1454  }
1455 
1456  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1457  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1458  dstFormat == AV_PIX_FMT_BGR8 ||
1459  dstFormat == AV_PIX_FMT_RGB8) {
1460  if (c->dither == SWS_DITHER_AUTO)
1462  if (!(flags & SWS_FULL_CHR_H_INT)) {
1463  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1465  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1466  av_get_pix_fmt_name(dstFormat));
1468  c->flags = flags;
1469  }
1470  }
1471  if (flags & SWS_FULL_CHR_H_INT) {
1472  if (c->dither == SWS_DITHER_BAYER) {
1474  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1475  av_get_pix_fmt_name(dstFormat));
1476  c->dither = SWS_DITHER_ED;
1477  }
1478  }
1479  }
1480  if (isPlanarRGB(dstFormat)) {
1481  if (!(flags & SWS_FULL_CHR_H_INT)) {
1483  "%s output is not supported with half chroma resolution, switching to full\n",
1484  av_get_pix_fmt_name(dstFormat));
1486  c->flags = flags;
1487  }
1488  }
1489 
1490  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1491  * chroma interpolation */
1492  if (flags & SWS_FULL_CHR_H_INT &&
1493  isAnyRGB(dstFormat) &&
1494  !isPlanarRGB(dstFormat) &&
1495  dstFormat != AV_PIX_FMT_RGBA64LE &&
1496  dstFormat != AV_PIX_FMT_RGBA64BE &&
1497  dstFormat != AV_PIX_FMT_BGRA64LE &&
1498  dstFormat != AV_PIX_FMT_BGRA64BE &&
1499  dstFormat != AV_PIX_FMT_RGB48LE &&
1500  dstFormat != AV_PIX_FMT_RGB48BE &&
1501  dstFormat != AV_PIX_FMT_BGR48LE &&
1502  dstFormat != AV_PIX_FMT_BGR48BE &&
1503  dstFormat != AV_PIX_FMT_RGBA &&
1504  dstFormat != AV_PIX_FMT_ARGB &&
1505  dstFormat != AV_PIX_FMT_BGRA &&
1506  dstFormat != AV_PIX_FMT_ABGR &&
1507  dstFormat != AV_PIX_FMT_RGB24 &&
1508  dstFormat != AV_PIX_FMT_BGR24 &&
1509  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1510  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1511  dstFormat != AV_PIX_FMT_BGR8 &&
1512  dstFormat != AV_PIX_FMT_RGB8
1513  ) {
1515  "full chroma interpolation for destination format '%s' not yet implemented\n",
1516  av_get_pix_fmt_name(dstFormat));
1518  c->flags = flags;
1519  }
1520  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1521  c->chrDstHSubSample = 1;
1522 
1523  // drop some chroma lines if the user wants it
1524  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1526  c->chrSrcVSubSample += c->vChrDrop;
1527 
1528  /* drop every other pixel for chroma calculation unless user
1529  * wants full chroma */
1530  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1531  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1532  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1533  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1534  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1535  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1536  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1537  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1538  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1539  srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE &&
1540  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1541  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1542  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1543  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1544  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1545  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1546  (flags & SWS_FAST_BILINEAR)))
1547  c->chrSrcHSubSample = 1;
1548 
1549  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1550  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1551  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1552  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1553  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1554 
1555  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1556  goto nomem;
1557 
1558  c->srcBpc = desc_src->comp[0].depth;
1559  if (c->srcBpc < 8)
1560  c->srcBpc = 8;
1561  c->dstBpc = desc_dst->comp[0].depth;
1562  if (c->dstBpc < 8)
1563  c->dstBpc = 8;
1564  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1565  c->srcBpc = 16;
1566  if (c->dstBpc == 16)
1567  dst_stride <<= 1;
1568 
1569  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1570  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1571  c->chrDstW >= c->chrSrcW &&
1572  (srcW & 15) == 0;
1573  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1574 
1575  && (flags & SWS_FAST_BILINEAR)) {
1576  if (flags & SWS_PRINT_INFO)
1577  av_log(c, AV_LOG_INFO,
1578  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1579  }
1580  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1581  c->canMMXEXTBeUsed = 0;
1582  } else
1583  c->canMMXEXTBeUsed = 0;
1584 
1585  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1586  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1587 
1588  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1589  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1590  * correct scaling.
1591  * n-2 is the last chrominance sample available.
1592  * This is not perfect, but no one should notice the difference, the more
1593  * correct variant would be like the vertical one, but that would require
1594  * some special code for the first and last pixel */
1595  if (flags & SWS_FAST_BILINEAR) {
1596  if (c->canMMXEXTBeUsed) {
1597  c->lumXInc += 20;
1598  c->chrXInc += 20;
1599  }
1600  // we don't use the x86 asm scaler if MMX is available
1601  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1602  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1603  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1604  }
1605  }
1606 
1607  // hardcoded for now
1608  c->gamma_value = 2.2;
1609  tmpFmt = AV_PIX_FMT_RGBA64LE;
1610 
1611 
1612  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1613  SwsContext *c2;
1614  c->cascaded_context[0] = NULL;
1615 
1616  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1617  srcW, srcH, tmpFmt, 64);
1618  if (ret < 0)
1619  return ret;
1620 
1621  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1622  srcW, srcH, tmpFmt,
1623  flags, NULL, NULL, c->param);
1624  if (!c->cascaded_context[0]) {
1625  return AVERROR(ENOMEM);
1626  }
1627 
1628  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1629  dstW, dstH, tmpFmt,
1630  flags, srcFilter, dstFilter, c->param);
1631 
1632  if (!c->cascaded_context[1])
1633  return AVERROR(ENOMEM);
1634 
1635  c2 = c->cascaded_context[1];
1636  c2->is_internal_gamma = 1;
1637  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1638  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1639  if (!c2->gamma || !c2->inv_gamma)
1640  return AVERROR(ENOMEM);
1641 
1642  // is_internal_flag is set after creating the context
1643  // to properly create the gamma convert FilterDescriptor
1644  // we have to re-initialize it
1646  if ((ret = ff_init_filters(c2)) < 0) {
1648  c->cascaded_context[1] = NULL;
1649  return ret;
1650  }
1651 
1652  c->cascaded_context[2] = NULL;
1653  if (dstFormat != tmpFmt) {
1654  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1655  dstW, dstH, tmpFmt, 64);
1656  if (ret < 0)
1657  return ret;
1658 
1659  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1660  dstW, dstH, dstFormat,
1661  flags, NULL, NULL, c->param);
1662  if (!c->cascaded_context[2])
1663  return AVERROR(ENOMEM);
1664  }
1665  return 0;
1666  }
1667 
1668  if (isBayer(srcFormat)) {
1669  if (!unscaled ||
1670  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1671  dstFormat != AV_PIX_FMT_RGB48)) {
1672  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1673 
1674  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1675  srcW, srcH, tmpFormat, 64);
1676  if (ret < 0)
1677  return ret;
1678 
1679  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1680  srcW, srcH, tmpFormat,
1681  flags, srcFilter, NULL, c->param);
1682  if (!c->cascaded_context[0])
1683  return AVERROR(ENOMEM);
1684 
1685  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1686  dstW, dstH, dstFormat,
1687  flags, NULL, dstFilter, c->param);
1688  if (!c->cascaded_context[1])
1689  return AVERROR(ENOMEM);
1690  return 0;
1691  }
1692  }
1693 
1694  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1695  for (i = 0; i < 256; ++i){
1696  c->uint2float_lut[i] = (float)i * float_mult;
1697  }
1698  }
1699 
1700  // float will be converted to uint16_t
1701  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1702  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1703  dstFormat != AV_PIX_FMT_GRAY8))){
1704  c->srcBpc = 16;
1705  }
1706 
1707  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1708  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1709 
1710  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1711  if (!unscaled ||
1712  dstFormat != tmpFormat ||
1713  usesHFilter || usesVFilter ||
1714  c->srcRange != c->dstRange
1715  ) {
1716  c->cascaded_mainindex = 1;
1717  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1718  srcW, srcH, tmpFormat, 64);
1719  if (ret < 0)
1720  return ret;
1721 
1722  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1723  srcW, srcH, tmpFormat,
1724  flags, c->param);
1725  if (!c->cascaded_context[0])
1726  return AVERROR(EINVAL);
1727  c->cascaded_context[0]->alphablend = c->alphablend;
1728  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1729  if (ret < 0)
1730  return ret;
1731 
1732  c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1733  dstW, dstH, dstFormat,
1734  flags, c->param);
1735  if (!c->cascaded_context[1])
1736  return AVERROR(EINVAL);
1737 
1738  c->cascaded_context[1]->srcRange = c->srcRange;
1739  c->cascaded_context[1]->dstRange = c->dstRange;
1740  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1741  if (ret < 0)
1742  return ret;
1743 
1744  return 0;
1745  }
1746  }
1747  }
1748 
1749  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1750  if (unscaled && !usesHFilter && !usesVFilter &&
1751  c->alphablend != SWS_ALPHA_BLEND_NONE &&
1752  isALPHA(srcFormat) &&
1753  (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
1754  alphaless_fmt(srcFormat) == dstFormat
1755  ) {
1756  c->convert_unscaled = ff_sws_alphablendaway;
1757 
1758  if (flags & SWS_PRINT_INFO)
1759  av_log(c, AV_LOG_INFO,
1760  "using alpha blendaway %s -> %s special converter\n",
1761  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1762  return 0;
1763  }
1764 
1765  /* unscaled special cases */
1766  if (unscaled && !usesHFilter && !usesVFilter &&
1767  (c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
1768  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1769 
1771 
1772  if (c->convert_unscaled) {
1773  if (flags & SWS_PRINT_INFO)
1774  av_log(c, AV_LOG_INFO,
1775  "using unscaled %s -> %s special converter\n",
1776  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1777  return 0;
1778  }
1779  }
1780 
1781 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1782 #define USE_MMAP 1
1783 #else
1784 #define USE_MMAP 0
1785 #endif
1786 
1787  /* precalculate horizontal scaler filter coefficients */
1788  {
1789 #if HAVE_MMXEXT_INLINE
1790 // can't downscale !!!
1791  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1792  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1793  NULL, NULL, 8);
1794  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1795  NULL, NULL, NULL, 4);
1796 
1797 #if USE_MMAP
1798  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1799  PROT_READ | PROT_WRITE,
1800  MAP_PRIVATE | MAP_ANONYMOUS,
1801  -1, 0);
1802  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1803  PROT_READ | PROT_WRITE,
1804  MAP_PRIVATE | MAP_ANONYMOUS,
1805  -1, 0);
1806 #elif HAVE_VIRTUALALLOC
1807  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1808  c->lumMmxextFilterCodeSize,
1809  MEM_COMMIT,
1810  PAGE_EXECUTE_READWRITE);
1811  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1812  c->chrMmxextFilterCodeSize,
1813  MEM_COMMIT,
1814  PAGE_EXECUTE_READWRITE);
1815 #else
1816  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1817  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1818 #endif
1819 
1820 #ifdef MAP_ANONYMOUS
1821  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1822 #else
1823  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1824 #endif
1825  {
1826  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1827  return AVERROR(ENOMEM);
1828  }
1829 
1830  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1831  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1832  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1833  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1834  goto nomem;
1835 
1836  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1837  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1838  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1839  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1840 
1841 #if USE_MMAP
1842  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1843  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1844  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1845  ret = AVERROR(EINVAL);
1846  goto fail;
1847  }
1848 #endif
1849  } else
1850 #endif /* HAVE_MMXEXT_INLINE */
1851  {
1852  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1853  PPC_ALTIVEC(cpu_flags) ? 8 :
1854  have_neon(cpu_flags) ? 4 :
1855  have_lsx(cpu_flags) ? 8 :
1856  have_lasx(cpu_flags) ? 8 : 1;
1857 
1858  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1859  &c->hLumFilterSize, c->lumXInc,
1860  srcW, dstW, filterAlign, 1 << 14,
1862  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1863  c->param,
1864  get_local_pos(c, 0, 0, 0),
1865  get_local_pos(c, 0, 0, 0))) < 0)
1866  goto fail;
1867  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1868  goto nomem;
1869  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1870  &c->hChrFilterSize, c->chrXInc,
1871  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1873  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1874  c->param,
1875  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1876  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1877  goto fail;
1878  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1879  goto nomem;
1880  }
1881  } // initialize horizontal stuff
1882 
1883  /* precalculate vertical scaler filter coefficients */
1884  {
1885  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1886  PPC_ALTIVEC(cpu_flags) ? 8 :
1887  have_neon(cpu_flags) ? 2 : 1;
1888 
1889  if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1890  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1892  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1893  c->param,
1894  get_local_pos(c, 0, 0, 1),
1895  get_local_pos(c, 0, 0, 1))) < 0)
1896  goto fail;
1897  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1898  c->chrYInc, c->chrSrcH, c->chrDstH,
1899  filterAlign, (1 << 12),
1901  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1902  c->param,
1903  get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
1904  get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
1905 
1906  goto fail;
1907 
1908 #if HAVE_ALTIVEC
1909  if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->dstH) ||
1910  !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1911  goto nomem;
1912 
1913  for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
1914  int j;
1915  short *p = (short *)&c->vYCoeffsBank[i];
1916  for (j = 0; j < 8; j++)
1917  p[j] = c->vLumFilter[i];
1918  }
1919 
1920  for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
1921  int j;
1922  short *p = (short *)&c->vCCoeffsBank[i];
1923  for (j = 0; j < 8; j++)
1924  p[j] = c->vChrFilter[i];
1925  }
1926 #endif
1927  }
1928 
1929  for (i = 0; i < 4; i++)
1930  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->dstW + 3))
1931  goto nomem;
1932 
1933  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;
1934 
1935  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1936  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1937  c->uv_offx2 = dst_stride + 16;
1938 
1939  av_assert0(c->chrDstH <= dstH);
1940 
1941  if (flags & SWS_PRINT_INFO) {
1942  const char *scaler = NULL, *cpucaps;
1943 
1944  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1945  if (flags & scale_algorithms[i].flag) {
1946  scaler = scale_algorithms[i].description;
1947  break;
1948  }
1949  }
1950  if (!scaler)
1951  scaler = "ehh flags invalid?!";
1952  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1953  scaler,
1954  av_get_pix_fmt_name(srcFormat),
1955 #ifdef DITHER1XBPP
1956  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1957  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1958  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1959  "dithered " : "",
1960 #else
1961  "",
1962 #endif
1963  av_get_pix_fmt_name(dstFormat));
1964 
1965  if (INLINE_MMXEXT(cpu_flags))
1966  cpucaps = "MMXEXT";
1967  else if (INLINE_MMX(cpu_flags))
1968  cpucaps = "MMX";
1969  else if (PPC_ALTIVEC(cpu_flags))
1970  cpucaps = "AltiVec";
1971  else
1972  cpucaps = "C";
1973 
1974  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1975 
1976  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1978  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1979  c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
1981  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1982  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1983  c->chrXInc, c->chrYInc);
1984  }
1985 
1987 
1988  return ff_init_filters(c);
1989 nomem:
1990  ret = AVERROR(ENOMEM);
1991 fail: // FIXME replace things by appropriate error codes
1992  if (ret == RETCODE_USE_CASCADE) {
1993  int tmpW = sqrt(srcW * (int64_t)dstW);
1994  int tmpH = sqrt(srcH * (int64_t)dstH);
1995  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1996 
1997  if (isALPHA(srcFormat))
1998  tmpFormat = AV_PIX_FMT_YUVA420P;
1999 
2000  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
2001  return AVERROR(EINVAL);
2002 
2003  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
2004  tmpW, tmpH, tmpFormat, 64);
2005  if (ret < 0)
2006  return ret;
2007 
2008  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
2009  tmpW, tmpH, tmpFormat,
2010  flags, srcFilter, NULL, c->param);
2011  if (!c->cascaded_context[0])
2012  return AVERROR(ENOMEM);
2013 
2014  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
2015  dstW, dstH, dstFormat,
2016  flags, NULL, dstFilter, c->param);
2017  if (!c->cascaded_context[1])
2018  return AVERROR(ENOMEM);
2019  return 0;
2020  }
2021  return ret;
2022 }
2023 
2025  SwsFilter *src_filter, SwsFilter *dst_filter)
2026 {
2027  int ret;
2028 
2029  ret = avpriv_slicethread_create(&c->slicethread, (void*)c,
2030  ff_sws_slice_worker, NULL, c->nb_threads);
2031  if (ret == AVERROR(ENOSYS)) {
2032  c->nb_threads = 1;
2033  return 0;
2034  } else if (ret < 0)
2035  return ret;
2036 
2037  c->nb_threads = ret;
2038 
2039  c->slice_ctx = av_calloc(c->nb_threads, sizeof(*c->slice_ctx));
2040  c->slice_err = av_calloc(c->nb_threads, sizeof(*c->slice_err));
2041  if (!c->slice_ctx || !c->slice_err)
2042  return AVERROR(ENOMEM);
2043 
2044  for (int i = 0; i < c->nb_threads; i++) {
2045  c->slice_ctx[i] = sws_alloc_context();
2046  if (!c->slice_ctx[i])
2047  return AVERROR(ENOMEM);
2048 
2049  c->slice_ctx[i]->parent = c;
2050 
2051  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
2052  if (ret < 0)
2053  return ret;
2054 
2055  c->slice_ctx[i]->nb_threads = 1;
2056 
2057  ret = sws_init_single_context(c->slice_ctx[i], src_filter, dst_filter);
2058  if (ret < 0)
2059  return ret;
2060 
2061  c->nb_slice_ctx++;
2062 
2063  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
2065  "Error-diffusion dither is in use, scaling will be single-threaded.");
2066  break;
2067  }
2068  }
2069 
2070  return 0;
2071 }
2072 
2074  SwsFilter *dstFilter)
2075 {
2076  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
2077  enum AVPixelFormat src_format, dst_format;
2078  int ret;
2079 
2080  c->frame_src = av_frame_alloc();
2081  c->frame_dst = av_frame_alloc();
2082  if (!c->frame_src || !c->frame_dst)
2083  return AVERROR(ENOMEM);
2084 
2085  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
2086  return AVERROR_UNKNOWN;
2087 
2088  src_format = c->srcFormat;
2089  dst_format = c->dstFormat;
2090  c->srcRange |= handle_jpeg(&c->srcFormat);
2091  c->dstRange |= handle_jpeg(&c->dstFormat);
2092 
2093  if (src_format != c->srcFormat || dst_format != c->dstFormat)
2094  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
2095 
2096  if (c->nb_threads != 1) {
2097  ret = context_init_threaded(c, srcFilter, dstFilter);
2098  if (ret < 0 || c->nb_threads > 1)
2099  return ret;
2100  // threading disabled in this build, init as single-threaded
2101  }
2102 
2103  return sws_init_single_context(c, srcFilter, dstFilter);
2104 }
2105 
2106 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
2107  int dstW, int dstH, enum AVPixelFormat dstFormat,
2108  int flags, SwsFilter *srcFilter,
2109  SwsFilter *dstFilter, const double *param)
2110 {
2111  SwsContext *c;
2112 
2113  c = alloc_set_opts(srcW, srcH, srcFormat,
2114  dstW, dstH, dstFormat,
2115  flags, param);
2116  if (!c)
2117  return NULL;
2118 
2119  if (sws_init_context(c, srcFilter, dstFilter) < 0) {
2120  sws_freeContext(c);
2121  return NULL;
2122  }
2123 
2124  return c;
2125 }
2126 
2127 static int isnan_vec(SwsVector *a)
2128 {
2129  int i;
2130  for (i=0; i<a->length; i++)
2131  if (isnan(a->coeff[i]))
2132  return 1;
2133  return 0;
2134 }
2135 
2136 static void makenan_vec(SwsVector *a)
2137 {
2138  int i;
2139  for (i=0; i<a->length; i++)
2140  a->coeff[i] = NAN;
2141 }
2142 
2144 {
2145  SwsVector *vec;
2146 
2147  if(length <= 0 || length > INT_MAX/ sizeof(double))
2148  return NULL;
2149 
2150  vec = av_malloc(sizeof(SwsVector));
2151  if (!vec)
2152  return NULL;
2153  vec->length = length;
2154  vec->coeff = av_malloc(sizeof(double) * length);
2155  if (!vec->coeff)
2156  av_freep(&vec);
2157  return vec;
2158 }
2159 
2160 SwsVector *sws_getGaussianVec(double variance, double quality)
2161 {
2162  const int length = (int)(variance * quality + 0.5) | 1;
2163  int i;
2164  double middle = (length - 1) * 0.5;
2165  SwsVector *vec;
2166 
2167  if(variance < 0 || quality < 0)
2168  return NULL;
2169 
2170  vec = sws_allocVec(length);
2171 
2172  if (!vec)
2173  return NULL;
2174 
2175  for (i = 0; i < length; i++) {
2176  double dist = i - middle;
2177  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2178  sqrt(2 * variance * M_PI);
2179  }
2180 
2181  sws_normalizeVec(vec, 1.0);
2182 
2183  return vec;
2184 }
2185 
2186 /**
2187  * Allocate and return a vector with length coefficients, all
2188  * with the same value c.
2189  */
2190 static
2191 SwsVector *sws_getConstVec(double c, int length)
2192 {
2193  int i;
2194  SwsVector *vec = sws_allocVec(length);
2195 
2196  if (!vec)
2197  return NULL;
2198 
2199  for (i = 0; i < length; i++)
2200  vec->coeff[i] = c;
2201 
2202  return vec;
2203 }
2204 
2205 /**
2206  * Allocate and return a vector with just one coefficient, with
2207  * value 1.0.
2208  */
2209 static
2211 {
2212  return sws_getConstVec(1.0, 1);
2213 }
2214 
2215 static double sws_dcVec(SwsVector *a)
2216 {
2217  int i;
2218  double sum = 0;
2219 
2220  for (i = 0; i < a->length; i++)
2221  sum += a->coeff[i];
2222 
2223  return sum;
2224 }
2225 
2226 void sws_scaleVec(SwsVector *a, double scalar)
2227 {
2228  int i;
2229 
2230  for (i = 0; i < a->length; i++)
2231  a->coeff[i] *= scalar;
2232 }
2233 
2235 {
2237 }
2238 
2240 {
2241  int length = FFMAX(a->length, b->length);
2242  int i;
2243  SwsVector *vec = sws_getConstVec(0.0, length);
2244 
2245  if (!vec)
2246  return NULL;
2247 
2248  for (i = 0; i < a->length; i++)
2249  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2250  for (i = 0; i < b->length; i++)
2251  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2252 
2253  return vec;
2254 }
2255 
2256 /* shift left / or right if "shift" is negative */
2258 {
2259  int length = a->length + FFABS(shift) * 2;
2260  int i;
2261  SwsVector *vec = sws_getConstVec(0.0, length);
2262 
2263  if (!vec)
2264  return NULL;
2265 
2266  for (i = 0; i < a->length; i++) {
2267  vec->coeff[i + (length - 1) / 2 -
2268  (a->length - 1) / 2 - shift] = a->coeff[i];
2269  }
2270 
2271  return vec;
2272 }
2273 
2274 static
2276 {
2277  SwsVector *shifted = sws_getShiftedVec(a, shift);
2278  if (!shifted) {
2279  makenan_vec(a);
2280  return;
2281  }
2282  av_free(a->coeff);
2283  a->coeff = shifted->coeff;
2284  a->length = shifted->length;
2285  av_free(shifted);
2286 }
2287 
2288 static
2290 {
2291  SwsVector *sum = sws_sumVec(a, b);
2292  if (!sum) {
2293  makenan_vec(a);
2294  return;
2295  }
2296  av_free(a->coeff);
2297  a->coeff = sum->coeff;
2298  a->length = sum->length;
2299  av_free(sum);
2300 }
2301 
2302 /**
2303  * Print with av_log() a textual representation of the vector a
2304  * if log_level <= av_log_level.
2305  */
2306 static
2307 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2308 {
2309  int i;
2310  double max = 0;
2311  double min = 0;
2312  double range;
2313 
2314  for (i = 0; i < a->length; i++)
2315  if (a->coeff[i] > max)
2316  max = a->coeff[i];
2317 
2318  for (i = 0; i < a->length; i++)
2319  if (a->coeff[i] < min)
2320  min = a->coeff[i];
2321 
2322  range = max - min;
2323 
2324  for (i = 0; i < a->length; i++) {
2325  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2326  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2327  for (; x > 0; x--)
2328  av_log(log_ctx, log_level, " ");
2329  av_log(log_ctx, log_level, "|\n");
2330  }
2331 }
2332 
2334 {
2335  if (!a)
2336  return;
2337  av_freep(&a->coeff);
2338  a->length = 0;
2339  av_free(a);
2340 }
2341 
2343 {
2344  if (!filter)
2345  return;
2346 
2347  sws_freeVec(filter->lumH);
2348  sws_freeVec(filter->lumV);
2349  sws_freeVec(filter->chrH);
2350  sws_freeVec(filter->chrV);
2351  av_free(filter);
2352 }
2353 
2354 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2355  float lumaSharpen, float chromaSharpen,
2356  float chromaHShift, float chromaVShift,
2357  int verbose)
2358 {
2359  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2360  if (!filter)
2361  return NULL;
2362 
2363  if (lumaGBlur != 0.0) {
2364  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2365  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2366  } else {
2367  filter->lumH = sws_getIdentityVec();
2368  filter->lumV = sws_getIdentityVec();
2369  }
2370 
2371  if (chromaGBlur != 0.0) {
2372  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2373  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2374  } else {
2375  filter->chrH = sws_getIdentityVec();
2376  filter->chrV = sws_getIdentityVec();
2377  }
2378 
2379  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2380  goto fail;
2381 
2382  if (chromaSharpen != 0.0) {
2383  SwsVector *id = sws_getIdentityVec();
2384  if (!id)
2385  goto fail;
2386  sws_scaleVec(filter->chrH, -chromaSharpen);
2387  sws_scaleVec(filter->chrV, -chromaSharpen);
2388  sws_addVec(filter->chrH, id);
2389  sws_addVec(filter->chrV, id);
2390  sws_freeVec(id);
2391  }
2392 
2393  if (lumaSharpen != 0.0) {
2394  SwsVector *id = sws_getIdentityVec();
2395  if (!id)
2396  goto fail;
2397  sws_scaleVec(filter->lumH, -lumaSharpen);
2398  sws_scaleVec(filter->lumV, -lumaSharpen);
2399  sws_addVec(filter->lumH, id);
2400  sws_addVec(filter->lumV, id);
2401  sws_freeVec(id);
2402  }
2403 
2404  if (chromaHShift != 0.0)
2405  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2406 
2407  if (chromaVShift != 0.0)
2408  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2409 
2410  sws_normalizeVec(filter->chrH, 1.0);
2411  sws_normalizeVec(filter->chrV, 1.0);
2412  sws_normalizeVec(filter->lumH, 1.0);
2413  sws_normalizeVec(filter->lumV, 1.0);
2414 
2415  if (isnan_vec(filter->chrH) ||
2416  isnan_vec(filter->chrV) ||
2417  isnan_vec(filter->lumH) ||
2418  isnan_vec(filter->lumV))
2419  goto fail;
2420 
2421  if (verbose)
2423  if (verbose)
2425 
2426  return filter;
2427 
2428 fail:
2429  sws_freeVec(filter->lumH);
2430  sws_freeVec(filter->lumV);
2431  sws_freeVec(filter->chrH);
2432  sws_freeVec(filter->chrV);
2433  av_freep(&filter);
2434  return NULL;
2435 }
2436 
2438 {
2439  int i;
2440  if (!c)
2441  return;
2442 
2443  for (i = 0; i < c->nb_slice_ctx; i++)
2444  sws_freeContext(c->slice_ctx[i]);
2445  av_freep(&c->slice_ctx);
2446  av_freep(&c->slice_err);
2447 
2448  avpriv_slicethread_free(&c->slicethread);
2449 
2450  for (i = 0; i < 4; i++)
2451  av_freep(&c->dither_error[i]);
2452 
2453  av_frame_free(&c->frame_src);
2454  av_frame_free(&c->frame_dst);
2455 
2456  av_freep(&c->src_ranges.ranges);
2457 
2458  av_freep(&c->vLumFilter);
2459  av_freep(&c->vChrFilter);
2460  av_freep(&c->hLumFilter);
2461  av_freep(&c->hChrFilter);
2462 #if HAVE_ALTIVEC
2463  av_freep(&c->vYCoeffsBank);
2464  av_freep(&c->vCCoeffsBank);
2465 #endif
2466 
2467  av_freep(&c->vLumFilterPos);
2468  av_freep(&c->vChrFilterPos);
2469  av_freep(&c->hLumFilterPos);
2470  av_freep(&c->hChrFilterPos);
2471 
2472 #if HAVE_MMX_INLINE
2473 #if USE_MMAP
2474  if (c->lumMmxextFilterCode)
2475  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2476  if (c->chrMmxextFilterCode)
2477  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2478 #elif HAVE_VIRTUALALLOC
2479  if (c->lumMmxextFilterCode)
2480  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2481  if (c->chrMmxextFilterCode)
2482  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2483 #else
2484  av_free(c->lumMmxextFilterCode);
2485  av_free(c->chrMmxextFilterCode);
2486 #endif
2487  c->lumMmxextFilterCode = NULL;
2488  c->chrMmxextFilterCode = NULL;
2489 #endif /* HAVE_MMX_INLINE */
2490 
2491  av_freep(&c->yuvTable);
2492  av_freep(&c->formatConvBuffer);
2493 
2494  sws_freeContext(c->cascaded_context[0]);
2495  sws_freeContext(c->cascaded_context[1]);
2496  sws_freeContext(c->cascaded_context[2]);
2497  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2498  av_freep(&c->cascaded_tmp[0]);
2499  av_freep(&c->cascaded1_tmp[0]);
2500 
2501  av_freep(&c->gamma);
2502  av_freep(&c->inv_gamma);
2503 
2504  av_freep(&c->rgb0_scratch);
2505  av_freep(&c->xyz_scratch);
2506 
2507  ff_free_filters(c);
2508 
2509  av_free(c);
2510 }
2511 
2513  int srcH, enum AVPixelFormat srcFormat,
2514  int dstW, int dstH,
2515  enum AVPixelFormat dstFormat, int flags,
2516  SwsFilter *srcFilter,
2517  SwsFilter *dstFilter,
2518  const double *param)
2519 {
2520  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2522  int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
2523  src_v_chr_pos = -513, dst_v_chr_pos = -513;
2524 
2525  if (!param)
2526  param = default_param;
2527 
2528  if (context &&
2529  (context->srcW != srcW ||
2530  context->srcH != srcH ||
2531  context->srcFormat != srcFormat ||
2532  context->dstW != dstW ||
2533  context->dstH != dstH ||
2534  context->dstFormat != dstFormat ||
2535  context->flags != flags ||
2536  context->param[0] != param[0] ||
2537  context->param[1] != param[1])) {
2538 
2539  av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
2540  av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
2541  av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
2542  av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
2544  context = NULL;
2545  }
2546 
2547  if (!context) {
2548  if (!(context = sws_alloc_context()))
2549  return NULL;
2550  context->srcW = srcW;
2551  context->srcH = srcH;
2552  context->srcFormat = srcFormat;
2553  context->dstW = dstW;
2554  context->dstH = dstH;
2555  context->dstFormat = dstFormat;
2556  context->flags = flags;
2557  context->param[0] = param[0];
2558  context->param[1] = param[1];
2559 
2560  av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
2561  av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
2562  av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
2563  av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
2564 
2565  if (sws_init_context(context, srcFilter, dstFilter) < 0) {
2567  return NULL;
2568  }
2569  }
2570  return context;
2571 }
2572 
2573 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2574 {
2575  Range *tmp;
2576  unsigned int idx;
2577 
2578  /* find the first existing range after the new one */
2579  for (idx = 0; idx < rl->nb_ranges; idx++)
2580  if (rl->ranges[idx].start > start)
2581  break;
2582 
2583  /* check for overlap */
2584  if (idx > 0) {
2585  Range *prev = &rl->ranges[idx - 1];
2586  if (prev->start + prev->len > start)
2587  return AVERROR(EINVAL);
2588  }
2589  if (idx < rl->nb_ranges) {
2590  Range *next = &rl->ranges[idx];
2591  if (start + len > next->start)
2592  return AVERROR(EINVAL);
2593  }
2594 
2596  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2597  if (!tmp)
2598  return AVERROR(ENOMEM);
2599  rl->ranges = tmp;
2600 
2601  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2602  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2603  rl->ranges[idx].start = start;
2604  rl->ranges[idx].len = len;
2605  rl->nb_ranges++;
2606 
2607  /* merge ranges */
2608  if (idx > 0) {
2609  Range *prev = &rl->ranges[idx - 1];
2610  Range *cur = &rl->ranges[idx];
2611  if (prev->start + prev->len == cur->start) {
2612  prev->len += cur->len;
2613  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2614  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2615  rl->nb_ranges--;
2616  idx--;
2617  }
2618  }
2619  if (idx < rl->nb_ranges - 1) {
2620  Range *cur = &rl->ranges[idx];
2621  Range *next = &rl->ranges[idx + 1];
2622  if (cur->start + cur->len == next->start) {
2623  cur->len += next->len;
2624  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2625  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2626  rl->nb_ranges--;
2627  }
2628  }
2629 
2630  return 0;
2631 }
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:823
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:2512
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:891
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:1654
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:2210
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:1247
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
handle_0alpha
static int handle_0alpha(enum AVPixelFormat *format)
Definition: utils.c:995
AV_PIX_FMT_YUV440P12BE
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:301
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
RU_IDX
#define RU_IDX
Definition: swscale_internal.h: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:203
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
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2917
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c: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:2257
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:2333
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_PIX_FMT_AYUV64LE
@ AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:302
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:132
AV_PIX_FMT_BAYER_GBRG16BE
@ AV_PIX_FMT_BAYER_GBRG16BE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:294
sws_init_single_context
static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Definition: utils.c:1311
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:2127
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:708
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:185
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:49
ub
#define ub(width, name)
Definition: cbs_h2645.c:401
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:476
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:339
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2993
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:722
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:2573
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:2307
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
intreadwrite.h
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: alphablend.c:23
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:172
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
AV_PIX_FMT_P416LE
@ AV_PIX_FMT_P416LE
interleaved chroma YUV 4:4:4, 48bpp, little-endian
Definition: pixfmt.h:399
AV_PIX_FMT_BAYER_RGGB16LE
@ AV_PIX_FMT_BAYER_RGGB16LE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:291
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:491
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
height
static int height
Definition: utils.c:158
AV_PIX_FMT_P210LE
@ AV_PIX_FMT_P210LE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:390
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AV_PIX_FMT_BAYER_BGGR8
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
Definition: pixfmt.h:285
SWS_FULL_CHR_H_INP
#define SWS_FULL_CHR_H_INP
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:2143
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:2160
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:74
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:534
AV_PIX_FMT_BAYER_GRBG16LE
@ AV_PIX_FMT_BAYER_GRBG16LE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:295
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:159
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:157
alloc_gamma_tbl
static uint16_t * alloc_gamma_tbl(double e)
Definition: utils.c:1233
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:497
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:130
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale_internal.h: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
asm.h
W
@ W
Definition: vf_addroi.c:27
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:2354
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:58
V
#define V
Definition: avdct.c:31
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:118
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:368
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:95
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1217
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:2136
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:180
AV_PIX_FMT_Y210LE
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:382
ff_sws_init_range_convert_aarch64
av_cold void ff_sws_init_range_convert_aarch64(SwsContext *c)
Definition: swscale.c:223
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:2289
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1217
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:2226
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:2191
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:799
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:2125
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: swscale.h:80
AV_PIX_FMT_P212LE
@ AV_PIX_FMT_P212LE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian
Definition: pixfmt.h:427
SWS_X
#define SWS_X
Definition: swscale.h:68
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:153
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
have_lsx
#define have_lsx(flags)
Definition: cpu.h:28
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c:1221
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h: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:2106
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:837
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
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:736
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:155
AV_PIX_FMT_RGBAF16BE
@ AV_PIX_FMT_RGBAF16BE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian.
Definition: pixfmt.h:403
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:198
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:139
have_neon
#define have_neon(flags)
Definition: cpu.h:26
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
SwsFilter
Definition: swscale.h:122
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:406
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:2024
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2275
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_sws_init_range_convert_loongarch
av_cold void ff_sws_init_range_convert_loongarch(SwsContext *c)
Definition: swscale_init_loongarch.c:27
FormatEntry::is_supported_in
uint8_t is_supported_in
Definition: utils.c:64
SWS_LANCZOS
#define SWS_LANCZOS
Definition: swscale.h:74
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GRAY9BE
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:338
AV_PIX_FMT_NV24
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:371
ff_sws_init_range_convert_x86
av_cold void ff_sws_init_range_convert_x86(SwsContext *c)
Definition: swscale.c:477
ff_free_filters
int ff_free_filters(SwsContext *c)
Definition: slice.c:389
AV_PIX_FMT_BAYER_GBRG8
@ AV_PIX_FMT_BAYER_GBRG8
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
Definition: pixfmt.h:287
exp2
#define exp2(x)
Definition: libm.h:288
getSplineCoeff
static double getSplineCoeff(double a, double b, double c, double d, double dist)
Definition: utils.c:376
sws_isSupportedOutput
int sws_isSupportedOutput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported output format, 0 otherwise.
Definition: utils.c:364
swscale_internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
AV_PIX_FMT_XYZ12BE
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
Definition: pixfmt.h:197
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:470
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:133
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:372
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
sws_freeFilter
void sws_freeFilter(SwsFilter *filter)
Definition: utils.c:2342
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:845
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:365
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:323
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:363
pos
unsigned int pos
Definition: spdifenc.c:414
sws_getColorspaceDetails
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Definition: utils.c:1193
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
sws_init_context
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:2073
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:2437
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:830
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:2239
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:2215
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:2234
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:859
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