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  int64_t lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1228  int64_t 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  int64_t chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1406  int64_t 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  lumXInc += 20;
1418  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  lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1423  chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1424  }
1425  }
1426  if (chrXInc < 10 || chrXInc > INT_MAX ||
1427  chrYInc < 10 || chrYInc > INT_MAX ||
1428  lumXInc < 10 || lumXInc > INT_MAX ||
1429  lumYInc < 10 || lumYInc > INT_MAX)
1430  return AVERROR_PATCHWELCOME;
1431 
1432  c->lumXInc = lumXInc;
1433  c->lumYInc = lumYInc;
1434  c->chrXInc = chrXInc;
1435  c->chrYInc = chrYInc;
1436 
1437 
1438  // hardcoded for now
1439  c->gamma_value = 2.2;
1440  tmpFmt = AV_PIX_FMT_RGBA64LE;
1441 
1442  if (!unscaled && sws->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1443  SwsInternal *c2;
1444  c->cascaded_context[0] = NULL;
1445 
1446  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1447  srcW, srcH, tmpFmt, 64);
1448  if (ret < 0)
1449  return ret;
1450 
1451  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1452  srcW, srcH, tmpFmt,
1453  flags, NULL, NULL,
1454  sws->scaler_params);
1455  if (!c->cascaded_context[0]) {
1456  return AVERROR(ENOMEM);
1457  }
1458 
1459  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1460  dstW, dstH, tmpFmt,
1461  flags, srcFilter, dstFilter,
1462  sws->scaler_params);
1463 
1464  if (!c->cascaded_context[1])
1465  return AVERROR(ENOMEM);
1466 
1467  c2 = sws_internal(c->cascaded_context[1]);
1468  c2->is_internal_gamma = 1;
1469  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1470  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1471  if (!c2->gamma || !c2->inv_gamma)
1472  return AVERROR(ENOMEM);
1473 
1474  // is_internal_flag is set after creating the context
1475  // to properly create the gamma convert FilterDescriptor
1476  // we have to re-initialize it
1477  ff_free_filters(c2);
1478  if ((ret = ff_init_filters(c2)) < 0) {
1479  sws_freeContext(c->cascaded_context[1]);
1480  c->cascaded_context[1] = NULL;
1481  return ret;
1482  }
1483 
1484  c->cascaded_context[2] = NULL;
1485  if (dstFormat != tmpFmt) {
1486  ret = av_image_alloc(c->cascaded_tmp[1], c->cascaded_tmpStride[1],
1487  dstW, dstH, tmpFmt, 64);
1488  if (ret < 0)
1489  return ret;
1490 
1491  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1492  dstW, dstH, dstFormat,
1493  flags, NULL, NULL,
1494  sws->scaler_params);
1495  if (!c->cascaded_context[2])
1496  return AVERROR(ENOMEM);
1497  }
1498  return 0;
1499  }
1500 
1501  if (isBayer(srcFormat)) {
1502  if (!unscaled ||
1503  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1504  dstFormat != AV_PIX_FMT_RGB48)) {
1505  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1506 
1507  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1508  srcW, srcH, tmpFormat, 64);
1509  if (ret < 0)
1510  return ret;
1511 
1512  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1513  srcW, srcH, tmpFormat,
1514  flags, srcFilter, NULL,
1515  sws->scaler_params);
1516  if (!c->cascaded_context[0])
1517  return AVERROR(ENOMEM);
1518 
1519  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1520  dstW, dstH, dstFormat,
1521  flags, NULL, dstFilter,
1522  sws->scaler_params);
1523  if (!c->cascaded_context[1])
1524  return AVERROR(ENOMEM);
1525  return 0;
1526  }
1527  }
1528 
1529  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1530  for (i = 0; i < 256; ++i){
1531  c->uint2float_lut[i] = (float)i * float_mult;
1532  }
1533  }
1534 
1535  // float will be converted to uint16_t
1536  if ((srcFormat == AV_PIX_FMT_GRAYF32BE || srcFormat == AV_PIX_FMT_GRAYF32LE) &&
1537  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1538  dstFormat != AV_PIX_FMT_GRAY8))){
1539  c->srcBpc = 16;
1540  }
1541 
1542  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1543  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1544 
1545  if (tmpFormat != AV_PIX_FMT_NONE && sws->alpha_blend != SWS_ALPHA_BLEND_NONE) {
1546  if (!unscaled ||
1547  dstFormat != tmpFormat ||
1548  usesHFilter || usesVFilter ||
1549  sws->src_range != sws->dst_range
1550  ) {
1551  c->cascaded_mainindex = 1;
1552  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1553  srcW, srcH, tmpFormat, 64);
1554  if (ret < 0)
1555  return ret;
1556 
1557  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1558  srcW, srcH, tmpFormat,
1559  flags, sws->scaler_params);
1560  if (!c->cascaded_context[0])
1561  return AVERROR(EINVAL);
1562  c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
1563  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1564  if (ret < 0)
1565  return ret;
1566 
1567  c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1568  dstW, dstH, dstFormat,
1569  flags, sws->scaler_params);
1570  if (!c->cascaded_context[1])
1571  return AVERROR(EINVAL);
1572 
1573  c->cascaded_context[1]->src_range = sws->src_range;
1574  c->cascaded_context[1]->dst_range = sws->dst_range;
1575  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1576  if (ret < 0)
1577  return ret;
1578 
1579  return 0;
1580  }
1581  }
1582  }
1583 
1584  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1585  if (unscaled && !usesHFilter && !usesVFilter &&
1586  sws->alpha_blend != SWS_ALPHA_BLEND_NONE &&
1587  isALPHA(srcFormat) &&
1588  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat)) &&
1589  alphaless_fmt(srcFormat) == dstFormat
1590  ) {
1591  c->convert_unscaled = ff_sws_alphablendaway;
1592 
1593  if (flags & SWS_PRINT_INFO)
1594  av_log(c, AV_LOG_INFO,
1595  "using alpha blendaway %s -> %s special converter\n",
1596  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1597  return 0;
1598  }
1599 
1600  /* unscaled special cases */
1601  if (unscaled && !usesHFilter && !usesVFilter &&
1602  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat) ||
1603  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1604 
1605  ff_get_unscaled_swscale(c);
1606 
1607  if (c->convert_unscaled) {
1608  if (flags & SWS_PRINT_INFO)
1609  av_log(c, AV_LOG_INFO,
1610  "using unscaled %s -> %s special converter\n",
1611  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1612  return 0;
1613  }
1614  }
1615 
1616 #if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
1617 #define USE_MMAP 1
1618 #else
1619 #define USE_MMAP 0
1620 #endif
1621 
1622  /* precalculate horizontal scaler filter coefficients */
1623  {
1624 #if HAVE_MMXEXT_INLINE
1625 // can't downscale !!!
1626  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1627  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1628  NULL, NULL, 8);
1629  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1630  NULL, NULL, NULL, 4);
1631 
1632 #if USE_MMAP
1633  c->lumMmxextFilterCode = mmap(NULL, c->lumMmxextFilterCodeSize,
1634  PROT_READ | PROT_WRITE,
1635  MAP_PRIVATE | MAP_ANONYMOUS,
1636  -1, 0);
1637  c->chrMmxextFilterCode = mmap(NULL, c->chrMmxextFilterCodeSize,
1638  PROT_READ | PROT_WRITE,
1639  MAP_PRIVATE | MAP_ANONYMOUS,
1640  -1, 0);
1641 #elif HAVE_VIRTUALALLOC
1642  c->lumMmxextFilterCode = VirtualAlloc(NULL,
1643  c->lumMmxextFilterCodeSize,
1644  MEM_COMMIT,
1645  PAGE_EXECUTE_READWRITE);
1646  c->chrMmxextFilterCode = VirtualAlloc(NULL,
1647  c->chrMmxextFilterCodeSize,
1648  MEM_COMMIT,
1649  PAGE_EXECUTE_READWRITE);
1650 #else
1651  c->lumMmxextFilterCode = av_malloc(c->lumMmxextFilterCodeSize);
1652  c->chrMmxextFilterCode = av_malloc(c->chrMmxextFilterCodeSize);
1653 #endif
1654 
1655 #ifdef MAP_ANONYMOUS
1656  if (c->lumMmxextFilterCode == MAP_FAILED || c->chrMmxextFilterCode == MAP_FAILED)
1657 #else
1658  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode)
1659 #endif
1660  {
1661  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1662  return AVERROR(ENOMEM);
1663  }
1664 
1665  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1666  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1667  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1668  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1669  goto nomem;
1670 
1671  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1672  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1673  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1674  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1675 
1676 #if USE_MMAP
1677  if ( mprotect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1
1678  || mprotect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize, PROT_EXEC | PROT_READ) == -1) {
1679  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1680  ret = AVERROR(EINVAL);
1681  goto fail;
1682  }
1683 #endif
1684  } else
1685 #endif /* HAVE_MMXEXT_INLINE */
1686  {
1687  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1688  PPC_ALTIVEC(cpu_flags) ? 8 :
1689  have_neon(cpu_flags) ? 4 :
1690  have_lsx(cpu_flags) ? 8 :
1691  have_lasx(cpu_flags) ? 8 : 1;
1692 
1693  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1694  &c->hLumFilterSize, c->lumXInc,
1695  srcW, dstW, filterAlign, 1 << 14,
1696  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1697  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1698  sws->scaler_params,
1699  get_local_pos(c, 0, 0, 0),
1700  get_local_pos(c, 0, 0, 0))) < 0)
1701  goto fail;
1702  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1703  goto nomem;
1704  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1705  &c->hChrFilterSize, c->chrXInc,
1706  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1707  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1708  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1709  sws->scaler_params,
1710  get_local_pos(c, c->chrSrcHSubSample, sws->src_h_chr_pos, 0),
1711  get_local_pos(c, c->chrDstHSubSample, sws->dst_h_chr_pos, 0))) < 0)
1712  goto fail;
1713  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1714  goto nomem;
1715  }
1716  } // initialize horizontal stuff
1717 
1718  /* precalculate vertical scaler filter coefficients */
1719  {
1720  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1721  PPC_ALTIVEC(cpu_flags) ? 8 :
1722  have_neon(cpu_flags) ? 2 : 1;
1723 
1724  ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1725  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1726  (flags & SWS_BICUBLIN) ? (flags | SWS_BICUBIC) : flags,
1727  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1728  sws->scaler_params,
1729  get_local_pos(c, 0, 0, 1),
1730  get_local_pos(c, 0, 0, 1));
1731  int usecascade = (ret == RETCODE_USE_CASCADE);
1732  if (ret < 0 && !usecascade)
1733  goto fail;
1734  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1735  c->chrYInc, c->chrSrcH, c->chrDstH,
1736  filterAlign, (1 << 12),
1737  (flags & SWS_BICUBLIN) ? (flags | SWS_BILINEAR) : flags,
1738  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1739  sws->scaler_params,
1740  get_local_pos(c, c->chrSrcVSubSample, sws->src_v_chr_pos, 1),
1741  get_local_pos(c, c->chrDstVSubSample, sws->dst_v_chr_pos, 1))) < 0)
1742 
1743  goto fail;
1744  if (usecascade) {
1745  ret = RETCODE_USE_CASCADE;
1746  goto fail;
1747  }
1748 
1749 #if HAVE_ALTIVEC
1750  ret = ff_sws_init_altivec_bufs(c);
1751  if (ret < 0)
1752  goto fail;
1753 #endif
1754  }
1755 
1756  for (i = 0; i < 4; i++)
1757  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], sws->dst_w + 3))
1758  goto nomem;
1759 
1760  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(sws->src_format) && isALPHA(sws->dst_format)) ? 1 : 0;
1761 
1762  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1763  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1764  c->uv_offx2 = dst_stride + 16;
1765 
1766  av_assert0(c->chrDstH <= dstH);
1767 
1768  if (flags & SWS_PRINT_INFO) {
1769  const char *scaler = NULL, *cpucaps;
1770 
1771  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1772  if (flags & scale_algorithms[i].flag) {
1773  scaler = scale_algorithms[i].description;
1774  break;
1775  }
1776  }
1777  if (!scaler)
1778  scaler = "ehh flags invalid?!";
1779  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1780  scaler,
1781  av_get_pix_fmt_name(srcFormat),
1782  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1783  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1784  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1785  "dithered " : "",
1786  av_get_pix_fmt_name(dstFormat));
1787 
1788  if (INLINE_MMXEXT(cpu_flags))
1789  cpucaps = "MMXEXT";
1790  else if (INLINE_MMX(cpu_flags))
1791  cpucaps = "MMX";
1792  else if (PPC_ALTIVEC(cpu_flags))
1793  cpucaps = "AltiVec";
1794  else
1795  cpucaps = "C";
1796 
1797  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1798 
1799  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1800  av_log(c, AV_LOG_DEBUG,
1801  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1802  sws->src_w, sws->src_h, sws->dst_w, sws->dst_h, c->lumXInc, c->lumYInc);
1803  av_log(c, AV_LOG_DEBUG,
1804  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1805  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1806  c->chrXInc, c->chrYInc);
1807  }
1808 
1809  ff_sws_init_scale(c);
1810 
1811  return ff_init_filters(c);
1812 nomem:
1813  ret = AVERROR(ENOMEM);
1814 fail: // FIXME replace things by appropriate error codes
1815  if (ret == RETCODE_USE_CASCADE) {
1816  int tmpW = sqrt(srcW * (int64_t)dstW);
1817  int tmpH = sqrt(srcH * (int64_t)dstH);
1818  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1819 
1820  if (isALPHA(srcFormat))
1821  tmpFormat = AV_PIX_FMT_YUVA420P;
1822 
1823  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1824  return AVERROR(EINVAL);
1825 
1826  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1827  tmpW, tmpH, tmpFormat, 64);
1828  if (ret < 0)
1829  return ret;
1830 
1831  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1832  tmpW, tmpH, tmpFormat,
1833  flags, srcFilter, NULL,
1834  sws->scaler_params);
1835  if (!c->cascaded_context[0])
1836  return AVERROR(ENOMEM);
1837 
1838  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
1839  dstW, dstH, dstFormat,
1840  flags, NULL, dstFilter,
1841  sws->scaler_params);
1842  if (!c->cascaded_context[1])
1843  return AVERROR(ENOMEM);
1844  return 0;
1845  }
1846  return ret;
1847 }
1848 
1849 static int context_init_threaded(SwsContext *sws,
1850  SwsFilter *src_filter, SwsFilter *dst_filter)
1851 {
1852  SwsInternal *c = sws_internal(sws);
1853  int ret;
1854 
1855  ret = avpriv_slicethread_create(&c->slicethread, (void*) sws,
1856  ff_sws_slice_worker, NULL, sws->threads);
1857  if (ret == AVERROR(ENOSYS)) {
1858  sws->threads = 1;
1859  return 0;
1860  } else if (ret < 0)
1861  return ret;
1862 
1863  sws->threads = ret;
1864 
1865  c->slice_ctx = av_calloc(sws->threads, sizeof(*c->slice_ctx));
1866  c->slice_err = av_calloc(sws->threads, sizeof(*c->slice_err));
1867  if (!c->slice_ctx || !c->slice_err)
1868  return AVERROR(ENOMEM);
1869 
1870  for (int i = 0; i < sws->threads; i++) {
1871  SwsContext *slice;
1872  slice = c->slice_ctx[i] = sws_alloc_context();
1873  if (!slice)
1874  return AVERROR(ENOMEM);
1875  sws_internal(slice)->parent = sws;
1876  c->nb_slice_ctx++;
1877 
1878  ret = av_opt_copy(slice, sws);
1879  if (ret < 0)
1880  return ret;
1881  slice->threads = 1;
1882 
1883  ret = ff_sws_init_single_context(slice, src_filter, dst_filter);
1884  if (ret < 0)
1885  return ret;
1886 
1887  if (slice->dither == SWS_DITHER_ED) {
1888  av_log(c, AV_LOG_VERBOSE,
1889  "Error-diffusion dither is in use, scaling will be single-threaded.");
1890  break;
1891  }
1892  }
1893 
1894  return 0;
1895 }
1896 
1897 av_cold int sws_init_context(SwsContext *sws, SwsFilter *srcFilter,
1898  SwsFilter *dstFilter)
1899 {
1900  SwsInternal *c = sws_internal(sws);
1901  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1902  enum AVPixelFormat src_format, dst_format;
1903  int ret;
1904 
1905  c->is_legacy_init = 1;
1906  c->frame_src = av_frame_alloc();
1907  c->frame_dst = av_frame_alloc();
1908  if (!c->frame_src || !c->frame_dst)
1909  return AVERROR(ENOMEM);
1910 
1911  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1912  return AVERROR_UNKNOWN;
1913 
1914  src_format = sws->src_format;
1915  dst_format = sws->dst_format;
1916  sws->src_range |= handle_jpeg(&sws->src_format);
1917  sws->dst_range |= handle_jpeg(&sws->dst_format);
1918 
1919  if (src_format != sws->src_format || dst_format != sws->dst_format)
1920  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1921 
1922  if (sws->threads != 1) {
1923  ret = context_init_threaded(sws, srcFilter, dstFilter);
1924  if (ret < 0 || sws->threads > 1)
1925  return ret;
1926  // threading disabled in this build, init as single-threaded
1927  }
1928 
1929  return ff_sws_init_single_context(sws, srcFilter, dstFilter);
1930 }
1931 
1932 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
1933  int dstW, int dstH, enum AVPixelFormat dstFormat,
1934  int flags, SwsFilter *srcFilter,
1935  SwsFilter *dstFilter, const double *param)
1936 {
1937  SwsContext *sws;
1938 
1939  sws = alloc_set_opts(srcW, srcH, srcFormat,
1940  dstW, dstH, dstFormat,
1941  flags, param);
1942  if (!sws)
1943  return NULL;
1944 
1945  if (sws_init_context(sws, srcFilter, dstFilter) < 0) {
1946  sws_freeContext(sws);
1947  return NULL;
1948  }
1949 
1950  return sws;
1951 }
1952 
1953 static int isnan_vec(SwsVector *a)
1954 {
1955  int i;
1956  for (i=0; i<a->length; i++)
1957  if (isnan(a->coeff[i]))
1958  return 1;
1959  return 0;
1960 }
1961 
1962 static void makenan_vec(SwsVector *a)
1963 {
1964  int i;
1965  for (i=0; i<a->length; i++)
1966  a->coeff[i] = NAN;
1967 }
1968 
1969 SwsVector *sws_allocVec(int length)
1970 {
1971  SwsVector *vec;
1972 
1973  if(length <= 0 || length > INT_MAX/ sizeof(double))
1974  return NULL;
1975 
1976  vec = av_malloc(sizeof(SwsVector));
1977  if (!vec)
1978  return NULL;
1979  vec->length = length;
1980  vec->coeff = av_malloc(sizeof(double) * length);
1981  if (!vec->coeff)
1982  av_freep(&vec);
1983  return vec;
1984 }
1985 
1986 SwsVector *sws_getGaussianVec(double variance, double quality)
1987 {
1988  const int length = (int)(variance * quality + 0.5) | 1;
1989  int i;
1990  double middle = (length - 1) * 0.5;
1991  SwsVector *vec;
1992 
1993  if(variance < 0 || quality < 0)
1994  return NULL;
1995 
1996  vec = sws_allocVec(length);
1997 
1998  if (!vec)
1999  return NULL;
2000 
2001  for (i = 0; i < length; i++) {
2002  double dist = i - middle;
2003  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
2004  sqrt(2 * variance * M_PI);
2005  }
2006 
2007  sws_normalizeVec(vec, 1.0);
2008 
2009  return vec;
2010 }
2011 
2012 /**
2013  * Allocate and return a vector with length coefficients, all
2014  * with the same value c.
2015  */
2016 static
2017 SwsVector *sws_getConstVec(double c, int length)
2018 {
2019  int i;
2020  SwsVector *vec = sws_allocVec(length);
2021 
2022  if (!vec)
2023  return NULL;
2024 
2025  for (i = 0; i < length; i++)
2026  vec->coeff[i] = c;
2027 
2028  return vec;
2029 }
2030 
2031 /**
2032  * Allocate and return a vector with just one coefficient, with
2033  * value 1.0.
2034  */
2035 static
2036 SwsVector *sws_getIdentityVec(void)
2037 {
2038  return sws_getConstVec(1.0, 1);
2039 }
2040 
2041 static double sws_dcVec(SwsVector *a)
2042 {
2043  int i;
2044  double sum = 0;
2045 
2046  for (i = 0; i < a->length; i++)
2047  sum += a->coeff[i];
2048 
2049  return sum;
2050 }
2051 
2052 void sws_scaleVec(SwsVector *a, double scalar)
2053 {
2054  int i;
2055 
2056  for (i = 0; i < a->length; i++)
2057  a->coeff[i] *= scalar;
2058 }
2059 
2060 void sws_normalizeVec(SwsVector *a, double height)
2061 {
2062  sws_scaleVec(a, height / sws_dcVec(a));
2063 }
2064 
2065 static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
2066 {
2067  int length = FFMAX(a->length, b->length);
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 - (a->length - 1) / 2] += a->coeff[i];
2076  for (i = 0; i < b->length; i++)
2077  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2078 
2079  return vec;
2080 }
2081 
2082 /* shift left / or right if "shift" is negative */
2083 static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
2084 {
2085  int length = a->length + FFABS(shift) * 2;
2086  int i;
2087  SwsVector *vec = sws_getConstVec(0.0, length);
2088 
2089  if (!vec)
2090  return NULL;
2091 
2092  for (i = 0; i < a->length; i++) {
2093  vec->coeff[i + (length - 1) / 2 -
2094  (a->length - 1) / 2 - shift] = a->coeff[i];
2095  }
2096 
2097  return vec;
2098 }
2099 
2100 static
2101 void sws_shiftVec(SwsVector *a, int shift)
2102 {
2103  SwsVector *shifted = sws_getShiftedVec(a, shift);
2104  if (!shifted) {
2105  makenan_vec(a);
2106  return;
2107  }
2108  av_free(a->coeff);
2109  a->coeff = shifted->coeff;
2110  a->length = shifted->length;
2111  av_free(shifted);
2112 }
2113 
2114 static
2115 void sws_addVec(SwsVector *a, SwsVector *b)
2116 {
2117  SwsVector *sum = sws_sumVec(a, b);
2118  if (!sum) {
2119  makenan_vec(a);
2120  return;
2121  }
2122  av_free(a->coeff);
2123  a->coeff = sum->coeff;
2124  a->length = sum->length;
2125  av_free(sum);
2126 }
2127 
2128 /**
2129  * Print with av_log() a textual representation of the vector a
2130  * if log_level <= av_log_level.
2131  */
2132 static
2133 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2134 {
2135  int i;
2136  double max = 0;
2137  double min = 0;
2138  double range;
2139 
2140  for (i = 0; i < a->length; i++)
2141  if (a->coeff[i] > max)
2142  max = a->coeff[i];
2143 
2144  for (i = 0; i < a->length; i++)
2145  if (a->coeff[i] < min)
2146  min = a->coeff[i];
2147 
2148  range = max - min;
2149 
2150  for (i = 0; i < a->length; i++) {
2151  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2152  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2153  for (; x > 0; x--)
2154  av_log(log_ctx, log_level, " ");
2155  av_log(log_ctx, log_level, "|\n");
2156  }
2157 }
2158 
2159 void sws_freeVec(SwsVector *a)
2160 {
2161  if (!a)
2162  return;
2163  av_freep(&a->coeff);
2164  a->length = 0;
2165  av_free(a);
2166 }
2167 
2168 void sws_freeFilter(SwsFilter *filter)
2169 {
2170  if (!filter)
2171  return;
2172 
2173  sws_freeVec(filter->lumH);
2174  sws_freeVec(filter->lumV);
2175  sws_freeVec(filter->chrH);
2176  sws_freeVec(filter->chrV);
2177  av_free(filter);
2178 }
2179 
2180 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2181  float lumaSharpen, float chromaSharpen,
2182  float chromaHShift, float chromaVShift,
2183  int verbose)
2184 {
2185  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2186  if (!filter)
2187  return NULL;
2188 
2189  if (lumaGBlur != 0.0) {
2190  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2191  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2192  } else {
2193  filter->lumH = sws_getIdentityVec();
2194  filter->lumV = sws_getIdentityVec();
2195  }
2196 
2197  if (chromaGBlur != 0.0) {
2198  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2199  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2200  } else {
2201  filter->chrH = sws_getIdentityVec();
2202  filter->chrV = sws_getIdentityVec();
2203  }
2204 
2205  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2206  goto fail;
2207 
2208  if (chromaSharpen != 0.0) {
2209  SwsVector *id = sws_getIdentityVec();
2210  if (!id)
2211  goto fail;
2212  sws_scaleVec(filter->chrH, -chromaSharpen);
2213  sws_scaleVec(filter->chrV, -chromaSharpen);
2214  sws_addVec(filter->chrH, id);
2215  sws_addVec(filter->chrV, id);
2216  sws_freeVec(id);
2217  }
2218 
2219  if (lumaSharpen != 0.0) {
2220  SwsVector *id = sws_getIdentityVec();
2221  if (!id)
2222  goto fail;
2223  sws_scaleVec(filter->lumH, -lumaSharpen);
2224  sws_scaleVec(filter->lumV, -lumaSharpen);
2225  sws_addVec(filter->lumH, id);
2226  sws_addVec(filter->lumV, id);
2227  sws_freeVec(id);
2228  }
2229 
2230  if (chromaHShift != 0.0)
2231  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2232 
2233  if (chromaVShift != 0.0)
2234  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2235 
2236  sws_normalizeVec(filter->chrH, 1.0);
2237  sws_normalizeVec(filter->chrV, 1.0);
2238  sws_normalizeVec(filter->lumH, 1.0);
2239  sws_normalizeVec(filter->lumV, 1.0);
2240 
2241  if (isnan_vec(filter->chrH) ||
2242  isnan_vec(filter->chrV) ||
2243  isnan_vec(filter->lumH) ||
2244  isnan_vec(filter->lumV))
2245  goto fail;
2246 
2247  if (verbose)
2248  sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
2249  if (verbose)
2250  sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
2251 
2252  return filter;
2253 
2254 fail:
2255  sws_freeVec(filter->lumH);
2256  sws_freeVec(filter->lumV);
2257  sws_freeVec(filter->chrH);
2258  sws_freeVec(filter->chrV);
2259  av_freep(&filter);
2260  return NULL;
2261 }
2262 
2263 void sws_freeContext(SwsContext *sws)
2264 {
2265  SwsInternal *c = sws_internal(sws);
2266  int i;
2267  if (!c)
2268  return;
2269 
2270  av_refstruct_unref(&c->hw_priv);
2271 
2272  for (i = 0; i < FF_ARRAY_ELEMS(c->graph); i++)
2273  ff_sws_graph_free(&c->graph[i]);
2274 
2275  for (i = 0; i < c->nb_slice_ctx; i++)
2276  sws_freeContext(c->slice_ctx[i]);
2277  av_freep(&c->slice_ctx);
2278  av_freep(&c->slice_err);
2279 
2280  avpriv_slicethread_free(&c->slicethread);
2281 
2282  for (i = 0; i < 4; i++)
2283  av_freep(&c->dither_error[i]);
2284 
2285  av_frame_free(&c->frame_src);
2286  av_frame_free(&c->frame_dst);
2287 
2288  av_freep(&c->src_ranges.ranges);
2289 
2290  av_freep(&c->vLumFilter);
2291  av_freep(&c->vChrFilter);
2292  av_freep(&c->hLumFilter);
2293  av_freep(&c->hChrFilter);
2294 #if HAVE_ALTIVEC
2295  ff_sws_free_altivec_bufs(c);
2296 #endif
2297 
2298  av_freep(&c->vLumFilterPos);
2299  av_freep(&c->vChrFilterPos);
2300  av_freep(&c->hLumFilterPos);
2301  av_freep(&c->hChrFilterPos);
2302 
2303 #if HAVE_MMX_INLINE
2304 #if USE_MMAP
2305  if (c->lumMmxextFilterCode)
2306  munmap(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2307  if (c->chrMmxextFilterCode)
2308  munmap(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2309 #elif HAVE_VIRTUALALLOC
2310  if (c->lumMmxextFilterCode)
2311  VirtualFree(c->lumMmxextFilterCode, 0, MEM_RELEASE);
2312  if (c->chrMmxextFilterCode)
2313  VirtualFree(c->chrMmxextFilterCode, 0, MEM_RELEASE);
2314 #else
2315  av_free(c->lumMmxextFilterCode);
2316  av_free(c->chrMmxextFilterCode);
2317 #endif
2318  c->lumMmxextFilterCode = NULL;
2319  c->chrMmxextFilterCode = NULL;
2320 #endif /* HAVE_MMX_INLINE */
2321 
2322  av_freep(&c->yuvTable);
2323  av_freep(&c->formatConvBuffer);
2324 
2325  sws_freeContext(c->cascaded_context[0]);
2326  sws_freeContext(c->cascaded_context[1]);
2327  sws_freeContext(c->cascaded_context[2]);
2328  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2329  av_freep(&c->cascaded_tmp[0][0]);
2330  av_freep(&c->cascaded_tmp[1][0]);
2331 
2332  av_freep(&c->gamma);
2333  av_freep(&c->inv_gamma);
2334 #if CONFIG_SMALL
2335  av_freep(&c->xyz2rgb.gamma.in);
2336 #endif
2337 
2338  av_freep(&c->rgb0_scratch);
2339  av_freep(&c->xyz_scratch);
2340 
2341  ff_free_filters(c);
2342 
2343  av_free(c);
2344 }
2345 
2346 void sws_free_context(SwsContext **pctx)
2347 {
2348  SwsContext *ctx = *pctx;
2349  if (!ctx)
2350  return;
2351 
2352  sws_freeContext(ctx);
2353  *pctx = NULL;
2354 }
2355 
2356 SwsContext *sws_getCachedContext(SwsContext *prev, int srcW,
2357  int srcH, enum AVPixelFormat srcFormat,
2358  int dstW, int dstH,
2359  enum AVPixelFormat dstFormat, int flags,
2360  SwsFilter *srcFilter,
2361  SwsFilter *dstFilter,
2362  const double *param)
2363 {
2364  SwsContext *sws;
2365  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2366  SWS_PARAM_DEFAULT };
2367 
2368  if (!param)
2369  param = default_param;
2370 
2371  if (prev && (prev->src_w == srcW &&
2372  prev->src_h == srcH &&
2373  prev->src_format == srcFormat &&
2374  prev->dst_w == dstW &&
2375  prev->dst_h == dstH &&
2376  prev->dst_format == dstFormat &&
2377  prev->flags == flags &&
2378  prev->scaler_params[0] == param[0] &&
2379  prev->scaler_params[1] == param[1])) {
2380  return prev;
2381  }
2382 
2383  if (!(sws = sws_alloc_context())) {
2384  sws_free_context(&prev);
2385  return NULL;
2386  }
2387 
2388  if (prev) {
2389  av_opt_copy(sws, prev);
2390  sws_free_context(&prev);
2391  }
2392 
2393  sws->src_w = srcW;
2394  sws->src_h = srcH;
2395  sws->src_format = srcFormat;
2396  sws->dst_w = dstW;
2397  sws->dst_h = dstH;
2398  sws->dst_format = dstFormat;
2399  sws->flags = flags;
2400  sws->scaler_params[0] = param[0];
2401  sws->scaler_params[1] = param[1];
2402 
2403  if (sws_init_context(sws, srcFilter, dstFilter) < 0)
2404  sws_free_context(&sws);
2405 
2406  return sws;
2407 }
2408 
2409 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2410 {
2411  Range *tmp;
2412  unsigned int idx;
2413 
2414  /* find the first existing range after the new one */
2415  for (idx = 0; idx < rl->nb_ranges; idx++)
2416  if (rl->ranges[idx].start > start)
2417  break;
2418 
2419  /* check for overlap */
2420  if (idx > 0) {
2421  Range *prev = &rl->ranges[idx - 1];
2422  if (prev->start + prev->len > start)
2423  return AVERROR(EINVAL);
2424  }
2425  if (idx < rl->nb_ranges) {
2426  Range *next = &rl->ranges[idx];
2427  if (start + len > next->start)
2428  return AVERROR(EINVAL);
2429  }
2430 
2431  tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated,
2432  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2433  if (!tmp)
2434  return AVERROR(ENOMEM);
2435  rl->ranges = tmp;
2436 
2437  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2438  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2439  rl->ranges[idx].start = start;
2440  rl->ranges[idx].len = len;
2441  rl->nb_ranges++;
2442 
2443  /* merge ranges */
2444  if (idx > 0) {
2445  Range *prev = &rl->ranges[idx - 1];
2446  Range *cur = &rl->ranges[idx];
2447  if (prev->start + prev->len == cur->start) {
2448  prev->len += cur->len;
2449  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2450  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2451  rl->nb_ranges--;
2452  idx--;
2453  }
2454  }
2455  if (idx < rl->nb_ranges - 1) {
2456  Range *cur = &rl->ranges[idx];
2457  Range *next = &rl->ranges[idx + 1];
2458  if (cur->start + cur->len == next->start) {
2459  cur->len += next->len;
2460  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2461  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2462  rl->nb_ranges--;
2463  }
2464  }
2465 
2466  return 0;
2467 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:857
flags
const SwsFlags flags[]
Definition: swscale.c: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:925
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale.h:81
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c: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:2036
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
SWS_MAX_REDUCE_CUTOFF
#define SWS_MAX_REDUCE_CUTOFF
Definition: filters.h:41
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:2263
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:802
SWSINTERNAL_ADDITIONAL_ASM_SIZE
#define SWSINTERNAL_ADDITIONAL_ASM_SIZE
Definition: swscale_internal.h:46
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:469
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
SWS_BILINEAR
@ SWS_BILINEAR
bilinear filtering
Definition: swscale.h: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:2083
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
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:2159
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:1953
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:742
ub
#define ub(width, name)
Definition: cbs_apv.c:125
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
SWS_FULL_CHR_H_INP
@ SWS_FULL_CHR_H_INP
Perform full chroma interpolation when downscaling RGB sources.
Definition: swscale.h: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:2356
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:1897
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: alphablend.c:23
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3484
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:756
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:77
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:522
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale.h:85
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:191
xyzgammainv_tab
static uint16_t xyzgammainv_tab[65536]
Definition: utils.c: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:111
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
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:2409
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:2133
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:415
ops.h
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:1969
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:2381
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:1986
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: filters.h:42
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:389
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
ff_free_filters
int ff_free_filters(SwsInternal *c)
Definition: slice.c:386
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:310
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:530
NULL
#define NULL
Definition: coverity.c:32
RETCODE_USE_CASCADE
#define RETCODE_USE_CASCADE
Definition: swscale_internal.h:74
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AV_PIX_FMT_GBRAPF16BE
@ AV_PIX_FMT_GBRAPF16BE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian.
Definition: pixfmt.h:468
asm.h
SWS_BICUBIC
@ SWS_BICUBIC
2-tap cubic B-spline
Definition: swscale.h: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:2180
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:1962
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:2115
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:414
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:2052
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:2017
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
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:809
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:1551
handle_0alpha
static int handle_0alpha(int *format)
Definition: utils.c:812
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:423
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:413
shift
static int shift(int a, int b)
Definition: bonk.c:261
W
@ W
Definition: vf_addroi.c:27
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:871
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:137
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
SWS_POINT
@ SWS_POINT
nearest neighbor
Definition: swscale.h: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:770
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:419
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:421
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:2101
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:2168
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:879
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:89
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:399
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:469
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:1932
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:864
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
ff_init_filters
int ff_init_filters(SwsInternal *c)
Definition: slice.c:246
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:471
SwsContext::dst_w
int dst_w
Definition: swscale.h: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:420
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
sws_sumVec
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2065
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:2346
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:422
SWS_SRC_V_CHR_DROP_MASK
#define SWS_SRC_V_CHR_DROP_MASK
Definition: swscale.h:388
sws_dcVec
static double sws_dcVec(SwsVector *a)
Definition: utils.c:2041
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:2060
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:893
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
Definition: swscale_internal.h:475
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:145
min
float min
Definition: vorbis_enc_data.h:429
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:178
context_init_threaded
static int context_init_threaded(SwsContext *sws, SwsFilter *src_filter, SwsFilter *dst_filter)
Definition: utils.c:1849
Generated on Sat Aug 15 2026 03:21:15 for FFmpeg by   doxygen 1.8.17