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