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