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 
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 {
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 {
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;
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];
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) {
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
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 
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) {
535  } else {
538  }
539  } else {
540  if (c->srcRange) {
543  } else {
546  }
547  }
548  }
549 }
550 
552 {
553  enum AVPixelFormat srcFormat = c->srcFormat;
554 
556  &c->yuv2nv12cX, &c->yuv2packed1,
557  &c->yuv2packed2, &c->yuv2packedX, &c->yuv2anyX);
558 
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) {
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 
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 
584 {
585  sws_init_swscale(c);
586 
587  if (ARCH_PPC)
589  if (ARCH_X86)
591  if (ARCH_AARCH64)
593  if (ARCH_ARM)
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;
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;
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,
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,
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 {
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 }
#define BU
int plane
Which of the 4 planes contains the component.
Definition: pixdesc.h:35
#define NULL
Definition: coverity.c:32
void(* hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
static void lumRangeToJpeg_c(int16_t *dst, int width)
Definition: swscale.c:178
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
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:2542
static enum AVPixelFormat pix_fmt
static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width)
Definition: swscale.c:169
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
int chrSrcH
Height of source chroma planes.
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
Definition: swscale.c:599
uint32_t pal_rgb[256]
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int16_t * rgbgamma
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
#define GU
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:87
return srcSliceH
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
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
static void lumRangeToJpeg16_c(int16_t *_dst, int width)
Definition: swscale.c:214
Struct which holds all necessary data for processing a slice.
int16_t * rgbgammainv
#define RU
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
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:36
Convenience header that includes libavutil&#39;s core.
int16_t * xyzgammainv
void(* hyScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Scale one horizontal line of input data using a filter over the input lines, to produce one (differen...
static atomic_int cpu_flags
Definition: cpu.c:50
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
const uint8_t * lumDither8
#define BY
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:87
void(* hyscale_fast)(struct SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
Scale one horizontal line of input data using a bilinear filter to produce one line of output data...
#define SWS_PRINT_INFO
Definition: swscale.h:75
int dstY
Last destination vertical line output from last slice.
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
void ff_sws_init_input_funcs(SwsContext *c)
uint8_t base
Definition: vp3data.h:202
int srcH
Height of source luma/alpha planes.
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
static void rgb48Toxyz12(struct SwsContext *c, uint16_t *dst, const uint16_t *src, int stride, int h)
Definition: swscale.c:684
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
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
Definition: slice.c:119
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
static void lumRangeFromJpeg_c(int16_t *dst, int width)
Definition: swscale.c:185
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
int vChrFilterSize
Vertical filter size for chroma pixels.
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:188
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
#define AV_CPU_FLAG_MMXEXT
SSE integer functions or AMD MMX ext.
Definition: cpu.h:32
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
int cascaded_tmpStride[4]
av_cold void ff_sws_init_swscale_x86(SwsContext *c)
Definition: swscale.c:394
#define SWS_FAST_BILINEAR
Definition: swscale.h:58
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
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 (...
int16_t rgb2xyz_matrix[3][4]
external API header
enum AVPixelFormat dstFormat
Destination pixel format.
#define BV
#define isALPHA(x)
Definition: swscale.c:51
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define av_log(a,...)
yuv2packedX_fn yuv2packedX
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_cold void ff_sws_init_swscale_aarch64(SwsContext *c)
Definition: swscale.c:32
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
#define DEBUG_BUFFERS(...)
Definition: swscale.c:233
int dstH
Height of destination luma/alpha planes.
int * dither_error[4]
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:254
yuv2anyX_fn yuv2anyX
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:375
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
SwsFunc ff_getSwsFunc(SwsContext *c)
Return function pointer to fastest main scaler path function depending on architecture and available ...
Definition: swscale.c:583
#define RV
static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width)
Definition: swscale.c:160
const char * r
Definition: vf_curves.c:114
yuv2packed1_fn yuv2packed1
simple assert() macros that are a bit more flexible than ISO C assert().
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
GLsizei GLsizei * length
Definition: opengl_enc.c:114
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)
uint8_t bits
Definition: vp3data.h:202
void(* hcscale_fast)(struct SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
#define FFMAX(a, b)
Definition: common.h:94
static int check_image_pointers(const uint8_t *const data[4], enum AVPixelFormat pix_fmt, const int linesizes[4])
Definition: swscale.c:611
uint8_t * cascaded1_tmp[4]
static av_cold void sws_init_swscale(SwsContext *c)
Definition: swscale.c:551
SwsPlane plane[MAX_SLICE_PLANES]
color planes
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)
int sliceH
number of lines
int16_t * xyzgamma
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst, const uint16_t *src, int stride, int h)
Definition: swscale.c:628
av_cold void ff_sws_init_swscale_ppc(SwsContext *c)
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
#define RGB2YUV_SHIFT
void ff_updateMMXDitherTables(SwsContext *c, int dstY)
#define b
Definition: input.c:41
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:146
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FFMIN(a, b)
Definition: common.h:96
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
#define RY
#define width
yuv2planar1_fn yuv2plane1
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
yuv2interleavedX_fn yuv2nv12cX
int32_t
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int available_lines
max number of lines that can be hold by this plane
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:526
struct SwsFilterDescriptor * desc
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
int dstW
Width of destination luma/alpha planes.
uint8_t * cascaded_tmp[4]
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
int(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
int cascaded1_tmpStride[4]
int needs_hcscale
Set if there are chroma planes to be converted.
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
#define isGray(x)
Definition: swscale.c:40
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:374
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
int width
Slice line width.
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...
int16_t xyz2rgb_matrix[3][4]
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
yuv2planarX_fn yuv2planeX
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:372
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...
const uint8_t ff_dither_8x8_128[9][8]
Definition: swscale.c:39
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
struct SwsSlice * slice
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&#39;t need to export the SwsContext.
Definition: swscale.c:744
static av_always_inline void fillPlane(uint8_t *plane, int stride, int width, int height, int y, uint8_t val)
Definition: swscale.c:55
static void lumRangeFromJpeg16_c(int16_t *_dst, int width)
Definition: swscale.c:223
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
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...
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
byte swapping routines
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT uint8_t * _dstV
Definition: input.c:397
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:93
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
uint16_t * dstV
Definition: input.c:402
const uint8_t * chrDither8
static void chrRangeToJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
Definition: swscale.c:192
#define flags(name, subs,...)
Definition: cbs_av1.c:560
#define SWS_BITEXACT
Definition: swscale.h:84
static int swscale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale.c:237
SwsDither dither
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:76
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
int
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
yuv2packed2_fn yuv2packed2
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)
Y , 8bpp.
Definition: pixfmt.h:74
#define GY
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:75
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
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...
enum AVPixelFormat srcFormat
Source pixel format.
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
struct SwsContext * cascaded_context[3]
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
SwsFunc swscale
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
#define GV
#define av_free(p)
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:373
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...
static void chrRangeFromJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
Definition: swscale.c:203
#define AV_CPU_FLAG_SSE2
PIV SSE2 functions.
Definition: cpu.h:36
static const uint8_t sws_pb_64[8]
Definition: swscale.c:51
#define av_always_inline
Definition: attributes.h:45
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
#define stride
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
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
int sliceY
index of first line
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
int srcW
Width of source luma/alpha planes.
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image...
int flags
Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
static void process(NormalizeContext *s, AVFrame *in, AVFrame *out)
Definition: vf_normalize.c:156
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
uint32_t pal_yuv[256]
void(* yuv2interleavedX_fn)(enum AVPixelFormat dstFormat, const uint8_t *chrDither, 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 ...
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
int i
Definition: input.c:406
av_cold void ff_sws_init_swscale_arm(SwsContext *c)
Definition: swscale.c:32
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
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