FFmpeg
swscale.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <inttypes.h>
22 #include <math.h>
23 #include <stdio.h>
24 #include <string.h>
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/avutil.h"
28 #include "libavutil/bswap.h"
29 #include "libavutil/cpu.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "config.h"
35 #include "rgb2rgb.h"
36 #include "swscale_internal.h"
37 #include "swscale.h"
38 
39 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_128)[9][8] = {
40  { 36, 68, 60, 92, 34, 66, 58, 90, },
41  { 100, 4, 124, 28, 98, 2, 122, 26, },
42  { 52, 84, 44, 76, 50, 82, 42, 74, },
43  { 116, 20, 108, 12, 114, 18, 106, 10, },
44  { 32, 64, 56, 88, 38, 70, 62, 94, },
45  { 96, 0, 120, 24, 102, 6, 126, 30, },
46  { 48, 80, 40, 72, 54, 86, 46, 78, },
47  { 112, 16, 104, 8, 118, 22, 110, 14, },
48  { 36, 68, 60, 92, 34, 66, 58, 90, },
49 };
50 
51 DECLARE_ALIGNED(8, static const uint8_t, sws_pb_64)[8] = {
52  64, 64, 64, 64, 64, 64, 64, 64
53 };
54 
55 static av_always_inline void fillPlane(uint8_t *plane, int stride, int width,
56  int height, int y, uint8_t val)
57 {
58  int i;
59  uint8_t *ptr = plane + stride * y;
60  for (i = 0; i < height; i++) {
61  memset(ptr, val, width);
62  ptr += stride;
63  }
64 }
65 
66 static void hScale16To19_c(SwsContext *c, int16_t *_dst, int dstW,
67  const uint8_t *_src, const int16_t *filter,
68  const int32_t *filterPos, int filterSize)
69 {
70  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
71  int i;
72  int32_t *dst = (int32_t *) _dst;
73  const uint16_t *src = (const uint16_t *) _src;
74  int bits = desc->comp[0].depth - 1;
75  int sh = bits - 4;
76 
77  if ((isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
78  sh = 9;
79  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
80  sh = 16 - 1 - 4;
81  }
82 
83  for (i = 0; i < dstW; i++) {
84  int j;
85  int srcPos = filterPos[i];
86  int val = 0;
87 
88  for (j = 0; j < filterSize; j++) {
89  val += src[srcPos + j] * filter[filterSize * i + j];
90  }
91  // filter=14 bit, input=16 bit, output=30 bit, >> 11 makes 19 bit
92  dst[i] = FFMIN(val >> sh, (1 << 19) - 1);
93  }
94 }
95 
96 static void hScale16To15_c(SwsContext *c, int16_t *dst, int dstW,
97  const uint8_t *_src, const int16_t *filter,
98  const int32_t *filterPos, int filterSize)
99 {
100  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
101  int i;
102  const uint16_t *src = (const uint16_t *) _src;
103  int sh = desc->comp[0].depth - 1;
104 
105  if (sh<15) {
106  sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
107  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
108  sh = 16 - 1;
109  }
110 
111  for (i = 0; i < dstW; i++) {
112  int j;
113  int srcPos = filterPos[i];
114  int val = 0;
115 
116  for (j = 0; j < filterSize; j++) {
117  val += src[srcPos + j] * filter[filterSize * i + j];
118  }
119  // filter=14 bit, input=16 bit, output=30 bit, >> 15 makes 15 bit
120  dst[i] = FFMIN(val >> sh, (1 << 15) - 1);
121  }
122 }
123 
124 // bilinear / bicubic scaling
125 static void hScale8To15_c(SwsContext *c, int16_t *dst, int dstW,
126  const uint8_t *src, const int16_t *filter,
127  const int32_t *filterPos, int filterSize)
128 {
129  int i;
130  for (i = 0; i < dstW; i++) {
131  int j;
132  int srcPos = filterPos[i];
133  int val = 0;
134  for (j = 0; j < filterSize; j++) {
135  val += ((int)src[srcPos + j]) * filter[filterSize * i + j];
136  }
137  dst[i] = FFMIN(val >> 7, (1 << 15) - 1); // the cubic equation does overflow ...
138  }
139 }
140 
141 static void hScale8To19_c(SwsContext *c, int16_t *_dst, int dstW,
142  const uint8_t *src, const int16_t *filter,
143  const int32_t *filterPos, int filterSize)
144 {
145  int i;
146  int32_t *dst = (int32_t *) _dst;
147  for (i = 0; i < dstW; i++) {
148  int j;
149  int srcPos = filterPos[i];
150  int val = 0;
151  for (j = 0; j < filterSize; j++) {
152  val += ((int)src[srcPos + j]) * filter[filterSize * i + j];
153  }
154  dst[i] = FFMIN(val >> 3, (1 << 19) - 1); // the cubic equation does overflow ...
155  }
156 }
157 
158 // FIXME all pal and rgb srcFormats could do this conversion as well
159 // FIXME all scalers more complex than bilinear could do half of this transform
160 static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width)
161 {
162  int i;
163  for (i = 0; i < width; i++) {
164  dstU[i] = (FFMIN(dstU[i], 30775) * 4663 - 9289992) >> 12; // -264
165  dstV[i] = (FFMIN(dstV[i], 30775) * 4663 - 9289992) >> 12; // -264
166  }
167 }
168 
169 static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width)
170 {
171  int i;
172  for (i = 0; i < width; i++) {
173  dstU[i] = (dstU[i] * 1799 + 4081085) >> 11; // 1469
174  dstV[i] = (dstV[i] * 1799 + 4081085) >> 11; // 1469
175  }
176 }
177 
178 static void lumRangeToJpeg_c(int16_t *dst, int width)
179 {
180  int i;
181  for (i = 0; i < width; i++)
182  dst[i] = (FFMIN(dst[i], 30189) * 19077 - 39057361) >> 14;
183 }
184 
185 static void lumRangeFromJpeg_c(int16_t *dst, int width)
186 {
187  int i;
188  for (i = 0; i < width; i++)
189  dst[i] = (dst[i] * 14071 + 33561947) >> 14;
190 }
191 
192 static void chrRangeToJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
193 {
194  int i;
195  int32_t *dstU = (int32_t *) _dstU;
196  int32_t *dstV = (int32_t *) _dstV;
197  for (i = 0; i < width; i++) {
198  dstU[i] = (FFMIN(dstU[i], 30775 << 4) * 4663 - (9289992 << 4)) >> 12; // -264
199  dstV[i] = (FFMIN(dstV[i], 30775 << 4) * 4663 - (9289992 << 4)) >> 12; // -264
200  }
201 }
202 
203 static void chrRangeFromJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
204 {
205  int i;
206  int32_t *dstU = (int32_t *) _dstU;
207  int32_t *dstV = (int32_t *) _dstV;
208  for (i = 0; i < width; i++) {
209  dstU[i] = (dstU[i] * 1799 + (4081085 << 4)) >> 11; // 1469
210  dstV[i] = (dstV[i] * 1799 + (4081085 << 4)) >> 11; // 1469
211  }
212 }
213 
214 static void lumRangeToJpeg16_c(int16_t *_dst, int width)
215 {
216  int i;
217  int32_t *dst = (int32_t *) _dst;
218  for (i = 0; i < width; i++) {
219  dst[i] = ((int)(FFMIN(dst[i], 30189 << 4) * 4769U - (39057361 << 2))) >> 12;
220  }
221 }
222 
223 static void lumRangeFromJpeg16_c(int16_t *_dst, int width)
224 {
225  int i;
226  int32_t *dst = (int32_t *) _dst;
227  for (i = 0; i < width; i++)
228  dst[i] = (dst[i]*(14071/4) + (33561947<<4)/4)>>12;
229 }
230 
231 
232 #define DEBUG_SWSCALE_BUFFERS 0
233 #define DEBUG_BUFFERS(...) \
234  if (DEBUG_SWSCALE_BUFFERS) \
235  av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
236 
237 static int swscale(SwsContext *c, const uint8_t *src[],
238  int srcStride[], int srcSliceY,
239  int srcSliceH, uint8_t *dst[], int dstStride[])
240 {
241  /* load a few things into local vars to make the code more readable?
242  * and faster */
243  const int dstW = c->dstW;
244  const int dstH = c->dstH;
245 
246  const enum AVPixelFormat dstFormat = c->dstFormat;
247  const int flags = c->flags;
248  int32_t *vLumFilterPos = c->vLumFilterPos;
249  int32_t *vChrFilterPos = c->vChrFilterPos;
250 
251  const int vLumFilterSize = c->vLumFilterSize;
252  const int vChrFilterSize = c->vChrFilterSize;
253 
254  yuv2planar1_fn yuv2plane1 = c->yuv2plane1;
255  yuv2planarX_fn yuv2planeX = c->yuv2planeX;
256  yuv2interleavedX_fn yuv2nv12cX = c->yuv2nv12cX;
257  yuv2packed1_fn yuv2packed1 = c->yuv2packed1;
258  yuv2packed2_fn yuv2packed2 = c->yuv2packed2;
259  yuv2packedX_fn yuv2packedX = c->yuv2packedX;
260  yuv2anyX_fn yuv2anyX = c->yuv2anyX;
261  const int chrSrcSliceY = srcSliceY >> c->chrSrcVSubSample;
262  const int chrSrcSliceH = AV_CEIL_RSHIFT(srcSliceH, c->chrSrcVSubSample);
263  int should_dither = isNBPS(c->srcFormat) ||
264  is16BPS(c->srcFormat);
265  int lastDstY;
266 
267  /* vars which will change and which we need to store back in the context */
268  int dstY = c->dstY;
269  int lastInLumBuf = c->lastInLumBuf;
270  int lastInChrBuf = c->lastInChrBuf;
271 
272  int lumStart = 0;
273  int lumEnd = c->descIndex[0];
274  int chrStart = lumEnd;
275  int chrEnd = c->descIndex[1];
276  int vStart = chrEnd;
277  int vEnd = c->numDesc;
278  SwsSlice *src_slice = &c->slice[lumStart];
279  SwsSlice *hout_slice = &c->slice[c->numSlice-2];
280  SwsSlice *vout_slice = &c->slice[c->numSlice-1];
281  SwsFilterDescriptor *desc = c->desc;
282 
283  int needAlpha = c->needAlpha;
284 
285  int hasLumHoles = 1;
286  int hasChrHoles = 1;
287 
288  if (isPacked(c->srcFormat)) {
289  src[1] =
290  src[2] =
291  src[3] = src[0];
292  srcStride[1] =
293  srcStride[2] =
294  srcStride[3] = srcStride[0];
295  }
296  srcStride[1] *= 1 << c->vChrDrop;
297  srcStride[2] *= 1 << c->vChrDrop;
298 
299  DEBUG_BUFFERS("swscale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",
300  src[0], srcStride[0], src[1], srcStride[1],
301  src[2], srcStride[2], src[3], srcStride[3],
302  dst[0], dstStride[0], dst[1], dstStride[1],
303  dst[2], dstStride[2], dst[3], dstStride[3]);
304  DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",
305  srcSliceY, srcSliceH, dstY, dstH);
306  DEBUG_BUFFERS("vLumFilterSize: %d vChrFilterSize: %d\n",
307  vLumFilterSize, vChrFilterSize);
308 
309  if (dstStride[0]&15 || dstStride[1]&15 ||
310  dstStride[2]&15 || dstStride[3]&15) {
311  static int warnedAlready = 0; // FIXME maybe move this into the context
312  if (flags & SWS_PRINT_INFO && !warnedAlready) {
313  av_log(c, AV_LOG_WARNING,
314  "Warning: dstStride is not aligned!\n"
315  " ->cannot do aligned memory accesses anymore\n");
316  warnedAlready = 1;
317  }
318  }
319 
320  if ( (uintptr_t)dst[0]&15 || (uintptr_t)dst[1]&15 || (uintptr_t)dst[2]&15
321  || (uintptr_t)src[0]&15 || (uintptr_t)src[1]&15 || (uintptr_t)src[2]&15
322  || dstStride[0]&15 || dstStride[1]&15 || dstStride[2]&15 || dstStride[3]&15
323  || srcStride[0]&15 || srcStride[1]&15 || srcStride[2]&15 || srcStride[3]&15
324  ) {
325  static int warnedAlready=0;
326  int cpu_flags = av_get_cpu_flags();
327  if (HAVE_MMXEXT && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){
328  av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speed loss\n");
329  warnedAlready=1;
330  }
331  }
332 
333  /* Note the user might start scaling the picture in the middle so this
334  * will not get executed. This is not really intended but works
335  * currently, so people might do it. */
336  if (srcSliceY == 0) {
337  dstY = 0;
338  lastInLumBuf = -1;
339  lastInChrBuf = -1;
340  }
341 
342  if (!should_dither) {
343  c->chrDither8 = c->lumDither8 = sws_pb_64;
344  }
345  lastDstY = dstY;
346 
347  ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,
348  yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, c->use_mmx_vfilter);
349 
350  ff_init_slice_from_src(src_slice, (uint8_t**)src, srcStride, c->srcW,
351  srcSliceY, srcSliceH, chrSrcSliceY, chrSrcSliceH, 1);
352 
353  ff_init_slice_from_src(vout_slice, (uint8_t**)dst, dstStride, c->dstW,
354  dstY, dstH, dstY >> c->chrDstVSubSample,
355  AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample), 0);
356  if (srcSliceY == 0) {
357  hout_slice->plane[0].sliceY = lastInLumBuf + 1;
358  hout_slice->plane[1].sliceY = lastInChrBuf + 1;
359  hout_slice->plane[2].sliceY = lastInChrBuf + 1;
360  hout_slice->plane[3].sliceY = lastInLumBuf + 1;
361 
362  hout_slice->plane[0].sliceH =
363  hout_slice->plane[1].sliceH =
364  hout_slice->plane[2].sliceH =
365  hout_slice->plane[3].sliceH = 0;
366  hout_slice->width = dstW;
367  }
368 
369  for (; dstY < dstH; dstY++) {
370  const int chrDstY = dstY >> c->chrDstVSubSample;
371  int use_mmx_vfilter= c->use_mmx_vfilter;
372 
373  // First line needed as input
374  const int firstLumSrcY = FFMAX(1 - vLumFilterSize, vLumFilterPos[dstY]);
375  const int firstLumSrcY2 = FFMAX(1 - vLumFilterSize, vLumFilterPos[FFMIN(dstY | ((1 << c->chrDstVSubSample) - 1), dstH - 1)]);
376  // First line needed as input
377  const int firstChrSrcY = FFMAX(1 - vChrFilterSize, vChrFilterPos[chrDstY]);
378 
379  // Last line needed as input
380  int lastLumSrcY = FFMIN(c->srcH, firstLumSrcY + vLumFilterSize) - 1;
381  int lastLumSrcY2 = FFMIN(c->srcH, firstLumSrcY2 + vLumFilterSize) - 1;
382  int lastChrSrcY = FFMIN(c->chrSrcH, firstChrSrcY + vChrFilterSize) - 1;
383  int enough_lines;
384 
385  int i;
386  int posY, cPosY, firstPosY, lastPosY, firstCPosY, lastCPosY;
387 
388  // handle holes (FAST_BILINEAR & weird filters)
389  if (firstLumSrcY > lastInLumBuf) {
390 
391  hasLumHoles = lastInLumBuf != firstLumSrcY - 1;
392  if (hasLumHoles) {
393  hout_slice->plane[0].sliceY = firstLumSrcY;
394  hout_slice->plane[3].sliceY = firstLumSrcY;
395  hout_slice->plane[0].sliceH =
396  hout_slice->plane[3].sliceH = 0;
397  }
398 
399  lastInLumBuf = firstLumSrcY - 1;
400  }
401  if (firstChrSrcY > lastInChrBuf) {
402 
403  hasChrHoles = lastInChrBuf != firstChrSrcY - 1;
404  if (hasChrHoles) {
405  hout_slice->plane[1].sliceY = firstChrSrcY;
406  hout_slice->plane[2].sliceY = firstChrSrcY;
407  hout_slice->plane[1].sliceH =
408  hout_slice->plane[2].sliceH = 0;
409  }
410 
411  lastInChrBuf = firstChrSrcY - 1;
412  }
413 
414  DEBUG_BUFFERS("dstY: %d\n", dstY);
415  DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",
416  firstLumSrcY, lastLumSrcY, lastInLumBuf);
417  DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",
418  firstChrSrcY, lastChrSrcY, lastInChrBuf);
419 
420  // Do we have enough lines in this slice to output the dstY line
421  enough_lines = lastLumSrcY2 < srcSliceY + srcSliceH &&
422  lastChrSrcY < AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample);
423 
424  if (!enough_lines) {
425  lastLumSrcY = srcSliceY + srcSliceH - 1;
426  lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;
427  DEBUG_BUFFERS("buffering slice: lastLumSrcY %d lastChrSrcY %d\n",
428  lastLumSrcY, lastChrSrcY);
429  }
430 
431  av_assert0((lastLumSrcY - firstLumSrcY + 1) <= hout_slice->plane[0].available_lines);
432  av_assert0((lastChrSrcY - firstChrSrcY + 1) <= hout_slice->plane[1].available_lines);
433 
434 
435  posY = hout_slice->plane[0].sliceY + hout_slice->plane[0].sliceH;
436  if (posY <= lastLumSrcY && !hasLumHoles) {
437  firstPosY = FFMAX(firstLumSrcY, posY);
438  lastPosY = FFMIN(firstLumSrcY + hout_slice->plane[0].available_lines - 1, srcSliceY + srcSliceH - 1);
439  } else {
440  firstPosY = posY;
441  lastPosY = lastLumSrcY;
442  }
443 
444  cPosY = hout_slice->plane[1].sliceY + hout_slice->plane[1].sliceH;
445  if (cPosY <= lastChrSrcY && !hasChrHoles) {
446  firstCPosY = FFMAX(firstChrSrcY, cPosY);
447  lastCPosY = FFMIN(firstChrSrcY + hout_slice->plane[1].available_lines - 1, AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample) - 1);
448  } else {
449  firstCPosY = cPosY;
450  lastCPosY = lastChrSrcY;
451  }
452 
453  ff_rotate_slice(hout_slice, lastPosY, lastCPosY);
454 
455  if (posY < lastLumSrcY + 1) {
456  for (i = lumStart; i < lumEnd; ++i)
457  desc[i].process(c, &desc[i], firstPosY, lastPosY - firstPosY + 1);
458  }
459 
460  lastInLumBuf = lastLumSrcY;
461 
462  if (cPosY < lastChrSrcY + 1) {
463  for (i = chrStart; i < chrEnd; ++i)
464  desc[i].process(c, &desc[i], firstCPosY, lastCPosY - firstCPosY + 1);
465  }
466 
467  lastInChrBuf = lastChrSrcY;
468 
469  if (!enough_lines)
470  break; // we can't output a dstY line so let's try with the next slice
471 
472 #if HAVE_MMX_INLINE
473  ff_updateMMXDitherTables(c, dstY);
474 #endif
475  if (should_dither) {
476  c->chrDither8 = ff_dither_8x8_128[chrDstY & 7];
477  c->lumDither8 = ff_dither_8x8_128[dstY & 7];
478  }
479  if (dstY >= dstH - 2) {
480  /* hmm looks like we can't use MMX here without overwriting
481  * this array's tail */
482  ff_sws_init_output_funcs(c, &yuv2plane1, &yuv2planeX, &yuv2nv12cX,
483  &yuv2packed1, &yuv2packed2, &yuv2packedX, &yuv2anyX);
484  use_mmx_vfilter= 0;
485  ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,
486  yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, use_mmx_vfilter);
487  }
488 
489  {
490  for (i = vStart; i < vEnd; ++i)
491  desc[i].process(c, &desc[i], dstY, 1);
492  }
493  }
494  if (isPlanar(dstFormat) && isALPHA(dstFormat) && !needAlpha) {
495  int length = dstW;
496  int height = dstY - lastDstY;
497 
498  if (is16BPS(dstFormat) || isNBPS(dstFormat)) {
499  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
500  fillPlane16(dst[3], dstStride[3], length, height, lastDstY,
501  1, desc->comp[3].depth,
502  isBE(dstFormat));
503  } else if (is32BPS(dstFormat)) {
504  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
505  fillPlane32(dst[3], dstStride[3], length, height, lastDstY,
506  1, desc->comp[3].depth,
507  isBE(dstFormat), desc->flags & AV_PIX_FMT_FLAG_FLOAT);
508  } else
509  fillPlane(dst[3], dstStride[3], length, height, lastDstY, 255);
510  }
511 
512 #if HAVE_MMXEXT_INLINE
513  if (av_get_cpu_flags() & AV_CPU_FLAG_MMXEXT)
514  __asm__ volatile ("sfence" ::: "memory");
515 #endif
516  emms_c();
517 
518  /* store changed local vars back in the context */
519  c->dstY = dstY;
520  c->lastInLumBuf = lastInLumBuf;
521  c->lastInChrBuf = lastInChrBuf;
522 
523  return dstY - lastDstY;
524 }
525 
526 av_cold void ff_sws_init_range_convert(SwsContext *c)
527 {
528  c->lumConvertRange = NULL;
529  c->chrConvertRange = NULL;
530  if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {
531  if (c->dstBpc <= 14) {
532  if (c->srcRange) {
533  c->lumConvertRange = lumRangeFromJpeg_c;
534  c->chrConvertRange = chrRangeFromJpeg_c;
535  } else {
536  c->lumConvertRange = lumRangeToJpeg_c;
537  c->chrConvertRange = chrRangeToJpeg_c;
538  }
539  } else {
540  if (c->srcRange) {
541  c->lumConvertRange = lumRangeFromJpeg16_c;
542  c->chrConvertRange = chrRangeFromJpeg16_c;
543  } else {
544  c->lumConvertRange = lumRangeToJpeg16_c;
545  c->chrConvertRange = chrRangeToJpeg16_c;
546  }
547  }
548  }
549 }
550 
551 static av_cold void sws_init_swscale(SwsContext *c)
552 {
553  enum AVPixelFormat srcFormat = c->srcFormat;
554 
555  ff_sws_init_output_funcs(c, &c->yuv2plane1, &c->yuv2planeX,
556  &c->yuv2nv12cX, &c->yuv2packed1,
557  &c->yuv2packed2, &c->yuv2packedX, &c->yuv2anyX);
558 
559  ff_sws_init_input_funcs(c);
560 
561  if (c->srcBpc == 8) {
562  if (c->dstBpc <= 14) {
563  c->hyScale = c->hcScale = hScale8To15_c;
564  if (c->flags & SWS_FAST_BILINEAR) {
565  c->hyscale_fast = ff_hyscale_fast_c;
566  c->hcscale_fast = ff_hcscale_fast_c;
567  }
568  } else {
569  c->hyScale = c->hcScale = hScale8To19_c;
570  }
571  } else {
572  c->hyScale = c->hcScale = c->dstBpc > 14 ? hScale16To19_c
573  : hScale16To15_c;
574  }
575 
576  ff_sws_init_range_convert(c);
577 
578  if (!(isGray(srcFormat) || isGray(c->dstFormat) ||
579  srcFormat == AV_PIX_FMT_MONOBLACK || srcFormat == AV_PIX_FMT_MONOWHITE))
580  c->needs_hcscale = 1;
581 }
582 
583 SwsFunc ff_getSwsFunc(SwsContext *c)
584 {
585  sws_init_swscale(c);
586 
587  if (ARCH_PPC)
588  ff_sws_init_swscale_ppc(c);
589  if (ARCH_X86)
590  ff_sws_init_swscale_x86(c);
591  if (ARCH_AARCH64)
592  ff_sws_init_swscale_aarch64(c);
593  if (ARCH_ARM)
594  ff_sws_init_swscale_arm(c);
595 
596  return swscale;
597 }
598 
599 static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
600 {
601  if (!isALPHA(format))
602  src[3] = NULL;
603  if (!isPlanar(format)) {
604  src[3] = src[2] = NULL;
605 
606  if (!usePal(format))
607  src[1] = NULL;
608  }
609 }
610 
611 static int check_image_pointers(const uint8_t * const data[4], enum AVPixelFormat pix_fmt,
612  const int linesizes[4])
613 {
614  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
615  int i;
616 
617  av_assert2(desc);
618 
619  for (i = 0; i < 4; i++) {
620  int plane = desc->comp[i].plane;
621  if (!data[plane] || !linesizes[plane])
622  return 0;
623  }
624 
625  return 1;
626 }
627 
628 static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst,
629  const uint16_t *src, int stride, int h)
630 {
631  int xp,yp;
632  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
633 
634  for (yp=0; yp<h; yp++) {
635  for (xp=0; xp+2<stride; xp+=3) {
636  int x, y, z, r, g, b;
637 
638  if (desc->flags & AV_PIX_FMT_FLAG_BE) {
639  x = AV_RB16(src + xp + 0);
640  y = AV_RB16(src + xp + 1);
641  z = AV_RB16(src + xp + 2);
642  } else {
643  x = AV_RL16(src + xp + 0);
644  y = AV_RL16(src + xp + 1);
645  z = AV_RL16(src + xp + 2);
646  }
647 
648  x = c->xyzgamma[x>>4];
649  y = c->xyzgamma[y>>4];
650  z = c->xyzgamma[z>>4];
651 
652  // convert from XYZlinear to sRGBlinear
653  r = c->xyz2rgb_matrix[0][0] * x +
654  c->xyz2rgb_matrix[0][1] * y +
655  c->xyz2rgb_matrix[0][2] * z >> 12;
656  g = c->xyz2rgb_matrix[1][0] * x +
657  c->xyz2rgb_matrix[1][1] * y +
658  c->xyz2rgb_matrix[1][2] * z >> 12;
659  b = c->xyz2rgb_matrix[2][0] * x +
660  c->xyz2rgb_matrix[2][1] * y +
661  c->xyz2rgb_matrix[2][2] * z >> 12;
662 
663  // limit values to 12-bit depth
664  r = av_clip_uintp2(r, 12);
665  g = av_clip_uintp2(g, 12);
666  b = av_clip_uintp2(b, 12);
667 
668  // convert from sRGBlinear to RGB and scale from 12bit to 16bit
669  if (desc->flags & AV_PIX_FMT_FLAG_BE) {
670  AV_WB16(dst + xp + 0, c->rgbgamma[r] << 4);
671  AV_WB16(dst + xp + 1, c->rgbgamma[g] << 4);
672  AV_WB16(dst + xp + 2, c->rgbgamma[b] << 4);
673  } else {
674  AV_WL16(dst + xp + 0, c->rgbgamma[r] << 4);
675  AV_WL16(dst + xp + 1, c->rgbgamma[g] << 4);
676  AV_WL16(dst + xp + 2, c->rgbgamma[b] << 4);
677  }
678  }
679  src += stride;
680  dst += stride;
681  }
682 }
683 
684 static void rgb48Toxyz12(struct SwsContext *c, uint16_t *dst,
685  const uint16_t *src, int stride, int h)
686 {
687  int xp,yp;
688  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
689 
690  for (yp=0; yp<h; yp++) {
691  for (xp=0; xp+2<stride; xp+=3) {
692  int x, y, z, r, g, b;
693 
694  if (desc->flags & AV_PIX_FMT_FLAG_BE) {
695  r = AV_RB16(src + xp + 0);
696  g = AV_RB16(src + xp + 1);
697  b = AV_RB16(src + xp + 2);
698  } else {
699  r = AV_RL16(src + xp + 0);
700  g = AV_RL16(src + xp + 1);
701  b = AV_RL16(src + xp + 2);
702  }
703 
704  r = c->rgbgammainv[r>>4];
705  g = c->rgbgammainv[g>>4];
706  b = c->rgbgammainv[b>>4];
707 
708  // convert from sRGBlinear to XYZlinear
709  x = c->rgb2xyz_matrix[0][0] * r +
710  c->rgb2xyz_matrix[0][1] * g +
711  c->rgb2xyz_matrix[0][2] * b >> 12;
712  y = c->rgb2xyz_matrix[1][0] * r +
713  c->rgb2xyz_matrix[1][1] * g +
714  c->rgb2xyz_matrix[1][2] * b >> 12;
715  z = c->rgb2xyz_matrix[2][0] * r +
716  c->rgb2xyz_matrix[2][1] * g +
717  c->rgb2xyz_matrix[2][2] * b >> 12;
718 
719  // limit values to 12-bit depth
720  x = av_clip_uintp2(x, 12);
721  y = av_clip_uintp2(y, 12);
722  z = av_clip_uintp2(z, 12);
723 
724  // convert from XYZlinear to X'Y'Z' and scale from 12bit to 16bit
725  if (desc->flags & AV_PIX_FMT_FLAG_BE) {
726  AV_WB16(dst + xp + 0, c->xyzgammainv[x] << 4);
727  AV_WB16(dst + xp + 1, c->xyzgammainv[y] << 4);
728  AV_WB16(dst + xp + 2, c->xyzgammainv[z] << 4);
729  } else {
730  AV_WL16(dst + xp + 0, c->xyzgammainv[x] << 4);
731  AV_WL16(dst + xp + 1, c->xyzgammainv[y] << 4);
732  AV_WL16(dst + xp + 2, c->xyzgammainv[z] << 4);
733  }
734  }
735  src += stride;
736  dst += stride;
737  }
738 }
739 
740 /**
741  * swscale wrapper, so we don't need to export the SwsContext.
742  * Assumes planar YUV to be in YUV order instead of YVU.
743  */
744 int attribute_align_arg sws_scale(struct SwsContext *c,
745  const uint8_t * const srcSlice[],
746  const int srcStride[], int srcSliceY,
747  int srcSliceH, uint8_t *const dst[],
748  const int dstStride[])
749 {
750  int i, ret;
751  const uint8_t *src2[4];
752  uint8_t *dst2[4];
753  uint8_t *rgb0_tmp = NULL;
754  int macro_height = isBayer(c->srcFormat) ? 2 : (1 << c->chrSrcVSubSample);
755  // copy strides, so they can safely be modified
756  int srcStride2[4];
757  int dstStride2[4];
758  int srcSliceY_internal = srcSliceY;
759 
760  if (!srcStride || !dstStride || !dst || !srcSlice) {
761  av_log(c, AV_LOG_ERROR, "One of the input parameters to sws_scale() is NULL, please check the calling code\n");
762  return 0;
763  }
764 
765  for (i=0; i<4; i++) {
766  srcStride2[i] = srcStride[i];
767  dstStride2[i] = dstStride[i];
768  }
769 
770  if ((srcSliceY & (macro_height-1)) ||
771  ((srcSliceH& (macro_height-1)) && srcSliceY + srcSliceH != c->srcH) ||
772  srcSliceY + srcSliceH > c->srcH) {
773  av_log(c, AV_LOG_ERROR, "Slice parameters %d, %d are invalid\n", srcSliceY, srcSliceH);
774  return AVERROR(EINVAL);
775  }
776 
777  if (c->gamma_flag && c->cascaded_context[0]) {
778  ret = sws_scale(c->cascaded_context[0],
779  srcSlice, srcStride, srcSliceY, srcSliceH,
780  c->cascaded_tmp, c->cascaded_tmpStride);
781 
782  if (ret < 0)
783  return ret;
784 
785  if (c->cascaded_context[2])
786  ret = sws_scale(c->cascaded_context[1], (const uint8_t * const *)c->cascaded_tmp, c->cascaded_tmpStride, srcSliceY, srcSliceH, c->cascaded1_tmp, c->cascaded1_tmpStride);
787  else
788  ret = sws_scale(c->cascaded_context[1], (const uint8_t * const *)c->cascaded_tmp, c->cascaded_tmpStride, srcSliceY, srcSliceH, dst, dstStride);
789 
790  if (ret < 0)
791  return ret;
792 
793  if (c->cascaded_context[2]) {
794  ret = sws_scale(c->cascaded_context[2],
795  (const uint8_t * const *)c->cascaded1_tmp, c->cascaded1_tmpStride, c->cascaded_context[1]->dstY - ret, c->cascaded_context[1]->dstY,
796  dst, dstStride);
797  }
798  return ret;
799  }
800 
801  if (c->cascaded_context[0] && srcSliceY == 0 && srcSliceH == c->cascaded_context[0]->srcH) {
802  ret = sws_scale(c->cascaded_context[0],
803  srcSlice, srcStride, srcSliceY, srcSliceH,
804  c->cascaded_tmp, c->cascaded_tmpStride);
805  if (ret < 0)
806  return ret;
807  ret = sws_scale(c->cascaded_context[1],
808  (const uint8_t * const * )c->cascaded_tmp, c->cascaded_tmpStride, 0, c->cascaded_context[0]->dstH,
809  dst, dstStride);
810  return ret;
811  }
812 
813  memcpy(src2, srcSlice, sizeof(src2));
814  memcpy(dst2, dst, sizeof(dst2));
815 
816  // do not mess up sliceDir if we have a "trailing" 0-size slice
817  if (srcSliceH == 0)
818  return 0;
819 
820  if (!check_image_pointers(srcSlice, c->srcFormat, srcStride)) {
821  av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
822  return 0;
823  }
824  if (!check_image_pointers((const uint8_t* const*)dst, c->dstFormat, dstStride)) {
825  av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
826  return 0;
827  }
828 
829  if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
830  av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
831  return 0;
832  }
833  if (c->sliceDir == 0) {
834  if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
835  }
836 
837  if (usePal(c->srcFormat)) {
838  for (i = 0; i < 256; i++) {
839  int r, g, b, y, u, v, a = 0xff;
840  if (c->srcFormat == AV_PIX_FMT_PAL8) {
841  uint32_t p = ((const uint32_t *)(srcSlice[1]))[i];
842  a = (p >> 24) & 0xFF;
843  r = (p >> 16) & 0xFF;
844  g = (p >> 8) & 0xFF;
845  b = p & 0xFF;
846  } else if (c->srcFormat == AV_PIX_FMT_RGB8) {
847  r = ( i >> 5 ) * 36;
848  g = ((i >> 2) & 7) * 36;
849  b = ( i & 3) * 85;
850  } else if (c->srcFormat == AV_PIX_FMT_BGR8) {
851  b = ( i >> 6 ) * 85;
852  g = ((i >> 3) & 7) * 36;
853  r = ( i & 7) * 36;
854  } else if (c->srcFormat == AV_PIX_FMT_RGB4_BYTE) {
855  r = ( i >> 3 ) * 255;
856  g = ((i >> 1) & 3) * 85;
857  b = ( i & 1) * 255;
858  } else if (c->srcFormat == AV_PIX_FMT_GRAY8 || c->srcFormat == AV_PIX_FMT_GRAY8A) {
859  r = g = b = i;
860  } else {
861  av_assert1(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
862  b = ( i >> 3 ) * 255;
863  g = ((i >> 1) & 3) * 85;
864  r = ( i & 1) * 255;
865  }
866 #define RGB2YUV_SHIFT 15
867 #define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
868 #define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
869 #define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
870 #define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
871 #define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
872 #define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
873 #define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
874 #define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
875 #define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
876 
877  y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
878  u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
879  v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
880  c->pal_yuv[i]= y + (u<<8) + (v<<16) + ((unsigned)a<<24);
881 
882  switch (c->dstFormat) {
883  case AV_PIX_FMT_BGR32:
884 #if !HAVE_BIGENDIAN
885  case AV_PIX_FMT_RGB24:
886 #endif
887  c->pal_rgb[i]= r + (g<<8) + (b<<16) + ((unsigned)a<<24);
888  break;
889  case AV_PIX_FMT_BGR32_1:
890 #if HAVE_BIGENDIAN
891  case AV_PIX_FMT_BGR24:
892 #endif
893  c->pal_rgb[i]= a + (r<<8) + (g<<16) + ((unsigned)b<<24);
894  break;
895  case AV_PIX_FMT_RGB32_1:
896 #if HAVE_BIGENDIAN
897  case AV_PIX_FMT_RGB24:
898 #endif
899  c->pal_rgb[i]= a + (b<<8) + (g<<16) + ((unsigned)r<<24);
900  break;
901  case AV_PIX_FMT_RGB32:
902 #if !HAVE_BIGENDIAN
903  case AV_PIX_FMT_BGR24:
904 #endif
905  default:
906  c->pal_rgb[i]= b + (g<<8) + (r<<16) + ((unsigned)a<<24);
907  }
908  }
909  }
910 
911  if (c->src0Alpha && !c->dst0Alpha && isALPHA(c->dstFormat)) {
912  uint8_t *base;
913  int x,y;
914  rgb0_tmp = av_malloc(FFABS(srcStride[0]) * srcSliceH + 32);
915  if (!rgb0_tmp)
916  return AVERROR(ENOMEM);
917 
918  base = srcStride[0] < 0 ? rgb0_tmp - srcStride[0] * (srcSliceH-1) : rgb0_tmp;
919  for (y=0; y<srcSliceH; y++){
920  memcpy(base + srcStride[0]*y, src2[0] + srcStride[0]*y, 4*c->srcW);
921  for (x=c->src0Alpha-1; x<4*c->srcW; x+=4) {
922  base[ srcStride[0]*y + x] = 0xFF;
923  }
924  }
925  src2[0] = base;
926  }
927 
928  if (c->srcXYZ && !(c->dstXYZ && c->srcW==c->dstW && c->srcH==c->dstH)) {
929  uint8_t *base;
930  rgb0_tmp = av_malloc(FFABS(srcStride[0]) * srcSliceH + 32);
931  if (!rgb0_tmp)
932  return AVERROR(ENOMEM);
933 
934  base = srcStride[0] < 0 ? rgb0_tmp - srcStride[0] * (srcSliceH-1) : rgb0_tmp;
935 
936  xyz12Torgb48(c, (uint16_t*)base, (const uint16_t*)src2[0], srcStride[0]/2, srcSliceH);
937  src2[0] = base;
938  }
939 
940  if (!srcSliceY && (c->flags & SWS_BITEXACT) && c->dither == SWS_DITHER_ED && c->dither_error[0])
941  for (i = 0; i < 4; i++)
942  memset(c->dither_error[i], 0, sizeof(c->dither_error[0][0]) * (c->dstW+2));
943 
944  if (c->sliceDir != 1) {
945  // slices go from bottom to top => we flip the image internally
946  for (i=0; i<4; i++) {
947  srcStride2[i] *= -1;
948  dstStride2[i] *= -1;
949  }
950 
951  src2[0] += (srcSliceH - 1) * srcStride[0];
952  if (!usePal(c->srcFormat))
953  src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
954  src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
955  src2[3] += (srcSliceH - 1) * srcStride[3];
956  dst2[0] += ( c->dstH - 1) * dstStride[0];
957  dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
958  dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
959  dst2[3] += ( c->dstH - 1) * dstStride[3];
960 
961  srcSliceY_internal = c->srcH-srcSliceY-srcSliceH;
962  }
963  reset_ptr(src2, c->srcFormat);
964  reset_ptr((void*)dst2, c->dstFormat);
965 
966  /* reset slice direction at end of frame */
967  if (srcSliceY_internal + srcSliceH == c->srcH)
968  c->sliceDir = 0;
969  ret = c->swscale(c, src2, srcStride2, srcSliceY_internal, srcSliceH, dst2, dstStride2);
970 
971  if (c->dstXYZ && !(c->srcXYZ && c->srcW==c->dstW && c->srcH==c->dstH)) {
972  int dstY = c->dstY ? c->dstY : srcSliceY + srcSliceH;
973  uint16_t *dst16 = (uint16_t*)(dst2[0] + (dstY - ret) * dstStride2[0]);
974  av_assert0(dstY >= ret);
975  av_assert0(ret >= 0);
976  av_assert0(c->dstH >= dstY);
977 
978  /* replace on the same data */
979  rgb48Toxyz12(c, dst16, dst16, dstStride2[0]/2, ret);
980  }
981 
982  av_free(rgb0_tmp);
983  return ret;
984 }
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:758
yuv2packed2_fn
void(* yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2], const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing bilinear scalin...
Definition: swscale_internal.h:202
stride
int stride
Definition: mace.c:144
yuv2planar1_fn
void(* yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output without any additional vertical scaling (...
Definition: swscale_internal.h:98
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
process
static void process(NormalizeContext *s, AVFrame *in, AVFrame *out)
Definition: vf_normalize.c:156
yuv2packed1_fn
void(* yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc, const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc, uint8_t *dest, int dstW, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output without any additional v...
Definition: swscale_internal.h:169
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
SwsPlane::sliceH
int sliceH
number of lines
Definition: swscale_internal.h:966
hScale16To19_c
static void hScale16To19_c(SwsContext *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:66
isPacked
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:789
r
const char * r
Definition: vf_curves.c:114
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
chrRangeFromJpeg16_c
static void chrRangeFromJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
Definition: swscale.c:203
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:372
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
ff_hyscale_fast_c
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
Definition: hscale_fast_bilinear.c:23
ff_rotate_slice
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
Definition: slice.c:119
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:188
SwsSlice::plane
SwsPlane plane[MAX_SLICE_PLANES]
color planes
Definition: swscale_internal.h:984
pixdesc.h
hScale8To15_c
static void hScale8To15_c(SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:125
GV
#define GV
ff_sws_init_input_funcs
void ff_sws_init_input_funcs(SwsContext *c)
b
#define b
Definition: input.c:41
SwsFilterDescriptor
Struct which holds all necessary data for processing a slice.
Definition: swscale_internal.h:991
yuv2planeX
static void FUNC() yuv2planeX(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Definition: swscale_ppc_template.c:81
data
const char data[16]
Definition: mxf.c:91
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
isGray
#define isGray(x)
Definition: swscale.c:40
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:371
base
uint8_t base
Definition: vp3data.h:202
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
mathematics.h
sws_scale
int attribute_align_arg sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
swscale wrapper, so we don't need to export the SwsContext.
Definition: swscale.c:744
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
RV
#define RV
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:93
DEBUG_BUFFERS
#define DEBUG_BUFFERS(...)
Definition: swscale.c:233
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:50
xyz12Torgb48
static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst, const uint16_t *src, int stride, int h)
Definition: swscale.c:628
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
SWS_FAST_BILINEAR
#define SWS_FAST_BILINEAR
Definition: swscale.h:58
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:643
ff_sws_init_swscale_aarch64
av_cold void ff_sws_init_swscale_aarch64(SwsContext *c)
Definition: swscale.c:32
SWS_BITEXACT
#define SWS_BITEXACT
Definition: swscale.h:84
SwsFunc
int(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_internal.h:82
yuv2anyX_fn
void(* yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t **dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to YUV/RGB output by doing multi-point vertical scaling...
Definition: swscale_internal.h:268
U
#define U(x)
Definition: vp56_arith.h:37
hScale8To19_c
static void hScale8To19_c(SwsContext *c, int16_t *_dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:141
val
static double val(void *priv, double ch)
Definition: aeval.c:76
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:657
RY
#define RY
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
sws_init_swscale
static av_cold void sws_init_swscale(SwsContext *c)
Definition: swscale.c:551
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:69
width
#define width
intreadwrite.h
GU
#define GU
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
ff_sws_init_swscale_arm
av_cold void ff_sws_init_swscale_arm(SwsContext *c)
Definition: swscale.c:32
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
g
const char * g
Definition: vf_curves.c:115
SwsSlice::width
int width
Slice line width.
Definition: swscale_internal.h:978
bits
uint8_t bits
Definition: vp3data.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:90
lumRangeFromJpeg_c
static void lumRangeFromJpeg_c(int16_t *dst, int width)
Definition: swscale.c:185
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
ff_init_vscale_pfn
void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX, yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2, yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx)
setup vertical scaler functions
Definition: vscale.c:257
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:373
int32_t
int32_t
Definition: audio_convert.c:194
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:526
AV_PIX_FMT_GRAY8A
@ AV_PIX_FMT_GRAY8A
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:146
fillPlane
static av_always_inline void fillPlane(uint8_t *plane, int stride, int width, int height, int y, uint8_t val)
Definition: swscale.c:55
NULL
#define NULL
Definition: coverity.c:32
SwsPlane::available_lines
int available_lines
max number of lines that can be hold by this plane
Definition: swscale_internal.h:964
ff_sws_init_swscale_x86
av_cold void ff_sws_init_swscale_x86(SwsContext *c)
Definition: swscale.c:383
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:76
src
#define src
Definition: vp8dsp.c:254
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
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
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
chrRangeToJpeg_c
static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width)
Definition: swscale.c:160
AV_CPU_FLAG_SSE2
#define AV_CPU_FLAG_SSE2
PIV SSE2 functions.
Definition: cpu.h:36
ff_getSwsFunc
SwsFunc ff_getSwsFunc(SwsContext *c)
Return function pointer to fastest main scaler path function depending on architecture and available ...
Definition: swscale.c:583
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:664
desc
const char * desc
Definition: nvenc.c:79
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
fillPlane16
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
Definition: swscale_internal.h:910
usePal
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:820
BV
#define BV
cpu.h
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:765
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
hScale16To15_c
static void hScale16To15_c(SwsContext *c, int16_t *dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:96
srcSliceH
return srcSliceH
Definition: yuv2rgb_template.c:87
chrRangeToJpeg16_c
static void chrRangeToJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
Definition: swscale.c:192
swscale
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale.c:237
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
is32BPS
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:650
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:370
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
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
ff_hcscale_fast_c
void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
Definition: hscale_fast_bilinear.c:38
fillPlane32
static void fillPlane32(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian, int is_float)
Definition: swscale_internal.h:931
GY
#define GY
isALPHA
#define isALPHA(x)
Definition: swscale.c:51
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
check_image_pointers
static int check_image_pointers(const uint8_t *const data[4], enum AVPixelFormat pix_fmt, const int linesizes[4])
Definition: swscale.c:611
av_always_inline
#define av_always_inline
Definition: attributes.h:49
swscale_internal.h
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
SwsSlice
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
Definition: swscale_internal.h:976
ff_init_slice_from_src
int ff_init_slice_from_src(SwsSlice *s, uint8_t *src[4], int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH, int relative)
Definition: slice.c:147
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ff_sws_init_output_funcs
av_cold void ff_sws_init_output_funcs(SwsContext *c, yuv2planar1_fn *yuv2plane1, yuv2planarX_fn *yuv2planeX, yuv2interleavedX_fn *yuv2nv12cX, yuv2packed1_fn *yuv2packed1, yuv2packed2_fn *yuv2packed2, yuv2packedX_fn *yuv2packedX, yuv2anyX_fn *yuv2anyX)
Definition: output.c:2533
ret
ret
Definition: filter_design.txt:187
bswap.h
sws_pb_64
static const uint8_t sws_pb_64[8]
Definition: swscale.c:51
ff_sws_init_swscale_ppc
av_cold void ff_sws_init_swscale_ppc(SwsContext *c)
Definition: swscale_altivec.c:238
yuv2planarX_fn
void(* yuv2planarX_fn)(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output with multi-point vertical scaling between...
Definition: swscale_internal.h:114
yuv2interleavedX_fn
void(* yuv2interleavedX_fn)(struct SwsContext *c, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest, int dstW)
Write one line of horizontally scaled chroma to interleaved output with multi-point vertical scaling ...
Definition: swscale_internal.h:133
reset_ptr
static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
Definition: swscale.c:599
yuv2packedX_fn
void(* yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing multi-point ver...
Definition: swscale_internal.h:234
ff_dither_8x8_128
const uint8_t ff_dither_8x8_128[9][8]
Definition: swscale.c:39
AV_CPU_FLAG_MMXEXT
#define AV_CPU_FLAG_MMXEXT
SSE integer functions or AMD MMX ext.
Definition: cpu.h:32
RU
#define RU
lumRangeToJpeg_c
static void lumRangeToJpeg_c(int16_t *dst, int width)
Definition: swscale.c:178
BU
#define BU
lumRangeFromJpeg16_c
static void lumRangeFromJpeg16_c(int16_t *_dst, int width)
Definition: swscale.c:223
SWS_PRINT_INFO
#define SWS_PRINT_INFO
Definition: swscale.h:75
avutil.h
lumRangeToJpeg16_c
static void lumRangeToJpeg16_c(int16_t *_dst, int width)
Definition: swscale.c:214
SwsPlane::sliceY
int sliceY
index of first line
Definition: swscale_internal.h:965
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
BY
#define BY
chrRangeFromJpeg_c
static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width)
Definition: swscale.c:169
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
ff_updateMMXDitherTables
void ff_updateMMXDitherTables(SwsContext *c, int dstY)
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:798
int
int
Definition: ffmpeg_filter.c:192
SwsContext
Definition: swscale_internal.h:280
rgb48Toxyz12
static void rgb48Toxyz12(struct SwsContext *c, uint16_t *dst, const uint16_t *src, int stride, int h)
Definition: swscale.c:684
rgb2rgb.h
swscale.h
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:94
Generated on Wed Aug 24 2022 21:32:09 for FFmpeg by   doxygen 1.8.17