FFmpeg
swscale_internal.h
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 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
23 
24 #include "config.h"
25 #include "version.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avutil.h"
29 #include "libavutil/common.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/log.h"
32 #include "libavutil/pixfmt.h"
33 #include "libavutil/pixdesc.h"
35 
36 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
37 
38 #define YUVRGB_TABLE_HEADROOM 512
39 #define YUVRGB_TABLE_LUMA_HEADROOM 512
40 
41 #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
42 
43 #define DITHER1XBPP
44 
45 #if HAVE_BIGENDIAN
46 #define ALT32_CORR (-1)
47 #else
48 #define ALT32_CORR 1
49 #endif
50 
51 #if ARCH_X86_64
52 # define APCK_PTR2 8
53 # define APCK_COEF 16
54 # define APCK_SIZE 24
55 #else
56 # define APCK_PTR2 4
57 # define APCK_COEF 8
58 # define APCK_SIZE 16
59 #endif
60 
61 #define RETCODE_USE_CASCADE -12345
62 
63 struct SwsContext;
64 
65 typedef enum SwsDither {
73 } SwsDither;
74 
75 typedef enum SwsAlphaBlend {
81 
82 typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
83  int srcStride[], int srcSliceY, int srcSliceH,
84  uint8_t *dst[], int dstStride[]);
85 
86 /**
87  * Write one line of horizontally scaled data to planar output
88  * without any additional vertical scaling (or point-scaling).
89  *
90  * @param src scaled source data, 15 bits for 8-10-bit output,
91  * 19 bits for 16-bit output (in int32_t)
92  * @param dest pointer to the output plane. For >8-bit
93  * output, this is in uint16_t
94  * @param dstW width of destination in pixels
95  * @param dither ordered dither array of type int16_t and size 8
96  * @param offset Dither offset
97  */
98 typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
99  const uint8_t *dither, int offset);
100 
101 /**
102  * Write one line of horizontally scaled data to planar output
103  * with multi-point vertical scaling between input pixels.
104  *
105  * @param filter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
106  * @param src scaled luma (Y) or alpha (A) source data, 15 bits for
107  * 8-10-bit output, 19 bits for 16-bit output (in int32_t)
108  * @param filterSize number of vertical input lines to scale
109  * @param dest pointer to output plane. For >8-bit
110  * output, this is in uint16_t
111  * @param dstW width of destination pixels
112  * @param offset Dither offset
113  */
114 typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
115  const int16_t **src, uint8_t *dest, int dstW,
116  const uint8_t *dither, int offset);
117 
118 /**
119  * Write one line of horizontally scaled chroma to interleaved output
120  * with multi-point vertical scaling between input pixels.
121  *
122  * @param c SWS scaling context
123  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
124  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit
125  * output, 19 bits for 16-bit output (in int32_t)
126  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit
127  * output, 19 bits for 16-bit output (in int32_t)
128  * @param chrFilterSize number of vertical chroma input lines to scale
129  * @param dest pointer to the output plane. For >8-bit
130  * output, this is in uint16_t
131  * @param dstW width of chroma planes
132  */
133 typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
134  const int16_t *chrFilter,
135  int chrFilterSize,
136  const int16_t **chrUSrc,
137  const int16_t **chrVSrc,
138  uint8_t *dest, int dstW);
139 
140 /**
141  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
142  * output without any additional vertical scaling (or point-scaling). Note
143  * that this function may do chroma scaling, see the "uvalpha" argument.
144  *
145  * @param c SWS scaling context
146  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
147  * 19 bits for 16-bit output (in int32_t)
148  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
149  * 19 bits for 16-bit output (in int32_t)
150  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
151  * 19 bits for 16-bit output (in int32_t)
152  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
153  * 19 bits for 16-bit output (in int32_t)
154  * @param dest pointer to the output plane. For 16-bit output, this is
155  * uint16_t
156  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
157  * to write into dest[]
158  * @param uvalpha chroma scaling coefficient for the second line of chroma
159  * pixels, either 2048 or 0. If 0, one chroma input is used
160  * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
161  * is set, it generates 1 output pixel). If 2048, two chroma
162  * input pixels should be averaged for 2 output pixels (this
163  * only happens if SWS_FLAG_FULL_CHR_INT is not set)
164  * @param y vertical line number for this output. This does not need
165  * to be used to calculate the offset in the destination,
166  * but can be used to generate comfort noise using dithering
167  * for some output formats.
168  */
169 typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
170  const int16_t *chrUSrc[2],
171  const int16_t *chrVSrc[2],
172  const int16_t *alpSrc, uint8_t *dest,
173  int dstW, int uvalpha, int y);
174 /**
175  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
176  * output by doing bilinear scaling between two input lines.
177  *
178  * @param c SWS scaling context
179  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
180  * 19 bits for 16-bit output (in int32_t)
181  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
182  * 19 bits for 16-bit output (in int32_t)
183  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
184  * 19 bits for 16-bit output (in int32_t)
185  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
186  * 19 bits for 16-bit output (in int32_t)
187  * @param dest pointer to the output plane. For 16-bit output, this is
188  * uint16_t
189  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
190  * to write into dest[]
191  * @param yalpha luma/alpha scaling coefficients for the second input line.
192  * The first line's coefficients can be calculated by using
193  * 4096 - yalpha
194  * @param uvalpha chroma scaling coefficient for the second input line. The
195  * first line's coefficients can be calculated by using
196  * 4096 - uvalpha
197  * @param y vertical line number for this output. This does not need
198  * to be used to calculate the offset in the destination,
199  * but can be used to generate comfort noise using dithering
200  * for some output formats.
201  */
202 typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
203  const int16_t *chrUSrc[2],
204  const int16_t *chrVSrc[2],
205  const int16_t *alpSrc[2],
206  uint8_t *dest,
207  int dstW, int yalpha, int uvalpha, int y);
208 /**
209  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
210  * output by doing multi-point vertical scaling between input pixels.
211  *
212  * @param c SWS scaling context
213  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
214  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
215  * 19 bits for 16-bit output (in int32_t)
216  * @param lumFilterSize number of vertical luma/alpha input lines to scale
217  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
218  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
219  * 19 bits for 16-bit output (in int32_t)
220  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
221  * 19 bits for 16-bit output (in int32_t)
222  * @param chrFilterSize number of vertical chroma input lines to scale
223  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
224  * 19 bits for 16-bit output (in int32_t)
225  * @param dest pointer to the output plane. For 16-bit output, this is
226  * uint16_t
227  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
228  * to write into dest[]
229  * @param y vertical line number for this output. This does not need
230  * to be used to calculate the offset in the destination,
231  * but can be used to generate comfort noise using dithering
232  * or some output formats.
233  */
234 typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
235  const int16_t **lumSrc, int lumFilterSize,
236  const int16_t *chrFilter,
237  const int16_t **chrUSrc,
238  const int16_t **chrVSrc, int chrFilterSize,
239  const int16_t **alpSrc, uint8_t *dest,
240  int dstW, int y);
241 
242 /**
243  * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
244  * output by doing multi-point vertical scaling between input pixels.
245  *
246  * @param c SWS scaling context
247  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
248  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
249  * 19 bits for 16-bit output (in int32_t)
250  * @param lumFilterSize number of vertical luma/alpha input lines to scale
251  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
252  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
253  * 19 bits for 16-bit output (in int32_t)
254  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
255  * 19 bits for 16-bit output (in int32_t)
256  * @param chrFilterSize number of vertical chroma input lines to scale
257  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
258  * 19 bits for 16-bit output (in int32_t)
259  * @param dest pointer to the output planes. For 16-bit output, this is
260  * uint16_t
261  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
262  * to write into dest[]
263  * @param y vertical line number for this output. This does not need
264  * to be used to calculate the offset in the destination,
265  * but can be used to generate comfort noise using dithering
266  * or some output formats.
267  */
268 typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
269  const int16_t **lumSrc, int lumFilterSize,
270  const int16_t *chrFilter,
271  const int16_t **chrUSrc,
272  const int16_t **chrVSrc, int chrFilterSize,
273  const int16_t **alpSrc, uint8_t **dest,
274  int dstW, int y);
275 
276 struct SwsSlice;
277 struct SwsFilterDescriptor;
278 
279 /* This struct should be aligned on at least a 32-byte boundary. */
280 typedef struct SwsContext {
281  /**
282  * info on struct for av_log
283  */
285 
286  /**
287  * Note that src, dst, srcStride, dstStride will be copied in the
288  * sws_scale() wrapper so they can be freely modified here.
289  */
291  int srcW; ///< Width of source luma/alpha planes.
292  int srcH; ///< Height of source luma/alpha planes.
293  int dstH; ///< Height of destination luma/alpha planes.
294  int chrSrcW; ///< Width of source chroma planes.
295  int chrSrcH; ///< Height of source chroma planes.
296  int chrDstW; ///< Width of destination chroma planes.
297  int chrDstH; ///< Height of destination chroma planes.
300  enum AVPixelFormat dstFormat; ///< Destination pixel format.
301  enum AVPixelFormat srcFormat; ///< Source pixel format.
302  int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
303  int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
305  int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
306  int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
307  int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
308  int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
309  int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
310  int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
311  double param[2]; ///< Input parameters for scaling algorithms that need them.
312 
313  /* The cascaded_* fields allow spliting a scaler task into multiple
314  * sequential steps, this is for example used to limit the maximum
315  * downscaling factor that needs to be supported in one scaler.
316  */
323 
324  double gamma_value;
327  uint16_t *gamma;
328  uint16_t *inv_gamma;
329 
330  int numDesc;
331  int descIndex[2];
332  int numSlice;
333  struct SwsSlice *slice;
335 
336  uint32_t pal_yuv[256];
337  uint32_t pal_rgb[256];
338 
339  float uint2float_lut[256];
340 
341  /**
342  * @name Scaled horizontal lines ring buffer.
343  * The horizontal scaler keeps just enough scaled lines in a ring buffer
344  * so they may be passed to the vertical scaler. The pointers to the
345  * allocated buffers for each line are duplicated in sequence in the ring
346  * buffer to simplify indexing and avoid wrapping around between lines
347  * inside the vertical scaler code. The wrapping is done before the
348  * vertical scaler is called.
349  */
350  //@{
351  int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
352  int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
353  int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
354  int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source.
355  //@}
356 
359 
360  /**
361  * @name Horizontal and vertical filters.
362  * To better understand the following fields, here is a pseudo-code of
363  * their usage in filtering a horizontal line:
364  * @code
365  * for (i = 0; i < width; i++) {
366  * dst[i] = 0;
367  * for (j = 0; j < filterSize; j++)
368  * dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
369  * dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
370  * }
371  * @endcode
372  */
373  //@{
374  int16_t *hLumFilter; ///< Array of horizontal filter coefficients for luma/alpha planes.
375  int16_t *hChrFilter; ///< Array of horizontal filter coefficients for chroma planes.
376  int16_t *vLumFilter; ///< Array of vertical filter coefficients for luma/alpha planes.
377  int16_t *vChrFilter; ///< Array of vertical filter coefficients for chroma planes.
378  int32_t *hLumFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
379  int32_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
380  int32_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
381  int32_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
382  int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
383  int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
384  int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
385  int vChrFilterSize; ///< Vertical filter size for chroma pixels.
386  //@}
387 
388  int lumMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
389  int chrMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
390  uint8_t *lumMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
391  uint8_t *chrMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
392 
395 
396  int dstY; ///< Last destination vertical line output from last slice.
397  int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
398  void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
399  // alignment ensures the offset can be added in a single
400  // instruction on e.g. ARM
405  DECLARE_ALIGNED(16, int32_t, input_rgb2yuv_table)[16+40*4]; // This table can contain both C and SIMD formatted values, the C vales are always at the XY_IDX points
406 #define RY_IDX 0
407 #define GY_IDX 1
408 #define BY_IDX 2
409 #define RU_IDX 3
410 #define GU_IDX 4
411 #define BU_IDX 5
412 #define RV_IDX 6
413 #define GV_IDX 7
414 #define BV_IDX 8
415 #define RGB2YUV_SHIFT 15
416 
417  int *dither_error[4];
418 
419  //Colorspace stuff
420  int contrast, brightness, saturation; // for sws_getColorspaceDetails
423  int srcRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (source image).
424  int dstRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
427  int srcXYZ;
428  int dstXYZ;
439 
440 #define RED_DITHER "0*8"
441 #define GREEN_DITHER "1*8"
442 #define BLUE_DITHER "2*8"
443 #define Y_COEFF "3*8"
444 #define VR_COEFF "4*8"
445 #define UB_COEFF "5*8"
446 #define VG_COEFF "6*8"
447 #define UG_COEFF "7*8"
448 #define Y_OFFSET "8*8"
449 #define U_OFFSET "9*8"
450 #define V_OFFSET "10*8"
451 #define LUM_MMX_FILTER_OFFSET "11*8"
452 #define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
453 #define DSTW_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
454 #define ESP_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
455 #define VROUNDER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
456 #define U_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
457 #define V_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
458 #define Y_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
459 #define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
460 #define UV_OFF_PX "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
461 #define UV_OFF_BYTE "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
462 #define DITHER16 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
463 #define DITHER32 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
464 #define DITHER32_INT (11*8+4*4*MAX_FILTER_SIZE*3+80) // value equal to above, used for checking that the struct hasn't been changed by mistake
465 
466  DECLARE_ALIGNED(8, uint64_t, redDither);
469 
470  DECLARE_ALIGNED(8, uint64_t, yCoeff);
471  DECLARE_ALIGNED(8, uint64_t, vrCoeff);
472  DECLARE_ALIGNED(8, uint64_t, ubCoeff);
473  DECLARE_ALIGNED(8, uint64_t, vgCoeff);
474  DECLARE_ALIGNED(8, uint64_t, ugCoeff);
475  DECLARE_ALIGNED(8, uint64_t, yOffset);
476  DECLARE_ALIGNED(8, uint64_t, uOffset);
477  DECLARE_ALIGNED(8, uint64_t, vOffset);
480  int dstW; ///< Width of destination luma/alpha planes.
481  DECLARE_ALIGNED(8, uint64_t, esp);
482  DECLARE_ALIGNED(8, uint64_t, vRounder);
483  DECLARE_ALIGNED(8, uint64_t, u_temp);
484  DECLARE_ALIGNED(8, uint64_t, v_temp);
485  DECLARE_ALIGNED(8, uint64_t, y_temp);
487  // alignment of these values is not necessary, but merely here
488  // to maintain the same offset across x8632 and x86-64. Once we
489  // use proper offset macros in the asm, they can be removed.
490  DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
491  DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
492  DECLARE_ALIGNED(8, uint16_t, dither16)[8];
493  DECLARE_ALIGNED(8, uint32_t, dither32)[8];
494 
496 
497 #if HAVE_ALTIVEC
498  vector signed short CY;
499  vector signed short CRV;
500  vector signed short CBU;
501  vector signed short CGU;
502  vector signed short CGV;
503  vector signed short OY;
504  vector unsigned short CSHIFT;
505  vector signed short *vYCoeffsBank, *vCCoeffsBank;
506 #endif
507 
509 
510 /* pre defined color-spaces gamma */
511 #define XYZ_GAMMA (2.6f)
512 #define RGB_GAMMA (2.2f)
513  int16_t *xyzgamma;
514  int16_t *rgbgamma;
515  int16_t *xyzgammainv;
516  int16_t *rgbgammainv;
517  int16_t xyz2rgb_matrix[3][4];
518  int16_t rgb2xyz_matrix[3][4];
519 
520  /* function pointers for swscale() */
528 
529  /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
530  void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
531  int width, uint32_t *pal);
532  /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
533  void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
534  int width, uint32_t *pal);
535  /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
536  void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
537  const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
538  int width, uint32_t *pal);
539 
540  /**
541  * Functions to read planar input, such as planar RGB, and convert
542  * internally to Y/UV/A.
543  */
544  /** @{ */
545  void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
546  void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
547  int width, int32_t *rgb2yuv);
548  void (*readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
549  /** @} */
550 
551  /**
552  * Scale one horizontal line of input data using a bilinear filter
553  * to produce one line of output data. Compared to SwsContext->hScale(),
554  * please take note of the following caveats when using these:
555  * - Scaling is done using only 7 bits instead of 14-bit coefficients.
556  * - You can use no more than 5 input pixels to produce 4 output
557  * pixels. Therefore, this filter should not be used for downscaling
558  * by more than ~20% in width (because that equals more than 5/4th
559  * downscaling and thus more than 5 pixels input per 4 pixels output).
560  * - In general, bilinear filters create artifacts during downscaling
561  * (even when <20%), because one output pixel will span more than one
562  * input pixel, and thus some pixels will need edges of both neighbor
563  * pixels to interpolate the output pixel. Since you can use at most
564  * two input pixels per output pixel in bilinear scaling, this is
565  * impossible and thus downscaling by any size will create artifacts.
566  * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
567  * in SwsContext->flags.
568  */
569  /** @{ */
570  void (*hyscale_fast)(struct SwsContext *c,
571  int16_t *dst, int dstWidth,
572  const uint8_t *src, int srcW, int xInc);
573  void (*hcscale_fast)(struct SwsContext *c,
574  int16_t *dst1, int16_t *dst2, int dstWidth,
575  const uint8_t *src1, const uint8_t *src2,
576  int srcW, int xInc);
577  /** @} */
578 
579  /**
580  * Scale one horizontal line of input data using a filter over the input
581  * lines, to produce one (differently sized) line of output data.
582  *
583  * @param dst pointer to destination buffer for horizontally scaled
584  * data. If the number of bits per component of one
585  * destination pixel (SwsContext->dstBpc) is <= 10, data
586  * will be 15 bpc in 16 bits (int16_t) width. Else (i.e.
587  * SwsContext->dstBpc == 16), data will be 19bpc in
588  * 32 bits (int32_t) width.
589  * @param dstW width of destination image
590  * @param src pointer to source data to be scaled. If the number of
591  * bits per component of a source pixel (SwsContext->srcBpc)
592  * is 8, this is 8bpc in 8 bits (uint8_t) width. Else
593  * (i.e. SwsContext->dstBpc > 8), this is native depth
594  * in 16 bits (uint16_t) width. In other words, for 9-bit
595  * YUV input, this is 9bpc, for 10-bit YUV input, this is
596  * 10bpc, and for 16-bit RGB or YUV, this is 16bpc.
597  * @param filter filter coefficients to be used per output pixel for
598  * scaling. This contains 14bpp filtering coefficients.
599  * Guaranteed to contain dstW * filterSize entries.
600  * @param filterPos position of the first input pixel to be used for
601  * each output pixel during scaling. Guaranteed to
602  * contain dstW entries.
603  * @param filterSize the number of input coefficients to be used (and
604  * thus the number of input pixels to be used) for
605  * creating a single output pixel. Is aligned to 4
606  * (and input coefficients thus padded with zeroes)
607  * to simplify creating SIMD code.
608  */
609  /** @{ */
610  void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
611  const uint8_t *src, const int16_t *filter,
612  const int32_t *filterPos, int filterSize);
613  void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
614  const uint8_t *src, const int16_t *filter,
615  const int32_t *filterPos, int filterSize);
616  /** @} */
617 
618  /// Color range conversion function for luma plane if needed.
619  void (*lumConvertRange)(int16_t *dst, int width);
620  /// Color range conversion function for chroma planes if needed.
621  void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
622 
623  int needs_hcscale; ///< Set if there are chroma planes to be converted.
624 
626 
628 } SwsContext;
629 //FIXME check init (where 0)
630 
632 int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
633  int fullRange, int brightness,
634  int contrast, int saturation);
635 void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4],
636  int brightness, int contrast, int saturation);
637 
639  int lastInLumBuf, int lastInChrBuf);
640 
642 
645 
647 {
649  av_assert0(desc);
650  return desc->comp[0].depth == 16;
651 }
652 
654 {
656  av_assert0(desc);
657  return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
658 }
659 
661 {
663  av_assert0(desc);
664  return desc->flags & AV_PIX_FMT_FLAG_BE;
665 }
666 
668 {
670  av_assert0(desc);
671  return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
672 }
673 
675 {
677  av_assert0(desc);
678  return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
679 }
680 
681 /*
682  * Identity semi-planar YUV formats. Specifically, those are YUV formats
683  * where the second and third components (U & V) are on the same plane.
684  */
686 {
688  av_assert0(desc);
689  return (isPlanarYUV(pix_fmt) && desc->comp[1].plane == desc->comp[2].plane);
690 }
691 
693 {
695  av_assert0(desc);
696  return (desc->flags & AV_PIX_FMT_FLAG_RGB);
697 }
698 
700 {
702  av_assert0(desc);
703  return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
704  !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
705  desc->nb_components <= 2 &&
708 }
709 
711 {
712  return pix_fmt == AV_PIX_FMT_RGB48BE ||
730 }
731 
733 {
734  return pix_fmt == AV_PIX_FMT_BGR48BE ||
752 }
753 
755 {
757  av_assert0(desc);
758  return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
759 }
760 
762 {
764  av_assert0(desc);
765  return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
767 }
768 
770 {
772  av_assert0(desc);
773  return desc->flags & AV_PIX_FMT_FLAG_FLOAT;
774 }
775 
777 {
779  av_assert0(desc);
780  if (pix_fmt == AV_PIX_FMT_PAL8)
781  return 1;
782  return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
783 }
784 
786 {
788  av_assert0(desc);
789  return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
792 }
793 
795 {
797  av_assert0(desc);
798  return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
799 }
800 
802 {
804  av_assert0(desc);
806 }
807 
809 {
811  av_assert0(desc);
812  return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
814 }
815 
817 {
818  switch (pix_fmt) {
819  case AV_PIX_FMT_PAL8:
821  case AV_PIX_FMT_BGR8:
822  case AV_PIX_FMT_GRAY8:
824  case AV_PIX_FMT_RGB8:
825  return 1;
826  default:
827  return 0;
828  }
829 }
830 
831 extern const uint64_t ff_dither4[2];
832 extern const uint64_t ff_dither8[2];
833 
834 extern const uint8_t ff_dither_2x2_4[3][8];
835 extern const uint8_t ff_dither_2x2_8[3][8];
836 extern const uint8_t ff_dither_4x4_16[5][8];
837 extern const uint8_t ff_dither_8x8_32[9][8];
838 extern const uint8_t ff_dither_8x8_73[9][8];
839 extern const uint8_t ff_dither_8x8_128[9][8];
840 extern const uint8_t ff_dither_8x8_220[9][8];
841 
842 extern const int32_t ff_yuv2rgb_coeffs[11][4];
843 
844 extern const AVClass ff_sws_context_class;
845 
846 /**
847  * Set c->swscale to an unscaled converter if one exists for the specific
848  * source and destination formats, bit depths, flags, etc.
849  */
854 
855 /**
856  * Return function pointer to fastest main scaler path function depending
857  * on architecture and available optimizations.
858  */
860 
875 
876 void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
877  const uint8_t *src, int srcW, int xInc);
878 void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
879  int dstWidth, const uint8_t *src1,
880  const uint8_t *src2, int srcW, int xInc);
881 int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
882  int16_t *filter, int32_t *filterPos,
883  int numSplits);
884 void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
885  int dstWidth, const uint8_t *src,
886  int srcW, int xInc);
887 void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
888  int dstWidth, const uint8_t *src1,
889  const uint8_t *src2, int srcW, int xInc);
890 
891 /**
892  * Allocate and return an SwsContext.
893  * This is like sws_getContext() but does not perform the init step, allowing
894  * the user to set additional AVOptions.
895  *
896  * @see sws_getContext()
897  */
899  int dstW, int dstH, enum AVPixelFormat dstFormat,
900  int flags, const double *param);
901 
903  int srcStride[], int srcSliceY, int srcSliceH,
904  uint8_t *dst[], int dstStride[]);
905 
906 static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
907  int alpha, int bits, const int big_endian)
908 {
909  int i, j;
910  uint8_t *ptr = plane + stride * y;
911  int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
912  for (i = 0; i < height; i++) {
913 #define FILL(wfunc) \
914  for (j = 0; j < width; j++) {\
915  wfunc(ptr+2*j, v);\
916  }
917  if (big_endian) {
918  FILL(AV_WB16);
919  } else {
920  FILL(AV_WL16);
921  }
922  ptr += stride;
923  }
924 }
925 
926 #define MAX_SLICE_PLANES 4
927 
928 /// Slice plane
929 typedef struct SwsPlane
930 {
931  int available_lines; ///< max number of lines that can be hold by this plane
932  int sliceY; ///< index of first line
933  int sliceH; ///< number of lines
934  uint8_t **line; ///< line buffer
935  uint8_t **tmp; ///< Tmp line buffer used by mmx code
936 } SwsPlane;
937 
938 /**
939  * Struct which defines a slice of an image to be scaled or an output for
940  * a scaled slice.
941  * A slice can also be used as intermediate ring buffer for scaling steps.
942  */
943 typedef struct SwsSlice
944 {
945  int width; ///< Slice line width
946  int h_chr_sub_sample; ///< horizontal chroma subsampling factor
947  int v_chr_sub_sample; ///< vertical chroma subsampling factor
948  int is_ring; ///< flag to identify if this slice is a ring buffer
949  int should_free_lines; ///< flag to identify if there are dynamic allocated lines
950  enum AVPixelFormat fmt; ///< planes pixel format
951  SwsPlane plane[MAX_SLICE_PLANES]; ///< color planes
952 } SwsSlice;
953 
954 /**
955  * Struct which holds all necessary data for processing a slice.
956  * A processing step can be a color conversion or horizontal/vertical scaling.
957  */
958 typedef struct SwsFilterDescriptor
959 {
960  SwsSlice *src; ///< Source slice
961  SwsSlice *dst; ///< Output slice
962 
963  int alpha; ///< Flag for processing alpha channel
964  void *instance; ///< Filter instance data
965 
966  /// Function for processing input slice sliceH lines starting from line sliceY
967  int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
969 
970 // warp input lines in the form (src + width*i + j) to slice format (line[i][j])
971 // relative=true means first line src[x][0] otherwise first line is src[x][lum/crh Y]
972 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);
973 
974 // Initialize scaler filter descriptor chain
976 
977 // Free all filter data
979 
980 /*
981  function for applying ring buffer logic into slice s
982  It checks if the slice can hold more @lum lines, if yes
983  do nothing otherwise remove @lum least used lines.
984  It applies the same procedure for @chr lines.
985 */
986 int ff_rotate_slice(SwsSlice *s, int lum, int chr);
987 
988 /// initializes gamma conversion descriptor
990 
991 /// initializes lum pixel format conversion descriptor
993 
994 /// initializes lum horizontal scaling descriptor
995 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
996 
997 /// initializes chr pixel format conversion descriptor
999 
1000 /// initializes chr horizontal scaling descriptor
1001 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
1002 
1004 
1005 /// initializes vertical scaling descriptors
1007 
1008 /// setup vertical scaler functions
1010  yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
1011  yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);
1012 
1013 //number of extra lines to process
1014 #define MAX_LINES_AHEAD 4
1015 
1016 #endif /* SWSCALE_SWSCALE_INTERNAL_H */
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:754
ff_sws_init_swscale_ppc
void ff_sws_init_swscale_ppc(SwsContext *c)
Definition: swscale_altivec.c:238
SwsContext::is_internal_gamma
int is_internal_gamma
Definition: swscale_internal.h:326
SwsContext::lastInChrBuf
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
Definition: swscale_internal.h:352
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
SwsContext::flags
int flags
Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc....
Definition: swscale_internal.h:397
SwsContext::vLumFilterSize
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
Definition: swscale_internal.h:384
SwsContext::saturation
int saturation
Definition: swscale_internal.h:420
stride
int stride
Definition: mace.c:144
SwsContext::vOffset
uint64_t vOffset
Definition: swscale_internal.h:477
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
SwsContext::chrToYV12
void(* chrToYV12)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal)
Unscaled conversion of chroma planes to YV12 for horizontal scaler.
Definition: swscale_internal.h:536
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
Definition: yuv2rgb.c:774
SwsFilterDescriptor::process
int(* process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH)
Function for processing input slice sliceH lines starting from line sliceY.
Definition: swscale_internal.h:967
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
ff_dither_8x8_128
const uint8_t ff_dither_8x8_128[9][8]
Definition: swscale.c:39
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:149
SwsContext::chrSrcW
int chrSrcW
Width of source chroma planes.
Definition: swscale_internal.h:294
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:808
SwsPlane::sliceH
int sliceH
number of lines
Definition: swscale_internal.h:933
isRGB
static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:692
isPacked
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:785
SwsPlane::line
uint8_t ** line
line buffer
Definition: swscale_internal.h:934
SWS_ALPHA_BLEND_NONE
@ SWS_ALPHA_BLEND_NONE
Definition: swscale_internal.h:76
SwsContext::formatConvBuffer
uint8_t * formatConvBuffer
Definition: swscale_internal.h:357
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:207
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:480
ff_dither_8x8_220
const uint8_t ff_dither_8x8_220[9][8]
Definition: output.c:84
rgb2yuv
static void fn() rgb2yuv(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], int16_t *rgb[3], ptrdiff_t s, int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], const int16_t yuv_offset[8])
Definition: colorspacedsp_template.c:130
ff_sws_init_swscale_vsx
void ff_sws_init_swscale_vsx(SwsContext *c)
Definition: swscale_vsx.c:2072
SwsContext::dstFormatBpp
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
Definition: swscale_internal.h:302
SwsContext::cascaded1_tmp
uint8_t * cascaded1_tmp[4]
Definition: swscale_internal.h:321
SwsContext::rgbgamma
int16_t * rgbgamma
Definition: swscale_internal.h:514
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale_internal.h:68
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:362
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:139
isPlanarYUV
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:674
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
SwsContext::dstY
int dstY
Last destination vertical line output from last slice.
Definition: swscale_internal.h:396
ff_sws_init_swscale_x86
void ff_sws_init_swscale_x86(SwsContext *c)
Definition: swscale.c:384
sws_alloc_set_opts
struct SwsContext * sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:1866
SwsContext::cascaded_mainindex
int cascaded_mainindex
Definition: swscale_internal.h:322
SwsContext::alphablend
SwsAlphaBlend alphablend
Definition: swscale_internal.h:627
SwsContext::chrDither8
const uint8_t * chrDither8
Definition: swscale_internal.h:495
SwsContext::cascaded1_tmpStride
int cascaded1_tmpStride[4]
Definition: swscale_internal.h:320
SwsContext::yOffset
uint64_t yOffset
Definition: swscale_internal.h:475
SwsContext::vrCoeff
uint64_t vrCoeff
Definition: swscale_internal.h:471
SwsContext::hChrFilterPos
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
Definition: swscale_internal.h:379
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:951
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale_internal.h:70
pixdesc.h
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
SwsContext::ubCoeff
uint64_t ubCoeff
Definition: swscale_internal.h:472
SwsContext::dstColorspaceTable
int dstColorspaceTable[4]
Definition: swscale_internal.h:422
isGray
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:699
ff_rotate_slice
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
Definition: slice.c:119
SwsContext::vChrFilter
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
Definition: swscale_internal.h:377
SwsContext::lumMmxFilter
int32_t lumMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:478
SWS_ALPHA_BLEND_NB
@ SWS_ALPHA_BLEND_NB
Definition: swscale_internal.h:79
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: alphablend.c:23
SwsContext::chrDstVSubSample
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
Definition: swscale_internal.h:308
ff_sws_init_input_funcs
void ff_sws_init_input_funcs(SwsContext *c)
SwsContext::vLumFilter
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
Definition: swscale_internal.h:376
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
SwsFilterDescriptor
Struct which holds all necessary data for processing a slice.
Definition: swscale_internal.h:958
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
table
static const uint16_t table[]
Definition: prosumer.c:206
SwsContext::av_class
const AVClass * av_class
info on struct for av_log
Definition: swscale_internal.h:284
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
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:361
SwsContext::yuv2planeX
yuv2planarX_fn yuv2planeX
Definition: swscale_internal.h:522
SwsContext::redDither
uint64_t redDither
Definition: swscale_internal.h:466
SwsContext::yuv2plane1
yuv2planar1_fn yuv2plane1
Definition: swscale_internal.h:521
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
SwsContext::srcRange
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
Definition: swscale_internal.h:423
CY
@ CY
Definition: vf_vpp_qsv.c:137
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
SwsContext::lumDither8
const uint8_t * lumDither8
Definition: swscale_internal.h:495
ff_get_unscaled_swscale_aarch64
void ff_get_unscaled_swscale_aarch64(SwsContext *c)
Definition: swscale_unscaled.c:127
SwsContext::needAlpha
int needAlpha
Definition: swscale_internal.h:358
SwsContext::xyzgamma
int16_t * xyzgamma
Definition: swscale_internal.h:513
SwsContext::pal_rgb
uint32_t pal_rgb[256]
Definition: swscale_internal.h:337
SwsContext::yuv2anyX
yuv2anyX_fn yuv2anyX
Definition: swscale_internal.h:527
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
SwsContext::cascaded_tmp
uint8_t * cascaded_tmp[4]
Definition: swscale_internal.h:319
SwsSlice::fmt
enum AVPixelFormat fmt
planes pixel format
Definition: swscale_internal.h:950
SwsFilterDescriptor::src
SwsSlice * src
Source slice.
Definition: swscale_internal.h:960
SwsContext::src0Alpha
int src0Alpha
Definition: swscale_internal.h:425
SwsContext::yuv2nv12cX
yuv2interleavedX_fn yuv2nv12cX
Definition: swscale_internal.h:523
SwsDither
SwsDither
Definition: swscale_internal.h:65
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:646
SwsFilterDescriptor::instance
void * instance
Filter instance data.
Definition: swscale_internal.h:964
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
SwsContext::yuvTable
void * yuvTable
Definition: swscale_internal.h:398
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
SwsContext::use_mmx_vfilter
int use_mmx_vfilter
Definition: swscale_internal.h:508
SwsContext::readLumPlanar
void(* readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
Functions to read planar input, such as planar RGB, and convert internally to Y/UV/A.
Definition: swscale_internal.h:545
SwsContext::hcscale_fast
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)
Definition: swscale_internal.h:573
SwsContext::rgbgammainv
int16_t * rgbgammainv
Definition: swscale_internal.h:516
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:431
SwsContext::xyz2rgb_matrix
int16_t xyz2rgb_matrix[3][4]
Definition: swscale_internal.h:517
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
plane
int plane
Definition: avisynth_c.h:384
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_dither_2x2_8
const uint8_t ff_dither_2x2_8[3][8]
Definition: output.c:45
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
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:653
SwsContext::hLumFilterSize
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
Definition: swscale_internal.h:382
SwsContext::srcBpc
int srcBpc
Definition: swscale_internal.h:304
SwsSlice::h_chr_sub_sample
int h_chr_sub_sample
horizontal chroma subsampling factor
Definition: swscale_internal.h:946
SwsContext::gamma_value
double gamma_value
Definition: swscale_internal.h:324
SwsContext::dstXYZ
int dstXYZ
Definition: swscale_internal.h:428
src
#define src
Definition: vp8dsp.c:254
SwsContext::lumYInc
int lumYInc
Definition: swscale_internal.h:299
ff_dither4
const uint64_t ff_dither4[2]
ff_dither_8x8_73
const uint8_t ff_dither_8x8_73[9][8]
Definition: output.c:71
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:540
SwsContext::dither_error
int * dither_error[4]
Definition: swscale_internal.h:417
MAX_FILTER_SIZE
#define MAX_FILTER_SIZE
Definition: swscale_internal.h:41
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
ff_hcscale_fast_mmxext
void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
SwsContext::table_gV
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:401
SwsContext::srcFormat
enum AVPixelFormat srcFormat
Source pixel format.
Definition: swscale_internal.h:301
av_cold
#define av_cold
Definition: attributes.h:84
SwsContext::uv_off
ptrdiff_t uv_off
offset (in pixels) between u and v planes
Definition: swscale_internal.h:490
SwsContext::chrSrcH
int chrSrcH
Height of source chroma planes.
Definition: swscale_internal.h:295
SwsContext::table_bU
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:404
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition: swscale_internal.h:38
ff_get_unscaled_swscale_arm
void ff_get_unscaled_swscale_arm(SwsContext *c)
Definition: swscale_unscaled.c:183
SwsContext::lumMmxextFilterCodeSize
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
Definition: swscale_internal.h:388
SwsContext::dither
SwsDither dither
Definition: swscale_internal.h:625
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:69
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
SwsContext::ugCoeff
uint64_t ugCoeff
Definition: swscale_internal.h:474
SwsContext::brightness
int brightness
Definition: swscale_internal.h:420
ff_dither_8x8_32
const uint8_t ff_dither_8x8_32[9][8]
Definition: output.c:59
CSHIFT
#define CSHIFT
Definition: audiogen.c:72
SwsSlice::width
int width
Slice line width.
Definition: swscale_internal.h:945
SwsContext::lumConvertRange
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
Definition: swscale_internal.h:619
bits
uint8_t bits
Definition: vp3data.h:202
ff_yuv2rgb_init_x86
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
Definition: yuv2rgb.c:72
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SwsPlane::tmp
uint8_t ** tmp
Tmp line buffer used by mmx code.
Definition: swscale_internal.h:935
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:177
ff_sws_context_class
const AVClass ff_sws_context_class
Definition: options.c:87
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:87
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
SwsContext::hcScale
void(* hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale_internal.h:613
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:250
SwsContext::contrast
int contrast
Definition: swscale_internal.h:420
SwsContext::lumXInc
int lumXInc
Definition: swscale_internal.h:298
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:363
SwsContext::vLumFilterPos
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
Definition: swscale_internal.h:380
SwsContext::vRounder
uint64_t vRounder
Definition: swscale_internal.h:482
SwsContext::dstFormat
enum AVPixelFormat dstFormat
Destination pixel format.
Definition: swscale_internal.h:300
int32_t
int32_t
Definition: audio_convert.c:194
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
SwsContext::yuv2rgb_y_offset
int yuv2rgb_y_offset
Definition: swscale_internal.h:433
isSemiPlanarYUV
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:685
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
SwsContext::yuv2packed2
yuv2packed2_fn yuv2packed2
Definition: swscale_internal.h:525
SwsContext::readChrPlanar
void(* readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
Definition: swscale_internal.h:546
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale_internal.h:66
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsContext *c)
Set c->swscale to an unscaled converter if one exists for the specific source and destination formats...
Definition: swscale_unscaled.c:1899
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_sws_init_swscale_aarch64
void ff_sws_init_swscale_aarch64(SwsContext *c)
Definition: swscale.c:32
SwsContext::xyzgammainv
int16_t * xyzgammainv
Definition: swscale_internal.h:515
SwsPlane::available_lines
int available_lines
max number of lines that can be hold by this plane
Definition: swscale_internal.h:931
SWS_ALPHA_BLEND_UNIFORM
@ SWS_ALPHA_BLEND_UNIFORM
Definition: swscale_internal.h:77
SwsContext::yuv2rgb_v2g_coeff
int yuv2rgb_v2g_coeff
Definition: swscale_internal.h:436
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
SwsContext::gamma_flag
int gamma_flag
Definition: swscale_internal.h:325
SwsContext::dstBpc
int dstBpc
Definition: swscale_internal.h:304
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
SwsContext::lumMmxextFilterCode
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
Definition: swscale_internal.h:390
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
NB_SWS_DITHER
@ NB_SWS_DITHER
Definition: swscale_internal.h:72
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:206
SwsPlane
Slice plane.
Definition: swscale_internal.h:929
SwsContext::greenDither
uint64_t greenDither
Definition: swscale_internal.h:467
SwsContext::blueDither
uint64_t blueDither
Definition: swscale_internal.h:468
ff_init_desc_hscale
int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)
initializes lum horizontal scaling descriptor
Definition: hscale.c:144
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
SwsContext::rgb2xyz_matrix
int16_t rgb2xyz_matrix[3][4]
Definition: swscale_internal.h:518
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:84
SwsContext::alpMmxFilter
int32_t alpMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:486
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
SwsContext::yuv2rgb_v2r_coeff
int yuv2rgb_v2r_coeff
Definition: swscale_internal.h:435
ff_init_desc_no_chr
int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
Definition: hscale.c:281
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Definition: swscale_internal.h:430
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
SwsContext::vChrFilterPos
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
Definition: swscale_internal.h:381
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:660
SwsContext::sliceDir
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
Definition: swscale_internal.h:310
desc
const char * desc
Definition: nvenc.c:68
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
SwsContext::chrSrcVSubSample
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
Definition: swscale_internal.h:306
ff_getSwsFunc
SwsFunc ff_getSwsFunc(SwsContext *c)
Return function pointer to fastest main scaler path function depending on architecture and available ...
Definition: swscale.c:598
SwsContext::yuv2rgb_u2g_coeff
int yuv2rgb_u2g_coeff
Definition: swscale_internal.h:437
SwsContext::hLumFilterPos
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
Definition: swscale_internal.h:378
SwsFilterDescriptor::dst
SwsSlice * dst
Output slice.
Definition: swscale_internal.h:961
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
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:906
usePal
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:816
SwsContext::v_temp
uint64_t v_temp
Definition: swscale_internal.h:484
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:761
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:140
SwsContext::srcFormatBpp
int srcFormatBpp
Number of bits per pixel of the source pixel format.
Definition: swscale_internal.h:303
SwsContext::srcColorspaceTable
int srcColorspaceTable[4]
Definition: swscale_internal.h:421
SwsContext::desc
struct SwsFilterDescriptor * desc
Definition: swscale_internal.h:334
SwsContext::srcH
int srcH
Height of source luma/alpha planes.
Definition: swscale_internal.h:292
ff_init_desc_chscale
int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)
initializes chr horizontal scaling descriptor
Definition: hscale.c:250
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:667
ff_init_desc_cfmt_convert
int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes chr pixel format conversion descriptor
Definition: hscale.c:235
SwsAlphaBlend
SwsAlphaBlend
Definition: swscale_internal.h:75
SwsContext::hyScale
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...
Definition: swscale_internal.h:610
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:142
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:679
SwsContext::uOffset
uint64_t uOffset
Definition: swscale_internal.h:476
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
SwsContext::dither32
uint32_t dither32[8]
Definition: swscale_internal.h:493
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:360
isBGRinInt
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:732
ff_yuv2rgb_init_ppc
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)
Definition: yuv2rgb_altivec.c:540
SwsContext::chrMmxextFilterCodeSize
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
Definition: swscale_internal.h:389
SwsContext::hLumFilter
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
Definition: swscale_internal.h:374
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
SwsContext::yuv2packedX
yuv2packedX_fn yuv2packedX
Definition: swscale_internal.h:526
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
SwsContext::vChrFilterSize
int vChrFilterSize
Vertical filter size for chroma pixels.
Definition: swscale_internal.h:385
SwsContext::y_temp
uint64_t y_temp
Definition: swscale_internal.h:485
AV_PIX_FMT_FLAG_BAYER
#define AV_PIX_FMT_FLAG_BAYER
The pixel format is following a Bayer pattern.
Definition: pixdesc.h:182
ff_init_gamma_convert
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice *src, uint16_t *table)
initializes gamma conversion descriptor
Definition: gamma.c:58
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:208
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
src1
#define src1
Definition: h264pred.c:139
SwsContext::srcW
int srcW
Width of source luma/alpha planes.
Definition: swscale_internal.h:291
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
SwsContext::yuv2rgb_u2b_coeff
int yuv2rgb_u2b_coeff
Definition: swscale_internal.h:438
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
ff_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:49
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
SwsContext::dither16
uint16_t dither16[8]
Definition: swscale_internal.h:492
SwsContext::dstRange
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
Definition: swscale_internal.h:424
SwsContext::numSlice
int numSlice
Definition: swscale_internal.h:332
common.h
SwsSlice::should_free_lines
int should_free_lines
flag to identify if there are dynamic allocated lines
Definition: swscale_internal.h:949
av_always_inline
#define av_always_inline
Definition: attributes.h:43
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
SwsSlice::is_ring
int is_ring
flag to identify if this slice is a ring buffer
Definition: swscale_internal.h:948
uint8_t
uint8_t
Definition: audio_convert.c:194
SwsContext::readAlpPlanar
void(* readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
Definition: swscale_internal.h:548
SwsContext::alpToYV12
void(* alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal)
Unscaled conversion of alpha plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:533
SwsContext::hChrFilter
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
Definition: swscale_internal.h:375
SwsSlice::v_chr_sub_sample
int v_chr_sub_sample
vertical chroma subsampling factor
Definition: swscale_internal.h:947
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:943
ff_init_filters
int ff_init_filters(SwsContext *c)
Definition: slice.c:249
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:769
SwsContext::chrYInc
int chrYInc
Definition: swscale_internal.h:299
SwsContext::slice
struct SwsSlice * slice
Definition: swscale_internal.h:333
version.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
SwsContext::lumBufIndex
int lumBufIndex
Index in ring buffer of the last scaled horizontal luma/alpha line from source.
Definition: swscale_internal.h:353
SwsFilterDescriptor::alpha
int alpha
Flag for processing alpha channel.
Definition: swscale_internal.h:963
SwsContext::srcXYZ
int srcXYZ
Definition: swscale_internal.h:427
pixfmt.h
ff_dither8
const uint64_t ff_dither8[2]
SwsContext::yuv2rgb_y_coeff
int yuv2rgb_y_coeff
Definition: swscale_internal.h:434
SWS_ALPHA_BLEND_CHECKERBOARD
@ SWS_ALPHA_BLEND_CHECKERBOARD
Definition: swscale_internal.h:78
SwsContext::numDesc
int numDesc
Definition: swscale_internal.h:330
SwsContext::table_rV
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:402
SwsContext::chrDstH
int chrDstH
Height of destination chroma planes.
Definition: swscale_internal.h:297
ff_free_filters
int ff_free_filters(SwsContext *c)
Definition: slice.c:380
ff_get_unscaled_swscale_ppc
void ff_get_unscaled_swscale_ppc(SwsContext *c)
Definition: yuv2yuv_altivec.c:187
SwsContext::input_rgb2yuv_table
int32_t input_rgb2yuv_table[16+40 *4]
Definition: swscale_internal.h:405
SwsContext::chrBufIndex
int chrBufIndex
Index in ring buffer of the last scaled horizontal chroma line from source.
Definition: swscale_internal.h:354
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
ff_sws_init_output_funcs
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:2454
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
SwsContext::inv_gamma
uint16_t * inv_gamma
Definition: swscale_internal.h:328
MAX_SLICE_PLANES
#define MAX_SLICE_PLANES
Definition: swscale_internal.h:926
isPackedRGB
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:801
SwsContext::cascaded_tmpStride
int cascaded_tmpStride[4]
Definition: swscale_internal.h:318
SwsContext::table_gU
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:403
config.h
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
SwsContext::chrXInc
int chrXInc
Definition: swscale_internal.h:298
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
SwsContext::dst0Alpha
int dst0Alpha
Definition: swscale_internal.h:426
SwsContext::warned_unuseable_bilinear
int warned_unuseable_bilinear
Definition: swscale_internal.h:394
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
SwsContext::chrMmxFilter
int32_t chrMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:479
ff_hyscale_fast_mmxext
void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
SwsContext::yCoeff
uint64_t yCoeff
Definition: swscale_internal.h:470
SwsContext::lumToYV12
void(* lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal)
Unscaled conversion of luma plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:530
avutil.h
ff_init_vscale
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
Definition: vscale.c:206
SwsPlane::sliceY
int sliceY
index of first line
Definition: swscale_internal.h:932
SwsContext::hChrFilterSize
int hChrFilterSize
Horizontal filter size for chroma pixels.
Definition: swscale_internal.h:383
SwsContext::vChrDrop
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
Definition: swscale_internal.h:309
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_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:113
util_altivec.h
SwsContext::u_temp
uint64_t u_temp
Definition: swscale_internal.h:483
lum
static double lum(void *priv, double x, double y, int plane)
Definition: vf_fftfilt.c:95
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
SwsContext::pal_yuv
uint32_t pal_yuv[256]
Definition: swscale_internal.h:336
SwsContext::chrDstHSubSample
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
Definition: swscale_internal.h:307
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:67
isRGBinInt
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:710
SwsContext::chrDstW
int chrDstW
Width of destination chroma planes.
Definition: swscale_internal.h:296
SwsContext::vgCoeff
uint64_t vgCoeff
Definition: swscale_internal.h:473
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
SwsContext::src_h_chr_pos
int src_h_chr_pos
Definition: swscale_internal.h:429
SwsContext::yuv2packed1
yuv2packed1_fn yuv2packed1
Definition: swscale_internal.h:524
ff_init_desc_fmt_convert
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes lum pixel format conversion descriptor
Definition: hscale.c:127
SwsContext::gamma
uint16_t * gamma
Definition: swscale_internal.h:327
ff_sws_init_swscale_arm
void ff_sws_init_swscale_arm(SwsContext *c)
Definition: swscale.c:32
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:794
SwsContext::cascaded_context
struct SwsContext * cascaded_context[3]
Definition: swscale_internal.h:317
SwsContext::descIndex
int descIndex[2]
Definition: swscale_internal.h:331
SwsContext::swscale
SwsFunc swscale
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
Definition: swscale_internal.h:290
SwsContext::uint2float_lut
float uint2float_lut[256]
Definition: swscale_internal.h:339
FILL
#define FILL(wfunc)
SwsContext::chrConvertRange
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
Definition: swscale_internal.h:621
SwsContext::dst_v_chr_pos
int dst_v_chr_pos
Definition: swscale_internal.h:432
ff_yuv2rgb_init_tables_ppc
void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
Definition: yuv2rgb_altivec.c:603
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale_internal.h:71
int
int
Definition: ffmpeg_filter.c:191
SwsContext
Definition: swscale_internal.h:280
SwsContext::chrSrcHSubSample
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
Definition: swscale_internal.h:305
SwsContext::chrMmxextFilterCode
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
Definition: swscale_internal.h:391
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:141
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:293
SwsContext::esp
uint64_t esp
Definition: swscale_internal.h:481
SwsContext::canMMXEXTBeUsed
int canMMXEXTBeUsed
Definition: swscale_internal.h:393
SwsContext::hyscale_fast
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.
Definition: swscale_internal.h:570
ff_dither_4x4_16
const uint8_t ff_dither_4x4_16[5][8]
Definition: output.c:51
ff_updateMMXDitherTables
void ff_updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex, int lastInLumBuf, int lastInChrBuf)
ff_dither_2x2_4
const uint8_t ff_dither_2x2_4[3][8]
Definition: output.c:39
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:776
SwsContext::lastInLumBuf
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
Definition: swscale_internal.h:351
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:148
SwsContext::uv_offx2
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
Definition: swscale_internal.h:491
SwsContext::needs_hcscale
int needs_hcscale
Set if there are chroma planes to be converted.
Definition: swscale_internal.h:623
SwsContext::param
double param[2]
Input parameters for scaling algorithms that need them.
Definition: swscale_internal.h:311
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57