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"
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;
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 
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;
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 
330 {
331  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
333 }
334 
336 {
337  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
339 }
340 
342 {
343  return (unsigned)pix_fmt < FF_ARRAY_ELEMS(format_entries) ?
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
374 
376  { SWS_AREA, "area averaging", 1 /* downscale only, for upscale it is bilinear */ },
377  { SWS_BICUBIC, "bicubic", 4 },
378  { SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 },
379  { SWS_BILINEAR, "bilinear", 2 },
380  { SWS_FAST_BILINEAR, "fast bilinear", -1 },
381  { SWS_GAUSS, "Gaussian", 8 /* infinite ;) */ },
382  { SWS_LANCZOS, "Lanczos", -1 /* custom */ },
383  { SWS_POINT, "nearest neighbor / point", -1 },
384  { SWS_SINC, "sinc", 20 /* infinite ;) */ },
385  { SWS_SPLINE, "bicubic spline", 20 /* infinite :)*/ },
386  { SWS_X, "experimental", 8 },
387 };
388 
389 static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
390  int *outFilterSize, int xInc, int srcW,
391  int dstW, int filterAlign, int one,
392  int flags, int cpu_flags,
393  SwsVector *srcFilter, SwsVector *dstFilter,
394  double param[2], int srcPos, int dstPos)
395 {
396  int i;
397  int filterSize;
398  int filter2Size;
399  int minFilterSize;
400  int64_t *filter = NULL;
401  int64_t *filter2 = NULL;
402  const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8));
403  int ret = -1;
404 
405  emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
406 
407  // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
408  if (!FF_ALLOC_TYPED_ARRAY(*filterPos, dstW + 3))
409  goto nomem;
410 
411  if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled
412  int i;
413  filterSize = 1;
414  if (!FF_ALLOCZ_TYPED_ARRAY(filter, dstW * filterSize))
415  goto nomem;
416 
417  for (i = 0; i < dstW; i++) {
418  filter[i * filterSize] = fone;
419  (*filterPos)[i] = i;
420  }
421  } else if (flags & SWS_POINT) { // lame looking point sampling mode
422  int i;
423  int64_t xDstInSrc;
424  filterSize = 1;
425  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
426  goto nomem;
427 
428  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
429  for (i = 0; i < dstW; i++) {
430  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
431 
432  (*filterPos)[i] = xx;
433  filter[i] = fone;
434  xDstInSrc += xInc;
435  }
436  } else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||
437  (flags & SWS_FAST_BILINEAR)) { // bilinear upscale
438  int i;
439  int64_t xDstInSrc;
440  filterSize = 2;
441  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
442  goto nomem;
443 
444  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
445  for (i = 0; i < dstW; i++) {
446  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
447  int j;
448 
449  (*filterPos)[i] = xx;
450  // bilinear upscale / linear interpolate / area averaging
451  for (j = 0; j < filterSize; j++) {
452  int64_t coeff = fone - FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
453  if (coeff < 0)
454  coeff = 0;
455  filter[i * filterSize + j] = coeff;
456  xx++;
457  }
458  xDstInSrc += xInc;
459  }
460  } else {
461  int64_t xDstInSrc;
462  int sizeFactor = -1;
463 
464  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
465  if (flags & scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
466  sizeFactor = scale_algorithms[i].size_factor;
467  break;
468  }
469  }
470  if (flags & SWS_LANCZOS)
471  sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;
472  av_assert0(sizeFactor > 0);
473 
474  if (xInc <= 1 << 16)
475  filterSize = 1 + sizeFactor; // upscale
476  else
477  filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
478 
479  filterSize = FFMIN(filterSize, srcW - 2);
480  filterSize = FFMAX(filterSize, 1);
481 
482  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
483  goto nomem;
484  xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
485  for (i = 0; i < dstW; i++) {
486  int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
487  int j;
488  (*filterPos)[i] = xx;
489  for (j = 0; j < filterSize; j++) {
490  int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
491  double floatd;
492  int64_t coeff;
493 
494  if (xInc > 1 << 16)
495  d = d * dstW / srcW;
496  floatd = d * (1.0 / (1 << 30));
497 
498  if (flags & SWS_BICUBIC) {
499  int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24);
500  int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);
501 
502  if (d >= 1LL << 31) {
503  coeff = 0.0;
504  } else {
505  int64_t dd = (d * d) >> 30;
506  int64_t ddd = (dd * d) >> 30;
507 
508  if (d < 1LL << 30)
509  coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
510  (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
511  (6 * (1 << 24) - 2 * B) * (1 << 30);
512  else
513  coeff = (-B - 6 * C) * ddd +
514  (6 * B + 30 * C) * dd +
515  (-12 * B - 48 * C) * d +
516  (8 * B + 24 * C) * (1 << 30);
517  }
518  coeff /= (1LL<<54)/fone;
519  } else if (flags & SWS_X) {
520  double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
521  double c;
522 
523  if (floatd < 1.0)
524  c = cos(floatd * M_PI);
525  else
526  c = -1.0;
527  if (c < 0.0)
528  c = -pow(-c, A);
529  else
530  c = pow(c, A);
531  coeff = (c * 0.5 + 0.5) * fone;
532  } else if (flags & SWS_AREA) {
533  int64_t d2 = d - (1 << 29);
534  if (d2 * xInc < -(1LL << (29 + 16)))
535  coeff = 1.0 * (1LL << (30 + 16));
536  else if (d2 * xInc < (1LL << (29 + 16)))
537  coeff = -d2 * xInc + (1LL << (29 + 16));
538  else
539  coeff = 0.0;
540  coeff *= fone >> (30 + 16);
541  } else if (flags & SWS_GAUSS) {
542  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
543  coeff = exp2(-p * floatd * floatd) * fone;
544  } else if (flags & SWS_SINC) {
545  coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
546  } else if (flags & SWS_LANCZOS) {
547  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
548  coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) /
549  (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
550  if (floatd > p)
551  coeff = 0;
552  } else if (flags & SWS_BILINEAR) {
553  coeff = (1 << 30) - d;
554  if (coeff < 0)
555  coeff = 0;
556  coeff *= fone >> 30;
557  } else if (flags & SWS_SPLINE) {
558  double p = -2.196152422706632;
559  coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone;
560  } else {
561  av_assert0(0);
562  }
563 
564  filter[i * filterSize + j] = coeff;
565  xx++;
566  }
567  xDstInSrc += 2 * xInc;
568  }
569  }
570 
571  /* apply src & dst Filter to filter -> filter2
572  * av_free(filter);
573  */
574  av_assert0(filterSize > 0);
575  filter2Size = filterSize;
576  if (srcFilter)
577  filter2Size += srcFilter->length - 1;
578  if (dstFilter)
579  filter2Size += dstFilter->length - 1;
580  av_assert0(filter2Size > 0);
581  if (!FF_ALLOCZ_TYPED_ARRAY(filter2, dstW * filter2Size))
582  goto nomem;
583  for (i = 0; i < dstW; i++) {
584  int j, k;
585 
586  if (srcFilter) {
587  for (k = 0; k < srcFilter->length; k++) {
588  for (j = 0; j < filterSize; j++)
589  filter2[i * filter2Size + k + j] +=
590  srcFilter->coeff[k] * filter[i * filterSize + j];
591  }
592  } else {
593  for (j = 0; j < filterSize; j++)
594  filter2[i * filter2Size + j] = filter[i * filterSize + j];
595  }
596  // FIXME dstFilter
597 
598  (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
599  }
600  av_freep(&filter);
601 
602  /* try to reduce the filter-size (step1 find size and shift left) */
603  // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
604  minFilterSize = 0;
605  for (i = dstW - 1; i >= 0; i--) {
606  int min = filter2Size;
607  int j;
608  int64_t cutOff = 0.0;
609 
610  /* get rid of near zero elements on the left by shifting left */
611  for (j = 0; j < filter2Size; j++) {
612  int k;
613  cutOff += FFABS(filter2[i * filter2Size]);
614 
615  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
616  break;
617 
618  /* preserve monotonicity because the core can't handle the
619  * filter otherwise */
620  if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
621  break;
622 
623  // move filter coefficients left
624  for (k = 1; k < filter2Size; k++)
625  filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
626  filter2[i * filter2Size + k - 1] = 0;
627  (*filterPos)[i]++;
628  }
629 
630  cutOff = 0;
631  /* count near zeros on the right */
632  for (j = filter2Size - 1; j > 0; j--) {
633  cutOff += FFABS(filter2[i * filter2Size + j]);
634 
635  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
636  break;
637  min--;
638  }
639 
640  if (min > minFilterSize)
641  minFilterSize = min;
642  }
643 
644  if (PPC_ALTIVEC(cpu_flags)) {
645  // we can handle the special case 4, so we don't want to go the full 8
646  if (minFilterSize < 5)
647  filterAlign = 4;
648 
649  /* We really don't want to waste our time doing useless computation, so
650  * fall back on the scalar C code for very small filters.
651  * Vectorizing is worth it only if you have a decent-sized vector. */
652  if (minFilterSize < 3)
653  filterAlign = 1;
654  }
655 
656  if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
657  // special case for unscaled vertical filtering
658  if (minFilterSize == 1 && filterAlign == 2)
659  filterAlign = 1;
660  }
661 
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)) {
680  goto fail;
681  }
682  *outFilterSize = filterSize;
683 
684  if (flags & SWS_PRINT_INFO)
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,
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,
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,
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 
929 {
930  switch (*format) {
931  case AV_PIX_FMT_YUVJ420P:
933  return 1;
934  case AV_PIX_FMT_YUVJ411P:
936  return 1;
937  case AV_PIX_FMT_YUVJ422P:
939  return 1;
940  case AV_PIX_FMT_YUVJ444P:
942  return 1;
943  case AV_PIX_FMT_YUVJ440P:
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 
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 
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 
997 {
998  return !isYUV(format) && !isGray(format);
999 }
1000 
1001 int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4],
1002  int srcRange, const int table[4], int dstRange,
1003  int brightness, int contrast, int saturation)
1004 {
1005  const AVPixFmtDescriptor *desc_dst;
1006  const AVPixFmtDescriptor *desc_src;
1007  int need_reinit = 0;
1008 
1009  if (c->nb_slice_ctx) {
1010  int parent_ret = 0;
1011  for (int i = 0; i < c->nb_slice_ctx; i++) {
1012  int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table,
1013  srcRange, table, dstRange,
1014  brightness, contrast, saturation);
1015  if (ret < 0)
1016  parent_ret = ret;
1017  }
1018 
1019  return parent_ret;
1020  }
1021 
1022  handle_formats(c);
1023  desc_dst = av_pix_fmt_desc_get(c->dstFormat);
1024  desc_src = av_pix_fmt_desc_get(c->srcFormat);
1025 
1026  if(range_override_needed(c->dstFormat))
1027  dstRange = 0;
1028  if(range_override_needed(c->srcFormat))
1029  srcRange = 0;
1030 
1031  if (c->srcRange != srcRange ||
1032  c->dstRange != dstRange ||
1033  c->brightness != brightness ||
1034  c->contrast != contrast ||
1035  c->saturation != saturation ||
1036  memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
1037  memcmp(c->dstColorspaceTable, table, sizeof(int) * 4)
1038  )
1039  need_reinit = 1;
1040 
1041  memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
1042  memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
1043 
1044 
1045 
1046  c->brightness = brightness;
1047  c->contrast = contrast;
1048  c->saturation = saturation;
1049  c->srcRange = srcRange;
1050  c->dstRange = dstRange;
1051 
1052  if (need_reinit)
1054 
1055  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1056  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1057 
1058  if (c->cascaded_context[c->cascaded_mainindex])
1059  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
1060 
1061  if (!need_reinit)
1062  return 0;
1063 
1064  if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
1065  if (!c->cascaded_context[0] &&
1066  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
1067  c->srcW && c->srcH && c->dstW && c->dstH) {
1068  enum AVPixelFormat tmp_format;
1069  int tmp_width, tmp_height;
1070  int srcW = c->srcW;
1071  int srcH = c->srcH;
1072  int dstW = c->dstW;
1073  int dstH = c->dstH;
1074  int ret;
1075  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
1076 
1077  if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
1078  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1079  tmp_format = AV_PIX_FMT_BGRA64;
1080  } else {
1081  tmp_format = AV_PIX_FMT_BGR48;
1082  }
1083  } else {
1084  if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
1085  tmp_format = AV_PIX_FMT_BGRA;
1086  } else {
1087  tmp_format = AV_PIX_FMT_BGR24;
1088  }
1089  }
1090 
1091  if (srcW*srcH > dstW*dstH) {
1092  tmp_width = dstW;
1093  tmp_height = dstH;
1094  } else {
1095  tmp_width = srcW;
1096  tmp_height = srcH;
1097  }
1098 
1099  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1100  tmp_width, tmp_height, tmp_format, 64);
1101  if (ret < 0)
1102  return ret;
1103 
1104  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
1105  tmp_width, tmp_height, tmp_format,
1106  c->flags, c->param);
1107  if (!c->cascaded_context[0])
1108  return -1;
1109 
1110  c->cascaded_context[0]->alphablend = c->alphablend;
1111  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1112  if (ret < 0)
1113  return ret;
1114  //we set both src and dst depending on that the RGB side will be ignored
1115  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
1116  srcRange, table, dstRange,
1117  brightness, contrast, saturation);
1118 
1119  c->cascaded_context[1] = sws_alloc_set_opts(tmp_width, tmp_height, tmp_format,
1120  dstW, dstH, c->dstFormat,
1121  c->flags, c->param);
1122  if (!c->cascaded_context[1])
1123  return -1;
1124  c->cascaded_context[1]->srcRange = srcRange;
1125  c->cascaded_context[1]->dstRange = dstRange;
1126  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1127  if (ret < 0)
1128  return ret;
1129  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
1130  srcRange, table, dstRange,
1131  0, 1 << 16, 1 << 16);
1132  return 0;
1133  }
1134  //We do not support this combination currently, we need to cascade more contexts to compensate
1135  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
1136  return -1; //AVERROR_PATCHWELCOME;
1137  return 0;
1138  }
1139 
1140  if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
1141  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1142  contrast, saturation);
1143  // FIXME factorize
1144 
1145 #if ARCH_PPC
1146  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
1147  contrast, saturation);
1148 #endif
1149  }
1150 
1151  fill_rgb2yuv_table(c, table, dstRange);
1152 
1153  return 0;
1154 }
1155 
1156 int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table,
1157  int *srcRange, int **table, int *dstRange,
1158  int *brightness, int *contrast, int *saturation)
1159 {
1160  if (!c )
1161  return -1;
1162 
1163  if (c->nb_slice_ctx) {
1164  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1165  table, dstRange, brightness, contrast,
1166  saturation);
1167  }
1168 
1169  *inv_table = c->srcColorspaceTable;
1170  *table = c->dstColorspaceTable;
1171  *srcRange = range_override_needed(c->srcFormat) ? 1 : c->srcRange;
1172  *dstRange = range_override_needed(c->dstFormat) ? 1 : c->dstRange;
1173  *brightness = c->brightness;
1174  *contrast = c->contrast;
1175  *saturation = c->saturation;
1176 
1177  return 0;
1178 }
1179 
1181 {
1182  SwsContext *c = av_mallocz(sizeof(SwsContext));
1183 
1184  av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
1185 
1186  if (c) {
1187  c->av_class = &ff_sws_context_class;
1189  atomic_init(&c->stride_unaligned_warned, 0);
1190  atomic_init(&c->data_unaligned_warned, 0);
1191  }
1192 
1193  return c;
1194 }
1195 
1196 static uint16_t * alloc_gamma_tbl(double e)
1197 {
1198  int i = 0;
1199  uint16_t * tbl;
1200  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1201  if (!tbl)
1202  return NULL;
1203 
1204  for (i = 0; i < 65536; ++i) {
1205  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1206  }
1207  return tbl;
1208 }
1209 
1211 {
1212  switch(fmt) {
1213  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1214  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1215  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1216  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1217  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1218 
1222 
1223  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1224 
1227 
1230 
1233 
1236 
1241 
1242  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1243  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1244 
1263 
1264 // case AV_PIX_FMT_AYUV64LE:
1265 // case AV_PIX_FMT_AYUV64BE:
1266 // case AV_PIX_FMT_PAL8:
1267  default: return AV_PIX_FMT_NONE;
1268  }
1269 }
1270 
1271 static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter,
1272  SwsFilter *dstFilter);
1273 
1275  SwsFilter *dstFilter)
1276 {
1277  int i;
1278  int usesVFilter, usesHFilter;
1279  int unscaled;
1280  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1281  int srcW = c->srcW;
1282  int srcH = c->srcH;
1283  int dstW = c->dstW;
1284  int dstH = c->dstH;
1285  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1286  int flags, cpu_flags;
1287  enum AVPixelFormat srcFormat, dstFormat;
1288  const AVPixFmtDescriptor *desc_src;
1289  const AVPixFmtDescriptor *desc_dst;
1290  int ret = 0;
1291  enum AVPixelFormat tmpFmt;
1292  static const float float_mult = 1.0f / 255.0f;
1293 
1295  flags = c->flags;
1296  emms_c();
1297 
1298  unscaled = (srcW == dstW && srcH == dstH);
1299 
1300  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1303  c->dstRange, 0, 1 << 16, 1 << 16);
1304 
1305  handle_formats(c);
1306  srcFormat = c->srcFormat;
1307  dstFormat = c->dstFormat;
1308  desc_src = av_pix_fmt_desc_get(srcFormat);
1309  desc_dst = av_pix_fmt_desc_get(dstFormat);
1310 
1311  // If the source has no alpha then disable alpha blendaway
1312  if (c->src0Alpha)
1313  c->alphablend = SWS_ALPHA_BLEND_NONE;
1314 
1315  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1316  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1317  if (!sws_isSupportedInput(srcFormat)) {
1318  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1319  av_get_pix_fmt_name(srcFormat));
1320  return AVERROR(EINVAL);
1321  }
1322  if (!sws_isSupportedOutput(dstFormat)) {
1323  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1324  av_get_pix_fmt_name(dstFormat));
1325  return AVERROR(EINVAL);
1326  }
1327  }
1328  av_assert2(desc_src && desc_dst);
1329 
1330  i = flags & (SWS_POINT |
1331  SWS_AREA |
1332  SWS_BILINEAR |
1334  SWS_BICUBIC |
1335  SWS_X |
1336  SWS_GAUSS |
1337  SWS_LANCZOS |
1338  SWS_SINC |
1339  SWS_SPLINE |
1340  SWS_BICUBLIN);
1341 
1342  /* provide a default scaler if not set by caller */
1343  if (!i) {
1344  if (dstW < srcW && dstH < srcH)
1345  flags |= SWS_BICUBIC;
1346  else if (dstW > srcW && dstH > srcH)
1347  flags |= SWS_BICUBIC;
1348  else
1349  flags |= SWS_BICUBIC;
1350  c->flags = flags;
1351  } else if (i & (i - 1)) {
1353  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1354  return AVERROR(EINVAL);
1355  }
1356  /* sanity check */
1357  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1358  /* FIXME check if these are enough and try to lower them after
1359  * fixing the relevant parts of the code */
1360  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1361  srcW, srcH, dstW, dstH);
1362  return AVERROR(EINVAL);
1363  }
1364  if (flags & SWS_FAST_BILINEAR) {
1365  if (srcW < 8 || dstW < 8) {
1367  c->flags = flags;
1368  }
1369  }
1370 
1371  if (!dstFilter)
1372  dstFilter = &dummyFilter;
1373  if (!srcFilter)
1374  srcFilter = &dummyFilter;
1375 
1376  c->lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1377  c->lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1378  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1379  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1380  c->vRounder = 4 * 0x0001000100010001ULL;
1381 
1382  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1383  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1384  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1385  (dstFilter->chrV && dstFilter->chrV->length > 1);
1386  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1387  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1388  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1389  (dstFilter->chrH && dstFilter->chrH->length > 1);
1390 
1391  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1392  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1393 
1394  c->dst_slice_align = 1 << c->chrDstVSubSample;
1395 
1396  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1397  if (dstW&1) {
1398  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1400  c->flags = flags;
1401  }
1402 
1403  if ( c->chrSrcHSubSample == 0
1404  && c->chrSrcVSubSample == 0
1405  && c->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1406  && !(c->flags & SWS_FAST_BILINEAR)
1407  ) {
1408  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1410  c->flags = flags;
1411  }
1412  }
1413 
1414  if (c->dither == SWS_DITHER_AUTO) {
1415  if (flags & SWS_ERROR_DIFFUSION)
1416  c->dither = SWS_DITHER_ED;
1417  }
1418 
1419  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1420  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1421  dstFormat == AV_PIX_FMT_BGR8 ||
1422  dstFormat == AV_PIX_FMT_RGB8) {
1423  if (c->dither == SWS_DITHER_AUTO)
1425  if (!(flags & SWS_FULL_CHR_H_INT)) {
1426  if (c->dither == SWS_DITHER_ED || c->dither == SWS_DITHER_A_DITHER || c->dither == SWS_DITHER_X_DITHER || c->dither == SWS_DITHER_NONE) {
1428  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1429  av_get_pix_fmt_name(dstFormat));
1431  c->flags = flags;
1432  }
1433  }
1434  if (flags & SWS_FULL_CHR_H_INT) {
1435  if (c->dither == SWS_DITHER_BAYER) {
1437  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1438  av_get_pix_fmt_name(dstFormat));
1439  c->dither = SWS_DITHER_ED;
1440  }
1441  }
1442  }
1443  if (isPlanarRGB(dstFormat)) {
1444  if (!(flags & SWS_FULL_CHR_H_INT)) {
1446  "%s output is not supported with half chroma resolution, switching to full\n",
1447  av_get_pix_fmt_name(dstFormat));
1449  c->flags = flags;
1450  }
1451  }
1452 
1453  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1454  * chroma interpolation */
1455  if (flags & SWS_FULL_CHR_H_INT &&
1456  isAnyRGB(dstFormat) &&
1457  !isPlanarRGB(dstFormat) &&
1458  dstFormat != AV_PIX_FMT_RGBA64LE &&
1459  dstFormat != AV_PIX_FMT_RGBA64BE &&
1460  dstFormat != AV_PIX_FMT_BGRA64LE &&
1461  dstFormat != AV_PIX_FMT_BGRA64BE &&
1462  dstFormat != AV_PIX_FMT_RGB48LE &&
1463  dstFormat != AV_PIX_FMT_RGB48BE &&
1464  dstFormat != AV_PIX_FMT_BGR48LE &&
1465  dstFormat != AV_PIX_FMT_BGR48BE &&
1466  dstFormat != AV_PIX_FMT_RGBA &&
1467  dstFormat != AV_PIX_FMT_ARGB &&
1468  dstFormat != AV_PIX_FMT_BGRA &&
1469  dstFormat != AV_PIX_FMT_ABGR &&
1470  dstFormat != AV_PIX_FMT_RGB24 &&
1471  dstFormat != AV_PIX_FMT_BGR24 &&
1472  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1473  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1474  dstFormat != AV_PIX_FMT_BGR8 &&
1475  dstFormat != AV_PIX_FMT_RGB8
1476  ) {
1478  "full chroma interpolation for destination format '%s' not yet implemented\n",
1479  av_get_pix_fmt_name(dstFormat));
1481  c->flags = flags;
1482  }
1483  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1484  c->chrDstHSubSample = 1;
1485 
1486  // drop some chroma lines if the user wants it
1487  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1489  c->chrSrcVSubSample += c->vChrDrop;
1490 
1491  /* drop every other pixel for chroma calculation unless user
1492  * wants full chroma */
1493  if (isAnyRGB(srcFormat) && !(flags & SWS_FULL_CHR_H_INP) &&
1494  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1495  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1496  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1497  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1498  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1499  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1500  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1501  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1502  srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE &&
1503  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1504  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1505  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1506  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1507  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1508  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1509  (flags & SWS_FAST_BILINEAR)))
1510  c->chrSrcHSubSample = 1;
1511 
1512  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1513  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1514  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1515  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1516  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1517 
1518  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1519  goto nomem;
1520 
1521  c->srcBpc = desc_src->comp[0].depth;
1522  if (c->srcBpc < 8)
1523  c->srcBpc = 8;
1524  c->dstBpc = desc_dst->comp[0].depth;
1525  if (c->dstBpc < 8)
1526  c->dstBpc = 8;
1527  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1528  c->srcBpc = 16;
1529  if (c->dstBpc == 16)
1530  dst_stride <<= 1;
1531 
1532  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1533  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1534  c->chrDstW >= c->chrSrcW &&
1535  (srcW & 15) == 0;
1536  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1537 
1538  && (flags & SWS_FAST_BILINEAR)) {
1539  if (flags & SWS_PRINT_INFO)
1540  av_log(c, AV_LOG_INFO,
1541  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1542  }
1543  if (usesHFilter || isNBPS(c->srcFormat) || is16BPS(c->srcFormat) || isAnyRGB(c->srcFormat))
1544  c->canMMXEXTBeUsed = 0;
1545  } else
1546  c->canMMXEXTBeUsed = 0;
1547 
1548  c->chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1549  c->chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1550 
1551  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1552  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1553  * correct scaling.
1554  * n-2 is the last chrominance sample available.
1555  * This is not perfect, but no one should notice the difference, the more
1556  * correct variant would be like the vertical one, but that would require
1557  * some special code for the first and last pixel */
1558  if (flags & SWS_FAST_BILINEAR) {
1559  if (c->canMMXEXTBeUsed) {
1560  c->lumXInc += 20;
1561  c->chrXInc += 20;
1562  }
1563  // we don't use the x86 asm scaler if MMX is available
1564  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1565  c->lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1566  c->chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1567  }
1568  }
1569 
1570  // hardcoded for now
1571  c->gamma_value = 2.2;
1572  tmpFmt = AV_PIX_FMT_RGBA64LE;
1573 
1574 
1575  if (!unscaled && c->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1576  SwsContext *c2;
1577  c->cascaded_context[0] = NULL;
1578 
1579  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1580  srcW, srcH, tmpFmt, 64);
1581  if (ret < 0)
1582  return ret;
1583 
1584  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1585  srcW, srcH, tmpFmt,
1586  flags, NULL, NULL, c->param);
1587  if (!c->cascaded_context[0]) {
1588  return AVERROR(ENOMEM);
1589  }
1590 
1591  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1592  dstW, dstH, tmpFmt,
1593  flags, srcFilter, dstFilter, c->param);
1594 
1595  if (!c->cascaded_context[1])
1596  return AVERROR(ENOMEM);
1597 
1598  c2 = c->cascaded_context[1];
1599  c2->is_internal_gamma = 1;
1600  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1601  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1602  if (!c2->gamma || !c2->inv_gamma)
1603  return AVERROR(ENOMEM);
1604 
1605  // is_internal_flag is set after creating the context
1606  // to properly create the gamma convert FilterDescriptor
1607  // we have to re-initialize it
1609  if ((ret = ff_init_filters(c2)) < 0) {
1611  c->cascaded_context[1] = NULL;
1612  return ret;
1613  }
1614 
1615  c->cascaded_context[2] = NULL;
1616  if (dstFormat != tmpFmt) {
1617  ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1618  dstW, dstH, tmpFmt, 64);
1619  if (ret < 0)
1620  return ret;
1621 
1622  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1623  dstW, dstH, dstFormat,
1624  flags, NULL, NULL, c->param);
1625  if (!c->cascaded_context[2])
1626  return AVERROR(ENOMEM);
1627  }
1628  return 0;
1629  }
1630 
1631  if (isBayer(srcFormat)) {
1632  if (!unscaled ||
1633  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1634  dstFormat != AV_PIX_FMT_RGB48)) {
1635  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1636 
1637  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1638  srcW, srcH, tmpFormat, 64);
1639  if (ret < 0)
1640  return ret;
1641 
1642  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1643  srcW, srcH, tmpFormat,
1644  flags, srcFilter, NULL, c->param);
1645  if (!c->cascaded_context[0])
1646  return AVERROR(ENOMEM);
1647 
1648  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1649  dstW, dstH, dstFormat,
1650  flags, NULL, dstFilter, c->param);
1651  if (!c->cascaded_context[1])
1652  return AVERROR(ENOMEM);
1653  return 0;
1654  }
1655  }
1656 
1657  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1658  for (i = 0; i < 256; ++i){
1659  c->uint2float_lut[i] = (float)i * float_mult;
1660  }
1661  }
1662 
1663  // float will be converted to uint16_t
1664  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1665  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1666  dstFormat != AV_PIX_FMT_GRAY8))){
1667  c->srcBpc = 16;
1668  }
1669 
1670  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1671  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1672 
1673  if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE) {
1674  if (!unscaled ||
1675  dstFormat != tmpFormat ||
1676  usesHFilter || usesVFilter ||
1677  c->srcRange != c->dstRange
1678  ) {
1679  c->cascaded_mainindex = 1;
1680  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1681  srcW, srcH, tmpFormat, 64);
1682  if (ret < 0)
1683  return ret;
1684 
1685  c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
1686  srcW, srcH, tmpFormat,
1687  flags, c->param);
1688  if (!c->cascaded_context[0])
1689  return AVERROR(EINVAL);
1690  c->cascaded_context[0]->alphablend = c->alphablend;
1691  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1692  if (ret < 0)
1693  return ret;
1694 
1695  c->cascaded_context[1] = sws_alloc_set_opts(srcW, srcH, tmpFormat,
1696  dstW, dstH, dstFormat,
1697  flags, c->param);
1698  if (!c->cascaded_context[1])
1699  return AVERROR(EINVAL);
1700 
1701  c->cascaded_context[1]->srcRange = c->srcRange;
1702  c->cascaded_context[1]->dstRange = c->dstRange;
1703  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1704  if (ret < 0)
1705  return ret;
1706 
1707  return 0;
1708  }
1709  }
1710  }
1711 
1712  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1713  if (unscaled && !usesHFilter && !usesVFilter &&
1714  c->alphablend != SWS_ALPHA_BLEND_NONE &&
1715  isALPHA(srcFormat) &&
1716  (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
1717  alphaless_fmt(srcFormat) == dstFormat
1718  ) {
1719  c->convert_unscaled = ff_sws_alphablendaway;
1720 
1721  if (flags & SWS_PRINT_INFO)
1722  av_log(c, AV_LOG_INFO,
1723  "using alpha blendaway %s -> %s special converter\n",
1724  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1725  return 0;
1726  }
1727 
1728  /* unscaled special cases */
1729  if (unscaled && !usesHFilter && !usesVFilter &&
1730  (c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
1731  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1732 
1734 
1735  if (c->convert_unscaled) {
1736  if (flags & SWS_PRINT_INFO)
1737  av_log(c, AV_LOG_INFO,
1738  "using unscaled %s -> %s special converter\n",
1739  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1740  return 0;
1741  }
1742  }
1743 
1744 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1745 #define USE_MMAP 1
1746 #else
1747 #define USE_MMAP 0
1748 #endif
1749 
1750  /* precalculate horizontal scaler filter coefficients */
1751  {
1752 #if HAVE_MMXEXT_INLINE
1753 // can't downscale !!!
1754  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1755  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1756  NULL, NULL, 8);
1757  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1758  NULL, NULL, NULL, 4);
1759 
1760 #if USE_MMAP
1761  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1762  PROT_READ | PROT_WRITE,
1763  MAP_PRIVATE | MAP_ANONYMOUS,
1764  -1, 0);
1765  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1766  PROT_READ | PROT_WRITE,
1767  MAP_PRIVATE | MAP_ANONYMOUS,
1768  -1, 0);
1769 #elif HAVE_VIRTUALALLOC
1770  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1771  c->lumMmxextFilterCodeSize,
1772  MEM_COMMIT,
1773  PAGE_EXECUTE_READWRITE);
1774  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1775  c->chrMmxextFilterCodeSize,
1776  MEM_COMMIT,
1777  PAGE_EXECUTE_READWRITE);
1778 #else
1779  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1780  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1781 #endif
1782 
1783 #ifdef MAP_ANONYMOUS
1784  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1785 #else
1786  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1787 #endif
1788  {
1789  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1790  return AVERROR(ENOMEM);
1791  }
1792 
1793  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1794  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1795  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1796  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1797  goto nomem;
1798 
1799  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1800  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1801  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1802  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1803 
1804 #if USE_MMAP
1805  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1806  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1807  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1808  ret = AVERROR(EINVAL);
1809  goto fail;
1810  }
1811 #endif
1812  } else
1813 #endif /* HAVE_MMXEXT_INLINE */
1814  {
1815  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1816  PPC_ALTIVEC(cpu_flags) ? 8 :
1817  have_neon(cpu_flags) ? 4 :
1818  have_lsx(cpu_flags) ? 8 :
1819  have_lasx(cpu_flags) ? 8 : 1;
1820 
1821  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1822  &c->hLumFilterSize, c->lumXInc,
1823  srcW, dstW, filterAlign, 1 << 14,
1825  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1826  c->param,
1827  get_local_pos(c, 0, 0, 0),
1828  get_local_pos(c, 0, 0, 0))) < 0)
1829  goto fail;
1830  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1831  goto nomem;
1832  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1833  &c->hChrFilterSize, c->chrXInc,
1834  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1836  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1837  c->param,
1838  get_local_pos(c, c->chrSrcHSubSample, c->src_h_chr_pos, 0),
1839  get_local_pos(c, c->chrDstHSubSample, c->dst_h_chr_pos, 0))) < 0)
1840  goto fail;
1841  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1842  goto nomem;
1843  }
1844  } // initialize horizontal stuff
1845 
1846  /* precalculate vertical scaler filter coefficients */
1847  {
1848  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1849  PPC_ALTIVEC(cpu_flags) ? 8 :
1850  have_neon(cpu_flags) ? 2 : 1;
1851 
1852  if ((ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1853  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1855  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1856  c->param,
1857  get_local_pos(c, 0, 0, 1),
1858  get_local_pos(c, 0, 0, 1))) < 0)
1859  goto fail;
1860  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1861  c->chrYInc, c->chrSrcH, c->chrDstH,
1862  filterAlign, (1 << 12),
1864  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1865  c->param,
1866  get_local_pos(c, c->chrSrcVSubSample, c->src_v_chr_pos, 1),
1867  get_local_pos(c, c->chrDstVSubSample, c->dst_v_chr_pos, 1))) < 0)
1868 
1869  goto fail;
1870 
1871 #if HAVE_ALTIVEC
1872  if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->dstH) ||
1873  !FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1874  goto nomem;
1875 
1876  for (i = 0; i < c->vLumFilterSize * c->dstH; i++) {
1877  int j;
1878  short *p = (short *)&c->vYCoeffsBank[i];
1879  for (j = 0; j < 8; j++)
1880  p[j] = c->vLumFilter[i];
1881  }
1882 
1883  for (i = 0; i < c->vChrFilterSize * c->chrDstH; i++) {
1884  int j;
1885  short *p = (short *)&c->vCCoeffsBank[i];
1886  for (j = 0; j < 8; j++)
1887  p[j] = c->vChrFilter[i];
1888  }
1889 #endif
1890  }
1891 
1892  for (i = 0; i < 4; i++)
1893  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->dstW + 3))
1894  goto nomem;
1895 
1896  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) ? 1 : 0;
1897 
1898  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1899  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1900  c->uv_offx2 = dst_stride + 16;
1901 
1902  av_assert0(c->chrDstH <= dstH);
1903 
1904  if (flags & SWS_PRINT_INFO) {
1905  const char *scaler = NULL, *cpucaps;
1906 
1907  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1908  if (flags & scale_algorithms[i].flag) {
1909  scaler = scale_algorithms[i].description;
1910  break;
1911  }
1912  }
1913  if (!scaler)
1914  scaler = "ehh flags invalid?!";
1915  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1916  scaler,
1917  av_get_pix_fmt_name(srcFormat),
1918 #ifdef DITHER1XBPP
1919  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1920  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1921  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1922  "dithered " : "",
1923 #else
1924  "",
1925 #endif
1926  av_get_pix_fmt_name(dstFormat));
1927 
1928  if (INLINE_MMXEXT(cpu_flags))
1929  cpucaps = "MMXEXT";
1930  else if (INLINE_MMX(cpu_flags))
1931  cpucaps = "MMX";
1932  else if (PPC_ALTIVEC(cpu_flags))
1933  cpucaps = "AltiVec";
1934  else
1935  cpucaps = "C";
1936 
1937  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1938 
1939  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1941  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1942  c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
1944  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1945  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1946  c->chrXInc, c->chrYInc);
1947  }
1948 
1950 
1951  return ff_init_filters(c);
1952 nomem:
1953  ret = AVERROR(ENOMEM);
1954 fail: // FIXME replace things by appropriate error codes
1955  if (ret == RETCODE_USE_CASCADE) {
1956  int tmpW = sqrt(srcW * (int64_t)dstW);
1957  int tmpH = sqrt(srcH * (int64_t)dstH);
1958  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1959 
1960  if (isALPHA(srcFormat))
1961  tmpFormat = AV_PIX_FMT_YUVA420P;
1962 
1963  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1964  return AVERROR(EINVAL);
1965 
1966  ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
1967  tmpW, tmpH, tmpFormat, 64);
1968  if (ret < 0)
1969  return ret;
1970 
1971  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1972  tmpW, tmpH, tmpFormat,
1973  flags, srcFilter, NULL, c->param);
1974  if (!c->cascaded_context[0])
1975  return AVERROR(ENOMEM);
1976 
1977  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
1978  dstW, dstH, dstFormat,
1979  flags, NULL, dstFilter, c->param);
1980  if (!c->cascaded_context[1])
1981  return AVERROR(ENOMEM);
1982  return 0;
1983  }
1984  return ret;
1985 }
1986 
1988  SwsFilter *src_filter, SwsFilter *dst_filter)
1989 {
1990  int ret;
1991 
1992  ret = avpriv_slicethread_create(&c->slicethread, (void*)c,
1993  ff_sws_slice_worker, NULL, c->nb_threads);
1994  if (ret == AVERROR(ENOSYS)) {
1995  c->nb_threads = 1;
1996  return 0;
1997  } else if (ret < 0)
1998  return ret;
1999 
2000  c->nb_threads = ret;
2001 
2002  c->slice_ctx = av_calloc(c->nb_threads, sizeof(*c->slice_ctx));
2003  c->slice_err = av_calloc(c->nb_threads, sizeof(*c->slice_err));
2004  if (!c->slice_ctx || !c->slice_err)
2005  return AVERROR(ENOMEM);
2006 
2007  for (int i = 0; i < c->nb_threads; i++) {
2008  c->slice_ctx[i] = sws_alloc_context();
2009  if (!c->slice_ctx[i])
2010  return AVERROR(ENOMEM);
2011 
2012  c->slice_ctx[i]->parent = c;
2013 
2014  ret = av_opt_copy((void*)c->slice_ctx[i], (void*)c);
2015  if (ret < 0)
2016  return ret;
2017 
2018  c->slice_ctx[i]->nb_threads = 1;
2019 
2020  ret = sws_init_single_context(c->slice_ctx[i], src_filter, dst_filter);
2021  if (ret < 0)
2022  return ret;
2023 
2024  c->nb_slice_ctx++;
2025 
2026  if (c->slice_ctx[i]->dither == SWS_DITHER_ED) {
2028  "Error-diffusion dither is in use, scaling will be single-threaded.");
2029  break;
2030  }
2031  }
2032 
2033  return 0;
2034 }
2035 
2037  SwsFilter *dstFilter)
2038 {
2039  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
2040  enum AVPixelFormat src_format, dst_format;
2041  int ret;
2042 
2043  c->frame_src = av_frame_alloc();
2044  c->frame_dst = av_frame_alloc();
2045  if (!c->frame_src || !c->frame_dst)
2046  return AVERROR(ENOMEM);
2047 
2048  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
2049  return AVERROR_UNKNOWN;
2050 
2051  src_format = c->srcFormat;
2052  dst_format = c->dstFormat;
2053  c->srcRange |= handle_jpeg(&c->srcFormat);
2054  c->dstRange |= handle_jpeg(&c->dstFormat);
2055 
2056  if (src_format != c->srcFormat || dst_format != c->dstFormat)
2057  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
2058 
2059  if (c->nb_threads != 1) {
2060  ret = context_init_threaded(c, srcFilter, dstFilter);
2061  if (ret < 0 || c->nb_threads > 1)
2062  return ret;
2063  // threading disabled in this build, init as single-threaded
2064  }
2065 
2066  return sws_init_single_context(c, srcFilter, dstFilter);
2067 }
2068 
2069 SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
2070  int dstW, int dstH, enum AVPixelFormat dstFormat,
2071  int flags, const double *param)
2072 {
2073  SwsContext *c;
2074 
2075  if (!(c = sws_alloc_context()))
2076  return NULL;
2077 
2078  c->flags = flags;
2079  c->srcW = srcW;
2080  c->srcH = srcH;
2081  c->dstW = dstW;
2082  c->dstH = dstH;
2083  c->srcFormat = srcFormat;
2084  c->dstFormat = dstFormat;
2085 
2086  if (param) {
2087  c->param[0] = param[0];
2088  c->param[1] = param[1];
2089  }
2090 
2091  return c;
2092 }
2093 
2094 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
2095  int dstW, int dstH, enum AVPixelFormat dstFormat,
2096  int flags, SwsFilter *srcFilter,
2097  SwsFilter *dstFilter, const double *param)
2098 {
2099  SwsContext *c;
2100 
2101  c = sws_alloc_set_opts(srcW, srcH, srcFormat,
2102  dstW, dstH, dstFormat,
2103  flags, param);
2104  if (!c)
2105  return NULL;
2106 
2107  if (sws_init_context(c, srcFilter, dstFilter) < 0) {
2108  sws_freeContext(c);
2109  return NULL;
2110  }
2111 
2112  return c;
2113 }
2114 
2115 static int isnan_vec(SwsVector *a)
2116 {
2117  int i;
2118  for (i=0; i<a->length; i++)
2119  if (isnan(a->coeff[i]))
2120  return 1;
2121  return 0;
2122 }
2123 
2124 static void makenan_vec(SwsVector *a)
2125 {
2126  int i;
2127  for (i=0; i<a->length; i++)
2128  a->coeff[i] = NAN;
2129 }
2130 
2132 {
2133  SwsVector *vec;
2134 
2135  if(length <= 0 || length > INT_MAX/ sizeof(double))
2136  return NULL;
2137 
2138  vec = av_malloc(sizeof(SwsVector));
2139  if (!vec)
2140  return NULL;
2141  vec->length = length;
2142  vec->coeff = av_malloc(sizeof(double) * length);
2143  if (!vec->coeff)
2144  av_freep(&vec);
2145  return vec;
2146 }
2147 
2148 SwsVector *sws_getGaussianVec(double variance, double quality)
2149 {
2150  const int length = (int)(variance * quality + 0.5) | 1;
2151  int i;
2152  double middle = (length - 1) * 0.5;
2153  SwsVector *vec;
2154 
2155  if(variance < 0 || quality < 0)
2156  return NULL;
2157 
2158  vec = sws_allocVec(length);
2159 
2160  if (!vec)
2161  return NULL;
2162 
2163  for (i = 0; i < length; i++) {
2164  double dist = i - middle;
2165  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2166  sqrt(2 * variance * M_PI);
2167  }
2168 
2169  sws_normalizeVec(vec, 1.0);
2170 
2171  return vec;
2172 }
2173 
2174 /**
2175  * Allocate and return a vector with length coefficients, all
2176  * with the same value c.
2177  */
2178 static
2179 SwsVector *sws_getConstVec(double c, int length)
2180 {
2181  int i;
2182  SwsVector *vec = sws_allocVec(length);
2183 
2184  if (!vec)
2185  return NULL;
2186 
2187  for (i = 0; i < length; i++)
2188  vec->coeff[i] = c;
2189 
2190  return vec;
2191 }
2192 
2193 /**
2194  * Allocate and return a vector with just one coefficient, with
2195  * value 1.0.
2196  */
2197 static
2199 {
2200  return sws_getConstVec(1.0, 1);
2201 }
2202 
2203 static double sws_dcVec(SwsVector *a)
2204 {
2205  int i;
2206  double sum = 0;
2207 
2208  for (i = 0; i < a->length; i++)
2209  sum += a->coeff[i];
2210 
2211  return sum;
2212 }
2213 
2214 void sws_scaleVec(SwsVector *a, double scalar)
2215 {
2216  int i;
2217 
2218  for (i = 0; i < a->length; i++)
2219  a->coeff[i] *= scalar;
2220 }
2221 
2223 {
2225 }
2226 
2228 {
2229  int length = FFMAX(a->length, b->length);
2230  int i;
2231  SwsVector *vec = sws_getConstVec(0.0, length);
2232 
2233  if (!vec)
2234  return NULL;
2235 
2236  for (i = 0; i < a->length; i++)
2237  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2238  for (i = 0; i < b->length; i++)
2239  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2240 
2241  return vec;
2242 }
2243 
2244 /* shift left / or right if "shift" is negative */
2246 {
2247  int length = a->length + FFABS(shift) * 2;
2248  int i;
2249  SwsVector *vec = sws_getConstVec(0.0, length);
2250 
2251  if (!vec)
2252  return NULL;
2253 
2254  for (i = 0; i < a->length; i++) {
2255  vec->coeff[i + (length - 1) / 2 -
2256  (a->length - 1) / 2 - shift] = a->coeff[i];
2257  }
2258 
2259  return vec;
2260 }
2261 
2262 static
2264 {
2265  SwsVector *shifted = sws_getShiftedVec(a, shift);
2266  if (!shifted) {
2267  makenan_vec(a);
2268  return;
2269  }
2270  av_free(a->coeff);
2271  a->coeff = shifted->coeff;
2272  a->length = shifted->length;
2273  av_free(shifted);
2274 }
2275 
2276 static
2278 {
2279  SwsVector *sum = sws_sumVec(a, b);
2280  if (!sum) {
2281  makenan_vec(a);
2282  return;
2283  }
2284  av_free(a->coeff);
2285  a->coeff = sum->coeff;
2286  a->length = sum->length;
2287  av_free(sum);
2288 }
2289 
2290 /**
2291  * Print with av_log() a textual representation of the vector a
2292  * if log_level <= av_log_level.
2293  */
2294 static
2295 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2296 {
2297  int i;
2298  double max = 0;
2299  double min = 0;
2300  double range;
2301 
2302  for (i = 0; i < a->length; i++)
2303  if (a->coeff[i] > max)
2304  max = a->coeff[i];
2305 
2306  for (i = 0; i < a->length; i++)
2307  if (a->coeff[i] < min)
2308  min = a->coeff[i];
2309 
2310  range = max - min;
2311 
2312  for (i = 0; i < a->length; i++) {
2313  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2314  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2315  for (; x > 0; x--)
2316  av_log(log_ctx, log_level, " ");
2317  av_log(log_ctx, log_level, "|\n");
2318  }
2319 }
2320 
2322 {
2323  if (!a)
2324  return;
2325  av_freep(&a->coeff);
2326  a->length = 0;
2327  av_free(a);
2328 }
2329 
2331 {
2332  if (!filter)
2333  return;
2334 
2335  sws_freeVec(filter->lumH);
2336  sws_freeVec(filter->lumV);
2337  sws_freeVec(filter->chrH);
2338  sws_freeVec(filter->chrV);
2339  av_free(filter);
2340 }
2341 
2342 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2343  float lumaSharpen, float chromaSharpen,
2344  float chromaHShift, float chromaVShift,
2345  int verbose)
2346 {
2347  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2348  if (!filter)
2349  return NULL;
2350 
2351  if (lumaGBlur != 0.0) {
2352  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2353  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2354  } else {
2355  filter->lumH = sws_getIdentityVec();
2356  filter->lumV = sws_getIdentityVec();
2357  }
2358 
2359  if (chromaGBlur != 0.0) {
2360  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2361  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2362  } else {
2363  filter->chrH = sws_getIdentityVec();
2364  filter->chrV = sws_getIdentityVec();
2365  }
2366 
2367  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2368  goto fail;
2369 
2370  if (chromaSharpen != 0.0) {
2371  SwsVector *id = sws_getIdentityVec();
2372  if (!id)
2373  goto fail;
2374  sws_scaleVec(filter->chrH, -chromaSharpen);
2375  sws_scaleVec(filter->chrV, -chromaSharpen);
2376  sws_addVec(filter->chrH, id);
2377  sws_addVec(filter->chrV, id);
2378  sws_freeVec(id);
2379  }
2380 
2381  if (lumaSharpen != 0.0) {
2382  SwsVector *id = sws_getIdentityVec();
2383  if (!id)
2384  goto fail;
2385  sws_scaleVec(filter->lumH, -lumaSharpen);
2386  sws_scaleVec(filter->lumV, -lumaSharpen);
2387  sws_addVec(filter->lumH, id);
2388  sws_addVec(filter->lumV, id);
2389  sws_freeVec(id);
2390  }
2391 
2392  if (chromaHShift != 0.0)
2393  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2394 
2395  if (chromaVShift != 0.0)
2396  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2397 
2398  sws_normalizeVec(filter->chrH, 1.0);
2399  sws_normalizeVec(filter->chrV, 1.0);
2400  sws_normalizeVec(filter->lumH, 1.0);
2401  sws_normalizeVec(filter->lumV, 1.0);
2402 
2403  if (isnan_vec(filter->chrH) ||
2404  isnan_vec(filter->chrV) ||
2405  isnan_vec(filter->lumH) ||
2406  isnan_vec(filter->lumV))
2407  goto fail;
2408 
2409  if (verbose)
2411  if (verbose)
2413 
2414  return filter;
2415 
2416 fail:
2417  sws_freeVec(filter->lumH);
2418  sws_freeVec(filter->lumV);
2419  sws_freeVec(filter->chrH);
2420  sws_freeVec(filter->chrV);
2421  av_freep(&filter);
2422  return NULL;
2423 }
2424 
2426 {
2427  int i;
2428  if (!c)
2429  return;
2430 
2431  for (i = 0; i < c->nb_slice_ctx; i++)
2432  sws_freeContext(c->slice_ctx[i]);
2433  av_freep(&c->slice_ctx);
2434  av_freep(&c->slice_err);
2435 
2436  avpriv_slicethread_free(&c->slicethread);
2437 
2438  for (i = 0; i < 4; i++)
2439  av_freep(&c->dither_error[i]);
2440 
2441  av_frame_free(&c->frame_src);
2442  av_frame_free(&c->frame_dst);
2443 
2444  av_freep(&c->src_ranges.ranges);
2445 
2446  av_freep(&c->vLumFilter);
2447  av_freep(&c->vChrFilter);
2448  av_freep(&c->hLumFilter);
2449  av_freep(&c->hChrFilter);
2450 #if HAVE_ALTIVEC
2451  av_freep(&c->vYCoeffsBank);
2452  av_freep(&c->vCCoeffsBank);
2453 #endif
2454 
2455  av_freep(&c->vLumFilterPos);
2456  av_freep(&c->vChrFilterPos);
2457  av_freep(&c->hLumFilterPos);
2458  av_freep(&c->hChrFilterPos);
2459 
2460 #if HAVE_MMX_INLINE
2461 #if USE_MMAP
2462  if (c->lumMmxextFilterCode)
2463  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2464  if (c->chrMmxextFilterCode)
2465  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2466 #elif HAVE_VIRTUALALLOC
2467  if (c->lumMmxextFilterCode)
2468  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2469  if (c->chrMmxextFilterCode)
2470  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2471 #else
2472  av_free(c->lumMmxextFilterCode);
2473  av_free(c->chrMmxextFilterCode);
2474 #endif
2475  c->lumMmxextFilterCode = NULL;
2476  c->chrMmxextFilterCode = NULL;
2477 #endif /* HAVE_MMX_INLINE */
2478 
2479  av_freep(&c->yuvTable);
2480  av_freep(&c->formatConvBuffer);
2481 
2482  sws_freeContext(c->cascaded_context[0]);
2483  sws_freeContext(c->cascaded_context[1]);
2484  sws_freeContext(c->cascaded_context[2]);
2485  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2486  av_freep(&c->cascaded_tmp[0]);
2487  av_freep(&c->cascaded1_tmp[0]);
2488 
2489  av_freep(&c->gamma);
2490  av_freep(&c->inv_gamma);
2491 
2492  av_freep(&c->rgb0_scratch);
2493  av_freep(&c->xyz_scratch);
2494 
2495  ff_free_filters(c);
2496 
2497  av_free(c);
2498 }
2499 
2501  int srcH, enum AVPixelFormat srcFormat,
2502  int dstW, int dstH,
2503  enum AVPixelFormat dstFormat, int flags,
2504  SwsFilter *srcFilter,
2505  SwsFilter *dstFilter,
2506  const double *param)
2507 {
2508  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2510  int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
2511  src_v_chr_pos = -513, dst_v_chr_pos = -513;
2512 
2513  if (!param)
2514  param = default_param;
2515 
2516  if (context &&
2517  (context->srcW != srcW ||
2518  context->srcH != srcH ||
2519  context->srcFormat != srcFormat ||
2520  context->dstW != dstW ||
2521  context->dstH != dstH ||
2522  context->dstFormat != dstFormat ||
2523  context->flags != flags ||
2524  context->param[0] != param[0] ||
2525  context->param[1] != param[1])) {
2526 
2527  av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
2528  av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
2529  av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
2530  av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
2532  context = NULL;
2533  }
2534 
2535  if (!context) {
2536  if (!(context = sws_alloc_context()))
2537  return NULL;
2538  context->srcW = srcW;
2539  context->srcH = srcH;
2540  context->srcFormat = srcFormat;
2541  context->dstW = dstW;
2542  context->dstH = dstH;
2543  context->dstFormat = dstFormat;
2544  context->flags = flags;
2545  context->param[0] = param[0];
2546  context->param[1] = param[1];
2547 
2548  av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
2549  av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
2550  av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
2551  av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
2552 
2553  if (sws_init_context(context, srcFilter, dstFilter) < 0) {
2555  return NULL;
2556  }
2557  }
2558  return context;
2559 }
2560 
2561 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2562 {
2563  Range *tmp;
2564  unsigned int idx;
2565 
2566  /* find the first existing range after the new one */
2567  for (idx = 0; idx < rl->nb_ranges; idx++)
2568  if (rl->ranges[idx].start > start)
2569  break;
2570 
2571  /* check for overlap */
2572  if (idx > 0) {
2573  Range *prev = &rl->ranges[idx - 1];
2574  if (prev->start + prev->len > start)
2575  return AVERROR(EINVAL);
2576  }
2577  if (idx < rl->nb_ranges) {
2578  Range *next = &rl->ranges[idx];
2579  if (start + len > next->start)
2580  return AVERROR(EINVAL);
2581  }
2582 
2584  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2585  if (!tmp)
2586  return AVERROR(ENOMEM);
2587  rl->ranges = tmp;
2588 
2589  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2590  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2591  rl->ranges[idx].start = start;
2592  rl->ranges[idx].len = len;
2593  rl->nb_ranges++;
2594 
2595  /* merge ranges */
2596  if (idx > 0) {
2597  Range *prev = &rl->ranges[idx - 1];
2598  Range *cur = &rl->ranges[idx];
2599  if (prev->start + prev->len == cur->start) {
2600  prev->len += cur->len;
2601  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2602  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2603  rl->nb_ranges--;
2604  idx--;
2605  }
2606  }
2607  if (idx < rl->nb_ranges - 1) {
2608  Range *cur = &rl->ranges[idx];
2609  Range *next = &rl->ranges[idx + 1];
2610  if (cur->start + cur->len == next->start) {
2611  cur->len += next->len;
2612  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2613  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2614  rl->nb_ranges--;
2615  }
2616  }
2617 
2618  return 0;
2619 }
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:2500
INLINE_MMX
#define INLINE_MMX(flags)
Definition: cpu.h:87
A
#define A(x)
Definition: vpx_arith.h:28
AV_PIX_FMT_XYZ12LE
@ AV_PIX_FMT_XYZ12LE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as lit...
Definition: pixfmt.h:196
av_pix_fmt_swap_endianness
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
Definition: pixdesc.c:3023
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:154
AV_PIX_FMT_XV30LE
@ AV_PIX_FMT_XV30LE
packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channe...
Definition: pixfmt.h:419
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:324
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:71
W
@ W
Definition: vf_addroi.c:27
AV_PIX_FMT_BAYER_GBRG16LE
@ AV_PIX_FMT_BAYER_GBRG16LE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:293
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:146
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:886
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:1435
cpu.h
AV_PIX_FMT_P416BE
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
Definition: pixfmt.h:402
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:140
SWS_ALPHA_BLEND_NONE
@ SWS_ALPHA_BLEND_NONE
Definition: swscale_internal.h:80
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:204
sws_getIdentityVec
static SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
Definition: utils.c:2198
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:514
libm.h
fill_xyztables
static void fill_xyztables(struct SwsContext *c)
Definition: utils.c: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:136
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:274
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h: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:185
pixdesc.h
RV_IDX
#define RV_IDX
Definition: swscale_internal.h:446
alphaless_fmt
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
Definition: utils.c:1210
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
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:305
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:348
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:345
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:433
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:312
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:82
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:448
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:269
have_lasx
#define have_lasx(flags)
Definition: cpu.h:29
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:482
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:128
isGray
#define isGray(x)
Definition: swscale.c:42
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2920
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:103
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:163
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:179
sws_getShiftedVec
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
Definition: utils.c:2245
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_PIX_FMT_BAYER_GRBG16BE
@ AV_PIX_FMT_BAYER_GRBG16BE
bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:296
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:52
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:325
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:368
AV_PIX_FMT_GBRAP14BE
@ AV_PIX_FMT_GBRAP14BE
planar GBR 4:4:4:4 56bpp, big-endian
Definition: pixfmt.h:436
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:114
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
AV_PIX_FMT_RGBAF16LE
@ AV_PIX_FMT_RGBAF16LE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian.
Definition: pixfmt.h:408
sws_freeVec
void sws_freeVec(SwsVector *a)
Definition: utils.c:2321
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:306
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:132
AV_PIX_FMT_BAYER_GBRG16BE
@ AV_PIX_FMT_BAYER_GBRG16BE
bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:294
sws_init_single_context
static int sws_init_single_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Definition: utils.c:1274
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:2115
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:315
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:104
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:500
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:268
avpriv_slicethread_create
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
Definition: slicethread.c:240
fail
#define fail()
Definition: checkasm.h:179
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:465
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:498
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:480
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:343
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:2996
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:466
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:191
SWS_POINT
#define SWS_POINT
Definition: swscale.h:69
AV_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:161
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:156
AV_CPU_FLAG_SLOW_GATHER
#define AV_CPU_FLAG_SLOW_GATHER
CPU has slow gathers.
Definition: cpu.h:58
AV_PIX_FMT_VUYA
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4, 32bpp, VUYAVUYA...
Definition: pixfmt.h:405
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:276
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:485
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:283
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:271
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:278
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
lrint
#define lrint
Definition: tablegen.h:53
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_PIX_FMT_BAYER_RGGB16BE
@ AV_PIX_FMT_BAYER_RGGB16BE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:292
initFilter
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[2], int srcPos, int dstPos)
Definition: utils.c: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:494
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:73
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
SWS_MAX_REDUCE_CUTOFF
#define SWS_MAX_REDUCE_CUTOFF
Definition: swscale.h: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:2561
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
sws_printVec2
static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
Print with av_log() a textual representation of the vector a if log_level <= av_log_level.
Definition: utils.c:2295
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:172
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
AV_PIX_FMT_P416LE
@ AV_PIX_FMT_P416LE
interleaved chroma YUV 4:4:4, 48bpp, little-endian
Definition: pixfmt.h:403
AV_PIX_FMT_BAYER_RGGB16LE
@ AV_PIX_FMT_BAYER_RGGB16LE
bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
Definition: pixfmt.h:291
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:495
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
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:394
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AV_PIX_FMT_BAYER_BGGR8
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
Definition: pixfmt.h:285
SWS_FULL_CHR_H_INP
#define SWS_FULL_CHR_H_INP
Definition: swscale.h:88
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
SwsVector::length
int length
number of coefficients in the vector
Definition: swscale.h:118
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:2131
AV_PIX_FMT_P016BE
@ AV_PIX_FMT_P016BE
like NV12, with 16bpp per component, big-endian
Definition: pixfmt.h:328
from
const char * from
Definition: jacosubdec.c:66
to
const char * to
Definition: webvttdec.c:35
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:280
get_local_pos
static av_cold int get_local_pos(SwsContext *s, int chr_subsample, int pos, int dir)
Definition: utils.c: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:479
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:187
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:493
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:94
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:170
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
sws_getGaussianVec
SwsVector * sws_getGaussianVec(double variance, double quality)
Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality,...
Definition: utils.c:2148
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:515
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:441
NAN
#define NAN
Definition: mathematics.h:115
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
SwsContext::dstFormat
enum AVPixelFormat dstFormat
Destination pixel format.
Definition: swscale_internal.h:330
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:162
AV_PIX_FMT_BAYER_RGGB8
@ AV_PIX_FMT_BAYER_RGGB8
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
Definition: pixfmt.h:286
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
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:295
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:159
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:157
alloc_gamma_tbl
static uint16_t * alloc_gamma_tbl(double e)
Definition: utils.c:1196
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:501
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:130
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale_internal.h:70
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:113
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:1974
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
SWS_SRC_V_CHR_DROP_SHIFT
#define SWS_SRC_V_CHR_DROP_SHIFT
Definition: swscale.h:78
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:347
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:314
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:412
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:473
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:74
AV_PIX_FMT_P210BE
@ AV_PIX_FMT_P210BE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
Definition: pixfmt.h:393
isnan
#define isnan(x)
Definition: libm.h:340
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:110
AV_PIX_FMT_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:210
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
sws_getDefaultFilter
SwsFilter * sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
Definition: utils.c:2342
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:83
AV_PIX_FMT_YUVA422P12LE
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:371
RangeList
Definition: swscale_internal.h:91
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:56
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:118
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:372
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:93
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1180
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:2124
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:180
AV_PIX_FMT_Y210LE
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:386
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:188
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
ff_sws_rgb2rgb_init
av_cold void ff_sws_rgb2rgb_init(void)
Definition: rgb2rgb.c:137
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:91
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:483
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:302
sws_addVec
static void sws_addVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2277
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:981
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:117
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
handle_formats
static void handle_formats(SwsContext *c)
Definition: utils.c: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:119
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:176
ff_sws_context_class
const AVClass ff_sws_context_class
Definition: options.c:88
exp
int8_t exp
Definition: eval.c:74
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
AVOnce
#define AVOnce
Definition: thread.h:202
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Definition: swscale_internal.h:464
Range
Definition: vf_colorbalance.c:37
sws_scaleVec
void sws_scaleVec(SwsVector *a, double scalar)
Scale all the coefficients of a by the scalar value.
Definition: utils.c:2214
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:2179
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:634
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:270
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:277
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:92
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1861
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:388
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:431
SWS_X
#define SWS_X
Definition: swscale.h:68
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:153
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
have_lsx
#define have_lsx(flags)
Definition: cpu.h:28
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c: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:75
RY_IDX
#define RY_IDX
Definition: swscale_internal.h:440
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:304
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:2094
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:289
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:267
cpu.h
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h: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:137
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SWS_FULL_CHR_H_INT
#define SWS_FULL_CHR_H_INT
Definition: swscale.h:86
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:273
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:468
AV_PIX_FMT_GRAY12LE
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:323
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:475
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:167
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:155
AV_PIX_FMT_RGBAF16BE
@ AV_PIX_FMT_RGBAF16BE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian.
Definition: pixfmt.h:407
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:198
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:139
have_neon
#define have_neon(flags)
Definition: cpu.h:26
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
SwsFilter
Definition: swscale.h:122
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:410
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
SWS_GAUSS
#define SWS_GAUSS
Definition: swscale.h:72
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:318
SwsFilter::lumV
SwsVector * lumV
Definition: swscale.h:124
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:117
attributes.h
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:263
sws_isSupportedInput
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
Return a positive value if pix_fmt is a supported input format, 0 otherwise.
Definition: utils.c: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:413
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:397
SWS_SPLINE
#define SWS_SPLINE
Definition: swscale.h:75
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:182
M_PI
#define M_PI
Definition: mathematics.h:67
slicethread.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
BY_IDX
#define BY_IDX
Definition: swscale_internal.h:442
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:183
flag
#define flag(name)
Definition: cbs_av1.c: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:373
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:177
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:477
SwsContext::srcW
int srcW
Width of source luma/alpha planes.
Definition: swscale_internal.h:321
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:115
sws_isSupportedEndiannessConversion
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: utils.c: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:109
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:1987
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2263
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:499
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:342
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:375
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:287
exp2
#define exp2(x)
Definition: libm.h:288
getSplineCoeff
static double getSplineCoeff(double a, double b, double c, double d, double dist)
Definition: utils.c: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:107
AV_PIX_FMT_XYZ12BE
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
Definition: pixfmt.h:197
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:474
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:133
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:346
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:376
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:481
sws_freeFilter
void sws_freeFilter(SwsFilter *filter)
Definition: utils.c:2330
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:214
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AV_PIX_FMT_GRAY12BE
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:322
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:207
ret
ret
Definition: filter_design.txt:187
XYZ_GAMMA
#define XYZ_GAMMA
Definition: swscale_internal.h:545
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:264
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AV_PIX_FMT_Y212LE
@ AV_PIX_FMT_Y212LE
packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:416
AV_PIX_FMT_BAYER_BGGR16BE
@ AV_PIX_FMT_BAYER_BGGR16BE
bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
Definition: pixfmt.h:290
AV_PIX_FMT_P410BE
@ AV_PIX_FMT_P410BE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
Definition: pixfmt.h:396
verbose
int verbose
Definition: checkasm.c:345
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:327
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:367
pos
unsigned int pos
Definition: spdifenc.c:413
sws_getColorspaceDetails
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Definition: utils.c:1156
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
sws_init_context
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:2036
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:279
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:275
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:29
c2
static const uint64_t c2
Definition: murmur3.c:53
FormatEntry::is_supported_out
uint8_t is_supported_out
Definition: utils.c:64
sws_freeContext
void sws_freeContext(SwsContext *c)
Free the swscaler context swsContext.
Definition: utils.c:2425
ScaleAlgorithm
Definition: utils.c:369
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:160
ff_shuffle_filter_coefficients
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
Definition: utils.c: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:400
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:181
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:112
Range::start
AVRational start
Definition: vf_pseudocolor.c:118
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:129
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:131
AV_PIX_FMT_P212BE
@ AV_PIX_FMT_P212BE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian
Definition: pixfmt.h:430
SWS_PRINT_INFO
#define SWS_PRINT_INFO
Definition: swscale.h:82
DITHER32_INT
#define DITHER32_INT
Definition: swscale_internal.h:498
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
AV_PIX_FMT_X2BGR10LE
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:390
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:77
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:311
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:445
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:186
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:120
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
ScaleAlgorithm::size_factor
int size_factor
size factor used when initing the filters
Definition: utils.c:372
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:399
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:2069
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:434
AV_PIX_FMT_GRAY14LE
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:365
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:422
sws_sumVec
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2227
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
AV_PIX_FMT_GRAY14BE
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:364
X86_MMX
#define X86_MMX(flags)
Definition: cpu.h:30
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:189
AV_PIX_FMT_YUV440P10BE
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:303
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:164
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:190
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
d
d
Definition: ffmpeg_filter.c:424
ff_yuv2rgb_init_tables_ppc
av_cold void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
Definition: yuv2rgb_altivec.c:598
cpu.h
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:262
avpriv_slicethread_free
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
Definition: slicethread.c:254
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
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:317
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:444
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:192
SWS_BILINEAR
#define SWS_BILINEAR
Definition: swscale.h:66
cpu.h
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:410
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:370
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:424
SwsContext
Definition: swscale_internal.h:299
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:138
SwsFilter::chrH
SwsVector * chrH
Definition: swscale.h: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:2203
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:323
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:272
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
sws_normalizeVec
void sws_normalizeVec(SwsVector *a, double height)
Scale all the coefficients of a so that their sum equals height.
Definition: utils.c:2222
cpu.h
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:175
APCK_SIZE
#define APCK_SIZE
Definition: swscale_internal.h:62
AV_PIX_FMT_BAYER_GRBG8
@ AV_PIX_FMT_BAYER_GRBG8
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
Definition: pixfmt.h:288
rgb2rgb.h
SWS_BICUBIC
#define SWS_BICUBIC
Definition: swscale.h:67
AV_PIX_FMT_GBRAP14LE
@ AV_PIX_FMT_GBRAP14LE
planar GBR 4:4:4:4 56bpp, little-endian
Definition: pixfmt.h:437
swscale.h
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2888
AV_PIX_FMT_UYYVYY411
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:89
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:854
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:145
SWS_ERROR_DIFFUSION
#define SWS_ERROR_DIFFUSION
Definition: swscale.h:92
min
float min
Definition: vorbis_enc_data.h:429
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:178
SwsContext::param
double param[2]
Input parameters for scaling algorithms that need them.
Definition: swscale_internal.h:342