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