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