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 #include <inttypes.h>
26 #include <math.h>
27 #include <stdio.h>
28 #include <string.h>
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/cpu.h"
33 #include "libavutil/csp.h"
34 #include "libavutil/emms.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/libm.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/mem.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/refstruct.h"
43 #include "libavutil/slicethread.h"
44 #include "libavutil/thread.h"
45 #include "libavutil/aarch64/cpu.h"
46 #include "libavutil/ppc/cpu.h"
47 #include "libavutil/x86/asm.h"
48 #include "libavutil/x86/cpu.h"
49 #include "libavutil/loongarch/cpu.h"
50 
51 #include "rgb2rgb.h"
52 #include "swscale.h"
53 #include "swscale_internal.h"
54 #include "graph.h"
55 #include "jit.h"
56 
57 #if CONFIG_VULKAN
58 #include "vulkan/ops.h"
59 #endif
60 
61 SwsBackend ff_sws_enabled_backends(const SwsContext *ctx)
62 {
63  if (ctx->backends)
64  return ctx->backends;
65 
66  SwsBackend fallback = SWS_BACKEND_STABLE;
67  if (ctx->flags & SWS_UNSTABLE)
68  fallback |= SWS_BACKEND_UNSTABLE;
69 
70  return fallback;
71 }
72 
73 /**
74  * Allocate and return an SwsContext without performing initialization.
75  */
76 static SwsContext *alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
77  int dstW, int dstH, enum AVPixelFormat dstFormat,
78  int flags, const double *param)
79 {
80  SwsContext *sws = sws_alloc_context();
81  if (!sws)
82  return NULL;
83 
84  sws->flags = flags;
85  sws->src_w = srcW;
86  sws->src_h = srcH;
87  sws->dst_w = dstW;
88  sws->dst_h = dstH;
89  sws->src_format = srcFormat;
90  sws->dst_format = dstFormat;
91 
92  for (int i = 0; param && i < SWS_NUM_SCALER_PARAMS; i++)
93  sws->scaler_params[i] = param[i];
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 scaler, int flags, int cpu_flags,
202  SwsVector *srcFilter, SwsVector *dstFilter,
203  double param[SWS_NUM_SCALER_PARAMS], 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 (scaler == 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) && (scaler == SWS_AREA)) ||
246  (scaler == 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 (scaler == scale_algorithms[i].flag && scale_algorithms[i].size_factor > 0) {
275  sizeFactor = scale_algorithms[i].size_factor;
276  break;
277  }
278  }
279  if (scaler == 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 (scaler == 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 (scaler == 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 (scaler == 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 (scaler == SWS_GAUSS) {
357  double p = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
358  coeff = exp2(-p * floatd * floatd) * fone;
359  } else if (scaler == SWS_SINC) {
360  coeff = (d ? sin(floatd * M_PI) / (floatd * M_PI) : 1.0) * fone;
361  } else if (scaler == 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 (scaler == SWS_BILINEAR) {
368  coeff = (1 << 30) - d;
369  if (coeff < 0)
370  coeff = 0;
371  coeff *= fone >> 30;
372  } else if (scaler == 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 static int scaler_flag(SwsScaler scaler, int fallback)
1123 {
1124  switch (scaler) {
1125  case SWS_SCALE_BILINEAR: return SWS_BILINEAR; break;
1126  case SWS_SCALE_BICUBIC: return SWS_BICUBIC; break;
1127  case SWS_SCALE_POINT: return SWS_POINT; break;
1128  case SWS_SCALE_AREA: return SWS_AREA; break;
1129  case SWS_SCALE_GAUSSIAN: return SWS_GAUSS; break;
1130  case SWS_SCALE_SINC: return SWS_SINC; break;
1131  case SWS_SCALE_LANCZOS: return SWS_LANCZOS; break;
1132  case SWS_SCALE_SPLINE: return SWS_SPLINE; break;
1133  default:
1134  return fallback;
1135  }
1136 }
1137 
1138 av_cold int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter,
1139  SwsFilter *dstFilter)
1140 {
1141  int i;
1142  int usesVFilter, usesHFilter;
1143  int unscaled;
1144  SwsInternal *c = sws_internal(sws);
1145  SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1146  int srcW = sws->src_w;
1147  int srcH = sws->src_h;
1148  int dstW = sws->dst_w;
1149  int dstH = sws->dst_h;
1150  int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1151  int flags, cpu_flags;
1152  enum AVPixelFormat srcFormat, dstFormat;
1153  const AVPixFmtDescriptor *desc_src;
1154  const AVPixFmtDescriptor *desc_dst;
1155  int ret = 0;
1156  enum AVPixelFormat tmpFmt;
1157  static const float float_mult = 1.0f / 255.0f;
1158 
1159  cpu_flags = av_get_cpu_flags();
1160  flags = sws->flags;
1161  emms_c();
1162 
1163  unscaled = (srcW == dstW && srcH == dstH);
1164 
1165  if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1166  sws_setColorspaceDetails(sws, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sws->src_range,
1167  ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1168  sws->dst_range, 0, 1 << 16, 1 << 16);
1169 
1170  ret = handle_formats(sws);
1171  if (ret < 0)
1172  return ret;
1173  srcFormat = sws->src_format;
1174  dstFormat = sws->dst_format;
1175  desc_src = av_pix_fmt_desc_get(srcFormat);
1176  desc_dst = av_pix_fmt_desc_get(dstFormat);
1177 
1178  // If the source has no alpha then disable alpha blendaway
1179  if (c->src0Alpha)
1180  sws->alpha_blend = SWS_ALPHA_BLEND_NONE;
1181 
1182  if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1183  av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
1184  if (!sws_isSupportedInput(srcFormat)) {
1185  av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n",
1186  av_get_pix_fmt_name(srcFormat));
1187  return AVERROR(EINVAL);
1188  }
1189  if (!sws_isSupportedOutput(dstFormat)) {
1190  av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n",
1191  av_get_pix_fmt_name(dstFormat));
1192  return AVERROR(EINVAL);
1193  }
1194  }
1195  av_assert2(desc_src && desc_dst);
1196 
1197  i = flags & (SWS_POINT |
1198  SWS_AREA |
1199  SWS_BILINEAR |
1200  SWS_FAST_BILINEAR |
1201  SWS_BICUBIC |
1202  SWS_X |
1203  SWS_GAUSS |
1204  SWS_LANCZOS |
1205  SWS_SINC |
1206  SWS_SPLINE |
1207  SWS_BICUBLIN);
1208 
1209  /* provide a default scaler if not set by caller */
1210  if (!i) {
1211  if (dstW < srcW && dstH < srcH)
1212  i = SWS_BICUBIC;
1213  else if (dstW > srcW && dstH > srcH)
1214  i = SWS_BICUBIC;
1215  else
1216  i = SWS_BICUBIC;
1217  flags |= i;
1218  sws->flags = flags;
1219  } else if (i & (i - 1)) {
1220  av_log(c, AV_LOG_ERROR,
1221  "Exactly one scaler algorithm must be chosen, got %X\n", i);
1222  return AVERROR(EINVAL);
1223  }
1224 
1225  if (i == SWS_FAST_BILINEAR) {
1226  if (srcW < 8 || dstW <= 8) {
1227  i = SWS_BILINEAR;
1228  flags ^= SWS_FAST_BILINEAR | i;
1229  sws->flags = flags;
1230  }
1231  }
1232 
1233  SwsScaler scaler_sub = sws->scaler_sub ? sws->scaler_sub : sws->scaler;
1234  int lum_scaler = scaler_flag(sws->scaler, i == SWS_BICUBLIN ? SWS_BICUBIC : i);
1235  int chr_scaler = scaler_flag(scaler_sub, i == SWS_BICUBLIN ? SWS_BILINEAR : i);
1236 
1237  /* sanity check */
1238  if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
1239  /* FIXME check if these are enough and try to lower them after
1240  * fixing the relevant parts of the code */
1241  av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
1242  srcW, srcH, dstW, dstH);
1243  return AVERROR(EINVAL);
1244  }
1245 
1246  if (!dstFilter)
1247  dstFilter = &dummyFilter;
1248  if (!srcFilter)
1249  srcFilter = &dummyFilter;
1250 
1251  int64_t lumXInc = (((int64_t)srcW << 16) + (dstW >> 1)) / dstW;
1252  int64_t lumYInc = (((int64_t)srcH << 16) + (dstH >> 1)) / dstH;
1253  c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
1254  c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
1255  c->vRounder = 4 * 0x0001000100010001ULL;
1256 
1257  usesVFilter = (srcFilter->lumV && srcFilter->lumV->length > 1) ||
1258  (srcFilter->chrV && srcFilter->chrV->length > 1) ||
1259  (dstFilter->lumV && dstFilter->lumV->length > 1) ||
1260  (dstFilter->chrV && dstFilter->chrV->length > 1);
1261  usesHFilter = (srcFilter->lumH && srcFilter->lumH->length > 1) ||
1262  (srcFilter->chrH && srcFilter->chrH->length > 1) ||
1263  (dstFilter->lumH && dstFilter->lumH->length > 1) ||
1264  (dstFilter->chrH && dstFilter->chrH->length > 1);
1265 
1266  av_pix_fmt_get_chroma_sub_sample(srcFormat, &c->chrSrcHSubSample, &c->chrSrcVSubSample);
1267  av_pix_fmt_get_chroma_sub_sample(dstFormat, &c->chrDstHSubSample, &c->chrDstVSubSample);
1268 
1269  c->dst_slice_align = 1 << c->chrDstVSubSample;
1270 
1271  if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) {
1272  if (dstW&1) {
1273  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1274  flags |= SWS_FULL_CHR_H_INT;
1275  sws->flags = flags;
1276  }
1277 
1278  if ( c->chrSrcHSubSample == 0
1279  && c->chrSrcVSubSample == 0
1280  && sws->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1281  && !(sws->flags & SWS_FAST_BILINEAR)
1282  ) {
1283  av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1284  flags |= SWS_FULL_CHR_H_INT;
1285  sws->flags = flags;
1286  }
1287  }
1288 
1289  if (sws->dither == SWS_DITHER_AUTO) {
1290  if (flags & SWS_ERROR_DIFFUSION)
1291  sws->dither = SWS_DITHER_ED;
1292  }
1293 
1294  if(dstFormat == AV_PIX_FMT_BGR4_BYTE ||
1295  dstFormat == AV_PIX_FMT_RGB4_BYTE ||
1296  dstFormat == AV_PIX_FMT_BGR8 ||
1297  dstFormat == AV_PIX_FMT_RGB8) {
1298  if (sws->dither == SWS_DITHER_AUTO)
1299  sws->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1300  if (!(flags & SWS_FULL_CHR_H_INT)) {
1301  if (sws->dither == SWS_DITHER_ED || sws->dither == SWS_DITHER_A_DITHER || sws->dither == SWS_DITHER_X_DITHER || sws->dither == SWS_DITHER_NONE) {
1302  av_log(c, AV_LOG_DEBUG,
1303  "Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1304  av_get_pix_fmt_name(dstFormat));
1305  flags |= SWS_FULL_CHR_H_INT;
1306  sws->flags = flags;
1307  }
1308  }
1309  if (flags & SWS_FULL_CHR_H_INT) {
1310  if (sws->dither == SWS_DITHER_BAYER) {
1311  av_log(c, AV_LOG_DEBUG,
1312  "Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1313  av_get_pix_fmt_name(dstFormat));
1314  sws->dither = SWS_DITHER_ED;
1315  }
1316  }
1317  }
1318  if (isPlanarRGB(dstFormat)) {
1319  if (!(flags & SWS_FULL_CHR_H_INT)) {
1320  av_log(c, AV_LOG_DEBUG,
1321  "%s output is not supported with half chroma resolution, switching to full\n",
1322  av_get_pix_fmt_name(dstFormat));
1323  flags |= SWS_FULL_CHR_H_INT;
1324  sws->flags = flags;
1325  }
1326  }
1327 
1328  /* reuse chroma for 2 pixels RGB/BGR unless user wants full
1329  * chroma interpolation */
1330  if (flags & SWS_FULL_CHR_H_INT &&
1331  isAnyRGB(dstFormat) &&
1332  !isPlanarRGB(dstFormat) &&
1333  dstFormat != AV_PIX_FMT_RGBA64LE &&
1334  dstFormat != AV_PIX_FMT_RGBA64BE &&
1335  dstFormat != AV_PIX_FMT_BGRA64LE &&
1336  dstFormat != AV_PIX_FMT_BGRA64BE &&
1337  dstFormat != AV_PIX_FMT_RGB48LE &&
1338  dstFormat != AV_PIX_FMT_RGB48BE &&
1339  dstFormat != AV_PIX_FMT_BGR48LE &&
1340  dstFormat != AV_PIX_FMT_BGR48BE &&
1341  dstFormat != AV_PIX_FMT_RGBA &&
1342  dstFormat != AV_PIX_FMT_ARGB &&
1343  dstFormat != AV_PIX_FMT_BGRA &&
1344  dstFormat != AV_PIX_FMT_ABGR &&
1345  dstFormat != AV_PIX_FMT_RGB24 &&
1346  dstFormat != AV_PIX_FMT_BGR24 &&
1347  dstFormat != AV_PIX_FMT_BGR4_BYTE &&
1348  dstFormat != AV_PIX_FMT_RGB4_BYTE &&
1349  dstFormat != AV_PIX_FMT_BGR8 &&
1350  dstFormat != AV_PIX_FMT_RGB8 &&
1351  dstFormat != AV_PIX_FMT_X2RGB10LE &&
1352  dstFormat != AV_PIX_FMT_X2BGR10LE
1353  ) {
1354  av_log(c, AV_LOG_WARNING,
1355  "full chroma interpolation for destination format '%s' not yet implemented\n",
1356  av_get_pix_fmt_name(dstFormat));
1357  flags &= ~SWS_FULL_CHR_H_INT;
1358  sws->flags = flags;
1359  }
1360  if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1361  c->chrDstHSubSample = 1;
1362 
1363  // drop some chroma lines if the user wants it
1364  c->vChrDrop = (flags & SWS_SRC_V_CHR_DROP_MASK) >>
1365  SWS_SRC_V_CHR_DROP_SHIFT;
1366  c->chrSrcVSubSample += c->vChrDrop;
1367 
1368  /* drop every other pixel for chroma calculation unless user
1369  * wants full chroma */
1370  if (isAnyRGB(srcFormat) && !(srcW & 1) && !(flags & SWS_FULL_CHR_H_INP) &&
1371  srcFormat != AV_PIX_FMT_RGB8 && srcFormat != AV_PIX_FMT_BGR8 &&
1372  srcFormat != AV_PIX_FMT_RGB4 && srcFormat != AV_PIX_FMT_BGR4 &&
1373  srcFormat != AV_PIX_FMT_RGB4_BYTE && srcFormat != AV_PIX_FMT_BGR4_BYTE &&
1374  srcFormat != AV_PIX_FMT_GBRP9BE && srcFormat != AV_PIX_FMT_GBRP9LE &&
1375  srcFormat != AV_PIX_FMT_GBRP10BE && srcFormat != AV_PIX_FMT_GBRP10LE &&
1376  srcFormat != AV_PIX_FMT_GBRP10MSBBE && srcFormat != AV_PIX_FMT_GBRP10MSBLE &&
1377  srcFormat != AV_PIX_FMT_GBRAP10BE && srcFormat != AV_PIX_FMT_GBRAP10LE &&
1378  srcFormat != AV_PIX_FMT_GBRP12BE && srcFormat != AV_PIX_FMT_GBRP12LE &&
1379  srcFormat != AV_PIX_FMT_GBRP12MSBBE && srcFormat != AV_PIX_FMT_GBRP12MSBLE &&
1380  srcFormat != AV_PIX_FMT_GBRAP12BE && srcFormat != AV_PIX_FMT_GBRAP12LE &&
1381  srcFormat != AV_PIX_FMT_GBRAP14BE && srcFormat != AV_PIX_FMT_GBRAP14LE &&
1382  srcFormat != AV_PIX_FMT_GBRP14BE && srcFormat != AV_PIX_FMT_GBRP14LE &&
1383  srcFormat != AV_PIX_FMT_GBRP16BE && srcFormat != AV_PIX_FMT_GBRP16LE &&
1384  srcFormat != AV_PIX_FMT_GBRAP16BE && srcFormat != AV_PIX_FMT_GBRAP16LE &&
1385  srcFormat != AV_PIX_FMT_GBRPF32BE && srcFormat != AV_PIX_FMT_GBRPF32LE &&
1386  srcFormat != AV_PIX_FMT_GBRAPF32BE && srcFormat != AV_PIX_FMT_GBRAPF32LE &&
1387  srcFormat != AV_PIX_FMT_GBRPF16BE && srcFormat != AV_PIX_FMT_GBRPF16LE &&
1388  srcFormat != AV_PIX_FMT_GBRAPF16BE && srcFormat != AV_PIX_FMT_GBRAPF16LE &&
1389  ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
1390  (flags & SWS_FAST_BILINEAR)))
1391  c->chrSrcHSubSample = 1;
1392 
1393  // Note the AV_CEIL_RSHIFT is so that we always round toward +inf.
1394  c->chrSrcW = AV_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
1395  c->chrSrcH = AV_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
1396  c->chrDstW = AV_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
1397  c->chrDstH = AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
1398 
1399  if (!FF_ALLOCZ_TYPED_ARRAY(c->formatConvBuffer, FFALIGN(srcW * 2 + 78, 16) * 2))
1400  goto nomem;
1401 
1402  c->srcBpc = desc_src->comp[0].depth;
1403  if (c->srcBpc < 8)
1404  c->srcBpc = 8;
1405  c->dstBpc = desc_dst->comp[0].depth;
1406  if (c->dstBpc < 8)
1407  c->dstBpc = 8;
1408  if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
1409  c->srcBpc = 16;
1410  if (c->dstBpc == 16)
1411  dst_stride <<= 1;
1412 
1413  if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
1414  c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
1415  c->chrDstW >= c->chrSrcW &&
1416  (srcW & 15) == 0;
1417  if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
1418 
1419  && (flags & SWS_FAST_BILINEAR)) {
1420  if (flags & SWS_PRINT_INFO)
1421  av_log(c, AV_LOG_INFO,
1422  "output width is not a multiple of 32 -> no MMXEXT scaler\n");
1423  }
1424  if (usesHFilter || isNBPS(sws->src_format) || is16BPS(sws->src_format) || isAnyRGB(sws->src_format))
1425  c->canMMXEXTBeUsed = 0;
1426  } else
1427  c->canMMXEXTBeUsed = 0;
1428 
1429  int64_t chrXInc = (((int64_t)c->chrSrcW << 16) + (c->chrDstW >> 1)) / c->chrDstW;
1430  int64_t chrYInc = (((int64_t)c->chrSrcH << 16) + (c->chrDstH >> 1)) / c->chrDstH;
1431 
1432  /* Match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src
1433  * to pixel n-2 of dst, but only for the FAST_BILINEAR mode otherwise do
1434  * correct scaling.
1435  * n-2 is the last chrominance sample available.
1436  * This is not perfect, but no one should notice the difference, the more
1437  * correct variant would be like the vertical one, but that would require
1438  * some special code for the first and last pixel */
1439  if (flags & SWS_FAST_BILINEAR) {
1440  if (c->canMMXEXTBeUsed) {
1441  lumXInc += 20;
1442  chrXInc += 20;
1443  }
1444  // we don't use the x86 asm scaler if MMX is available
1445  else if (INLINE_MMX(cpu_flags) && c->dstBpc <= 14) {
1446  lumXInc = ((int64_t)(srcW - 2) << 16) / (dstW - 2) - 20;
1447  chrXInc = ((int64_t)(c->chrSrcW - 2) << 16) / (c->chrDstW - 2) - 20;
1448  }
1449  }
1450  if (chrXInc < 10 || chrXInc > INT_MAX ||
1451  chrYInc < 10 || chrYInc > INT_MAX ||
1452  lumXInc < 10 || lumXInc > INT_MAX ||
1453  lumYInc < 10 || lumYInc > INT_MAX)
1454  return AVERROR_PATCHWELCOME;
1455 
1456  c->lumXInc = lumXInc;
1457  c->lumYInc = lumYInc;
1458  c->chrXInc = chrXInc;
1459  c->chrYInc = chrYInc;
1460 
1461 
1462  // hardcoded for now
1463  c->gamma_value = 2.2;
1464  tmpFmt = AV_PIX_FMT_RGBA64LE;
1465 
1466  if (!unscaled && sws->gamma_flag && (srcFormat != tmpFmt || dstFormat != tmpFmt)) {
1467  SwsInternal *c2;
1468  c->cascaded_context[0] = NULL;
1469 
1470  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1471  srcW, srcH, tmpFmt, 64);
1472  if (ret < 0)
1473  return ret;
1474 
1475  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1476  srcW, srcH, tmpFmt,
1477  flags, NULL, NULL,
1478  sws->scaler_params);
1479  if (!c->cascaded_context[0]) {
1480  return AVERROR(ENOMEM);
1481  }
1482 
1483  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1484  dstW, dstH, tmpFmt,
1485  flags, srcFilter, dstFilter,
1486  sws->scaler_params);
1487 
1488  if (!c->cascaded_context[1])
1489  return AVERROR(ENOMEM);
1490 
1491  c2 = sws_internal(c->cascaded_context[1]);
1492  c2->is_internal_gamma = 1;
1493  c2->gamma = alloc_gamma_tbl( c->gamma_value);
1494  c2->inv_gamma = alloc_gamma_tbl(1.f/c->gamma_value);
1495  if (!c2->gamma || !c2->inv_gamma)
1496  return AVERROR(ENOMEM);
1497 
1498  // is_internal_flag is set after creating the context
1499  // to properly create the gamma convert FilterDescriptor
1500  // we have to re-initialize it
1501  ff_free_filters(c2);
1502  if ((ret = ff_init_filters(c2)) < 0) {
1503  sws_freeContext(c->cascaded_context[1]);
1504  c->cascaded_context[1] = NULL;
1505  return ret;
1506  }
1507 
1508  c->cascaded_context[2] = NULL;
1509  if (dstFormat != tmpFmt) {
1510  ret = av_image_alloc(c->cascaded_tmp[1], c->cascaded_tmpStride[1],
1511  dstW, dstH, tmpFmt, 64);
1512  if (ret < 0)
1513  return ret;
1514 
1515  c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1516  dstW, dstH, dstFormat,
1517  flags, NULL, NULL,
1518  sws->scaler_params);
1519  if (!c->cascaded_context[2])
1520  return AVERROR(ENOMEM);
1521  }
1522  return 0;
1523  }
1524 
1525  if (isBayer(srcFormat)) {
1526  if (!unscaled ||
1527  (dstFormat != AV_PIX_FMT_RGB24 && dstFormat != AV_PIX_FMT_YUV420P &&
1528  dstFormat != AV_PIX_FMT_RGB48)) {
1529  enum AVPixelFormat tmpFormat = isBayer16BPS(srcFormat) ? AV_PIX_FMT_RGB48 : AV_PIX_FMT_RGB24;
1530 
1531  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1532  srcW, srcH, tmpFormat, 64);
1533  if (ret < 0)
1534  return ret;
1535 
1536  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1537  srcW, srcH, tmpFormat,
1538  flags, srcFilter, NULL,
1539  sws->scaler_params);
1540  if (!c->cascaded_context[0])
1541  return AVERROR(ENOMEM);
1542 
1543  c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1544  dstW, dstH, dstFormat,
1545  flags, NULL, dstFilter,
1546  sws->scaler_params);
1547  if (!c->cascaded_context[1])
1548  return AVERROR(ENOMEM);
1549  return 0;
1550  }
1551  }
1552 
1553  if (unscaled && c->srcBpc == 8 && dstFormat == AV_PIX_FMT_GRAYF32){
1554  for (i = 0; i < 256; ++i){
1555  c->uint2float_lut[i] = (float)i * float_mult;
1556  }
1557  }
1558 
1559  // float will be converted to uint16_t
1560  if (isFloat(srcFormat) && !isAnyRGB(srcFormat) &&
1561  (!unscaled || unscaled && dstFormat != srcFormat && (srcFormat != AV_PIX_FMT_GRAYF32 ||
1562  dstFormat != AV_PIX_FMT_GRAY8))){
1563  c->srcBpc = 16;
1564  }
1565 
1566  if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1567  enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1568 
1569  if (tmpFormat != AV_PIX_FMT_NONE && sws->alpha_blend != SWS_ALPHA_BLEND_NONE) {
1570  if (!unscaled ||
1571  dstFormat != tmpFormat ||
1572  usesHFilter || usesVFilter ||
1573  sws->src_range != sws->dst_range
1574  ) {
1575  c->cascaded_mainindex = 1;
1576  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1577  srcW, srcH, tmpFormat, 64);
1578  if (ret < 0)
1579  return ret;
1580 
1581  c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1582  srcW, srcH, tmpFormat,
1583  flags, sws->scaler_params);
1584  if (!c->cascaded_context[0])
1585  return AVERROR(EINVAL);
1586  c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
1587  ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1588  if (ret < 0)
1589  return ret;
1590 
1591  c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1592  dstW, dstH, dstFormat,
1593  flags, sws->scaler_params);
1594  if (!c->cascaded_context[1])
1595  return AVERROR(EINVAL);
1596 
1597  c->cascaded_context[1]->src_range = sws->src_range;
1598  c->cascaded_context[1]->dst_range = sws->dst_range;
1599  ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1600  if (ret < 0)
1601  return ret;
1602 
1603  return 0;
1604  }
1605  }
1606  }
1607 
1608  /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1609  if (unscaled && !usesHFilter && !usesVFilter &&
1610  sws->alpha_blend != SWS_ALPHA_BLEND_NONE &&
1611  isALPHA(srcFormat) &&
1612  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat)) &&
1613  alphaless_fmt(srcFormat) == dstFormat
1614  ) {
1615  c->convert_unscaled = ff_sws_alphablendaway;
1616 
1617  if (flags & SWS_PRINT_INFO)
1618  av_log(c, AV_LOG_INFO,
1619  "using alpha blendaway %s -> %s special converter\n",
1620  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1621  return 0;
1622  }
1623 
1624  /* unscaled special cases */
1625  if (unscaled && !usesHFilter && !usesVFilter &&
1626  (sws->src_range == sws->dst_range || isAnyRGB(dstFormat) ||
1627  isFloat(srcFormat) || isFloat(dstFormat) || isBayer(srcFormat))){
1628 
1629  ff_get_unscaled_swscale(c);
1630 
1631  if (c->convert_unscaled) {
1632  if (flags & SWS_PRINT_INFO)
1633  av_log(c, AV_LOG_INFO,
1634  "using unscaled %s -> %s special converter\n",
1635  av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1636  return 0;
1637  }
1638  }
1639 
1640  /* precalculate horizontal scaler filter coefficients */
1641  {
1642 #if HAVE_MMXEXT_INLINE
1643 // can't downscale !!!
1644  if (c->canMMXEXTBeUsed && (flags & SWS_FAST_BILINEAR)) {
1645  c->lumMmxextFilterCodeSize = ff_init_hscaler_mmxext(dstW, c->lumXInc, NULL,
1646  NULL, NULL, 8);
1647  c->chrMmxextFilterCodeSize = ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc,
1648  NULL, NULL, NULL, 4);
1649 
1650  c->lumMmxextFilterCode = ff_sws_jit_alloc(c->lumMmxextFilterCodeSize);
1651  c->chrMmxextFilterCode = ff_sws_jit_alloc(c->chrMmxextFilterCodeSize);
1652  if (!c->lumMmxextFilterCode || !c->chrMmxextFilterCode) {
1653  av_log(c, AV_LOG_ERROR, "Failed to allocate MMX2FilterCode\n");
1654  return AVERROR(ENOMEM);
1655  }
1656 
1657  if (!FF_ALLOCZ_TYPED_ARRAY(c->hLumFilter, dstW / 8 + 8) ||
1658  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilter, c->chrDstW / 4 + 8) ||
1659  !FF_ALLOCZ_TYPED_ARRAY(c->hLumFilterPos, dstW / 2 / 8 + 8) ||
1660  !FF_ALLOCZ_TYPED_ARRAY(c->hChrFilterPos, c->chrDstW / 2 / 4 + 8))
1661  goto nomem;
1662 
1663  ff_init_hscaler_mmxext( dstW, c->lumXInc, c->lumMmxextFilterCode,
1664  c->hLumFilter, (uint32_t*)c->hLumFilterPos, 8);
1665  ff_init_hscaler_mmxext(c->chrDstW, c->chrXInc, c->chrMmxextFilterCode,
1666  c->hChrFilter, (uint32_t*)c->hChrFilterPos, 4);
1667 
1668  if ((ret = ff_sws_jit_protect(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize)) < 0 ||
1669  (ret = ff_sws_jit_protect(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize)) < 0) {
1670  av_log(c, AV_LOG_ERROR, "mprotect failed, cannot use fast bilinear scaler\n");
1671  goto fail;
1672  }
1673  } else
1674 #endif /* HAVE_MMXEXT_INLINE */
1675  {
1676  const int filterAlign = X86_MMX(cpu_flags) ? 4 :
1677  PPC_ALTIVEC(cpu_flags) ? 8 :
1678  have_neon(cpu_flags) ? 4 :
1679  have_lsx(cpu_flags) ? 8 :
1680  have_lasx(cpu_flags) ? 8 : 1;
1681 
1682  if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
1683  &c->hLumFilterSize, c->lumXInc,
1684  srcW, dstW, filterAlign, 1 << 14,
1685  lum_scaler, flags,
1686  cpu_flags, srcFilter->lumH, dstFilter->lumH,
1687  sws->scaler_params,
1688  get_local_pos(c, 0, 0, 0),
1689  get_local_pos(c, 0, 0, 0))) < 0)
1690  goto fail;
1691  if (ff_shuffle_filter_coefficients(c, c->hLumFilterPos, c->hLumFilterSize, c->hLumFilter, dstW) < 0)
1692  goto nomem;
1693  if ((ret = initFilter(&c->hChrFilter, &c->hChrFilterPos,
1694  &c->hChrFilterSize, c->chrXInc,
1695  c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1696  chr_scaler, flags,
1697  cpu_flags, srcFilter->chrH, dstFilter->chrH,
1698  sws->scaler_params,
1699  get_local_pos(c, c->chrSrcHSubSample, sws->src_h_chr_pos, 0),
1700  get_local_pos(c, c->chrDstHSubSample, sws->dst_h_chr_pos, 0))) < 0)
1701  goto fail;
1702  if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1703  goto nomem;
1704  }
1705  } // initialize horizontal stuff
1706 
1707  /* precalculate vertical scaler filter coefficients */
1708  {
1709  const int filterAlign = X86_MMX(cpu_flags) ? 2 :
1710  PPC_ALTIVEC(cpu_flags) ? 8 :
1711  have_neon(cpu_flags) ? 2 : 1;
1712 
1713  ret = initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize,
1714  c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1715  lum_scaler, flags,
1716  cpu_flags, srcFilter->lumV, dstFilter->lumV,
1717  sws->scaler_params,
1718  get_local_pos(c, 0, 0, 1),
1719  get_local_pos(c, 0, 0, 1));
1720  int usecascade = (ret == RETCODE_USE_CASCADE);
1721  if (ret < 0 && !usecascade)
1722  goto fail;
1723  if ((ret = initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize,
1724  c->chrYInc, c->chrSrcH, c->chrDstH,
1725  filterAlign, (1 << 12),
1726  chr_scaler, flags,
1727  cpu_flags, srcFilter->chrV, dstFilter->chrV,
1728  sws->scaler_params,
1729  get_local_pos(c, c->chrSrcVSubSample, sws->src_v_chr_pos, 1),
1730  get_local_pos(c, c->chrDstVSubSample, sws->dst_v_chr_pos, 1))) < 0)
1731 
1732  goto fail;
1733  if (usecascade) {
1734  ret = RETCODE_USE_CASCADE;
1735  goto fail;
1736  }
1737 
1738 #if HAVE_ALTIVEC
1739  ret = ff_sws_init_altivec_bufs(c);
1740  if (ret < 0)
1741  goto fail;
1742 #endif
1743  }
1744 
1745  for (i = 0; i < 4; i++)
1746  if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], sws->dst_w + 3))
1747  goto nomem;
1748 
1749  c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(sws->src_format) && isALPHA(sws->dst_format)) ? 1 : 0;
1750 
1751  // 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1752  c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
1753  c->uv_offx2 = dst_stride + 16;
1754 
1755  av_assert0(c->chrDstH <= dstH);
1756 
1757  if (flags & SWS_PRINT_INFO) {
1758  const char *scaler = NULL, *cpucaps;
1759 
1760  for (i = 0; i < FF_ARRAY_ELEMS(scale_algorithms); i++) {
1761  if (flags & scale_algorithms[i].flag) {
1762  scaler = scale_algorithms[i].description;
1763  break;
1764  }
1765  }
1766  if (!scaler)
1767  scaler = "ehh flags invalid?!";
1768  av_log(c, AV_LOG_INFO, "%s scaler, from %s to %s%s ",
1769  scaler,
1770  av_get_pix_fmt_name(srcFormat),
1771  dstFormat == AV_PIX_FMT_BGR555 || dstFormat == AV_PIX_FMT_BGR565 ||
1772  dstFormat == AV_PIX_FMT_RGB444BE || dstFormat == AV_PIX_FMT_RGB444LE ||
1773  dstFormat == AV_PIX_FMT_BGR444BE || dstFormat == AV_PIX_FMT_BGR444LE ?
1774  "dithered " : "",
1775  av_get_pix_fmt_name(dstFormat));
1776 
1777  if (INLINE_MMXEXT(cpu_flags))
1778  cpucaps = "MMXEXT";
1779  else if (INLINE_MMX(cpu_flags))
1780  cpucaps = "MMX";
1781  else if (PPC_ALTIVEC(cpu_flags))
1782  cpucaps = "AltiVec";
1783  else
1784  cpucaps = "C";
1785 
1786  av_log(c, AV_LOG_INFO, "using %s\n", cpucaps);
1787 
1788  av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1789  av_log(c, AV_LOG_DEBUG,
1790  "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1791  sws->src_w, sws->src_h, sws->dst_w, sws->dst_h, c->lumXInc, c->lumYInc);
1792  av_log(c, AV_LOG_DEBUG,
1793  "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1794  c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
1795  c->chrXInc, c->chrYInc);
1796  }
1797 
1798  ff_sws_init_scale(c);
1799 
1800  return ff_init_filters(c);
1801 nomem:
1802  ret = AVERROR(ENOMEM);
1803 fail: // FIXME replace things by appropriate error codes
1804  if (ret == RETCODE_USE_CASCADE) {
1805  int tmpW = sqrt(srcW * (int64_t)dstW);
1806  int tmpH = sqrt(srcH * (int64_t)dstH);
1807  enum AVPixelFormat tmpFormat = AV_PIX_FMT_YUV420P;
1808 
1809  if (isALPHA(srcFormat))
1810  tmpFormat = AV_PIX_FMT_YUVA420P;
1811 
1812  if (srcW*(int64_t)srcH <= 4LL*dstW*dstH)
1813  return AVERROR(EINVAL);
1814 
1815  ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
1816  tmpW, tmpH, tmpFormat, 64);
1817  if (ret < 0)
1818  return ret;
1819 
1820  c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1821  tmpW, tmpH, tmpFormat,
1822  flags, srcFilter, NULL,
1823  sws->scaler_params);
1824  if (!c->cascaded_context[0])
1825  return AVERROR(ENOMEM);
1826 
1827  c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
1828  dstW, dstH, dstFormat,
1829  flags, NULL, dstFilter,
1830  sws->scaler_params);
1831  if (!c->cascaded_context[1])
1832  return AVERROR(ENOMEM);
1833  return 0;
1834  }
1835  return ret;
1836 }
1837 
1838 static int context_init_threaded(SwsContext *sws,
1839  SwsFilter *src_filter, SwsFilter *dst_filter)
1840 {
1841  SwsInternal *c = sws_internal(sws);
1842  int ret;
1843 
1844  ret = avpriv_slicethread_create(&c->slicethread, (void*) sws,
1845  ff_sws_slice_worker, NULL, sws->threads);
1846  if (ret == AVERROR(ENOSYS)) {
1847  sws->threads = 1;
1848  return 0;
1849  } else if (ret < 0)
1850  return ret;
1851 
1852  sws->threads = ret;
1853 
1854  c->slice_ctx = av_calloc(sws->threads, sizeof(*c->slice_ctx));
1855  c->slice_err = av_calloc(sws->threads, sizeof(*c->slice_err));
1856  if (!c->slice_ctx || !c->slice_err)
1857  return AVERROR(ENOMEM);
1858 
1859  for (int i = 0; i < sws->threads; i++) {
1860  SwsContext *slice;
1861  slice = c->slice_ctx[i] = sws_alloc_context();
1862  if (!slice)
1863  return AVERROR(ENOMEM);
1864  sws_internal(slice)->parent = sws;
1865  c->nb_slice_ctx++;
1866 
1867  ret = av_opt_copy(slice, sws);
1868  if (ret < 0)
1869  return ret;
1870  slice->threads = 1;
1871 
1872  ret = ff_sws_init_single_context(slice, src_filter, dst_filter);
1873  if (ret < 0)
1874  return ret;
1875 
1876  if (slice->dither == SWS_DITHER_ED) {
1877  av_log(c, AV_LOG_VERBOSE,
1878  "Error-diffusion dither is in use, scaling will be single-threaded.");
1879  break;
1880  }
1881  }
1882 
1883  return 0;
1884 }
1885 
1886 av_cold int sws_init_context(SwsContext *sws, SwsFilter *srcFilter,
1887  SwsFilter *dstFilter)
1888 {
1889  SwsInternal *c = sws_internal(sws);
1890  static AVOnce rgb2rgb_once = AV_ONCE_INIT;
1891  enum AVPixelFormat src_format, dst_format;
1892  int ret;
1893 
1894  c->is_legacy_init = 1;
1895  c->frame_src = av_frame_alloc();
1896  c->frame_dst = av_frame_alloc();
1897  if (!c->frame_src || !c->frame_dst)
1898  return AVERROR(ENOMEM);
1899 
1900  if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
1901  return AVERROR_UNKNOWN;
1902 
1903  src_format = sws->src_format;
1904  dst_format = sws->dst_format;
1905  sws->src_range |= handle_jpeg(&sws->src_format);
1906  sws->dst_range |= handle_jpeg(&sws->dst_format);
1907 
1908  if (src_format != sws->src_format || dst_format != sws->dst_format)
1909  av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
1910 
1911  if (sws->threads != 1) {
1912  ret = context_init_threaded(sws, srcFilter, dstFilter);
1913  if (ret < 0 || sws->threads > 1)
1914  return ret;
1915  // threading disabled in this build, init as single-threaded
1916  }
1917 
1918  return ff_sws_init_single_context(sws, srcFilter, dstFilter);
1919 }
1920 
1921 SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
1922  int dstW, int dstH, enum AVPixelFormat dstFormat,
1923  int flags, SwsFilter *srcFilter,
1924  SwsFilter *dstFilter, const double *param)
1925 {
1926  SwsContext *sws;
1927 
1928  sws = alloc_set_opts(srcW, srcH, srcFormat,
1929  dstW, dstH, dstFormat,
1930  flags, param);
1931  if (!sws)
1932  return NULL;
1933 
1934  if (sws_init_context(sws, srcFilter, dstFilter) < 0) {
1935  sws_freeContext(sws);
1936  return NULL;
1937  }
1938 
1939  return sws;
1940 }
1941 
1942 static int isnan_vec(SwsVector *a)
1943 {
1944  int i;
1945  for (i=0; i<a->length; i++)
1946  if (isnan(a->coeff[i]))
1947  return 1;
1948  return 0;
1949 }
1950 
1951 static void makenan_vec(SwsVector *a)
1952 {
1953  int i;
1954  for (i=0; i<a->length; i++)
1955  a->coeff[i] = NAN;
1956 }
1957 
1958 SwsVector *sws_allocVec(int length)
1959 {
1960  SwsVector *vec;
1961 
1962  if(length <= 0 || length > INT_MAX/ sizeof(double))
1963  return NULL;
1964 
1965  vec = av_malloc(sizeof(SwsVector));
1966  if (!vec)
1967  return NULL;
1968  vec->length = length;
1969  vec->coeff = av_malloc(sizeof(double) * length);
1970  if (!vec->coeff)
1971  av_freep(&vec);
1972  return vec;
1973 }
1974 
1975 SwsVector *sws_getGaussianVec(double variance, double quality)
1976 {
1977  const int length = (int)(variance * quality + 0.5) | 1;
1978  int i;
1979  double middle = (length - 1) * 0.5;
1980  SwsVector *vec;
1981 
1982  if(variance < 0 || quality < 0)
1983  return NULL;
1984 
1985  vec = sws_allocVec(length);
1986 
1987  if (!vec)
1988  return NULL;
1989 
1990  for (i = 0; i < length; i++) {
1991  double dist = i - middle;
1992  vec->coeff[i] = exp(-dist * dist / (2 * variance * variance)) /
1993  sqrt(2 * variance * M_PI);
1994  }
1995 
1996  sws_normalizeVec(vec, 1.0);
1997 
1998  return vec;
1999 }
2000 
2001 /**
2002  * Allocate and return a vector with length coefficients, all
2003  * with the same value c.
2004  */
2005 static
2006 SwsVector *sws_getConstVec(double c, int length)
2007 {
2008  int i;
2009  SwsVector *vec = sws_allocVec(length);
2010 
2011  if (!vec)
2012  return NULL;
2013 
2014  for (i = 0; i < length; i++)
2015  vec->coeff[i] = c;
2016 
2017  return vec;
2018 }
2019 
2020 /**
2021  * Allocate and return a vector with just one coefficient, with
2022  * value 1.0.
2023  */
2024 static
2025 SwsVector *sws_getIdentityVec(void)
2026 {
2027  return sws_getConstVec(1.0, 1);
2028 }
2029 
2030 static double sws_dcVec(SwsVector *a)
2031 {
2032  int i;
2033  double sum = 0;
2034 
2035  for (i = 0; i < a->length; i++)
2036  sum += a->coeff[i];
2037 
2038  return sum;
2039 }
2040 
2041 void sws_scaleVec(SwsVector *a, double scalar)
2042 {
2043  int i;
2044 
2045  for (i = 0; i < a->length; i++)
2046  a->coeff[i] *= scalar;
2047 }
2048 
2049 void sws_normalizeVec(SwsVector *a, double height)
2050 {
2051  sws_scaleVec(a, height / sws_dcVec(a));
2052 }
2053 
2054 static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b)
2055 {
2056  int length = FFMAX(a->length, b->length);
2057  int i;
2058  SwsVector *vec = sws_getConstVec(0.0, length);
2059 
2060  if (!vec)
2061  return NULL;
2062 
2063  for (i = 0; i < a->length; i++)
2064  vec->coeff[i + (length - 1) / 2 - (a->length - 1) / 2] += a->coeff[i];
2065  for (i = 0; i < b->length; i++)
2066  vec->coeff[i + (length - 1) / 2 - (b->length - 1) / 2] += b->coeff[i];
2067 
2068  return vec;
2069 }
2070 
2071 /* shift left / or right if "shift" is negative */
2072 static SwsVector *sws_getShiftedVec(SwsVector *a, int shift)
2073 {
2074  int length = a->length + FFABS(shift) * 2;
2075  int i;
2076  SwsVector *vec = sws_getConstVec(0.0, length);
2077 
2078  if (!vec)
2079  return NULL;
2080 
2081  for (i = 0; i < a->length; i++) {
2082  vec->coeff[i + (length - 1) / 2 -
2083  (a->length - 1) / 2 - shift] = a->coeff[i];
2084  }
2085 
2086  return vec;
2087 }
2088 
2089 static
2090 void sws_shiftVec(SwsVector *a, int shift)
2091 {
2092  SwsVector *shifted = sws_getShiftedVec(a, shift);
2093  if (!shifted) {
2094  makenan_vec(a);
2095  return;
2096  }
2097  av_free(a->coeff);
2098  a->coeff = shifted->coeff;
2099  a->length = shifted->length;
2100  av_free(shifted);
2101 }
2102 
2103 static
2104 void sws_addVec(SwsVector *a, SwsVector *b)
2105 {
2106  SwsVector *sum = sws_sumVec(a, b);
2107  if (!sum) {
2108  makenan_vec(a);
2109  return;
2110  }
2111  av_free(a->coeff);
2112  a->coeff = sum->coeff;
2113  a->length = sum->length;
2114  av_free(sum);
2115 }
2116 
2117 /**
2118  * Print with av_log() a textual representation of the vector a
2119  * if log_level <= av_log_level.
2120  */
2121 static
2122 void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level)
2123 {
2124  int i;
2125  double max = 0;
2126  double min = 0;
2127  double range;
2128 
2129  for (i = 0; i < a->length; i++)
2130  if (a->coeff[i] > max)
2131  max = a->coeff[i];
2132 
2133  for (i = 0; i < a->length; i++)
2134  if (a->coeff[i] < min)
2135  min = a->coeff[i];
2136 
2137  range = max - min;
2138 
2139  for (i = 0; i < a->length; i++) {
2140  int x = (int)((a->coeff[i] - min) * 60.0 / range + 0.5);
2141  av_log(log_ctx, log_level, "%1.3f ", a->coeff[i]);
2142  for (; x > 0; x--)
2143  av_log(log_ctx, log_level, " ");
2144  av_log(log_ctx, log_level, "|\n");
2145  }
2146 }
2147 
2148 void sws_freeVec(SwsVector *a)
2149 {
2150  if (!a)
2151  return;
2152  av_freep(&a->coeff);
2153  a->length = 0;
2154  av_free(a);
2155 }
2156 
2157 void sws_freeFilter(SwsFilter *filter)
2158 {
2159  if (!filter)
2160  return;
2161 
2162  sws_freeVec(filter->lumH);
2163  sws_freeVec(filter->lumV);
2164  sws_freeVec(filter->chrH);
2165  sws_freeVec(filter->chrV);
2166  av_free(filter);
2167 }
2168 
2169 SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
2170  float lumaSharpen, float chromaSharpen,
2171  float chromaHShift, float chromaVShift,
2172  int verbose)
2173 {
2174  SwsFilter *filter = av_malloc(sizeof(SwsFilter));
2175  if (!filter)
2176  return NULL;
2177 
2178  if (lumaGBlur != 0.0) {
2179  filter->lumH = sws_getGaussianVec(lumaGBlur, 3.0);
2180  filter->lumV = sws_getGaussianVec(lumaGBlur, 3.0);
2181  } else {
2182  filter->lumH = sws_getIdentityVec();
2183  filter->lumV = sws_getIdentityVec();
2184  }
2185 
2186  if (chromaGBlur != 0.0) {
2187  filter->chrH = sws_getGaussianVec(chromaGBlur, 3.0);
2188  filter->chrV = sws_getGaussianVec(chromaGBlur, 3.0);
2189  } else {
2190  filter->chrH = sws_getIdentityVec();
2191  filter->chrV = sws_getIdentityVec();
2192  }
2193 
2194  if (!filter->lumH || !filter->lumV || !filter->chrH || !filter->chrV)
2195  goto fail;
2196 
2197  if (chromaSharpen != 0.0) {
2198  SwsVector *id = sws_getIdentityVec();
2199  if (!id)
2200  goto fail;
2201  sws_scaleVec(filter->chrH, -chromaSharpen);
2202  sws_scaleVec(filter->chrV, -chromaSharpen);
2203  sws_addVec(filter->chrH, id);
2204  sws_addVec(filter->chrV, id);
2205  sws_freeVec(id);
2206  }
2207 
2208  if (lumaSharpen != 0.0) {
2209  SwsVector *id = sws_getIdentityVec();
2210  if (!id)
2211  goto fail;
2212  sws_scaleVec(filter->lumH, -lumaSharpen);
2213  sws_scaleVec(filter->lumV, -lumaSharpen);
2214  sws_addVec(filter->lumH, id);
2215  sws_addVec(filter->lumV, id);
2216  sws_freeVec(id);
2217  }
2218 
2219  if (chromaHShift != 0.0)
2220  sws_shiftVec(filter->chrH, (int)(chromaHShift + 0.5));
2221 
2222  if (chromaVShift != 0.0)
2223  sws_shiftVec(filter->chrV, (int)(chromaVShift + 0.5));
2224 
2225  sws_normalizeVec(filter->chrH, 1.0);
2226  sws_normalizeVec(filter->chrV, 1.0);
2227  sws_normalizeVec(filter->lumH, 1.0);
2228  sws_normalizeVec(filter->lumV, 1.0);
2229 
2230  if (isnan_vec(filter->chrH) ||
2231  isnan_vec(filter->chrV) ||
2232  isnan_vec(filter->lumH) ||
2233  isnan_vec(filter->lumV))
2234  goto fail;
2235 
2236  if (verbose)
2237  sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
2238  if (verbose)
2239  sws_printVec2(filter->lumH, NULL, AV_LOG_DEBUG);
2240 
2241  return filter;
2242 
2243 fail:
2244  sws_freeVec(filter->lumH);
2245  sws_freeVec(filter->lumV);
2246  sws_freeVec(filter->chrH);
2247  sws_freeVec(filter->chrV);
2248  av_freep(&filter);
2249  return NULL;
2250 }
2251 
2252 void sws_freeContext(SwsContext *sws)
2253 {
2254  SwsInternal *c = sws_internal(sws);
2255  int i;
2256  if (!c)
2257  return;
2258 
2259  av_refstruct_unref(&c->hw_priv);
2260 
2261  for (i = 0; i < FF_ARRAY_ELEMS(c->graph); i++)
2262  ff_sws_graph_free(&c->graph[i]);
2263  ff_frame_pool_uninit(&c->frame_pool);
2264 
2265  for (i = 0; i < c->nb_slice_ctx; i++)
2266  sws_freeContext(c->slice_ctx[i]);
2267  av_freep(&c->slice_ctx);
2268  av_freep(&c->slice_err);
2269 
2270  avpriv_slicethread_free(&c->slicethread);
2271 
2272  for (i = 0; i < 4; i++)
2273  av_freep(&c->dither_error[i]);
2274 
2275  av_frame_free(&c->frame_src);
2276  av_frame_free(&c->frame_dst);
2277 
2278  av_freep(&c->src_ranges.ranges);
2279 
2280  av_freep(&c->vLumFilter);
2281  av_freep(&c->vChrFilter);
2282  av_freep(&c->hLumFilter);
2283  av_freep(&c->hChrFilter);
2284 #if HAVE_ALTIVEC
2285  ff_sws_free_altivec_bufs(c);
2286 #endif
2287 
2288  av_freep(&c->vLumFilterPos);
2289  av_freep(&c->vChrFilterPos);
2290  av_freep(&c->hLumFilterPos);
2291  av_freep(&c->hChrFilterPos);
2292 
2293 #if HAVE_MMX_INLINE
2294  ff_sws_jit_free(c->lumMmxextFilterCode, c->lumMmxextFilterCodeSize);
2295  ff_sws_jit_free(c->chrMmxextFilterCode, c->chrMmxextFilterCodeSize);
2296  c->lumMmxextFilterCode = NULL;
2297  c->chrMmxextFilterCode = NULL;
2298 #endif /* HAVE_MMX_INLINE */
2299 
2300  av_freep(&c->yuvTable);
2301  av_freep(&c->formatConvBuffer);
2302 
2303  sws_freeContext(c->cascaded_context[0]);
2304  sws_freeContext(c->cascaded_context[1]);
2305  sws_freeContext(c->cascaded_context[2]);
2306  memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
2307  av_freep(&c->cascaded_tmp[0][0]);
2308  av_freep(&c->cascaded_tmp[1][0]);
2309 
2310  av_freep(&c->gamma);
2311  av_freep(&c->inv_gamma);
2312 #if CONFIG_SMALL
2313  av_freep(&c->xyz2rgb.gamma.in);
2314 #endif
2315 
2316  av_freep(&c->rgb0_scratch);
2317  av_freep(&c->xyz_scratch);
2318 
2319  ff_free_filters(c);
2320 
2321  av_free(c);
2322 }
2323 
2324 void sws_free_context(SwsContext **pctx)
2325 {
2326  SwsContext *ctx = *pctx;
2327  if (!ctx)
2328  return;
2329 
2330  sws_freeContext(ctx);
2331  *pctx = NULL;
2332 }
2333 
2334 SwsContext *sws_getCachedContext(SwsContext *prev, int srcW,
2335  int srcH, enum AVPixelFormat srcFormat,
2336  int dstW, int dstH,
2337  enum AVPixelFormat dstFormat, int flags,
2338  SwsFilter *srcFilter,
2339  SwsFilter *dstFilter,
2340  const double *param)
2341 {
2342  SwsContext *sws;
2343  static const double default_param[2] = { SWS_PARAM_DEFAULT,
2344  SWS_PARAM_DEFAULT };
2345 
2346  if (!param)
2347  param = default_param;
2348 
2349  if (prev && (prev->src_w == srcW &&
2350  prev->src_h == srcH &&
2351  prev->src_format == srcFormat &&
2352  prev->dst_w == dstW &&
2353  prev->dst_h == dstH &&
2354  prev->dst_format == dstFormat &&
2355  prev->flags == flags &&
2356  !memcmp(prev->scaler_params, param,
2357  sizeof(prev->scaler_params)))) {
2358  return prev;
2359  }
2360 
2361  if (!(sws = sws_alloc_context())) {
2362  sws_free_context(&prev);
2363  return NULL;
2364  }
2365 
2366  if (prev) {
2367  av_opt_copy(sws, prev);
2368  sws_free_context(&prev);
2369  }
2370 
2371  sws->src_w = srcW;
2372  sws->src_h = srcH;
2373  sws->src_format = srcFormat;
2374  sws->dst_w = dstW;
2375  sws->dst_h = dstH;
2376  sws->dst_format = dstFormat;
2377  sws->flags = flags;
2378  for (int i = 0; i < SWS_NUM_SCALER_PARAMS; i++)
2379  sws->scaler_params[i] = param[i];
2380 
2381  if (sws_init_context(sws, srcFilter, dstFilter) < 0)
2382  sws_free_context(&sws);
2383 
2384  return sws;
2385 }
2386 
2387 int ff_range_add(RangeList *rl, unsigned int start, unsigned int len)
2388 {
2389  Range *tmp;
2390  unsigned int idx;
2391 
2392  /* find the first existing range after the new one */
2393  for (idx = 0; idx < rl->nb_ranges; idx++)
2394  if (rl->ranges[idx].start > start)
2395  break;
2396 
2397  /* check for overlap */
2398  if (idx > 0) {
2399  Range *prev = &rl->ranges[idx - 1];
2400  if (prev->start + prev->len > start)
2401  return AVERROR(EINVAL);
2402  }
2403  if (idx < rl->nb_ranges) {
2404  Range *next = &rl->ranges[idx];
2405  if (start + len > next->start)
2406  return AVERROR(EINVAL);
2407  }
2408 
2409  tmp = av_fast_realloc(rl->ranges, &rl->ranges_allocated,
2410  (rl->nb_ranges + 1) * sizeof(*rl->ranges));
2411  if (!tmp)
2412  return AVERROR(ENOMEM);
2413  rl->ranges = tmp;
2414 
2415  memmove(rl->ranges + idx + 1, rl->ranges + idx,
2416  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2417  rl->ranges[idx].start = start;
2418  rl->ranges[idx].len = len;
2419  rl->nb_ranges++;
2420 
2421  /* merge ranges */
2422  if (idx > 0) {
2423  Range *prev = &rl->ranges[idx - 1];
2424  Range *cur = &rl->ranges[idx];
2425  if (prev->start + prev->len == cur->start) {
2426  prev->len += cur->len;
2427  memmove(rl->ranges + idx - 1, rl->ranges + idx,
2428  sizeof(*rl->ranges) * (rl->nb_ranges - idx));
2429  rl->nb_ranges--;
2430  idx--;
2431  }
2432  }
2433  if (idx < rl->nb_ranges - 1) {
2434  Range *cur = &rl->ranges[idx];
2435  Range *next = &rl->ranges[idx + 1];
2436  if (cur->start + cur->len == next->start) {
2437  cur->len += next->len;
2438  memmove(rl->ranges + idx, rl->ranges + idx + 1,
2439  sizeof(*rl->ranges) * (rl->nb_ranges - idx - 1));
2440  rl->nb_ranges--;
2441  }
2442  }
2443 
2444  return 0;
2445 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:72
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:862
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:3515
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
INLINE_MMXEXT
#define INLINE_MMXEXT(flags)
Definition: cpu.h:81
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:930
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:1671
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
PPC_ALTIVEC
#define PPC_ALTIVEC(flags)
Definition: cpu.h:25
flag
int flag
Definition: cpu.c:40
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:2025
libm.h
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:136
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3460
SwsContext::src_w
int src_w
Deprecated frame property overrides, for the legacy API only.
Definition: swscale.h:274
SWS_SCALE_BILINEAR
@ SWS_SCALE_BILINEAR
bilinear filtering
Definition: swscale.h:98
Z
#define Z
Definition: uops_tmpl.h:83
saturation
static IPT saturation(const CmsCtx *ctx, IPT ipt)
Definition: cms.c:559
av_cold
#define av_cold
Definition: attributes.h:119
int64_t
long long int64_t
Definition: coverity.c:34
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h:94
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:2252
cpu.h
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
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:475
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:807
SWSINTERNAL_ADDITIONAL_ASM_SIZE
#define SWSINTERNAL_ADDITIONAL_ASM_SIZE
Definition: swscale_internal.h:47
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:472
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:198
SWS_BITEXACT
@ SWS_BITEXACT
Definition: swscale.h:178
b
#define b
Definition: input.c:43
table
static const uint16_t table[]
Definition: prosumer.c:203
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:476
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:477
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:545
SwsContext::flags
unsigned flags
Bitmask of SWS_*.
Definition: swscale.h:240
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:3412
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_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:2072
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:203
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:321
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
cpu.h
scaler_flag
static int scaler_flag(SwsScaler scaler, int fallback)
Definition: utils.c:1122
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:2148
isnan_vec
static int isnan_vec(SwsVector *a)
Definition: utils.c:1942
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:197
initFilter
static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int scaler, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[SWS_NUM_SCALER_PARAMS], int srcPos, int dstPos)
Definition: utils.c:198
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:747
ub
#define ub(width, name)
Definition: cbs_apv.c:125
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:566
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:167
avpriv_slicethread_create
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
Definition: slicethread.c:261
ff_sws_jit_free
void ff_sws_jit_free(void *ptr, size_t size)
Definition: jit.c:99
SwsContext::src_v_chr_pos
int src_v_chr_pos
Source vertical chroma position in luma grid / 256.
Definition: swscale.h:280
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:564
Range::len
unsigned int len
Definition: swscale_internal.h:88
ONE
@ ONE
Definition: vc1_parser.c:50
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:543
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:2334
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:1886
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:3488
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:761
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:71
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:528
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_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:548
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
SwsBackend
SwsBackend
Definition: swscale.h:110
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
SWS_SCALE_BICUBIC
@ SWS_SCALE_BICUBIC
2-tap cubic BC-spline
Definition: swscale.h:99
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
avassert.h
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
lrint
#define lrint
Definition: tablegen.h:53
handle_jpeg
static int handle_jpeg(int *format)
Definition: utils.c: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:202
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:557
SwsContext::dither
SwsDither dither
Dither mode.
Definition: swscale.h:256
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
SWS_MAX_REDUCE_CUTOFF
#define SWS_MAX_REDUCE_CUTOFF
Filter kernel cut-off value.
Definition: swscale.h:447
emms_c
#define emms_c()
Definition: emms.h:88
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:2387
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:504
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:2122
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:495
W
#define W(a, i, v)
Definition: jpegls.h:119
intreadwrite.h
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:251
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:558
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
SWS_SCALE_LANCZOS
@ SWS_SCALE_LANCZOS
3-tap sinc/sinc
Definition: swscale.h:104
height
static int height
Definition: utils.c:158
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1484
SwsVector::length
int length
number of coefficients in the vector
Definition: swscale.h:480
ops.h
sws_allocVec
SwsVector * sws_allocVec(int length)
Allocate and return an uninitialized vector with length coefficients.
Definition: utils.c:1958
cpu.h
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_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_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:542
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
ff_sws_enabled_backends
SwsBackend ff_sws_enabled_backends(const SwsContext *ctx)
Definition: utils.c:61
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:556
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:2392
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:1975
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
AV_PIX_FMT_GBRAPF16LE
@ AV_PIX_FMT_GBRAPF16LE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian.
Definition: pixfmt.h:469
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:588
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:470
NAN
#define NAN
Definition: mathematics.h:115
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
Definition: hscale_fast_bilinear_simd.c:30
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_GBRP10MSBLE
@ AV_PIX_FMT_GBRP10MSBLE
planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
Definition: pixfmt.h:496
fail
#define fail
Definition: test.h:478
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:567
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:454
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:536
NULL
#define NULL
Definition: coverity.c:32
RETCODE_USE_CASCADE
#define RETCODE_USE_CASCADE
Definition: swscale_internal.h:75
SWS_BACKEND_STABLE
@ SWS_BACKEND_STABLE
Definition: swscale.h:113
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
jit.h
SWS_BICUBIC
@ SWS_BICUBIC
2-tap cubic B-spline
Definition: swscale.h:199
SwsContext::gamma_flag
int gamma_flag
Use gamma correct scaling.
Definition: swscale.h:266
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:2169
EXTERNAL_AVX2_FAST
#define EXTERNAL_AVX2_FAST(flags)
Definition: cpu.h:73
RangeList
Definition: swscale_internal.h:91
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:93
makenan_vec
static void makenan_vec(SwsVector *a)
Definition: utils.c:1951
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:278
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:188
SwsScaler
SwsScaler
Definition: swscale.h:96
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
ff_sws_rgb2rgb_init
av_cold void ff_sws_rgb2rgb_init(void)
Definition: rgb2rgb.c:127
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:91
attributes.h
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:546
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsInternal *c)
Definition: swscale.c:626
sws_addVec
static void sws_addVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2104
SwsVector::coeff
double * coeff
pointer to the list of coefficients
Definition: swscale.h:479
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:124
exp
int8_t exp
Definition: eval.c:76
have_neon
#define have_neon(flags)
Definition: cpu.h:26
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:283
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:2041
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:2006
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:2132
SWS_SCALE_SINC
@ SWS_SCALE_SINC
unwindowed sinc
Definition: swscale.h:103
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
SWS_PARAM_DEFAULT
#define SWS_PARAM_DEFAULT
Definition: swscale.h:456
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:890
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c:1605
handle_0alpha
static int handle_0alpha(int *format)
Definition: utils.c:812
SwsFilter::chrV
SwsVector * chrV
Definition: swscale.h:488
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:469
SwsInternal::parent
SwsContext * parent
Definition: swscale_internal.h:342
to
const char * to
Definition: webvttdec.c:36
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:478
shift
static int shift(int a, int b)
Definition: bonk.c:261
ff_sws_init_single_context
av_cold int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter, SwsFilter *dstFilter)
Definition: utils.c:1138
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:876
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:531
SWS_POINT
@ SWS_POINT
nearest neighbor
Definition: swscale.h:201
SwsContext::alpha_blend
SwsAlphaBlend alpha_blend
Alpha blending mode.
Definition: swscale.h:261
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:538
SWS_SPLINE
@ SWS_SPLINE
unwindowed natural cubic spline
Definition: swscale.h:207
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:775
SwsContext::src_h
int src_h
Width and height of the source frame.
Definition: swscale.h:274
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
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
have_lsx
#define have_lsx(flags)
Definition: cpu.h:28
SwsFilter
Definition: swscale.h:484
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:408
cpu_flags
CheckasmCpu cpu_flags
Definition: checkasm.c:84
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:486
have_lasx
#define have_lasx(flags)
Definition: cpu.h:29
ff_sws_jit_alloc
void * ff_sws_jit_alloc(size_t size)
Definition: jit.c:89
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:277
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:471
ff_frame_pool_uninit
av_cold void ff_frame_pool_uninit(FFFramePool *pool)
Deallocate the frame pool.
Definition: framepool.c:215
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_SCALE_POINT
@ SWS_SCALE_POINT
nearest neighbor (point sampling)
Definition: swscale.h:100
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:540
sws_isSupportedEndiannessConversion
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: format.c:299
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
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
sws_shiftVec
static void sws_shiftVec(SwsVector *a, int shift)
Definition: utils.c:2090
SWS_X
@ SWS_X
experimental
Definition: swscale.h:200
ff_sws_init_scale
void ff_sws_init_scale(SwsInternal *c)
Definition: swscale.c:697
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:565
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
s
uint8_t s
Definition: llvidencdsp.c:39
SwsContext::scaler
SwsScaler scaler
Scaling filter.
Definition: swscale.h:296
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
INLINE_MMX
#define INLINE_MMX(flags)
Definition: cpu.h:80
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
AV_PIX_FMT_XYZ12BE
@ AV_PIX_FMT_XYZ12BE
packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big...
Definition: pixfmt.h:197
SwsContext::scaler_sub
SwsScaler scaler_sub
Scaler used specifically for up/downsampling subsampled (chroma) planes.
Definition: swscale.h:304
len
int len
Definition: vorbis_enc_data.h:426
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:537
SwsContext::dst_h
int dst_h
Width and height of the destination frame.
Definition: swscale.h:275
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:544
ff_sws_init_altivec_bufs
int ff_sws_init_altivec_bufs(SwsInternal *c)
sws_freeFilter
void sws_freeFilter(SwsFilter *filter)
Definition: utils.c:2157
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:884
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:92
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:464
SWS_SCALE_GAUSSIAN
@ SWS_SCALE_GAUSSIAN
2-tap gaussian approximation
Definition: swscale.h:102
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale.h:83
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AV_PIX_FMT_GRAY12BE
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:318
AV_CPU_FLAG_MMX
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:32
SwsInternal
Definition: swscale_internal.h:337
ret
ret
Definition: filter_design.txt:187
XYZ_GAMMA
#define XYZ_GAMMA
Definition: swscale_internal.h:557
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
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:154
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:1921
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
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale.h:84
c2
static const uint64_t c2
Definition: murmur3.c:53
ScaleAlgorithm
Definition: utils.c:178
SWS_NUM_SCALER_PARAMS
#define SWS_NUM_SCALER_PARAMS
Extra parameters for fine-tuning certain scalers.
Definition: swscale.h:245
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:141
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
RGB_GAMMA
#define RGB_GAMMA
Definition: swscale_internal.h:558
SWS_BACKEND_UNSTABLE
@ SWS_BACKEND_UNSTABLE
Definition: swscale.h:121
SWS_SCALE_SPLINE
@ SWS_SCALE_SPLINE
unwindowned natural cubic spline
Definition: swscale.h:105
SWS_ERROR_DIFFUSION
@ SWS_ERROR_DIFFUSION
Set SwsContext.dither instead.
Definition: swscale.h:191
SWS_GAUSS
@ SWS_GAUSS
gaussian approximation
Definition: swscale.h:204
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
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:869
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:474
SwsContext::dst_w
int dst_w
Definition: swscale.h:275
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
AV_CPU_FLAG_SLOW_GATHER
#define AV_CPU_FLAG_SLOW_GATHER
CPU has slow gathers.
Definition: cpu.h:62
cpu.h
SwsContext::src_format
int src_format
Source pixel format.
Definition: swscale.h:276
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:279
AV_PIX_FMT_GRAY14LE
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:361
SwsFilter::lumH
SwsVector * lumH
Definition: swscale.h:485
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
cpu.h
sws_sumVec
static SwsVector * sws_sumVec(SwsVector *a, SwsVector *b)
Definition: utils.c:2054
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
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:2324
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)
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
X86_MMX
#define X86_MMX(flags)
Definition: cpu.h:25
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:262
avpriv_slicethread_free
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
Definition: slicethread.c:275
alloc_set_opts
static SwsContext * alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext without performing initialization.
Definition: utils.c:76
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:281
SWS_SCALE_AREA
@ SWS_SCALE_AREA
area averaging
Definition: swscale.h:101
sws_internal
static SwsInternal * sws_internal(const SwsContext *sws)
Definition: swscale_internal.h:79
ff_sws_jit_protect
int ff_sws_jit_protect(void *ptr, size_t size)
Definition: jit.c:94
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:177
SWS_LANCZOS
@ SWS_LANCZOS
3-tap sinc/sinc
Definition: swscale.h:206
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:473
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
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:282
SWS_SINC
@ SWS_SINC
unwindowed sinc
Definition: swscale.h:205
SwsContext
Main external API structure.
Definition: swscale.h:227
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:487
SWS_SRC_V_CHR_DROP_MASK
#define SWS_SRC_V_CHR_DROP_MASK
Definition: swscale.h:453
sws_dcVec
static double sws_dcVec(SwsVector *a)
Definition: utils.c:2030
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:2049
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:72
xyzgamma_tab
static uint16_t xyzgamma_tab[4096]
Definition: utils.c:713
SWS_UNSTABLE
@ SWS_UNSTABLE
Allow/prefer using experimental new code paths.
Definition: swscale.h:185
rgb2rgb.h
SwsContext::scaler_params
double scaler_params[SWS_NUM_SCALER_PARAMS]
Definition: swscale.h:246
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:3380
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:898
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
Definition: swscale_internal.h:478
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:1838
Generated on Sat Jul 18 2026 19:22:53 for FFmpeg by   doxygen 1.8.17