FFmpeg
utils.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2024 Niklas Haas
3  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config.h"
23 
24 #define _DEFAULT_SOURCE
25 #define _SVID_SOURCE // needed for MAP_ANONYMOUS
26 #define _DARWIN_C_SOURCE // needed for MAP_ANON
27 #include <inttypes.h>
28 #include <math.h>
29 #include <stdio.h>
30 #include <string.h>
31 #if HAVE_MMAP
32 #include <sys/mman.h>
33 #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
34 #define MAP_ANONYMOUS MAP_ANON
35 #endif
36 #endif
37 #if HAVE_VIRTUALALLOC
38 #include <windows.h>
39 #endif
40 
41 #include "libavutil/attributes.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/cpu.h"
44 #include "libavutil/csp.h"
45 #include "libavutil/emms.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/intreadwrite.h"
48 #include "libavutil/libm.h"
49 #include "libavutil/mathematics.h"
50 #include "libavutil/mem.h"
51 #include "libavutil/opt.h"
52 #include "libavutil/pixdesc.h"
53 #include "libavutil/refstruct.h"
54 #include "libavutil/slicethread.h"
55 #include "libavutil/thread.h"
56 #include "libavutil/aarch64/cpu.h"
57 #include "libavutil/ppc/cpu.h"
58 #include "libavutil/x86/asm.h"
59 #include "libavutil/x86/cpu.h"
60 #include "libavutil/loongarch/cpu.h"
61 
62 #include "rgb2rgb.h"
63 #include "swscale.h"
64 #include "swscale_internal.h"
65 #include "graph.h"
66 
67 #if CONFIG_VULKAN
68 #include "vulkan/ops.h"
69 #endif
70 
71 /**
72  * Allocate and return an SwsContext without performing initialization.
73  */
74 static SwsContext *alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
75  int dstW, int dstH, enum AVPixelFormat dstFormat,
76  int flags, const double *param)
77 {
78  SwsContext *sws = sws_alloc_context();
79  if (!sws)
80  return NULL;
81 
82  sws->flags = flags;
83  sws->src_w = srcW;
84  sws->src_h = srcH;
85  sws->dst_w = dstW;
86  sws->dst_h = dstH;
87  sws->src_format = srcFormat;
88  sws->dst_format = dstFormat;
89 
90  for (int i = 0; param && i < SWS_NUM_SCALER_PARAMS; i++)
91  sws->scaler_params[i] = param[i];
92 
93  return sws;
94 }
95 
96 int ff_shuffle_filter_coefficients(SwsInternal *c, int *filterPos,
97  int filterSize, int16_t *filter,
98  int dstW)
99 {
100 #if ARCH_X86_64
101  int i, j, k;
102  int cpu_flags = av_get_cpu_flags();
103  if (!filter)
104  return 0;
105  if (EXTERNAL_AVX2_FAST(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_SLOW_GATHER)) {
106  if ((c->srcBpc == 8) && (c->dstBpc <= 14)) {
107  int16_t *filterCopy = NULL;
108  if (filterSize > 4) {
109  filterCopy = av_malloc_array(dstW, filterSize * sizeof(*filterCopy));
110  if (!filterCopy)
111  return AVERROR(ENOMEM);
112  memcpy(filterCopy, filter, dstW * filterSize * sizeof(int16_t));
113  }
114  // Do not swap filterPos for pixels which won't be processed by
115  // the main loop.
116  for (i = 0; i + 16 <= dstW; i += 16) {
117  FFSWAP(int, filterPos[i + 2], filterPos[i + 4]);
118  FFSWAP(int, filterPos[i + 3], filterPos[i + 5]);
119  FFSWAP(int, filterPos[i + 10], filterPos[i + 12]);
120  FFSWAP(int, filterPos[i + 11], filterPos[i + 13]);
121  }
122  if (filterSize > 4) {
123  // 16 pixels are processed at a time.
124  for (i = 0; i + 16 <= dstW; i += 16) {
125  // 4 filter coeffs are processed at a time.
126  for (k = 0; k + 4 <= filterSize; k += 4) {
127  for (j = 0; j < 16; ++j) {
128  int from = (i + j) * filterSize + k;
129  int to = i * filterSize + j * 4 + k * 16;
130  memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t));
131  }
132  }
133  }
134  // 4 pixels are processed at a time in the tail.
135  for (; i < dstW; i += 4) {
136  // 4 filter coeffs are processed at a time.
137  int rem = dstW - i >= 4 ? 4 : dstW - i;
138  for (k = 0; k + 4 <= filterSize; k += 4) {
139  for (j = 0; j < rem; ++j) {
140  int from = (i + j) * filterSize + k;
141  int to = i * filterSize + j * 4 + k * 4;
142  memcpy(&filter[to], &filterCopy[from], 4 * sizeof(int16_t));
143  }
144  }
145  }
146  }
147  av_free(filterCopy);
148  }
149  }
150 #endif
151  return 0;
152 }
153 
154 static double getSplineCoeff(double a, double b, double c, double d,
155  double dist)
156 {
157  if (dist <= 1.0)
158  return ((d * dist + c) * dist + b) * dist + a;
159  else
160  return getSplineCoeff(0.0,
161  b + 2.0 * c + 3.0 * d,
162  c + 3.0 * d,
163  -b - 3.0 * c - 6.0 * d,
164  dist - 1.0);
165 }
166 
167 static av_cold int get_local_pos(SwsInternal *s, int chr_subsample, int pos, int dir)
168 {
169  if (pos == -1 || pos <= -513) {
170  pos = (128 << chr_subsample) - 128;
171  }
172  pos += 128; // relative to ideal left edge
173  return pos >> chr_subsample;
174 }
175 
176 typedef struct {
177  int flag; ///< flag associated to the algorithm
178  const char *description; ///< human-readable description
179  int size_factor; ///< size factor used when initing the filters
180 } ScaleAlgorithm;
181 
182 static const ScaleAlgorithm scale_algorithms[] = {
183  { SWS_AREA, "area averaging", 1 /* downscale only, for upscale it is bilinear */ },
184  { SWS_BICUBIC, "bicubic", 4 },
185  { SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 },
186  { SWS_BILINEAR, "bilinear", 2 },
187  { SWS_FAST_BILINEAR, "fast bilinear", -1 },
188  { SWS_GAUSS, "Gaussian", 8 /* infinite ;) */ },
189  { SWS_LANCZOS, "Lanczos", -1 /* custom */ },
190  { SWS_POINT, "nearest neighbor / point", -1 },
191  { SWS_SINC, "sinc", 20 /* infinite ;) */ },
192  { SWS_SPLINE, "bicubic spline", 20 /* infinite :)*/ },
193  { SWS_X, "experimental", 8 },
194 };
195 
196 static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
197  int *outFilterSize, int xInc, int srcW,
198  int dstW, int filterAlign, int one,
199  int scaler, int flags, int cpu_flags,
200  SwsVector *srcFilter, SwsVector *dstFilter,
201  double param[SWS_NUM_SCALER_PARAMS], int srcPos, int dstPos)
202 {
203  int i;
204  int filterSize;
205  int filter2Size;
206  int minFilterSize;
207  int64_t *filter = NULL;
208  int64_t *filter2 = NULL;
209  const int64_t fone = 1LL << (54 - FFMIN(av_log2(srcW/dstW), 8));
210  int ret = -1;
211 
212  emms_c(); // FIXME should not be required but IS (even for non-MMX versions)
213 
214  // NOTE: the +3 is for the MMX(+1) / SSE(+3) scaler which reads over the end
215  if (!FF_ALLOC_TYPED_ARRAY(*filterPos, dstW + 3))
216  goto nomem;
217 
218  if (FFABS(xInc - 0x10000) < 10 && srcPos == dstPos) { // unscaled
219  int i;
220  filterSize = 1;
221  if (!FF_ALLOCZ_TYPED_ARRAY(filter, dstW * filterSize))
222  goto nomem;
223 
224  for (i = 0; i < dstW; i++) {
225  filter[i * filterSize] = fone;
226  (*filterPos)[i] = i;
227  }
228  } else if (scaler == SWS_POINT) { // lame looking point sampling mode
229  int i;
230  int64_t xDstInSrc;
231  filterSize = 1;
232  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
233  goto nomem;
234 
235  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
236  for (i = 0; i < dstW; i++) {
237  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
238 
239  (*filterPos)[i] = xx;
240  filter[i] = fone;
241  xDstInSrc += xInc;
242  }
243  } else if ((xInc <= (1 << 16) && (scaler == SWS_AREA)) ||
244  (scaler == SWS_FAST_BILINEAR)) { // bilinear upscale
245  int i;
246  int64_t xDstInSrc;
247  filterSize = 2;
248  if (!FF_ALLOC_TYPED_ARRAY(filter, dstW * filterSize))
249  goto nomem;
250 
251  xDstInSrc = ((dstPos*(int64_t)xInc)>>8) - ((srcPos*0x8000LL)>>7);
252  for (i = 0; i < dstW; i++) {
253  int xx = (xDstInSrc - ((filterSize - 1) << 15) + (1 << 15)) >> 16;
254  int j;
255 
256  (*filterPos)[i] = xx;
257  // bilinear upscale / linear interpolate / area averaging
258  for (j = 0; j < filterSize; j++) {
259  int64_t coeff = fone - FFABS((int64_t)xx * (1 << 16) - xDstInSrc) * (fone >> 16);
260  if (coeff < 0)
261  coeff = 0;
262  filter[i * filterSize + j] = coeff;
263  xx++;
264  }
265  xDstInSrc += xInc;
266  }
267  } else {
268  int64_t xDstInSrc;
269  int sizeFactor = -1;
270 
271  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
272  if (scaler == scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
273  sizeFactor = scale_algorithms[i].size_factor;
274  break;
275  }
276  }
277  if (scaler == SWS_LANCZOS)
278  sizeFactor = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;
279  av_assert0(sizeFactor > 0);
280 
281  if (sizeFactor > 50) {
282  ret = AVERROR(EINVAL);
283  goto fail;
284  }
285 
286  if (xInc <= 1 << 16)
287  filterSize = 1 + sizeFactor; // upscale
288  else
289  filterSize = 1 + (sizeFactor * srcW + dstW - 1) / dstW;
290 
291  filterSize = FFMIN(filterSize, srcW - 2);
292  filterSize = FFMAX(filterSize, 1);
293 
294  filter = av_malloc_array(dstW, filterSize * sizeof(*filter));
295  if (!filter)
296  goto nomem;
297  xDstInSrc = ((dstPos*(int64_t)xInc)>>7) - ((srcPos*0x10000LL)>>7);
298  for (i = 0; i < dstW; i++) {
299  int xx = (xDstInSrc - (filterSize - 2) * (1LL<<16)) / (1 << 17);
300  int j;
301  (*filterPos)[i] = xx;
302  for (j = 0; j < filterSize; j++) {
303  int64_t d = (FFABS(((int64_t)xx * (1 << 17)) - xDstInSrc)) << 13;
304  double floatd;
305  int64_t coeff;
306 
307  if (xInc > 1 << 16)
308  d = d * dstW / srcW;
309  floatd = d * (1.0 / (1 << 30));
310 
311  if (scaler == SWS_BICUBIC) {
312  int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24);
313  int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);
314 
315  if (d >= 1LL << 31) {
316  coeff = 0.0;
317  } else {
318  int64_t dd = (d * d) >> 30;
319  int64_t ddd = (dd * d) >> 30;
320 
321  if (d < 1LL << 30)
322  coeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +
323  (-18 * (1 << 24) + 12 * B + 6 * C) * dd +
324  (6 * (1 << 24) - 2 * B) * (1 << 30);
325  else
326  coeff = (-B - 6 * C) * ddd +
327  (6 * B + 30 * C) * dd +
328  (-12 * B - 48 * C) * d +
329  (8 * B + 24 * C) * (1 << 30);
330  }
331  coeff /= (1LL<<54)/fone;
332  } else if (scaler == SWS_X) {
333  double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
334  double c;
335 
336  if (floatd < 1.0)
337  c = cos(floatd * M_PI);
338  else
339  c = -1.0;
340  if (c < 0.0)
341  c = -pow(-c, A);
342  else
343  c = pow(c, A);
344  coeff = (c * 0.5 + 0.5) * fone;
345  } else if (scaler == SWS_AREA) {
346  int64_t d2 = d - (1 << 29);
347  if (d2 * xInc < -(1LL << (29 + 16)))
348  coeff = 1.0 * (1LL << (30 + 16));
349  else if (d2 * xInc < (1LL << (29 + 16)))
350  coeff = -d2 * xInc + (1LL << (29 + 16));
351  else
352  coeff = 0.0;
353  coeff *= fone >> (30 + 16);
354  } else if (scaler == SWS_GAUSS) {
355  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
356  coeff = exp2(-p * floatd * floatd) * fone;
357  } else if (scaler == SWS_SINC) {
358  coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
359  } else if (scaler == SWS_LANCZOS) {
360  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
361  coeff = (d ? sin(floatd * M_PI) * sin(floatd * M_PI / p) /
362  (floatd * floatd * M_PI * M_PI / p) : 1.0) * fone;
363  if (floatd > p)
364  coeff = 0;
365  } else if (scaler == SWS_BILINEAR) {
366  coeff = (1 << 30) - d;
367  if (coeff < 0)
368  coeff = 0;
369  coeff *= fone >> 30;
370  } else if (scaler == SWS_SPLINE) {
371  double p = -2.196152422706632;
372  coeff = getSplineCoeff(1.0, 0.0, p, -p - 1.0, floatd) * fone;
373  } else {
374  av_assert0(0);
375  }
376 
377  filter[i * filterSize + j] = coeff;
378  xx++;
379  }
380  xDstInSrc += 2LL * xInc;
381  }
382  }
383 
384  /* apply src & dst Filter to filter -> filter2
385  * av_free(filter);
386  */
387  av_assert0(filterSize > 0);
388  filter2Size = filterSize;
389  if (srcFilter)
390  filter2Size += srcFilter->length - 1;
391  if (dstFilter)
392  filter2Size += dstFilter->length - 1;
393  av_assert0(filter2Size > 0);
394  filter2 = av_calloc(dstW, filter2Size * sizeof(*filter2));
395  if (!filter2)
396  goto nomem;
397  for (i = 0; i < dstW; i++) {
398  int j, k;
399 
400  if (srcFilter) {
401  for (k = 0; k < srcFilter->length; k++) {
402  for (j = 0; j < filterSize; j++)
403  filter2[i * filter2Size + k + j] +=
404  srcFilter->coeff[k] * filter[i * filterSize + j];
405  }
406  } else {
407  for (j = 0; j < filterSize; j++)
408  filter2[i * filter2Size + j] = filter[i * filterSize + j];
409  }
410  // FIXME dstFilter
411 
412  (*filterPos)[i] += (filterSize - 1) / 2 - (filter2Size - 1) / 2;
413  }
414  av_freep(&filter);
415 
416  /* try to reduce the filter-size (step1 find size and shift left) */
417  // Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
418  minFilterSize = 0;
419  for (i = dstW - 1; i >= 0; i--) {
420  int min = filter2Size;
421  int j;
422  int64_t cutOff = 0.0;
423 
424  /* get rid of near zero elements on the left by shifting left */
425  for (j = 0; j < filter2Size; j++) {
426  int k;
427  cutOff += FFABS(filter2[i * filter2Size]);
428 
429  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
430  break;
431 
432  /* preserve monotonicity because the core can't handle the
433  * filter otherwise */
434  if (i < dstW - 1 && (*filterPos)[i] >= (*filterPos)[i + 1])
435  break;
436 
437  // move filter coefficients left
438  for (k = 1; k < filter2Size; k++)
439  filter2[i * filter2Size + k - 1] = filter2[i * filter2Size + k];
440  filter2[i * filter2Size + k - 1] = 0;
441  (*filterPos)[i]++;
442  }
443 
444  cutOff = 0;
445  /* count near zeros on the right */
446  for (j = filter2Size - 1; j > 0; j--) {
447  cutOff += FFABS(filter2[i * filter2Size + j]);
448 
449  if (cutOff > SWS_MAX_REDUCE_CUTOFF * fone)
450  break;
451  min--;
452  }
453 
454  if (min > minFilterSize)
455  minFilterSize = min;
456  }
457 
458  if (PPC_ALTIVEC(cpu_flags)) {
459  // we can handle the special case 4, so we don't want to go the full 8
460  if (minFilterSize < 5)
461  filterAlign = 4;
462 
463  /* We really don't want to waste our time doing useless computation, so
464  * fall back on the scalar C code for very small filters.
465  * Vectorizing is worth it only if you have a decent-sized vector. */
466  if (minFilterSize < 3)
467  filterAlign = 1;
468  }
469 
470  if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX || have_neon(cpu_flags)) {
471  // special case for unscaled vertical filtering
472  if (minFilterSize == 1 && filterAlign == 2)
473  filterAlign = 1;
474  }
475 
476  if (have_lasx(cpu_flags) || have_lsx(cpu_flags)) {
477  int reNum = minFilterSize & (0x07);
478 
479  if (minFilterSize < 5)
480  filterAlign = 4;
481  if (reNum < 3)
482  filterAlign = 1;
483  }
484 
485  av_assert0(minFilterSize > 0);
486  filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
487  av_assert0(filterSize > 0);
488  filter = av_malloc_array(dstW, filterSize * sizeof(*filter));
489  if (!filter)
490  goto nomem;
491  if (filterSize >= MAX_FILTER_SIZE * 16 /
492  ((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16)) {
493  ret = RETCODE_USE_CASCADE;
494  goto fail;
495  }
496  *outFilterSize = filterSize;
497 
498  if (flags & SWS_PRINT_INFO)
499  av_log(NULL, AV_LOG_VERBOSE,
500  "SwScaler: reducing / aligning filtersize %d -> %d\n",
501  filter2Size, filterSize);
502  /* try to reduce the filter-size (step2 reduce it) */
503  for (i = 0; i < dstW; i++) {
504  int j;
505 
506  for (j = 0; j < filterSize; j++) {
507  if (j >= filter2Size)
508  filter[i * filterSize + j] = 0;
509  else
510  filter[i * filterSize + j] = filter2[i * filter2Size + j];
511  if ((flags & SWS_BITEXACT) && j >= minFilterSize)
512  filter[i * filterSize + j] = 0;
513  }
514  }
515 
516  // FIXME try to align filterPos if possible
517 
518  // fix borders
519  for (i = 0; i < dstW; i++) {
520  int j;
521  if ((*filterPos)[i] < 0) {
522  // move filter coefficients left to compensate for filterPos
523  for (j = 1; j < filterSize; j++) {
524  int left = FFMAX(j + (*filterPos)[i], 0);
525  filter[i * filterSize + left] += filter[i * filterSize + j];
526  filter[i * filterSize + j] = 0;
527  }
528  (*filterPos)[i]= 0;
529  }
530 
531  if ((*filterPos)[i] + filterSize > srcW) {
532  int shift = (*filterPos)[i] + FFMIN(filterSize - srcW, 0);
533  int64_t acc = 0;
534 
535  for (j = filterSize - 1; j >= 0; j--) {
536  if ((*filterPos)[i] + j >= srcW) {
537  acc += filter[i * filterSize + j];
538  filter[i * filterSize + j] = 0;
539  }
540  }
541  for (j = filterSize - 1; j >= 0; j--) {
542  if (j < shift) {
543  filter[i * filterSize + j] = 0;
544  } else {
545  filter[i * filterSize + j] = filter[i * filterSize + j - shift];
546  }
547  }
548 
549  (*filterPos)[i]-= shift;
550  filter[i * filterSize + srcW - 1 - (*filterPos)[i]] += acc;
551  }
552  av_assert0((*filterPos)[i] >= 0);
553  av_assert0((*filterPos)[i] < srcW);
554  if ((*filterPos)[i] + filterSize > srcW) {
555  for (j = 0; j < filterSize; j++) {
556  av_assert0((*filterPos)[i] + j < srcW || !filter[i * filterSize + j]);
557  }
558  }
559  }
560 
561  // Note the +1 is for the MMX scaler which reads over the end
562  /* align at 16 for AltiVec (needed by hScale_altivec_real) */
563  *outFilter = av_calloc(dstW + 3, *outFilterSize * sizeof(**outFilter));
564  if (!*outFilter)
565  goto nomem;
566 
567  /* normalize & store in outFilter */
568  for (i = 0; i < dstW; i++) {
569  int j;
570  int64_t error = 0;
571  int64_t sum = 0;
572 
573  for (j = 0; j < filterSize; j++) {
574  sum += filter[i * filterSize + j];
575  }
576  sum = (sum + one / 2) / one;
577  if (!sum) {
578  av_log(NULL, AV_LOG_WARNING, "SwScaler: zero vector in scaling\n");
579  sum = 1;
580  }
581  for (j = 0; j < *outFilterSize; j++) {
582  int64_t v = filter[i * filterSize + j] + error;
583  int intV = ROUNDED_DIV(v, sum);
584  (*outFilter)[i * (*outFilterSize) + j] = intV;
585  error = v - intV * sum;
586  }
587  }
588 
589  (*filterPos)[dstW + 0] =
590  (*filterPos)[dstW + 1] =
591  (*filterPos)[dstW + 2] = (*filterPos)[dstW - 1]; /* the MMX/SSE scaler will
592  * read over the end */
593  for (i = 0; i < *outFilterSize; i++) {
594  int k = (dstW - 1) * (*outFilterSize) + i;
595  (*outFilter)[k + 1 * (*outFilterSize)] =
596  (*outFilter)[k + 2 * (*outFilterSize)] =
597  (*outFilter)[k + 3 * (*outFilterSize)] = (*outFilter)[k];
598  }
599 
600  ret = 0;
601  goto done;
602 nomem:
603  ret = AVERROR(ENOMEM);
604 fail:
605  if(ret < 0)
606  av_log(NULL, ret == RETCODE_USE_CASCADE ? AV_LOG_DEBUG : AV_LOG_ERROR, "sws: initFilter failed\n");
607 done:
608  av_free(filter);
609  av_free(filter2);
610  return ret;
611 }
612 
613 static void fill_rgb2yuv_table(SwsInternal *c, const int table[4], int dstRange)
614 {
615  int64_t W, V, Z, Cy, Cu, Cv;
616  int64_t vr = table[0];
617  int64_t ub = table[1];
618  int64_t ug = -table[2];
619  int64_t vg = -table[3];
620  int64_t ONE = 65536;
621  int64_t cy = ONE;
622  uint8_t *p = (uint8_t*)c->input_rgb2yuv_table;
623  int i;
624  static const int8_t map[] = {
625  BY_IDX, GY_IDX, -1 , BY_IDX, BY_IDX, GY_IDX, -1 , BY_IDX,
626  RY_IDX, -1 , GY_IDX, RY_IDX, RY_IDX, -1 , GY_IDX, RY_IDX,
627  RY_IDX, GY_IDX, -1 , RY_IDX, RY_IDX, GY_IDX, -1 , RY_IDX,
628  BY_IDX, -1 , GY_IDX, BY_IDX, BY_IDX, -1 , GY_IDX, BY_IDX,
629  BU_IDX, GU_IDX, -1 , BU_IDX, BU_IDX, GU_IDX, -1 , BU_IDX,
630  RU_IDX, -1 , GU_IDX, RU_IDX, RU_IDX, -1 , GU_IDX, RU_IDX,
631  RU_IDX, GU_IDX, -1 , RU_IDX, RU_IDX, GU_IDX, -1 , RU_IDX,
632  BU_IDX, -1 , GU_IDX, BU_IDX, BU_IDX, -1 , GU_IDX, BU_IDX,
633  BV_IDX, GV_IDX, -1 , BV_IDX, BV_IDX, GV_IDX, -1 , BV_IDX,
634  RV_IDX, -1 , GV_IDX, RV_IDX, RV_IDX, -1 , GV_IDX, RV_IDX,
635  RV_IDX, GV_IDX, -1 , RV_IDX, RV_IDX, GV_IDX, -1 , RV_IDX,
636  BV_IDX, -1 , GV_IDX, BV_IDX, BV_IDX, -1 , GV_IDX, BV_IDX,
637  RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX,
638  BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX, BY_IDX, RY_IDX,
639  GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 ,
640  -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX, -1 , GY_IDX,
641  RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX,
642  BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX, BU_IDX, RU_IDX,
643  GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 ,
644  -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX, -1 , GU_IDX,
645  RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX,
646  BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX, BV_IDX, RV_IDX,
647  GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 ,
648  -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, -1 , GV_IDX, //23
649  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //24
650  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //25
651  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //26
652  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //27
653  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //28
654  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //29
655  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //30
656  -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 , //31
657  BY_IDX, GY_IDX, RY_IDX, -1 , -1 , -1 , -1 , -1 , //32
658  BU_IDX, GU_IDX, RU_IDX, -1 , -1 , -1 , -1 , -1 , //33
659  BV_IDX, GV_IDX, RV_IDX, -1 , -1 , -1 , -1 , -1 , //34
660  };
661 
662  dstRange = 0; //FIXME range = 1 is handled elsewhere
663 
664  if (!dstRange) {
665  cy = cy * 255 / 219;
666  } else {
667  vr = vr * 224 / 255;
668  ub = ub * 224 / 255;
669  ug = ug * 224 / 255;
670  vg = vg * 224 / 255;
671  }
672  W = ROUNDED_DIV(ONE*ONE*ug, ub);
673  V = ROUNDED_DIV(ONE*ONE*vg, vr);
674  Z = ONE*ONE-W-V;
675 
676  Cy = ROUNDED_DIV(cy*Z, ONE);
677  Cu = ROUNDED_DIV(ub*Z, ONE);
678  Cv = ROUNDED_DIV(vr*Z, ONE);
679 
680  c->input_rgb2yuv_table[RY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cy);
681  c->input_rgb2yuv_table[GY_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cy);
682  c->input_rgb2yuv_table[BY_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cy);
683 
684  c->input_rgb2yuv_table[RU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*V , Cu);
685  c->input_rgb2yuv_table[GU_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cu);
686  c->input_rgb2yuv_table[BU_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(Z+W) , Cu);
687 
688  c->input_rgb2yuv_table[RV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*(V+Z) , Cv);
689  c->input_rgb2yuv_table[GV_IDX] = -ROUNDED_DIV((1 << RGB2YUV_SHIFT)*ONE*ONE , Cv);
690  c->input_rgb2yuv_table[BV_IDX] = ROUNDED_DIV((1 << RGB2YUV_SHIFT)*W , Cv);
691 
692  if(/*!dstRange && */!memcmp(table, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sizeof(ff_yuv2rgb_coeffs[SWS_CS_DEFAULT]))) {
693  c->input_rgb2yuv_table[BY_IDX] = ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
694  c->input_rgb2yuv_table[BV_IDX] = (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
695  c->input_rgb2yuv_table[BU_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
696  c->input_rgb2yuv_table[GY_IDX] = ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
697  c->input_rgb2yuv_table[GV_IDX] = (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
698  c->input_rgb2yuv_table[GU_IDX] = (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
699  c->input_rgb2yuv_table[RY_IDX] = ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
700  c->input_rgb2yuv_table[RV_IDX] = ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
701  c->input_rgb2yuv_table[RU_IDX] = (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5));
702  }
703  for(i=0; i<FF_ARRAY_ELEMS(map); i++)
704  AV_WL16(p + 16*4 + 2*i, map[i] >= 0 ? c->input_rgb2yuv_table[map[i]] : 0);
705 }
706 
707 #if CONFIG_SMALL
708 static void init_xyz_tables(uint16_t xyzgamma_tab[4096], uint16_t xyzgammainv_tab[65536],
709  uint16_t rgbgamma_tab[65536], uint16_t rgbgammainv_tab[4096])
710 #else
711 static uint16_t xyzgamma_tab[4096], rgbgammainv_tab[4096];
712 static uint16_t rgbgamma_tab[65536], xyzgammainv_tab[65536];
713 static av_cold void init_xyz_tables(void)
714 #endif
715 {
716  double xyzgamma = XYZ_GAMMA;
717  double rgbgamma = 1.0 / RGB_GAMMA;
718  double xyzgammainv = 1.0 / XYZ_GAMMA;
719  double rgbgammainv = RGB_GAMMA;
720 
721  /* set input gamma vectors */
722  for (int i = 0; i < 4096; i++) {
723  xyzgamma_tab[i] = lrint(pow(i / 4095.0, xyzgamma) * 65535.0);
724  rgbgammainv_tab[i] = lrint(pow(i / 4095.0, rgbgammainv) * 65535.0);
725  }
726 
727  /* set output gamma vectors */
728  for (int i = 0; i < 65536; i++) {
729  rgbgamma_tab[i] = lrint(pow(i / 65535.0, rgbgamma) * 4095.0);
730  xyzgammainv_tab[i] = lrint(pow(i / 65535.0, xyzgammainv) * 4095.0);
731  }
732 }
733 
734 av_cold int ff_sws_fill_xyztables(SwsInternal *c)
735 {
736  static const int16_t xyz2rgb_matrix[3][3] = {
737  {13270, -6295, -2041},
738  {-3969, 7682, 170},
739  { 228, -835, 4329} };
740  static const int16_t rgb2xyz_matrix[3][3] = {
741  {1689, 1464, 739},
742  { 871, 2929, 296},
743  { 79, 488, 3891} };
744 
745  if (c->xyz2rgb.gamma.in)
746  return 0;
747 
748  memcpy(c->xyz2rgb.mat, xyz2rgb_matrix, sizeof(c->xyz2rgb.mat));
749  memcpy(c->rgb2xyz.mat, rgb2xyz_matrix, sizeof(c->rgb2xyz.mat));
750 
751 #if CONFIG_SMALL
752  c->xyz2rgb.gamma.in = av_malloc(sizeof(uint16_t) * 2 * (4096 + 65536));
753  if (!c->xyz2rgb.gamma.in)
754  return AVERROR(ENOMEM);
755  c->rgb2xyz.gamma.in = c->xyz2rgb.gamma.in + 4096;
756  c->xyz2rgb.gamma.out = c->rgb2xyz.gamma.in + 4096;
757  c->rgb2xyz.gamma.out = c->xyz2rgb.gamma.out + 65536;
758  init_xyz_tables(c->xyz2rgb.gamma.in, c->rgb2xyz.gamma.out,
759  c->xyz2rgb.gamma.out, c->rgb2xyz.gamma.in);
760 #else
761  c->xyz2rgb.gamma.in = xyzgamma_tab;
762  c->xyz2rgb.gamma.out = rgbgamma_tab;
763  c->rgb2xyz.gamma.in = rgbgammainv_tab;
764  c->rgb2xyz.gamma.out = xyzgammainv_tab;
765 
766  static AVOnce xyz_init_static_once = AV_ONCE_INIT;
767  ff_thread_once(&xyz_init_static_once, init_xyz_tables);
768 #endif
769  return 0;
770 }
771 
772 static int handle_jpeg(/* enum AVPixelFormat */ int *format)
773 {
774  switch (*format) {
775  case AV_PIX_FMT_YUVJ420P:
776  *format = AV_PIX_FMT_YUV420P;
777  return 1;
778  case AV_PIX_FMT_YUVJ411P:
779  *format = AV_PIX_FMT_YUV411P;
780  return 1;
781  case AV_PIX_FMT_YUVJ422P:
782  *format = AV_PIX_FMT_YUV422P;
783  return 1;
784  case AV_PIX_FMT_YUVJ444P:
785  *format = AV_PIX_FMT_YUV444P;
786  return 1;
787  case AV_PIX_FMT_YUVJ440P:
788  *format = AV_PIX_FMT_YUV440P;
789  return 1;
790  case AV_PIX_FMT_GRAY8:
791  case AV_PIX_FMT_YA8:
792  case AV_PIX_FMT_GRAY9LE:
793  case AV_PIX_FMT_GRAY9BE:
794  case AV_PIX_FMT_GRAY10LE:
795  case AV_PIX_FMT_GRAY10BE:
796  case AV_PIX_FMT_GRAY12LE:
797  case AV_PIX_FMT_GRAY12BE:
798  case AV_PIX_FMT_GRAY14LE:
799  case AV_PIX_FMT_GRAY14BE:
800  case AV_PIX_FMT_GRAY16LE:
801  case AV_PIX_FMT_GRAY16BE:
802  case AV_PIX_FMT_YA16BE:
803  case AV_PIX_FMT_YA16LE:
804  return 1;
805  default:
806  return 0;
807  }
808 }
809 
810 static int handle_0alpha(/* enum AVPixelFormat */ int *format)
811 {
812  switch (*format) {
813  case AV_PIX_FMT_0BGR : *format = AV_PIX_FMT_ABGR ; return 1;
814  case AV_PIX_FMT_BGR0 : *format = AV_PIX_FMT_BGRA ; return 4;
815  case AV_PIX_FMT_0RGB : *format = AV_PIX_FMT_ARGB ; return 1;
816  case AV_PIX_FMT_RGB0 : *format = AV_PIX_FMT_RGBA ; return 4;
817  default: return 0;
818  }
819 }
820 
821 static int handle_xyz(/* enum AVPixelFormat */ int *format)
822 {
823  switch (*format) {
824  case AV_PIX_FMT_XYZ12BE : *format = AV_PIX_FMT_RGB48BE; return 1;
825  case AV_PIX_FMT_XYZ12LE : *format = AV_PIX_FMT_RGB48LE; return 1;
826  default: return 0;
827  }
828 }
829 
830 static int handle_formats(SwsContext *sws)
831 {
832  SwsInternal *c = sws_internal(sws);
833  c->src0Alpha |= handle_0alpha(&sws->src_format);
834  c->dst0Alpha |= handle_0alpha(&sws->dst_format);
835  c->srcXYZ |= handle_xyz(&sws->src_format);
836  c->dstXYZ |= handle_xyz(&sws->dst_format);
837  if (c->srcXYZ || c->dstXYZ)
838  return ff_sws_fill_xyztables(c);
839  else
840  return 0;
841 }
842 
843 static int range_override_needed(enum AVPixelFormat format)
844 {
845  return !isYUV(format) && !isGray(format);
846 }
847 
848 int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4],
849  int srcRange, const int table[4], int dstRange,
850  int brightness, int contrast, int saturation)
851 {
852  SwsInternal *c = sws_internal(sws);
853  const AVPixFmtDescriptor *desc_dst;
854  const AVPixFmtDescriptor *desc_src;
855  int ret, need_reinit = 0;
856 
857  if (c->nb_slice_ctx) {
858  int parent_ret = 0;
859  for (int i = 0; i < c->nb_slice_ctx; i++) {
860  int ret = sws_setColorspaceDetails(c->slice_ctx[i], inv_table,
861  srcRange, table, dstRange,
862  brightness, contrast, saturation);
863  if (ret < 0)
864  parent_ret = ret;
865  }
866 
867  return parent_ret;
868  }
869 
870  ret = handle_formats(sws);
871  if (ret < 0)
872  return ret;
873  desc_dst = av_pix_fmt_desc_get(sws->dst_format);
874  desc_src = av_pix_fmt_desc_get(sws->src_format);
875 
876  if(range_override_needed(sws->dst_format))
877  dstRange = 0;
878  if(range_override_needed(sws->src_format))
879  srcRange = 0;
880 
881  if (sws->src_range != srcRange ||
882  sws->dst_range != dstRange ||
883  c->brightness != brightness ||
884  c->contrast != contrast ||
885  c->saturation != saturation ||
886  memcmp(c->srcColorspaceTable, inv_table, sizeof(int) * 4) ||
887  memcmp(c->dstColorspaceTable, table, sizeof(int) * 4)
888  )
889  need_reinit = 1;
890 
891  memmove(c->srcColorspaceTable, inv_table, sizeof(int) * 4);
892  memmove(c->dstColorspaceTable, table, sizeof(int) * 4);
893 
894 
895 
896  c->brightness = brightness;
897  c->contrast = contrast;
898  c->saturation = saturation;
899  sws->src_range = srcRange;
900  sws->dst_range = dstRange;
901 
902  if (need_reinit)
903  ff_sws_init_range_convert(c);
904 
905  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
906  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
907 
908  if (c->cascaded_context[c->cascaded_mainindex])
909  return sws_setColorspaceDetails(c->cascaded_context[c->cascaded_mainindex],inv_table, srcRange,table, dstRange, brightness, contrast, saturation);
910 
911  if (!need_reinit)
912  return 0;
913 
914  if ((isYUV(sws->dst_format) || isGray(sws->dst_format)) && (isYUV(sws->src_format) || isGray(sws->src_format))) {
915  if (!c->cascaded_context[0] &&
916  memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
917  sws->src_w && sws->src_h && sws->dst_w && sws->dst_h) {
918  enum AVPixelFormat tmp_format;
919  int tmp_width, tmp_height;
920  int srcW = sws->src_w;
921  int srcH = sws->src_h;
922  int dstW = sws->dst_w;
923  int dstH = sws->dst_h;
924  int ret;
925  av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
926 
927  if (isNBPS(sws->dst_format) || is16BPS(sws->dst_format)) {
928  if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) {
929  tmp_format = AV_PIX_FMT_BGRA64;
930  } else {
931  tmp_format = AV_PIX_FMT_BGR48;
932  }
933  } else {
934  if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) {
935  tmp_format = AV_PIX_FMT_BGRA;
936  } else {
937  tmp_format = AV_PIX_FMT_BGR24;
938  }
939  }
940 
941  if (srcW*srcH > dstW*dstH) {
942  tmp_width = dstW;
943  tmp_height = dstH;
944  } else {
945  tmp_width = srcW;
946  tmp_height = srcH;
947  }
948 
949  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
950  tmp_width, tmp_height, tmp_format, 64);
951  if (ret < 0)
952  return ret;
953 
954  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, sws->src_format,
955  tmp_width, tmp_height, tmp_format,
956  sws->flags, sws->scaler_params);
957  if (!c->cascaded_context[0])
958  return -1;
959 
960  c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
961  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
962  if (ret < 0)
963  return ret;
964  //we set both src and dst depending on that the RGB side will be ignored
965  sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
966  srcRange, table, dstRange,
967  brightness, contrast, saturation);
968 
969  c->cascaded_context[1] = alloc_set_opts(tmp_width, tmp_height, tmp_format,
970  dstW, dstH, sws->dst_format,
971  sws->flags, sws->scaler_params);
972  if (!c->cascaded_context[1])
973  return -1;
974  c->cascaded_context[1]->src_range = srcRange;
975  c->cascaded_context[1]->dst_range = dstRange;
976  ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
977  if (ret < 0)
978  return ret;
979  sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
980  srcRange, table, dstRange,
981  0, 1 << 16, 1 << 16);
982  return 0;
983  }
984  //We do not support this combination currently, we need to cascade more contexts to compensate
985  if (c->cascaded_context[0] && memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4))
986  return -1; //AVERROR_PATCHWELCOME;
987  return 0;
988  }
989 
990  if (!isYUV(sws->dst_format) && !isGray(sws->dst_format)) {
991  ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
992  contrast, saturation);
993  // FIXME factorize
994 
995 #if ARCH_PPC
996  ff_yuv2rgb_init_tables_ppc(c, inv_table, brightness,
997  contrast, saturation);
998 #endif
999  }
1000 
1001  fill_rgb2yuv_table(c, table, dstRange);
1002 
1003  return 0;
1004 }
1005 
1006 int sws_getColorspaceDetails(SwsContext *sws, int **inv_table,
1007  int *srcRange, int **table, int *dstRange,
1008  int *brightness, int *contrast, int *saturation)
1009 {
1010  SwsInternal *c = sws_internal(sws);
1011  if (!c)
1012  return -1;
1013 
1014  if (c->nb_slice_ctx) {
1015  return sws_getColorspaceDetails(c->slice_ctx[0], inv_table, srcRange,
1016  table, dstRange, brightness, contrast,
1017  saturation);
1018  }
1019 
1020  *inv_table = c->srcColorspaceTable;
1021  *table = c->dstColorspaceTable;
1022  *srcRange = range_override_needed(sws->src_format) ? 1 : sws->src_range;
1023  *dstRange = range_override_needed(sws->dst_format) ? 1 : sws->dst_range;
1024  *brightness = c->brightness;
1025  *contrast = c->contrast;
1026  *saturation = c->saturation;
1027 
1028  return 0;
1029 }
1030 
1031 SwsContext *sws_alloc_context(void)
1032 {
1033  SwsInternal *c = av_mallocz(sizeof(*c) + SWSINTERNAL_ADDITIONAL_ASM_SIZE);
1034  if (!c)
1035  return NULL;
1036 
1037  c->opts.av_class = &ff_sws_context_class;
1038  av_opt_set_defaults(c);
1039  atomic_init(&c->stride_unaligned_warned, 0);
1040  atomic_init(&c->data_unaligned_warned, 0);
1041 
1042  return &c->opts;
1043 }
1044 
1045 static uint16_t * alloc_gamma_tbl(double e)
1046 {
1047  int i = 0;
1048  uint16_t * tbl;
1049  tbl = (uint16_t*)av_malloc(sizeof(uint16_t) * 1 << 16);
1050  if (!tbl)
1051  return NULL;
1052 
1053  for (i = 0; i < 65536; ++i) {
1054  tbl[i] = pow(i / 65535.0, e) * 65535.0;
1055  }
1056  return tbl;
1057 }
1058 
1059 static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
1060 {
1061  switch(fmt) {
1062  case AV_PIX_FMT_ARGB: return AV_PIX_FMT_RGB24;
1063  case AV_PIX_FMT_RGBA: return AV_PIX_FMT_RGB24;
1064  case AV_PIX_FMT_ABGR: return AV_PIX_FMT_BGR24;
1065  case AV_PIX_FMT_BGRA: return AV_PIX_FMT_BGR24;
1066  case AV_PIX_FMT_YA8: return AV_PIX_FMT_GRAY8;
1067 
1068  case AV_PIX_FMT_YUVA420P: return AV_PIX_FMT_YUV420P;
1069  case AV_PIX_FMT_YUVA422P: return AV_PIX_FMT_YUV422P;
1070  case AV_PIX_FMT_YUVA444P: return AV_PIX_FMT_YUV444P;
1071 
1072  case AV_PIX_FMT_GBRAP: return AV_PIX_FMT_GBRP;
1073 
1074  case AV_PIX_FMT_GBRAP10LE: return AV_PIX_FMT_GBRP10;
1075  case AV_PIX_FMT_GBRAP10BE: return AV_PIX_FMT_GBRP10;
1076 
1077  case AV_PIX_FMT_GBRAP12LE: return AV_PIX_FMT_GBRP12;
1078  case AV_PIX_FMT_GBRAP12BE: return AV_PIX_FMT_GBRP12;
1079 
1080  case AV_PIX_FMT_GBRAP14LE: return AV_PIX_FMT_GBRP14;
1081  case AV_PIX_FMT_GBRAP14BE: return AV_PIX_FMT_GBRP14;
1082 
1083  case AV_PIX_FMT_GBRAP16LE: return AV_PIX_FMT_GBRP16;
1084  case AV_PIX_FMT_GBRAP16BE: return AV_PIX_FMT_GBRP16;
1085 
1086  case AV_PIX_FMT_RGBA64LE: return AV_PIX_FMT_RGB48;
1087  case AV_PIX_FMT_RGBA64BE: return AV_PIX_FMT_RGB48;
1088  case AV_PIX_FMT_BGRA64LE: return AV_PIX_FMT_BGR48;
1089  case AV_PIX_FMT_BGRA64BE: return AV_PIX_FMT_BGR48;
1090 
1091  case AV_PIX_FMT_YA16BE: return AV_PIX_FMT_GRAY16;
1092  case AV_PIX_FMT_YA16LE: return AV_PIX_FMT_GRAY16;
1093 
1094  case AV_PIX_FMT_YUVA420P9BE: return AV_PIX_FMT_YUV420P9;
1095  case AV_PIX_FMT_YUVA422P9BE: return AV_PIX_FMT_YUV422P9;
1096  case AV_PIX_FMT_YUVA444P9BE: return AV_PIX_FMT_YUV444P9;
1097  case AV_PIX_FMT_YUVA420P9LE: return AV_PIX_FMT_YUV420P9;
1098  case AV_PIX_FMT_YUVA422P9LE: return AV_PIX_FMT_YUV422P9;
1099  case AV_PIX_FMT_YUVA444P9LE: return AV_PIX_FMT_YUV444P9;
1100  case AV_PIX_FMT_YUVA420P10BE: return AV_PIX_FMT_YUV420P10;
1101  case AV_PIX_FMT_YUVA422P10BE: return AV_PIX_FMT_YUV422P10;
1102  case AV_PIX_FMT_YUVA444P10BE: return AV_PIX_FMT_YUV444P10;
1103  case AV_PIX_FMT_YUVA420P10LE: return AV_PIX_FMT_YUV420P10;
1104  case AV_PIX_FMT_YUVA422P10LE: return AV_PIX_FMT_YUV422P10;
1105  case AV_PIX_FMT_YUVA444P10LE: return AV_PIX_FMT_YUV444P10;
1106  case AV_PIX_FMT_YUVA420P16BE: return AV_PIX_FMT_YUV420P16;
1107  case AV_PIX_FMT_YUVA422P16BE: return AV_PIX_FMT_YUV422P16;
1108  case AV_PIX_FMT_YUVA444P16BE: return AV_PIX_FMT_YUV444P16;
1109  case AV_PIX_FMT_YUVA420P16LE: return AV_PIX_FMT_YUV420P16;
1110  case AV_PIX_FMT_YUVA422P16LE: return AV_PIX_FMT_YUV422P16;
1111  case AV_PIX_FMT_YUVA444P16LE: return AV_PIX_FMT_YUV444P16;
1112 
1113 // case AV_PIX_FMT_AYUV64LE:
1114 // case AV_PIX_FMT_AYUV64BE:
1115 // case AV_PIX_FMT_PAL8:
1116  default: return AV_PIX_FMT_NONE;
1117  }
1118 }
1119 
1120 static int scaler_flag(SwsScaler scaler, int fallback)
1121 {
1122  switch (scaler) {
1123  case SWS_SCALE_BILINEAR: return SWS_BILINEAR; break;
1124  case SWS_SCALE_BICUBIC: return SWS_BICUBIC; break;
1125  case SWS_SCALE_POINT: return SWS_POINT; break;
1126  case SWS_SCALE_AREA: return SWS_AREA; break;
1127  case SWS_SCALE_GAUSSIAN: return SWS_GAUSS; break;
1128  case SWS_SCALE_SINC: return SWS_SINC; break;
1129  case SWS_SCALE_LANCZOS: return SWS_LANCZOS; break;
1130  case SWS_SCALE_SPLINE: return SWS_SPLINE; break;
1131  default:
1132  return fallback;
1133  }
1134 }
1135 
1136 av_cold int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter,
1137  SwsFilter *dstFilter)
1138 {
1139  int i;
1140  int usesVFilter, usesHFilter;
1141  int unscaled;
1142  SwsInternal *c = sws_internal(sws);
1143  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1144  int srcW = sws->src_w;
1145  int srcH = sws->src_h;
1146  int dstW = sws->dst_w;
1147  int dstH = sws->dst_h;
1148  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1149  int flags, cpu_flags;
1150  enum AVPixelFormat srcFormat, dstFormat;
1151  const AVPixFmtDescriptor *desc_src;
1152  const AVPixFmtDescriptor *desc_dst;
1153  int ret = 0;
1154  enum AVPixelFormat tmpFmt;
1155  static const float float_mult = 1.0f / 255.0f;
1156 
1157  cpu_flags = av_get_cpu_flags();
1158  flags = sws->flags;
1159  emms_c();
1160 
1161  unscaled = (srcW == dstW && srcH == dstH);
1162 
1163  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1164  sws_setColorspaceDetails(sws, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sws->src_range,
1165  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1166  sws->dst_range, 0, 1 << 16, 1 << 16);
1167 
1168  ret = handle_formats(sws);
1169  if (ret < 0)
1170  return ret;
1171  srcFormat = sws->src_format;
1172  dstFormat = sws->dst_format;
1173  desc_src = av_pix_fmt_desc_get(srcFormat);
1174  desc_dst = av_pix_fmt_desc_get(dstFormat);
1175 
1176  // If the source has no alpha then disable alpha blendaway
1177  if (c->src0Alpha)
1178  sws->alpha_blend = SWS_ALPHA_BLEND_NONE;
1179 
1180  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1181  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1182  if (!sws_isSupportedInput(srcFormat)) {
1183  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1184  av_get_pix_fmt_name(srcFormat));
1185  return AVERROR(EINVAL);
1186  }
1187  if (!sws_isSupportedOutput(dstFormat)) {
1188  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1189  av_get_pix_fmt_name(dstFormat));
1190  return AVERROR(EINVAL);
1191  }
1192  }
1193  av_assert2(desc_src && desc_dst);
1194 
1195  i = flags & (SWS_POINT |
1196  SWS_AREA |
1197  SWS_BILINEAR |
1198  SWS_FAST_BILINEAR |
1199  SWS_BICUBIC |
1200  SWS_X |
1201  SWS_GAUSS |
1202  SWS_LANCZOS |
1203  SWS_SINC |
1204  SWS_SPLINE |
1205  SWS_BICUBLIN);
1206 
1207  /* provide a default scaler if not set by caller */
1208  if (!i) {
1209  if (dstW < srcW && dstH < srcH)
1210  i = SWS_BICUBIC;
1211  else if (dstW > srcW && dstH > srcH)
1212  i = SWS_BICUBIC;
1213  else
1214  i = SWS_BICUBIC;
1215  flags |= i;
1216  sws->flags = flags;
1217  } else if (i & (i - 1)) {
1218  av_log(c, AV_LOG_ERROR,
1219  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1220  return AVERROR(EINVAL);
1221  }
1222 
1223  if (i == SWS_FAST_BILINEAR) {
1224  if (srcW < 8 || dstW <= 8) {
1225  i = SWS_BILINEAR;
1226  flags ^= SWS_FAST_BILINEAR | i;
1227  sws->flags = flags;
1228  }
1229  }
1230 
1231  SwsScaler scaler_sub = sws->scaler_sub ? sws->scaler_sub : sws->scaler;
1232  int lum_scaler = scaler_flag(sws->scaler, i == SWS_BICUBLIN ? SWS_BICUBIC : i);
1233  int chr_scaler = scaler_flag(scaler_sub, i == SWS_BICUBLIN ? SWS_BILINEAR : i);
1234 
1235  /* sanity check */
1236  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1237  /* FIXME check if these are enough and try to lower them after
1238  * fixing the relevant parts of the code */
1239  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1240  srcW, srcH, dstW, dstH);
1241  return AVERROR(EINVAL);
1242  }
1243 
1244  if (!dstFilter)
1245  dstFilter = &dummyFilter;
1246  if (!srcFilter)
1247  srcFilter = &dummyFilter;
1248 
1249  int64_t lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1250  int64_t lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1251  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1252  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1253  c->vRounder = 4 * 0x0001000100010001ULL;
1254 
1255  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1256  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1257  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1258  (dstFilter->chrV && dstFilter->chrV->length > 1);
1259  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1260  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1261  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1262  (dstFilter->chrH && dstFilter->chrH->length > 1);
1263 
1264  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1265  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1266 
1267  c->dst_slice_align = 1 << c->chrDstVSubSample;
1268 
1269  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1270  if (dstW&1) {
1271  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1272  flags |= SWS_FULL_CHR_H_INT;
1273  sws->flags = flags;
1274  }
1275 
1276  if ( c->chrSrcHSubSample == 0
1277  && c->chrSrcVSubSample == 0
1278  && sws->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1279  && !(sws->flags & SWS_FAST_BILINEAR)
1280  ) {
1281  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1282  flags |= SWS_FULL_CHR_H_INT;
1283  sws->flags = flags;
1284  }
1285  }
1286 
1287  if (sws->dither == SWS_DITHER_AUTO) {
1288  if (flags & SWS_ERROR_DIFFUSION)
1289  sws->dither = SWS_DITHER_ED;
1290  }
1291 
1292  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1293  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1294  dstFormat == AV_PIX_FMT_BGR8 ||
1295  dstFormat == AV_PIX_FMT_RGB8) {
1296  if (sws->dither == SWS_DITHER_AUTO)
1297  sws->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1298  if (!(flags & SWS_FULL_CHR_H_INT)) {
1299  if (sws->dither == SWS_DITHER_ED || sws->dither == SWS_DITHER_A_DITHER || sws->dither == SWS_DITHER_X_DITHER || sws->dither == SWS_DITHER_NONE) {
1300  av_log(c, AV_LOG_DEBUG,
1301  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1302  av_get_pix_fmt_name(dstFormat));
1303  flags |= SWS_FULL_CHR_H_INT;
1304  sws->flags = flags;
1305  }
1306  }
1307  if (flags & SWS_FULL_CHR_H_INT) {
1308  if (sws->dither == SWS_DITHER_BAYER) {
1309  av_log(c, AV_LOG_DEBUG,
1310  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1311  av_get_pix_fmt_name(dstFormat));
1312  sws->dither = SWS_DITHER_ED;
1313  }
1314  }
1315  }
1316  if (isPlanarRGB(dstFormat)) {
1317  if (!(flags & SWS_FULL_CHR_H_INT)) {
1318  av_log(c, AV_LOG_DEBUG,
1319  "%s output is not supported with half chroma resolution, switching to full\n",
1320  av_get_pix_fmt_name(dstFormat));
1321  flags |= SWS_FULL_CHR_H_INT;
1322  sws->flags = flags;
1323  }
1324  }
1325 
1326  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1327  * chroma interpolation */
1328  if (flags & SWS_FULL_CHR_H_INT &&
1329  isAnyRGB(dstFormat) &&
1330  !isPlanarRGB(dstFormat) &&
1331  dstFormat != AV_PIX_FMT_RGBA64LE &&
1332  dstFormat != AV_PIX_FMT_RGBA64BE &&
1333  dstFormat != AV_PIX_FMT_BGRA64LE &&
1334  dstFormat != AV_PIX_FMT_BGRA64BE &&
1335  dstFormat != AV_PIX_FMT_RGB48LE &&
1336  dstFormat != AV_PIX_FMT_RGB48BE &&
1337  dstFormat != AV_PIX_FMT_BGR48LE &&
1338  dstFormat != AV_PIX_FMT_BGR48BE &&
1339  dstFormat != AV_PIX_FMT_RGBA &&
1340  dstFormat != AV_PIX_FMT_ARGB &&
1341  dstFormat != AV_PIX_FMT_BGRA &&
1342  dstFormat != AV_PIX_FMT_ABGR &&
1343  dstFormat != AV_PIX_FMT_RGB24 &&
1344  dstFormat != AV_PIX_FMT_BGR24 &&
1345  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1346  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1347  dstFormat != AV_PIX_FMT_BGR8 &&
1348  dstFormat != AV_PIX_FMT_RGB8 &&
1349  dstFormat != AV_PIX_FMT_X2RGB10LE &&
1350  dstFormat != AV_PIX_FMT_X2BGR10LE
1351  ) {
1352  av_log(c, AV_LOG_WARNING,
1353  "full chroma interpolation for destination format '%s' not yet implemented\n",
1354  av_get_pix_fmt_name(dstFormat));
1355  flags &= ~SWS_FULL_CHR_H_INT;
1356  sws->flags = flags;
1357  }
1358  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1359  c->chrDstHSubSample = 1;
1360 
1361  // drop some chroma lines if the user wants it
1362  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1363  SWS_SRC_V_CHR_DROP_SHIFT;
1364  c->chrSrcVSubSample += c->vChrDrop;
1365 
1366  /* drop every other pixel for chroma calculation unless user
1367  * wants full chroma */
1368  if (isAnyRGB(srcFormat) && !(srcW & 1) && !(flags & SWS_FULL_CHR_H_INP) &&
1369  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1370  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1371  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1372  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1373  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1374  srcFormat != AV_PIX_FMT_GBRP10MSBBE && srcFormat != AV_PIX_FMT_GBRP10MSBLE &&
1375  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1376  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1377  srcFormat != AV_PIX_FMT_GBRP12MSBBE && srcFormat != AV_PIX_FMT_GBRP12MSBLE &&
1378  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1379  srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE &&
1380  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1381  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1382  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1383  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1384  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1385  srcFormat != AV_PIX_FMT_GBRPF16BE && srcFormat != AV_PIX_FMT_GBRPF16LE &&
1386  srcFormat != AV_PIX_FMT_GBRAPF16BE && srcFormat != AV_PIX_FMT_GBRAPF16LE &&
1387  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1388  (flags & SWS_FAST_BILINEAR)))
1389  c->chrSrcHSubSample = 1;
1390 
1391  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1392  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1393  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1394  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1395  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1396 
1397  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1398  goto nomem;
1399 
1400  c->srcBpc = desc_src->comp[0].depth;
1401  if (c->srcBpc < 8)
1402  c->srcBpc = 8;
1403  c->dstBpc = desc_dst->comp[0].depth;
1404  if (c->dstBpc < 8)
1405  c->dstBpc = 8;
1406  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1407  c->srcBpc = 16;
1408  if (c->dstBpc == 16)
1409  dst_stride <<= 1;
1410 
1411  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1412  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1413  c->chrDstW >= c->chrSrcW &&
1414  (srcW & 15) == 0;
1415  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1416 
1417  && (flags & SWS_FAST_BILINEAR)) {
1418  if (flags & SWS_PRINT_INFO)
1419  av_log(c, AV_LOG_INFO,
1420  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1421  }
1422  if (usesHFilter || isNBPS(sws->src_format) || is16BPS(sws->src_format) || isAnyRGB(sws->src_format))
1423  c->canMMXEXTBeUsed = 0;
1424  } else
1425  c->canMMXEXTBeUsed = 0;
1426 
1427  int64_t chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1428  int64_t chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1429 
1430  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1431  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1432  * correct scaling.
1433  * n-2 is the last chrominance sample available.
1434  * This is not perfect, but no one should notice the difference, the more
1435  * correct variant would be like the vertical one, but that would require
1436  * some special code for the first and last pixel */
1437  if (flags & SWS_FAST_BILINEAR) {
1438  if (c->canMMXEXTBeUsed) {
1439  lumXInc += 20;
1440  chrXInc += 20;
1441  }
1442  // we don't use the x86 asm scaler if MMX is available
1443  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1444  lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1445  chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1446  }
1447  }
1448  if (chrXInc < 10 || chrXInc > INT_MAX ||
1449  chrYInc < 10 || chrYInc > INT_MAX ||
1450  lumXInc < 10 || lumXInc > INT_MAX ||
1451  lumYInc < 10 || lumYInc > INT_MAX)
1452  return AVERROR_PATCHWELCOME;
1453 
1454  c->lumXInc = lumXInc;
1455  c->lumYInc = lumYInc;
1456  c->chrXInc = chrXInc;
1457  c->chrYInc = chrYInc;
1458 
1459 
1460  // hardcoded for now
1461  c->gamma_value = 2.2;
1462  tmpFmt = AV_PIX_FMT_RGBA64LE;
1463 
1464  if (!unscaled && sws->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1465  SwsInternal *c2;
1466  c->cascaded_context[0] = NULL;
1467 
1468  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1469  srcW, srcH, tmpFmt, 64);
1470  if (ret < 0)
1471  return ret;
1472 
1473  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1474  srcW, srcH, tmpFmt,
1475  flags, NULL, NULL,
1476  sws->scaler_params);
1477  if (!c->cascaded_context[0]) {
1478  return AVERROR(ENOMEM);
1479  }
1480 
1481  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1482  dstW, dstH, tmpFmt,
1483  flags, srcFilter, dstFilter,
1484  sws->scaler_params);
1485 
1486  if (!c->cascaded_context[1])
1487  return AVERROR(ENOMEM);
1488 
1489  c2 = sws_internal(c->cascaded_context[1]);
1490  c2->is_internal_gamma = 1;
1491  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1492  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1493  if (!c2->gamma || !c2->inv_gamma)
1494  return AVERROR(ENOMEM);
1495 
1496  // is_internal_flag is set after creating the context
1497  // to properly create the gamma convert FilterDescriptor
1498  // we have to re-initialize it
1499  ff_free_filters(c2);
1500  if ((ret = ff_init_filters(c2)) < 0) {
1501  sws_freeContext(c->cascaded_context[1]);
1502  c->cascaded_context[1] = NULL;
1503  return ret;
1504  }
1505 
1506  c->cascaded_context[2] = NULL;
1507  if (dstFormat != tmpFmt) {
1508  ret = av_image_alloc(c->cascaded_tmp[1], c->cascaded_tmpStride[1],
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,
1516  sws->scaler_params);
1517  if (!c->cascaded_context[2])
1518  return AVERROR(ENOMEM);
1519  }
1520  return 0;
1521  }
1522 
1523  if (isBayer(srcFormat)) {
1524  if (!unscaled ||
1525  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1526  dstFormat != AV_PIX_FMT_RGB48)) {
1527  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1528 
1529  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1530  srcW, srcH, tmpFormat, 64);
1531  if (ret < 0)
1532  return ret;
1533 
1534  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1535  srcW, srcH, tmpFormat,
1536  flags, srcFilter, NULL,
1537  sws->scaler_params);
1538  if (!c->cascaded_context[0])
1539  return AVERROR(ENOMEM);
1540 
1541  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1542  dstW, dstH, dstFormat,
1543  flags, NULL, dstFilter,
1544  sws->scaler_params);
1545  if (!c->cascaded_context[1])
1546  return AVERROR(ENOMEM);
1547  return 0;
1548  }
1549  }
1550 
1551  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1552  for (i = 0; i < 256; ++i){
1553  c->uint2float_lut[i] = (float)i * float_mult;
1554  }
1555  }
1556 
1557  // float will be converted to uint16_t
1558  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1559  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1560  dstFormat != AV_PIX_FMT_GRAY8))){
1561  c->srcBpc = 16;
1562  }
1563 
1564  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1565  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1566 
1567  if (tmpFormat != AV_PIX_FMT_NONE && sws->alpha_blend != SWS_ALPHA_BLEND_NONE) {
1568  if (!unscaled ||
1569  dstFormat != tmpFormat ||
1570  usesHFilter || usesVFilter ||
1571  sws->src_range != sws->dst_range
1572  ) {
1573  c->cascaded_mainindex = 1;
1574  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1575  srcW, srcH, tmpFormat, 64);
1576  if (ret < 0)
1577  return ret;
1578 
1579  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1580  srcW, srcH, tmpFormat,
1581  flags, sws->scaler_params);
1582  if (!c->cascaded_context[0])
1583  return AVERROR(EINVAL);
1584  c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
1585  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1586  if (ret < 0)
1587  return ret;
1588 
1589  c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1590  dstW, dstH, dstFormat,
1591  flags, sws->scaler_params);
1592  if (!c->cascaded_context[1])
1593  return AVERROR(EINVAL);
1594 
1595  c->cascaded_context[1]->src_range = sws->src_range;
1596  c->cascaded_context[1]->dst_range = sws->dst_range;
1597  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1598  if (ret < 0)
1599  return ret;
1600 
1601  return 0;
1602  }
1603  }
1604  }
1605 
1606  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1607  if (unscaled && !usesHFilter && !usesVFilter &&
1608  sws->alpha_blend != SWS_ALPHA_BLEND_NONE &&
1609  isALPHA(srcFormat) &&
1610  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat)) &&
1611  alphaless_fmt(srcFormat) == dstFormat
1612  ) {
1613  c->convert_unscaled = ff_sws_alphablendaway;
1614 
1615  if (flags & SWS_PRINT_INFO)
1616  av_log(c, AV_LOG_INFO,
1617  "using alpha blendaway %s -> %s special converter\n",
1618  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1619  return 0;
1620  }
1621 
1622  /* unscaled special cases */
1623  if (unscaled && !usesHFilter && !usesVFilter &&
1624  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat) ||
1625  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1626 
1627  ff_get_unscaled_swscale(c);
1628 
1629  if (c->convert_unscaled) {
1630  if (flags & SWS_PRINT_INFO)
1631  av_log(c, AV_LOG_INFO,
1632  "using unscaled %s -> %s special converter\n",
1633  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1634  return 0;
1635  }
1636  }
1637 
1638 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1639 #define USE_MMAP 1
1640 #else
1641 #define USE_MMAP 0
1642 #endif
1643 
1644  /* precalculate horizontal scaler filter coefficients */
1645  {
1646 #if HAVE_MMXEXT_INLINE
1647 // can't downscale !!!
1648  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1649  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1650  NULL, NULL, 8);
1651  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1652  NULL, NULL, NULL, 4);
1653 
1654 #if USE_MMAP
1655  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1656  PROT_READ | PROT_WRITE,
1657  MAP_PRIVATE | MAP_ANONYMOUS,
1658  -1, 0);
1659  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1660  PROT_READ | PROT_WRITE,
1661  MAP_PRIVATE | MAP_ANONYMOUS,
1662  -1, 0);
1663 #elif HAVE_VIRTUALALLOC
1664  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1665  c->lumMmxextFilterCodeSize,
1666  MEM_COMMIT,
1667  PAGE_EXECUTE_READWRITE);
1668  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1669  c->chrMmxextFilterCodeSize,
1670  MEM_COMMIT,
1671  PAGE_EXECUTE_READWRITE);
1672 #else
1673  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1674  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1675 #endif
1676 
1677 #ifdef MAP_ANONYMOUS
1678  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1679 #else
1680  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1681 #endif
1682  {
1683  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1684  return AVERROR(ENOMEM);
1685  }
1686 
1687  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1688  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1689  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1690  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1691  goto nomem;
1692 
1693  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1694  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1695  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1696  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1697 
1698 #if USE_MMAP
1699  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1700  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1701  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1702  ret = AVERROR(EINVAL);
1703  goto fail;
1704  }
1705 #endif
1706  } else
1707 #endif /* HAVE_MMXEXT_INLINE */
1708  {
1709  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1710  PPC_ALTIVEC(cpu_flags) ? 8 :
1711  have_neon(cpu_flags) ? 4 :
1712  have_lsx(cpu_flags) ? 8 :
1713  have_lasx(cpu_flags) ? 8 : 1;
1714 
1715  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1716  &c->hLumFilterSize, c->lumXInc,
1717  srcW, dstW, filterAlign, 1 << 14,
1718  lum_scaler, flags,
1719  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1720  sws->scaler_params,
1721  get_local_pos(c, 0, 0, 0),
1722  get_local_pos(c, 0, 0, 0))) < 0)
1723  goto fail;
1724  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1725  goto nomem;
1726  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1727  &c->hChrFilterSize, c->chrXInc,
1728  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1729  chr_scaler, flags,
1730  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1731  sws->scaler_params,
1732  get_local_pos(c, c->chrSrcHSubSample, sws->src_h_chr_pos, 0),
1733  get_local_pos(c, c->chrDstHSubSample, sws->dst_h_chr_pos, 0))) < 0)
1734  goto fail;
1735  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1736  goto nomem;
1737  }
1738  } // initialize horizontal stuff
1739 
1740  /* precalculate vertical scaler filter coefficients */
1741  {
1742  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1743  PPC_ALTIVEC(cpu_flags) ? 8 :
1744  have_neon(cpu_flags) ? 2 : 1;
1745 
1746  ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1747  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1748  lum_scaler, flags,
1749  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1750  sws->scaler_params,
1751  get_local_pos(c, 0, 0, 1),
1752  get_local_pos(c, 0, 0, 1));
1753  int usecascade = (ret == RETCODE_USE_CASCADE);
1754  if (ret < 0 && !usecascade)
1755  goto fail;
1756  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1757  c->chrYInc, c->chrSrcH, c->chrDstH,
1758  filterAlign, (1 << 12),
1759  chr_scaler, flags,
1760  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1761  sws->scaler_params,
1762  get_local_pos(c, c->chrSrcVSubSample, sws->src_v_chr_pos, 1),
1763  get_local_pos(c, c->chrDstVSubSample, sws->dst_v_chr_pos, 1))) < 0)
1764 
1765  goto fail;
1766  if (usecascade) {
1767  ret = RETCODE_USE_CASCADE;
1768  goto fail;
1769  }
1770 
1771 #if HAVE_ALTIVEC
1772  ret = ff_sws_init_altivec_bufs(c);
1773  if (ret < 0)
1774  goto fail;
1775 #endif
1776  }
1777 
1778  for (i = 0; i < 4; i++)
1779  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], sws->dst_w + 3))
1780  goto nomem;
1781 
1782  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(sws->src_format) && isALPHA(sws->dst_format)) ? 1 : 0;
1783 
1784  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1785  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1786  c->uv_offx2 = dst_stride + 16;
1787 
1788  av_assert0(c->chrDstH <= dstH);
1789 
1790  if (flags & SWS_PRINT_INFO) {
1791  const char *scaler = NULL, *cpucaps;
1792 
1793  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1794  if (flags & scale_algorithms[i].flag) {
1795  scaler = scale_algorithms[i].description;
1796  break;
1797  }
1798  }
1799  if (!scaler)
1800  scaler = "ehh flags invalid?!";
1801  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1802  scaler,
1803  av_get_pix_fmt_name(srcFormat),
1804  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1805  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1806  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1807  "dithered " : "",
1808  av_get_pix_fmt_name(dstFormat));
1809 
1810  if (INLINE_MMXEXT(cpu_flags))
1811  cpucaps = "MMXEXT";
1812  else if (INLINE_MMX(cpu_flags))
1813  cpucaps = "MMX";
1814  else if (PPC_ALTIVEC(cpu_flags))
1815  cpucaps = "AltiVec";
1816  else
1817  cpucaps = "C";
1818 
1819  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1820 
1821  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1822  av_log(c, AV_LOG_DEBUG,
1823  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1824  sws->src_w, sws->src_h, sws->dst_w, sws->dst_h, c->lumXInc, c->lumYInc);
1825  av_log(c, AV_LOG_DEBUG,
1826  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1827  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1828  c->chrXInc, c->chrYInc);
1829  }
1830 
1831  ff_sws_init_scale(c);
1832 
1833  return ff_init_filters(c);
1834 nomem:
1835  ret = AVERROR(ENOMEM);
1836 fail: // FIXME replace things by appropriate error codes
1837  if (ret == RETCODE_USE_CASCADE) {
1838  int tmpW = sqrt(srcW * (int64_t)dstW);
1839  int tmpH = sqrt(srcH * (int64_t)dstH);
1840  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1841 
1842  if (isALPHA(srcFormat))
1843  tmpFormat = AV_PIX_FMT_YUVA420P;
1844 
1845  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1846  return AVERROR(EINVAL);
1847 
1848  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1849  tmpW, tmpH, tmpFormat, 64);
1850  if (ret < 0)
1851  return ret;
1852 
1853  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1854  tmpW, tmpH, tmpFormat,
1855  flags, srcFilter, NULL,
1856  sws->scaler_params);
1857  if (!c->cascaded_context[0])
1858  return AVERROR(ENOMEM);
1859 
1860  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
1861  dstW, dstH, dstFormat,
1862  flags, NULL, dstFilter,
1863  sws->scaler_params);
1864  if (!c->cascaded_context[1])
1865  return AVERROR(ENOMEM);
1866  return 0;
1867  }
1868  return ret;
1869 }
1870 
1871 static int context_init_threaded(SwsContext *sws,
1872  SwsFilter *src_filter, SwsFilter *dst_filter)
1873 {
1874  SwsInternal *c = sws_internal(sws);
1875  int ret;
1876 
1877  ret = avpriv_slicethread_create(&c->slicethread, (void*) sws,
1878  ff_sws_slice_worker, NULL, sws->threads);
1879  if (ret == AVERROR(ENOSYS)) {
1880  sws->threads = 1;
1881  return 0;
1882  } else if (ret < 0)
1883  return ret;
1884 
1885  sws->threads = ret;
1886 
1887  c->slice_ctx = av_calloc(sws->threads, sizeof(*c->slice_ctx));
1888  c->slice_err = av_calloc(sws->threads, sizeof(*c->slice_err));
1889  if (!c->slice_ctx || !c->slice_err)
1890  return AVERROR(ENOMEM);
1891 
1892  for (int i = 0; i < sws->threads; i++) {
1893  SwsContext *slice;
1894  slice = c->slice_ctx[i] = sws_alloc_context();
1895  if (!slice)
1896  return AVERROR(ENOMEM);
1897  sws_internal(slice)->parent = sws;
1898  c->nb_slice_ctx++;
1899 
1900  ret = av_opt_copy(slice, sws);
1901  if (ret < 0)
1902  return ret;
1903  slice->threads = 1;
1904 
1905  ret = ff_sws_init_single_context(slice, src_filter, dst_filter);
1906  if (ret < 0)
1907  return ret;
1908 
1909  if (slice->dither == SWS_DITHER_ED) {
1910  av_log(c, AV_LOG_VERBOSE,
1911  "Error-diffusion dither is in use, scaling will be single-threaded.");
1912  break;
1913  }
1914  }
1915 
1916  return 0;
1917 }
1918 
1919 av_cold int sws_init_context(SwsContext *sws, SwsFilter *srcFilter,
1920  SwsFilter *dstFilter)
1921 {
1922  SwsInternal *c = sws_internal(sws);
1923  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1924  enum AVPixelFormat src_format, dst_format;
1925  int ret;
1926 
1927  c->is_legacy_init = 1;
1928  c->frame_src = av_frame_alloc();
1929  c->frame_dst = av_frame_alloc();
1930  if (!c->frame_src || !c->frame_dst)
1931  return AVERROR(ENOMEM);
1932 
1933  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1934  return AVERROR_UNKNOWN;
1935 
1936  src_format = sws->src_format;
1937  dst_format = sws->dst_format;
1938  sws->src_range |= handle_jpeg(&sws->src_format);
1939  sws->dst_range |= handle_jpeg(&sws->dst_format);
1940 
1941  if (src_format != sws->src_format || dst_format != sws->dst_format)
1942  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1943 
1944  if (sws->threads != 1) {
1945  ret = context_init_threaded(sws, srcFilter, dstFilter);
1946  if (ret < 0 || sws->threads > 1)
1947  return ret;
1948  // threading disabled in this build, init as single-threaded
1949  }
1950 
1951  return ff_sws_init_single_context(sws, srcFilter, dstFilter);
1952 }
1953 
1954 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
1955  int dstW, int dstH, enum AVPixelFormat dstFormat,
1956  int flags, SwsFilter *srcFilter,
1957  SwsFilter *dstFilter, const double *param)
1958 {
1959  SwsContext *sws;
1960 
1961  sws = alloc_set_opts(srcW, srcH, srcFormat,
1962  dstW, dstH, dstFormat,
1963  flags, param);
1964  if (!sws)
1965  return NULL;
1966 
1967  if (sws_init_context(sws, srcFilter, dstFilter) < 0) {
1968  sws_freeContext(sws);
1969  return NULL;
1970  }
1971 
1972  return sws;
1973 }
1974 
1975 static int isnan_vec(SwsVector *a)
1976 {
1977  int i;
1978  for (i=0; i<a->length; i++)
1979  if (isnan(a->coeff[i]))
1980  return 1;
1981  return 0;
1982 }
1983 
1984 static void makenan_vec(SwsVector *a)
1985 {
1986  int i;
1987  for (i=0; i<a->length; i++)
1988  a->coeff[i] = NAN;
1989 }
1990 
1991 SwsVector *sws_allocVec(int length)
1992 {
1993  SwsVector *vec;
1994 
1995  if(length <= 0 || length > INT_MAX/ sizeof(double))
1996  return NULL;
1997 
1998  vec = av_malloc(sizeof(SwsVector));
1999  if (!vec)
2000  return NULL;
2001  vec->length = length;
2002  vec->coeff = av_malloc(sizeof(double) * length);
2003  if (!vec->coeff)
2004  av_freep(&vec);
2005  return vec;
2006 }
2007 
2008 SwsVector *sws_getGaussianVec(double variance, double quality)
2009 {
2010  const int length = (int)(variance * quality + 0.5) | 1;
2011  int i;
2012  double middle = (length - 1) * 0.5;
2013  SwsVector *vec;
2014 
2015  if(variance < 0 || quality < 0)
2016  return NULL;
2017 
2018  vec = sws_allocVec(length);
2019 
2020  if (!vec)
2021  return NULL;
2022 
2023  for (i = 0; i < length; i++) {
2024  double dist = i - middle;
2025  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2026  sqrt(2 * variance * M_PI);
2027  }
2028 
2029  sws_normalizeVec(vec, 1.0);
2030 
2031  return vec;
2032 }
2033 
2034 /**
2035  * Allocate and return a vector with length coefficients, all
2036  * with the same value c.
2037  */
2038 static
2039 SwsVector *sws_getConstVec(double c, int length)
2040 {
2041  int i;
2042  SwsVector *vec = sws_allocVec(length);
2043 
2044  if (!vec)
2045  return NULL;
2046 
2047  for (i = 0; i < length; i++)
2048  vec->coeff[i] = c;
2049 
2050  return vec;
2051 }
2052 
2053 /**
2054  * Allocate and return a vector with just one coefficient, with
2055  * value 1.0.
2056  */
2057 static
2058 SwsVector *sws_getIdentityVec(void)
2059 {
2060  return sws_getConstVec(1.0, 1);
2061 }
2062 
2063 static double sws_dcVec(SwsVector *a)
2064 {
2065  int i;
2066  double sum = 0;
2067 
2068  for (i = 0; i < a->length; i++)
2069  sum += a->coeff[i];
2070 
2071  return sum;
2072 }
2073 
2074 void sws_scaleVec(SwsVector *a, double scalar)
2075 {
2076  int i;
2077 
2078  for (i = 0; i < a->length; i++)
2079  a->coeff[i] *= scalar;
2080 }
2081 
2082 void sws_normalizeVec(SwsVector *a, double height)
2083 {
2084  sws_scaleVec(a, height / sws_dcVec(a));
2085 }
2086 
2087 static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
2088 {
2089  int length = FFMAX(a->length, b->length);
2090  int i;
2091  SwsVector *vec = sws_getConstVec(0.0, length);
2092 
2093  if (!vec)
2094  return NULL;
2095 
2096  for (i = 0; i < a->length; i++)
2097  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2098  for (i = 0; i < b->length; i++)
2099  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2100 
2101  return vec;
2102 }
2103 
2104 /* shift left / or right if "shift" is negative */
2105 static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
2106 {
2107  int length = a->length + FFABS(shift) * 2;
2108  int i;
2109  SwsVector *vec = sws_getConstVec(0.0, length);
2110 
2111  if (!vec)
2112  return NULL;
2113 
2114  for (i = 0; i < a->length; i++) {
2115  vec->coeff[i + (length - 1) / 2 -
2116  (a->length - 1) / 2 - shift] = a->coeff[i];
2117  }
2118 
2119  return vec;
2120 }
2121 
2122 static
2123 void sws_shiftVec(SwsVector *a, int shift)
2124 {
2125  SwsVector *shifted = sws_getShiftedVec(a, shift);
2126  if (!shifted) {
2127  makenan_vec(a);
2128  return;
2129  }
2130  av_free(a->coeff);
2131  a->coeff = shifted->coeff;
2132  a->length = shifted->length;
2133  av_free(shifted);
2134 }
2135 
2136 static
2137 void sws_addVec(SwsVector *a, SwsVector *b)
2138 {
2139  SwsVector *sum = sws_sumVec(a, b);
2140  if (!sum) {
2141  makenan_vec(a);
2142  return;
2143  }
2144  av_free(a->coeff);
2145  a->coeff = sum->coeff;
2146  a->length = sum->length;
2147  av_free(sum);
2148 }
2149 
2150 /**
2151  * Print with av_log() a textual representation of the vector a
2152  * if log_level <= av_log_level.
2153  */
2154 static
2155 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2156 {
2157  int i;
2158  double max = 0;
2159  double min = 0;
2160  double range;
2161 
2162  for (i = 0; i < a->length; i++)
2163  if (a->coeff[i] > max)
2164  max = a->coeff[i];
2165 
2166  for (i = 0; i < a->length; i++)
2167  if (a->coeff[i] < min)
2168  min = a->coeff[i];
2169 
2170  range = max - min;
2171 
2172  for (i = 0; i < a->length; i++) {
2173  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2174  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2175  for (; x > 0; x--)
2176  av_log(log_ctx, log_level, " ");
2177  av_log(log_ctx, log_level, "|\n");
2178  }
2179 }
2180 
2181 void sws_freeVec(SwsVector *a)
2182 {
2183  if (!a)
2184  return;
2185  av_freep(&a->coeff);
2186  a->length = 0;
2187  av_free(a);
2188 }
2189 
2190 void sws_freeFilter(SwsFilter *filter)
2191 {
2192  if (!filter)
2193  return;
2194 
2195  sws_freeVec(filter->lumH);
2196  sws_freeVec(filter->lumV);
2197  sws_freeVec(filter->chrH);
2198  sws_freeVec(filter->chrV);
2199  av_free(filter);
2200 }
2201 
2202 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2203  float lumaSharpen, float chromaSharpen,
2204  float chromaHShift, float chromaVShift,
2205  int verbose)
2206 {
2207  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2208  if (!filter)
2209  return NULL;
2210 
2211  if (lumaGBlur != 0.0) {
2212  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2213  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2214  } else {
2215  filter->lumH = sws_getIdentityVec();
2216  filter->lumV = sws_getIdentityVec();
2217  }
2218 
2219  if (chromaGBlur != 0.0) {
2220  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2221  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2222  } else {
2223  filter->chrH = sws_getIdentityVec();
2224  filter->chrV = sws_getIdentityVec();
2225  }
2226 
2227  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2228  goto fail;
2229 
2230  if (chromaSharpen != 0.0) {
2231  SwsVector *id = sws_getIdentityVec();
2232  if (!id)
2233  goto fail;
2234  sws_scaleVec(filter->chrH, -chromaSharpen);
2235  sws_scaleVec(filter->chrV, -chromaSharpen);
2236  sws_addVec(filter->chrH, id);
2237  sws_addVec(filter->chrV, id);
2238  sws_freeVec(id);
2239  }
2240 
2241  if (lumaSharpen != 0.0) {
2242  SwsVector *id = sws_getIdentityVec();
2243  if (!id)
2244  goto fail;
2245  sws_scaleVec(filter->lumH, -lumaSharpen);
2246  sws_scaleVec(filter->lumV, -lumaSharpen);
2247  sws_addVec(filter->lumH, id);
2248  sws_addVec(filter->lumV, id);
2249  sws_freeVec(id);
2250  }
2251 
2252  if (chromaHShift != 0.0)
2253  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2254 
2255  if (chromaVShift != 0.0)
2256  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2257 
2258  sws_normalizeVec(filter->chrH, 1.0);
2259  sws_normalizeVec(filter->chrV, 1.0);
2260  sws_normalizeVec(filter->lumH, 1.0);
2261  sws_normalizeVec(filter->lumV, 1.0);
2262 
2263  if (isnan_vec(filter->chrH) ||
2264  isnan_vec(filter->chrV) ||
2265  isnan_vec(filter->lumH) ||
2266  isnan_vec(filter->lumV))
2267  goto fail;
2268 
2269  if (verbose)
2270  sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
2271  if (verbose)
2272  sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
2273 
2274  return filter;
2275 
2276 fail:
2277  sws_freeVec(filter->lumH);
2278  sws_freeVec(filter->lumV);
2279  sws_freeVec(filter->chrH);
2280  sws_freeVec(filter->chrV);
2281  av_freep(&filter);
2282  return NULL;
2283 }
2284 
2285 void sws_freeContext(SwsContext *sws)
2286 {
2287  SwsInternal *c = sws_internal(sws);
2288  int i;
2289  if (!c)
2290  return;
2291 
2292  av_refstruct_unref(&c->hw_priv);
2293 
2294  for (i = 0; i < FF_ARRAY_ELEMS(c->graph); i++)
2295  ff_sws_graph_free(&c->graph[i]);
2296 
2297  for (i = 0; i < c->nb_slice_ctx; i++)
2298  sws_freeContext(c->slice_ctx[i]);
2299  av_freep(&c->slice_ctx);
2300  av_freep(&c->slice_err);
2301 
2302  avpriv_slicethread_free(&c->slicethread);
2303 
2304  for (i = 0; i < 4; i++)
2305  av_freep(&c->dither_error[i]);
2306 
2307  av_frame_free(&c->frame_src);
2308  av_frame_free(&c->frame_dst);
2309 
2310  av_freep(&c->src_ranges.ranges);
2311 
2312  av_freep(&c->vLumFilter);
2313  av_freep(&c->vChrFilter);
2314  av_freep(&c->hLumFilter);
2315  av_freep(&c->hChrFilter);
2316 #if HAVE_ALTIVEC
2317  ff_sws_free_altivec_bufs(c);
2318 #endif
2319 
2320  av_freep(&c->vLumFilterPos);
2321  av_freep(&c->vChrFilterPos);
2322  av_freep(&c->hLumFilterPos);
2323  av_freep(&c->hChrFilterPos);
2324 
2325 #if HAVE_MMX_INLINE
2326 #if USE_MMAP
2327  if (c->lumMmxextFilterCode)
2328  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2329  if (c->chrMmxextFilterCode)
2330  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2331 #elif HAVE_VIRTUALALLOC
2332  if (c->lumMmxextFilterCode)
2333  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2334  if (c->chrMmxextFilterCode)
2335  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2336 #else
2337  av_free(c->lumMmxextFilterCode);
2338  av_free(c->chrMmxextFilterCode);
2339 #endif
2340  c->lumMmxextFilterCode = NULL;
2341  c->chrMmxextFilterCode = NULL;
2342 #endif /* HAVE_MMX_INLINE */
2343 
2344  av_freep(&c->yuvTable);
2345  av_freep(&c->formatConvBuffer);
2346 
2347  sws_freeContext(c->cascaded_context[0]);
2348  sws_freeContext(c->cascaded_context[1]);
2349  sws_freeContext(c->cascaded_context[2]);
2350  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2351  av_freep(&c->cascaded_tmp[0][0]);
2352  av_freep(&c->cascaded_tmp[1][0]);
2353 
2354  av_freep(&c->gamma);
2355  av_freep(&c->inv_gamma);
2356 #if CONFIG_SMALL
2357  av_freep(&c->xyz2rgb.gamma.in);
2358 #endif
2359 
2360  av_freep(&c->rgb0_scratch);
2361  av_freep(&c->xyz_scratch);
2362 
2363  ff_free_filters(c);
2364 
2365  av_free(c);
2366 }
2367 
2368 void sws_free_context(SwsContext **pctx)
2369 {
2370  SwsContext *ctx = *pctx;
2371  if (!ctx)
2372  return;
2373 
2374  sws_freeContext(ctx);
2375  *pctx = NULL;
2376 }
2377 
2378 SwsContext *sws_getCachedContext(SwsContext *prev, int srcW,
2379  int srcH, enum AVPixelFormat srcFormat,
2380  int dstW, int dstH,
2381  enum AVPixelFormat dstFormat, int flags,
2382  SwsFilter *srcFilter,
2383  SwsFilter *dstFilter,
2384  const double *param)
2385 {
2386  SwsContext *sws;
2387  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2388  SWS_PARAM_DEFAULT };
2389 
2390  if (!param)
2391  param = default_param;
2392 
2393  if (prev && (prev->src_w == srcW &&
2394  prev->src_h == srcH &&
2395  prev->src_format == srcFormat &&
2396  prev->dst_w == dstW &&
2397  prev->dst_h == dstH &&
2398  prev->dst_format == dstFormat &&
2399  prev->flags == flags &&
2400  !memcmp(prev->scaler_params, param,
2401  sizeof(prev->scaler_params)))) {
2402  return prev;
2403  }
2404 
2405  if (!(sws = sws_alloc_context())) {
2406  sws_free_context(&prev);
2407  return NULL;
2408  }
2409 
2410  if (prev) {
2411  av_opt_copy(sws, prev);
2412  sws_free_context(&prev);
2413  }
2414 
2415  sws->src_w = srcW;
2416  sws->src_h = srcH;
2417  sws->src_format = srcFormat;
2418  sws->dst_w = dstW;
2419  sws->dst_h = dstH;
2420  sws->dst_format = dstFormat;
2421  sws->flags = flags;
2422  for (int i = 0; i < SWS_NUM_SCALER_PARAMS; i++)
2423  sws->scaler_params[i] = param[i];
2424 
2425  if (sws_init_context(sws, srcFilter, dstFilter) < 0)
2426  sws_free_context(&sws);
2427 
2428  return sws;
2429 }
2430 
2431 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2432 {
2433  Range *tmp;
2434  unsigned int idx;
2435 
2436  /* find the first existing range after the new one */
2437  for (idx = 0; idx < rl->nb_ranges; idx++)
2438  if (rl->ranges[idx].start > start)
2439  break;
2440 
2441  /* check for overlap */
2442  if (idx > 0) {
2443  Range *prev = &rl->ranges[idx - 1];
2444  if (prev->start + prev->len > start)
2445  return AVERROR(EINVAL);
2446  }
2447  if (idx < rl->nb_ranges) {
2448  Range *next = &rl->ranges[idx];
2449  if (start + len > next->start)
2450  return AVERROR(EINVAL);
2451  }
2452 
2453  tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated,
2454  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2455  if (!tmp)
2456  return AVERROR(ENOMEM);
2457  rl->ranges = tmp;
2458 
2459  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2460  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2461  rl->ranges[idx].start = start;
2462  rl->ranges[idx].len = len;
2463  rl->nb_ranges++;
2464 
2465  /* merge ranges */
2466  if (idx > 0) {
2467  Range *prev = &rl->ranges[idx - 1];
2468  Range *cur = &rl->ranges[idx];
2469  if (prev->start + prev->len == cur->start) {
2470  prev->len += cur->len;
2471  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2472  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2473  rl->nb_ranges--;
2474  idx--;
2475  }
2476  }
2477  if (idx < rl->nb_ranges - 1) {
2478  Range *cur = &rl->ranges[idx];
2479  Range *next = &rl->ranges[idx + 1];
2480  if (cur->start + cur->len == next->start) {
2481  cur->len += next->len;
2482  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2483  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2484  rl->nb_ranges--;
2485  }
2486  }
2487 
2488  return 0;
2489 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:857
flags
const SwsFlags flags[]
Definition: swscale.c:62
INLINE_MMX
#define INLINE_MMX(flags)
Definition: cpu.h:80
A
#define A(x)
Definition: vpx_arith.h:28
AV_PIX_FMT_XYZ12LE
@ AV_PIX_FMT_XYZ12LE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as lit...
Definition: pixfmt.h:196
av_pix_fmt_swap_endianness
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
Definition: pixdesc.c:3511
sws_setColorspaceDetails
int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
Definition: utils.c:848
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_PIX_FMT_GRAY10BE
@ AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
Definition: pixfmt.h:320
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:146
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:925
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale.h:81
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1672
cpu.h
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:204
sws_getIdentityVec
static SwsVector * sws_getIdentityVec(void)
Allocate and return a vector with just one coefficient, with value 1.0.
Definition: utils.c:2058
libm.h
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:136
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
SwsContext::src_w
int src_w
Deprecated frame property overrides, for the legacy API only.
Definition: swscale.h:253
SWS_SCALE_BILINEAR
@ SWS_SCALE_BILINEAR
bilinear filtering
Definition: swscale.h:98
saturation
static IPT saturation(const CmsCtx *ctx, IPT ipt)
Definition: cms.c:559
int64_t
long long int64_t
Definition: coverity.c:34
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h:91
MAX_FILTER_SIZE
#define MAX_FILTER_SIZE
Definition: af_dynaudnorm.c:36
sws_freeContext
void sws_freeContext(SwsContext *sws)
Free the swscaler context swsContext.
Definition: utils.c:2285
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
EXTERNAL_AVX2_FAST
#define EXTERNAL_AVX2_FAST(flags)
Definition: cpu.h:73
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:185
pixdesc.h
RV_IDX
#define RV_IDX
Definition: swscale_internal.h:472
alphaless_fmt
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
Definition: utils.c:1059
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale.h:80
isGray
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:802
SWSINTERNAL_ADDITIONAL_ASM_SIZE
#define SWSINTERNAL_ADDITIONAL_ASM_SIZE
Definition: swscale_internal.h:46
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:469
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
SWS_BILINEAR
@ SWS_BILINEAR
bilinear filtering
Definition: swscale.h:177
SWS_BITEXACT
@ SWS_BITEXACT
Definition: swscale.h:157
b
#define b
Definition: input.c:42
table
static const uint16_t table[]
Definition: prosumer.c:203
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:473
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:474
have_lasx
#define have_lasx(flags)
Definition: cpu.h:29
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
SwsContext::flags
unsigned flags
Bitmask of SWS_*.
Definition: swscale.h:219
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:3408
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
max
#define max(a, b)
Definition: cuda_runtime.h:33
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:109
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:179
sws_getShiftedVec
static SwsVector * sws_getShiftedVec(SwsVector *a, int shift)
Definition: utils.c:2105
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
SWS_BICUBLIN
@ SWS_BICUBLIN
bicubic luma, bilinear chroma
Definition: swscale.h:182
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:56
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:321
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:364
AV_PIX_FMT_GBRAP14BE
@ AV_PIX_FMT_GBRAP14BE
planar GBR 4:4:4:4 56bpp, big-endian
Definition: pixfmt.h:432
SWS_ALPHA_BLEND_NONE
@ SWS_ALPHA_BLEND_NONE
Definition: swscale.h:89
scaler_flag
static int scaler_flag(SwsScaler scaler, int fallback)
Definition: utils.c:1120
W
@ W
Definition: vf_addroi.c:27
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
sws_freeVec
void sws_freeVec(SwsVector *a)
Definition: utils.c:2181
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:1975
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:311
SWS_FAST_BILINEAR
@ SWS_FAST_BILINEAR
Scaler selection options.
Definition: swscale.h:176
initFilter
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int scaler, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[SWS_NUM_SCALER_PARAMS], int srcPos, int dstPos)
Definition: utils.c:196
ff_sws_fill_xyztables
av_cold int ff_sws_fill_xyztables(SwsInternal *c)
Definition: utils.c:734
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:104
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:742
ub
#define ub(width, name)
Definition: cbs_apv.c:125
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
SWS_FULL_CHR_H_INP
@ SWS_FULL_CHR_H_INP
Perform full chroma interpolation when downscaling RGB sources.
Definition: swscale.h:146
avpriv_slicethread_create
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
Definition: slicethread.c:261
fail
#define fail()
Definition: checkasm.h:220
SwsContext::src_v_chr_pos
int src_v_chr_pos
Source vertical chroma position in luma grid / 256.
Definition: swscale.h:259
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
Range::len
unsigned int len
Definition: swscale_internal.h:85
ONE
@ ONE
Definition: vc1_parser.c:50
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
sws_getCachedContext
SwsContext * sws_getCachedContext(SwsContext *prev, 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:2378
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:339
sws_init_context
av_cold int sws_init_context(SwsContext *sws, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:1919
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: alphablend.c:23
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3484
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:756
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:77
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:522
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale.h:85
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:191
xyzgammainv_tab
static uint16_t xyzgammainv_tab[65536]
Definition: utils.c:712
refstruct.h
AV_CPU_FLAG_SLOW_GATHER
#define AV_CPU_FLAG_SLOW_GATHER
CPU has slow gathers.
Definition: cpu.h:62
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:283
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
SWS_SCALE_BICUBIC
@ SWS_SCALE_BICUBIC
2-tap cubic BC-spline
Definition: swscale.h:99
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
lrint
#define lrint
Definition: tablegen.h:53
handle_jpeg
static int handle_jpeg(int *format)
Definition: utils.c:772
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
SWS_AREA
@ SWS_AREA
area averaging
Definition: swscale.h:181
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:106
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:551
SwsContext::dither
SwsDither dither
Dither mode.
Definition: swscale.h:235
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
SWS_MAX_REDUCE_CUTOFF
#define SWS_MAX_REDUCE_CUTOFF
Definition: swscale.h:417
emms_c
#define emms_c()
Definition: emms.h:89
float
float
Definition: af_crystalizer.c:122
ff_range_add
int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
Definition: utils.c:2431
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
sws_printVec2
static void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
Print with av_log() a textual representation of the vector a if log_level <= av_log_level.
Definition: utils.c:2155
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:172
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
SwsContext::threads
int threads
How many threads to use for processing, or 0 for automatic selection.
Definition: swscale.h:230
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:552
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
SWS_SCALE_LANCZOS
@ SWS_SCALE_LANCZOS
3-tap sinc/sinc
Definition: swscale.h:104
height
static int height
Definition: utils.c:158
SwsVector::length
int length
number of coefficients in the vector
Definition: swscale.h:441
ops.h
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:1991
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale.h:82
from
const char * from
Definition: jacosubdec.c:64
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:280
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsInternal *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
B
#define B
Definition: huffyuv.h:42
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:187
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:550
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsInternal *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:2379
ff_yuv2rgb_init_tables_ppc
av_cold void ff_yuv2rgb_init_tables_ppc(SwsInternal *c, const int inv_table[4], int brightness, int contrast, int saturation)
Definition: yuv2rgb_altivec.c:638
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
scale_algorithms
static const ScaleAlgorithm scale_algorithms[]
Definition: utils.c:182
ScaleAlgorithm::flag
int flag
flag associated to the algorithm
Definition: utils.c:177
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:94
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:170
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
sws_getGaussianVec
SwsVector * sws_getGaussianVec(double variance, double quality)
Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality,...
Definition: utils.c:2008
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GBRAPF16LE
@ AV_PIX_FMT_GBRAPF16LE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian.
Definition: pixfmt.h:469
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:582
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:467
NAN
#define NAN
Definition: mathematics.h:115
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
Definition: hscale_fast_bilinear_simd.c:30
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_GBRP10MSBLE
@ AV_PIX_FMT_GBRP10MSBLE
planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
Definition: pixfmt.h:496
alloc_gamma_tbl
static uint16_t * alloc_gamma_tbl(double e)
Definition: utils.c:1045
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:561
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
SWS_SRC_V_CHR_DROP_SHIFT
#define SWS_SRC_V_CHR_DROP_SHIFT
Definition: swscale.h:413
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
ff_free_filters
int ff_free_filters(SwsInternal *c)
Definition: slice.c:386
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:310
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:530
NULL
#define NULL
Definition: coverity.c:32
RETCODE_USE_CASCADE
#define RETCODE_USE_CASCADE
Definition: swscale_internal.h:74
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AV_PIX_FMT_GBRAPF16BE
@ AV_PIX_FMT_GBRAPF16BE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian.
Definition: pixfmt.h:468
asm.h
SWS_BICUBIC
@ SWS_BICUBIC
2-tap cubic B-spline
Definition: swscale.h:178
SwsContext::gamma_flag
int gamma_flag
Use gamma correct scaling.
Definition: swscale.h:245
isnan
#define isnan(x)
Definition: libm.h:342
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:110
AV_PIX_FMT_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:210
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
sws_getDefaultFilter
SwsFilter * sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
Definition: utils.c:2202
RangeList
Definition: swscale_internal.h:88
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:58
V
#define V
Definition: avdct.c:32
rgbgamma_tab
static uint16_t rgbgamma_tab[65536]
Definition: utils.c:712
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:90
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:1984
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:180
SwsContext::src_range
int src_range
Source is full range.
Definition: swscale.h:257
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:188
SwsScaler
SwsScaler
Definition: swscale.h:96
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
ff_sws_rgb2rgb_init
av_cold void ff_sws_rgb2rgb_init(void)
Definition: rgb2rgb.c:127
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:91
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsInternal *c)
Definition: swscale.c:627
sws_addVec
static void sws_addVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2137
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:440
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
range_override_needed
static int range_override_needed(enum AVPixelFormat format)
Definition: utils.c:843
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:176
AV_PIX_FMT_GBRP12MSBLE
@ AV_PIX_FMT_GBRP12MSBLE
planar GBR 4:4:4 36bpp, lowest bits zero, little-endian
Definition: pixfmt.h:498
ff_sws_context_class
const AVClass ff_sws_context_class
Definition: options.c:111
exp
int8_t exp
Definition: eval.c:76
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
AVOnce
#define AVOnce
Definition: thread.h:202
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Destination horizontal chroma position.
Definition: swscale.h:262
Range
Definition: vf_colorbalance.c:37
sws_scaleVec
void sws_scaleVec(SwsVector *a, double scalar)
Scale all the coefficients of a by the scalar value.
Definition: utils.c:2074
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
sws_getConstVec
static SwsVector * sws_getConstVec(double c, int length)
Allocate and return a vector with length coefficients, all with the same value c.
Definition: utils.c:2039
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:92
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2145
SWS_SCALE_SINC
@ SWS_SCALE_SINC
unwindowed sinc
Definition: swscale.h:103
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: swscale.h:415
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
ff_sws_graph_free
void ff_sws_graph_free(SwsGraph **pgraph)
Uninitialize any state associate with this filter graph and free it.
Definition: graph.c:806
have_lsx
#define have_lsx(flags)
Definition: cpu.h:28
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c:1541
handle_0alpha
static int handle_0alpha(int *format)
Definition: utils.c:810
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:449
f
f
Definition: af_crystalizer.c:122
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
RY_IDX
#define RY_IDX
Definition: swscale_internal.h:466
SwsInternal::parent
SwsContext * parent
Definition: swscale_internal.h:339
PPC_ALTIVEC
#define PPC_ALTIVEC(flags)
Definition: cpu.h:25
to
const char * to
Definition: webvttdec.c:35
AV_PIX_FMT_GBRP10MSBBE
@ AV_PIX_FMT_GBRP10MSBBE
planar GBR 4:4:4 30bpp, lowest bits zero, big-endian
Definition: pixfmt.h:495
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext and set its fields to default values.
Definition: utils.c:1031
SwsVector
Definition: swscale.h:439
shift
static int shift(int a, int b)
Definition: bonk.c:261
cpu.h
ff_sws_init_single_context
av_cold int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter, SwsFilter *dstFilter)
Definition: utils.c:1136
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:871
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:137
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
SWS_POINT
@ SWS_POINT
nearest neighbor
Definition: swscale.h:180
SwsContext::alpha_blend
SwsAlphaBlend alpha_blend
Alpha blending mode.
Definition: swscale.h:240
AV_PIX_FMT_GRAY12LE
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:319
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:532
SWS_SPLINE
@ SWS_SPLINE
unwindowed natural cubic spline
Definition: swscale.h:186
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:770
SwsContext::src_h
int src_h
Width and height of the source frame.
Definition: swscale.h:253
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_PIX_FMT_GBRP12MSBBE
@ AV_PIX_FMT_GBRP12MSBBE
planar GBR 4:4:4 36bpp, lowest bits zero, big-endian
Definition: pixfmt.h:497
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
ff_shuffle_filter_coefficients
int ff_shuffle_filter_coefficients(SwsInternal *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
Definition: utils.c:96
sws_getColorspaceDetails
int sws_getColorspaceDetails(SwsContext *sws, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Definition: utils.c:1006
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:139
have_neon
#define have_neon(flags)
Definition: cpu.h:26
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
SwsFilter
Definition: swscale.h:445
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:408
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:314
csp.h
SwsFilter::lumV
SwsVector * lumV
Definition: swscale.h:447
attributes.h
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:263
SwsContext::dst_format
int dst_format
Destination pixel format.
Definition: swscale.h:256
sws_isSupportedInput
#define sws_isSupportedInput(x)
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:182
M_PI
#define M_PI
Definition: mathematics.h:67
slicethread.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
BY_IDX
#define BY_IDX
Definition: swscale_internal.h:468
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:183
handle_xyz
static int handle_xyz(int *format)
Definition: utils.c:821
emms.h
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:177
SWS_SCALE_POINT
@ SWS_SCALE_POINT
nearest neighbor (point sampling)
Definition: swscale.h:100
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:534
sws_isSupportedEndiannessConversion
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: format.c:302
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:109
ff_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:47
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2123
SWS_X
@ SWS_X
experimental
Definition: swscale.h:179
ff_sws_init_scale
void ff_sws_init_scale(SwsInternal *c)
Definition: swscale.c:698
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AV_PIX_FMT_GRAY9BE
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:338
SwsContext::scaler
SwsScaler scaler
Scaling filter.
Definition: swscale.h:275
exp2
#define exp2(x)
Definition: libm.h:290
getSplineCoeff
static double getSplineCoeff(double a, double b, double c, double d, double dist)
Definition: utils.c:154
swscale_internal.h
graph.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
AV_PIX_FMT_XYZ12BE
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
Definition: pixfmt.h:197
SwsContext::scaler_sub
SwsScaler scaler_sub
Scaler used specifically for up/downsampling subsampled (chroma) planes.
Definition: swscale.h:283
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:531
SwsContext::dst_h
int dst_h
Width and height of the destination frame.
Definition: swscale.h:254
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
ff_sws_init_altivec_bufs
int ff_sws_init_altivec_bufs(SwsInternal *c)
sws_freeFilter
void sws_freeFilter(SwsFilter *filter)
Definition: utils.c:2190
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:879
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:89
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:425
SWS_SCALE_GAUSSIAN
@ SWS_SCALE_GAUSSIAN
2-tap gaussian approximation
Definition: swscale.h:102
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale.h:83
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AV_PIX_FMT_GRAY12BE
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:318
SwsInternal
Definition: swscale_internal.h:334
ret
ret
Definition: filter_design.txt:187
XYZ_GAMMA
#define XYZ_GAMMA
Definition: swscale_internal.h:554
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:264
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
av_malloc
void * av_malloc(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:98
verbose
int verbose
Definition: checkasm.c:473
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:363
rgbgammainv_tab
static uint16_t rgbgammainv_tab[4096]
Definition: utils.c:711
pos
unsigned int pos
Definition: spdifenc.c:414
SWS_FULL_CHR_H_INT
@ SWS_FULL_CHR_H_INT
Perform full chroma upsampling when upscaling to RGB.
Definition: swscale.h:133
sws_getContext
SwsContext * sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:1954
flag
#define flag(name)
Definition: cbs_av1.c:496
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:279
init_xyz_tables
static av_cold void init_xyz_tables(void)
Definition: utils.c:713
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:32
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale.h:84
c2
static const uint64_t c2
Definition: murmur3.c:53
ScaleAlgorithm
Definition: utils.c:176
SWS_NUM_SCALER_PARAMS
#define SWS_NUM_SCALER_PARAMS
Extra parameters for fine-tuning certain scalers.
Definition: swscale.h:224
fill_rgb2yuv_table
static void fill_rgb2yuv_table(SwsInternal *c, const int table[4], int dstRange)
Definition: utils.c:613
SWS_PRINT_INFO
@ SWS_PRINT_INFO
Emit verbose log of scaling parameters.
Definition: swscale.h:120
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
RGB_GAMMA
#define RGB_GAMMA
Definition: swscale_internal.h:555
SWS_SCALE_SPLINE
@ SWS_SCALE_SPLINE
unwindowned natural cubic spline
Definition: swscale.h:105
SWS_ERROR_DIFFUSION
@ SWS_ERROR_DIFFUSION
Set SwsContext.dither instead.
Definition: swscale.h:170
SWS_GAUSS
@ SWS_GAUSS
gaussian approximation
Definition: swscale.h:183
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
ScaleAlgorithm::description
const char * description
human-readable description
Definition: utils.c:178
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
INLINE_MMXEXT
#define INLINE_MMXEXT(flags)
Definition: cpu.h:81
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:181
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
Range::start
AVRational start
Definition: vf_pseudocolor.c:118
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
AV_PIX_FMT_X2BGR10LE
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:386
isBayer16BPS
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:864
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
ff_init_filters
int ff_init_filters(SwsInternal *c)
Definition: slice.c:246
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:471
SwsContext::dst_w
int dst_w
Definition: swscale.h:254
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:186
SwsContext::src_format
int src_format
Source pixel format.
Definition: swscale.h:255
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
ScaleAlgorithm::size_factor
int size_factor
size factor used when initing the filters
Definition: utils.c:179
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
SwsContext::dst_range
int dst_range
Destination is full range.
Definition: swscale.h:258
AV_PIX_FMT_GRAY14LE
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:361
SwsFilter::lumH
SwsVector * lumH
Definition: swscale.h:446
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
sws_sumVec
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2087
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
AV_PIX_FMT_GRAY14BE
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:360
X86_MMX
#define X86_MMX(flags)
Definition: cpu.h:25
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:189
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:190
sws_free_context
void sws_free_context(SwsContext **pctx)
Free the context and everything associated with it, and write NULL to the provided pointer.
Definition: utils.c:2368
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
ff_sws_free_altivec_bufs
void ff_sws_free_altivec_bufs(SwsInternal *c)
cpu.h
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:262
avpriv_slicethread_free
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
Definition: slicethread.c:275
alloc_set_opts
static SwsContext * alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext without performing initialization.
Definition: utils.c:74
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SwsContext::src_h_chr_pos
int src_h_chr_pos
Source horizontal chroma position.
Definition: swscale.h:260
SWS_SCALE_AREA
@ SWS_SCALE_AREA
area averaging
Definition: swscale.h:101
sws_internal
static SwsInternal * sws_internal(const SwsContext *sws)
Definition: swscale_internal.h:78
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
SWS_ACCURATE_RND
@ SWS_ACCURATE_RND
Force bit-exact output.
Definition: swscale.h:156
SWS_LANCZOS
@ SWS_LANCZOS
3-tap sinc/sinc
Definition: swscale.h:185
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:470
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:192
cpu.h
AV_PIX_FMT_GBRPF16BE
@ AV_PIX_FMT_GBRPF16BE
IEEE-754 half precision planer GBR 4:4:4, 48bpp, big-endian.
Definition: pixfmt.h:466
SwsContext::dst_v_chr_pos
int dst_v_chr_pos
Destination vertical chroma position.
Definition: swscale.h:261
SWS_SINC
@ SWS_SINC
unwindowed sinc
Definition: swscale.h:184
SwsContext
Main external API structure.
Definition: swscale.h:206
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:138
handle_formats
static int handle_formats(SwsContext *sws)
Definition: utils.c:830
SwsFilter::chrH
SwsVector * chrH
Definition: swscale.h:448
SWS_SRC_V_CHR_DROP_MASK
#define SWS_SRC_V_CHR_DROP_MASK
Definition: swscale.h:412
sws_dcVec
static double sws_dcVec(SwsVector *a)
Definition: utils.c:2063
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
sws_normalizeVec
void sws_normalizeVec(SwsVector *a, double height)
Scale all the coefficients of a so that their sum equals height.
Definition: utils.c:2082
cpu.h
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:175
APCK_SIZE
#define APCK_SIZE
Definition: swscale_internal.h:71
xyzgamma_tab
static uint16_t xyzgamma_tab[4096]
Definition: utils.c:711
rgb2rgb.h
SwsContext::scaler_params
double scaler_params[SWS_NUM_SCALER_PARAMS]
Definition: swscale.h:225
get_local_pos
static av_cold int get_local_pos(SwsInternal *s, int chr_subsample, int pos, int dir)
Definition: utils.c:167
AV_PIX_FMT_GBRAP14LE
@ AV_PIX_FMT_GBRAP14LE
planar GBR 4:4:4:4 56bpp, little-endian
Definition: pixfmt.h:433
swscale.h
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
AV_PIX_FMT_GBRPF16LE
@ AV_PIX_FMT_GBRPF16LE
IEEE-754 half precision planer GBR 4:4:4, 48bpp, little-endian.
Definition: pixfmt.h:467
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:893
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
Definition: swscale_internal.h:475
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:145
min
float min
Definition: vorbis_enc_data.h:429
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:178
context_init_threaded
static int context_init_threaded(SwsContext *sws, SwsFilter *src_filter, SwsFilter *dst_filter)
Definition: utils.c:1871
Generated on Fri Mar 13 2026 19:22:48 for FFmpeg by   doxygen 1.8.17