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 dstFormat destination pixel format
123  * @param chrDither ordered dither array of type uint8_t and size 8
124  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
125  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit
126  * output, 19 bits for 16-bit output (in int32_t)
127  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit
128  * output, 19 bits for 16-bit output (in int32_t)
129  * @param chrFilterSize number of vertical chroma input lines to scale
130  * @param dest pointer to the output plane. For >8-bit
131  * output, this is in uint16_t
132  * @param dstW width of chroma planes
133  */
135  const uint8_t *chrDither,
136  const int16_t *chrFilter,
137  int chrFilterSize,
138  const int16_t **chrUSrc,
139  const int16_t **chrVSrc,
140  uint8_t *dest, int dstW);
141 
142 /**
143  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
144  * output without any additional vertical scaling (or point-scaling). Note
145  * that this function may do chroma scaling, see the "uvalpha" argument.
146  *
147  * @param c SWS scaling context
148  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
149  * 19 bits for 16-bit output (in int32_t)
150  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
151  * 19 bits for 16-bit output (in int32_t)
152  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
153  * 19 bits for 16-bit output (in int32_t)
154  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
155  * 19 bits for 16-bit output (in int32_t)
156  * @param dest pointer to the output plane. For 16-bit output, this is
157  * uint16_t
158  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
159  * to write into dest[]
160  * @param uvalpha chroma scaling coefficient for the second line of chroma
161  * pixels, either 2048 or 0. If 0, one chroma input is used
162  * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
163  * is set, it generates 1 output pixel). If 2048, two chroma
164  * input pixels should be averaged for 2 output pixels (this
165  * only happens if SWS_FLAG_FULL_CHR_INT is not set)
166  * @param y vertical line number for this output. This does not need
167  * to be used to calculate the offset in the destination,
168  * but can be used to generate comfort noise using dithering
169  * for some output formats.
170  */
171 typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
172  const int16_t *chrUSrc[2],
173  const int16_t *chrVSrc[2],
174  const int16_t *alpSrc, uint8_t *dest,
175  int dstW, int uvalpha, int y);
176 /**
177  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
178  * output by doing bilinear scaling between two input lines.
179  *
180  * @param c SWS scaling context
181  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
182  * 19 bits for 16-bit output (in int32_t)
183  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
184  * 19 bits for 16-bit output (in int32_t)
185  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
186  * 19 bits for 16-bit output (in int32_t)
187  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
188  * 19 bits for 16-bit output (in int32_t)
189  * @param dest pointer to the output plane. For 16-bit output, this is
190  * uint16_t
191  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
192  * to write into dest[]
193  * @param yalpha luma/alpha scaling coefficients for the second input line.
194  * The first line's coefficients can be calculated by using
195  * 4096 - yalpha
196  * @param uvalpha chroma scaling coefficient for the second input line. The
197  * first line's coefficients can be calculated by using
198  * 4096 - uvalpha
199  * @param y vertical line number for this output. This does not need
200  * to be used to calculate the offset in the destination,
201  * but can be used to generate comfort noise using dithering
202  * for some output formats.
203  */
204 typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
205  const int16_t *chrUSrc[2],
206  const int16_t *chrVSrc[2],
207  const int16_t *alpSrc[2],
208  uint8_t *dest,
209  int dstW, int yalpha, int uvalpha, int y);
210 /**
211  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
212  * output by doing multi-point vertical scaling between input pixels.
213  *
214  * @param c SWS scaling context
215  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
216  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
217  * 19 bits for 16-bit output (in int32_t)
218  * @param lumFilterSize number of vertical luma/alpha input lines to scale
219  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
220  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
221  * 19 bits for 16-bit output (in int32_t)
222  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
223  * 19 bits for 16-bit output (in int32_t)
224  * @param chrFilterSize number of vertical chroma input lines to scale
225  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
226  * 19 bits for 16-bit output (in int32_t)
227  * @param dest pointer to the output plane. For 16-bit output, this is
228  * uint16_t
229  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
230  * to write into dest[]
231  * @param y vertical line number for this output. This does not need
232  * to be used to calculate the offset in the destination,
233  * but can be used to generate comfort noise using dithering
234  * or some output formats.
235  */
236 typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
237  const int16_t **lumSrc, int lumFilterSize,
238  const int16_t *chrFilter,
239  const int16_t **chrUSrc,
240  const int16_t **chrVSrc, int chrFilterSize,
241  const int16_t **alpSrc, uint8_t *dest,
242  int dstW, int y);
243 
244 /**
245  * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
246  * output by doing multi-point vertical scaling between input pixels.
247  *
248  * @param c SWS scaling context
249  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
250  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
251  * 19 bits for 16-bit output (in int32_t)
252  * @param lumFilterSize number of vertical luma/alpha input lines to scale
253  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
254  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
255  * 19 bits for 16-bit output (in int32_t)
256  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
257  * 19 bits for 16-bit output (in int32_t)
258  * @param chrFilterSize number of vertical chroma input lines to scale
259  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
260  * 19 bits for 16-bit output (in int32_t)
261  * @param dest pointer to the output planes. For 16-bit output, this is
262  * uint16_t
263  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
264  * to write into dest[]
265  * @param y vertical line number for this output. This does not need
266  * to be used to calculate the offset in the destination,
267  * but can be used to generate comfort noise using dithering
268  * or some output formats.
269  */
270 typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
271  const int16_t **lumSrc, int lumFilterSize,
272  const int16_t *chrFilter,
273  const int16_t **chrUSrc,
274  const int16_t **chrVSrc, int chrFilterSize,
275  const int16_t **alpSrc, uint8_t **dest,
276  int dstW, int y);
277 
278 struct SwsSlice;
279 struct SwsFilterDescriptor;
280 
281 /* This struct should be aligned on at least a 32-byte boundary. */
282 typedef struct SwsContext {
283  /**
284  * info on struct for av_log
285  */
287 
288  /**
289  * Note that src, dst, srcStride, dstStride will be copied in the
290  * sws_scale() wrapper so they can be freely modified here.
291  */
293  int srcW; ///< Width of source luma/alpha planes.
294  int srcH; ///< Height of source luma/alpha planes.
295  int dstH; ///< Height of destination luma/alpha planes.
296  int chrSrcW; ///< Width of source chroma planes.
297  int chrSrcH; ///< Height of source chroma planes.
298  int chrDstW; ///< Width of destination chroma planes.
299  int chrDstH; ///< Height of destination chroma planes.
302  enum AVPixelFormat dstFormat; ///< Destination pixel format.
303  enum AVPixelFormat srcFormat; ///< Source pixel format.
304  int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
305  int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
307  int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
308  int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
309  int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
310  int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
311  int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
312  int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
313  double param[2]; ///< Input parameters for scaling algorithms that need them.
314 
315  /* The cascaded_* fields allow spliting a scaler task into multiple
316  * sequential steps, this is for example used to limit the maximum
317  * downscaling factor that needs to be supported in one scaler.
318  */
325 
326  double gamma_value;
329  uint16_t *gamma;
330  uint16_t *inv_gamma;
331 
332  int numDesc;
333  int descIndex[2];
334  int numSlice;
335  struct SwsSlice *slice;
337 
338  uint32_t pal_yuv[256];
339  uint32_t pal_rgb[256];
340 
341  float uint2float_lut[256];
342 
343  /**
344  * @name Scaled horizontal lines ring buffer.
345  * The horizontal scaler keeps just enough scaled lines in a ring buffer
346  * so they may be passed to the vertical scaler. The pointers to the
347  * allocated buffers for each line are duplicated in sequence in the ring
348  * buffer to simplify indexing and avoid wrapping around between lines
349  * inside the vertical scaler code. The wrapping is done before the
350  * vertical scaler is called.
351  */
352  //@{
353  int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
354  int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
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.
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  /** @{ */
571  int16_t *dst, int dstWidth,
572  const uint8_t *src, int srcW, int xInc);
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 
641 
644 
646 {
647  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
648  av_assert0(desc);
649  return desc->comp[0].depth == 16;
650 }
651 
653 {
654  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
655  av_assert0(desc);
656  return desc->comp[0].depth == 32;
657 }
658 
660 {
661  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
662  av_assert0(desc);
663  return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
664 }
665 
667 {
668  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
669  av_assert0(desc);
670  return desc->flags & AV_PIX_FMT_FLAG_BE;
671 }
672 
674 {
675  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
676  av_assert0(desc);
677  return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
678 }
679 
681 {
682  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
683  av_assert0(desc);
684  return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
685 }
686 
687 /*
688  * Identity semi-planar YUV formats. Specifically, those are YUV formats
689  * where the second and third components (U & V) are on the same plane.
690  */
692 {
693  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
694  av_assert0(desc);
695  return (isPlanarYUV(pix_fmt) && desc->comp[1].plane == desc->comp[2].plane);
696 }
697 
699 {
700  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
701  av_assert0(desc);
702  return (desc->flags & AV_PIX_FMT_FLAG_RGB);
703 }
704 
706 {
707  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
708  av_assert0(desc);
709  return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
710  !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
711  desc->nb_components <= 2 &&
712  pix_fmt != AV_PIX_FMT_MONOBLACK &&
713  pix_fmt != AV_PIX_FMT_MONOWHITE;
714 }
715 
717 {
718  return pix_fmt == AV_PIX_FMT_RGB48BE ||
719  pix_fmt == AV_PIX_FMT_RGB48LE ||
720  pix_fmt == AV_PIX_FMT_RGB32 ||
721  pix_fmt == AV_PIX_FMT_RGB32_1 ||
722  pix_fmt == AV_PIX_FMT_RGB24 ||
723  pix_fmt == AV_PIX_FMT_RGB565BE ||
724  pix_fmt == AV_PIX_FMT_RGB565LE ||
725  pix_fmt == AV_PIX_FMT_RGB555BE ||
726  pix_fmt == AV_PIX_FMT_RGB555LE ||
727  pix_fmt == AV_PIX_FMT_RGB444BE ||
728  pix_fmt == AV_PIX_FMT_RGB444LE ||
729  pix_fmt == AV_PIX_FMT_RGB8 ||
730  pix_fmt == AV_PIX_FMT_RGB4 ||
731  pix_fmt == AV_PIX_FMT_RGB4_BYTE ||
732  pix_fmt == AV_PIX_FMT_RGBA64BE ||
733  pix_fmt == AV_PIX_FMT_RGBA64LE ||
734  pix_fmt == AV_PIX_FMT_MONOBLACK ||
735  pix_fmt == AV_PIX_FMT_MONOWHITE;
736 }
737 
739 {
740  return pix_fmt == AV_PIX_FMT_BGR48BE ||
741  pix_fmt == AV_PIX_FMT_BGR48LE ||
742  pix_fmt == AV_PIX_FMT_BGR32 ||
743  pix_fmt == AV_PIX_FMT_BGR32_1 ||
744  pix_fmt == AV_PIX_FMT_BGR24 ||
745  pix_fmt == AV_PIX_FMT_BGR565BE ||
746  pix_fmt == AV_PIX_FMT_BGR565LE ||
747  pix_fmt == AV_PIX_FMT_BGR555BE ||
748  pix_fmt == AV_PIX_FMT_BGR555LE ||
749  pix_fmt == AV_PIX_FMT_BGR444BE ||
750  pix_fmt == AV_PIX_FMT_BGR444LE ||
751  pix_fmt == AV_PIX_FMT_BGR8 ||
752  pix_fmt == AV_PIX_FMT_BGR4 ||
753  pix_fmt == AV_PIX_FMT_BGR4_BYTE ||
754  pix_fmt == AV_PIX_FMT_BGRA64BE ||
755  pix_fmt == AV_PIX_FMT_BGRA64LE ||
756  pix_fmt == AV_PIX_FMT_MONOBLACK ||
757  pix_fmt == AV_PIX_FMT_MONOWHITE;
758 }
759 
761 {
762  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
763  av_assert0(desc);
764  return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
765 }
766 
768 {
769  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
770  av_assert0(desc);
771  return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
772  pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
773 }
774 
776 {
777  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
778  av_assert0(desc);
779  return desc->flags & AV_PIX_FMT_FLAG_FLOAT;
780 }
781 
783 {
784  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
785  av_assert0(desc);
786  if (pix_fmt == AV_PIX_FMT_PAL8)
787  return 1;
788  return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
789 }
790 
792 {
793  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
794  av_assert0(desc);
795  return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
796  pix_fmt == AV_PIX_FMT_PAL8 ||
797  pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
798 }
799 
801 {
802  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
803  av_assert0(desc);
804  return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
805 }
806 
808 {
809  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
810  av_assert0(desc);
812 }
813 
815 {
816  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
817  av_assert0(desc);
818  return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
820 }
821 
823 {
824  switch (pix_fmt) {
825  case AV_PIX_FMT_PAL8:
827  case AV_PIX_FMT_BGR8:
828  case AV_PIX_FMT_GRAY8:
830  case AV_PIX_FMT_RGB8:
831  return 1;
832  default:
833  return 0;
834  }
835 }
836 
837 extern const uint64_t ff_dither4[2];
838 extern const uint64_t ff_dither8[2];
839 
840 extern const uint8_t ff_dither_2x2_4[3][8];
841 extern const uint8_t ff_dither_2x2_8[3][8];
842 extern const uint8_t ff_dither_4x4_16[5][8];
843 extern const uint8_t ff_dither_8x8_32[9][8];
844 extern const uint8_t ff_dither_8x8_73[9][8];
845 extern const uint8_t ff_dither_8x8_128[9][8];
846 extern const uint8_t ff_dither_8x8_220[9][8];
847 
848 extern const int32_t ff_yuv2rgb_coeffs[11][4];
849 
850 extern const AVClass ff_sws_context_class;
851 
852 /**
853  * Set c->swscale to an unscaled converter if one exists for the specific
854  * source and destination formats, bit depths, flags, etc.
855  */
860 
861 /**
862  * Return function pointer to fastest main scaler path function depending
863  * on architecture and available optimizations.
864  */
866 
881 
882 void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
883  const uint8_t *src, int srcW, int xInc);
884 void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
885  int dstWidth, const uint8_t *src1,
886  const uint8_t *src2, int srcW, int xInc);
887 int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
888  int16_t *filter, int32_t *filterPos,
889  int numSplits);
890 void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
891  int dstWidth, const uint8_t *src,
892  int srcW, int xInc);
893 void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
894  int dstWidth, const uint8_t *src1,
895  const uint8_t *src2, int srcW, int xInc);
896 
897 /**
898  * Allocate and return an SwsContext.
899  * This is like sws_getContext() but does not perform the init step, allowing
900  * the user to set additional AVOptions.
901  *
902  * @see sws_getContext()
903  */
905  int dstW, int dstH, enum AVPixelFormat dstFormat,
906  int flags, const double *param);
907 
909  int srcStride[], int srcSliceY, int srcSliceH,
910  uint8_t *dst[], int dstStride[]);
911 
912 static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
913  int alpha, int bits, const int big_endian)
914 {
915  int i, j;
916  uint8_t *ptr = plane + stride * y;
917  int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
918  for (i = 0; i < height; i++) {
919 #define FILL(wfunc) \
920  for (j = 0; j < width; j++) {\
921  wfunc(ptr+2*j, v);\
922  }
923  if (big_endian) {
924  FILL(AV_WB16);
925  } else {
926  FILL(AV_WL16);
927  }
928  ptr += stride;
929  }
930 #undef FILL
931 }
932 
933 static inline void fillPlane32(uint8_t *plane, int stride, int width, int height, int y,
934  int alpha, int bits, const int big_endian, int is_float)
935 {
936  int i, j;
937  uint8_t *ptr = plane + stride * y;
938  uint32_t v;
939  uint32_t onef32 = 0x3f800000;
940  if (is_float)
941  v = alpha ? onef32 : 0;
942  else
943  v = alpha ? 0xFFFFFFFF>>(32-bits) : (1<<(bits-1));
944 
945  for (i = 0; i < height; i++) {
946 #define FILL(wfunc) \
947  for (j = 0; j < width; j++) {\
948  wfunc(ptr+4*j, v);\
949  }
950  if (big_endian) {
951  FILL(AV_WB32);
952  } else {
953  FILL(AV_WL32);
954  }
955  ptr += stride;
956  }
957 #undef FILL
958 }
959 
960 
961 #define MAX_SLICE_PLANES 4
962 
963 /// Slice plane
964 typedef struct SwsPlane
965 {
966  int available_lines; ///< max number of lines that can be hold by this plane
967  int sliceY; ///< index of first line
968  int sliceH; ///< number of lines
969  uint8_t **line; ///< line buffer
970  uint8_t **tmp; ///< Tmp line buffer used by mmx code
971 } SwsPlane;
972 
973 /**
974  * Struct which defines a slice of an image to be scaled or an output for
975  * a scaled slice.
976  * A slice can also be used as intermediate ring buffer for scaling steps.
977  */
978 typedef struct SwsSlice
979 {
980  int width; ///< Slice line width
981  int h_chr_sub_sample; ///< horizontal chroma subsampling factor
982  int v_chr_sub_sample; ///< vertical chroma subsampling factor
983  int is_ring; ///< flag to identify if this slice is a ring buffer
984  int should_free_lines; ///< flag to identify if there are dynamic allocated lines
985  enum AVPixelFormat fmt; ///< planes pixel format
986  SwsPlane plane[MAX_SLICE_PLANES]; ///< color planes
987 } SwsSlice;
988 
989 /**
990  * Struct which holds all necessary data for processing a slice.
991  * A processing step can be a color conversion or horizontal/vertical scaling.
992  */
993 typedef struct SwsFilterDescriptor
994 {
995  SwsSlice *src; ///< Source slice
996  SwsSlice *dst; ///< Output slice
997 
998  int alpha; ///< Flag for processing alpha channel
999  void *instance; ///< Filter instance data
1000 
1001  /// Function for processing input slice sliceH lines starting from line sliceY
1002  int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
1004 
1005 // warp input lines in the form (src + width*i + j) to slice format (line[i][j])
1006 // relative=true means first line src[x][0] otherwise first line is src[x][lum/crh Y]
1007 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);
1008 
1009 // Initialize scaler filter descriptor chain
1010 int ff_init_filters(SwsContext *c);
1011 
1012 // Free all filter data
1013 int ff_free_filters(SwsContext *c);
1014 
1015 /*
1016  function for applying ring buffer logic into slice s
1017  It checks if the slice can hold more @lum lines, if yes
1018  do nothing otherwise remove @lum least used lines.
1019  It applies the same procedure for @chr lines.
1020 */
1021 int ff_rotate_slice(SwsSlice *s, int lum, int chr);
1022 
1023 /// initializes gamma conversion descriptor
1025 
1026 /// initializes lum pixel format conversion descriptor
1028 
1029 /// initializes lum horizontal scaling descriptor
1030 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
1031 
1032 /// initializes chr pixel format conversion descriptor
1034 
1035 /// initializes chr horizontal scaling descriptor
1036 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
1037 
1039 
1040 /// initializes vertical scaling descriptors
1042 
1043 /// setup vertical scaler functions
1047 
1048 //number of extra lines to process
1049 #define MAX_LINES_AHEAD 4
1050 
1051 #endif /* SWSCALE_SWSCALE_INTERNAL_H */
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
uint64_t vrCoeff
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
int plane
Which of the 4 planes contains the component.
Definition: pixdesc.h:35
void(* hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
const uint64_t ff_dither8[2]
Definition: swscale.c:36
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
static enum AVPixelFormat pix_fmt
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
int chrSrcH
Height of source chroma planes.
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
uint64_t y_temp
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
#define YUVRGB_TABLE_HEADROOM
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
uint64_t v_temp
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
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
uint32_t pal_rgb[256]
int16_t * rgbgamma
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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
SwsAlphaBlend alphablend
return srcSliceH
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
int h_chr_sub_sample
horizontal chroma subsampling factor
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
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)
Struct which holds all necessary data for processing a slice.
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
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
int16_t * rgbgammainv
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.
const uint8_t ff_dither_8x8_73[9][8]
Definition: output.c:71
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
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.
uint64_t redDither
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Convenience header that includes libavutil&#39;s core.
int16_t * xyzgammainv
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:140
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...
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:49
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
void ff_get_unscaled_swscale_arm(SwsContext *c)
const uint8_t * lumDither8
swscale version macros
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...
int dstY
Last destination vertical line output from last slice.
uint64_t blueDither
uint16_t dither16[8]
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
void ff_sws_init_input_funcs(SwsContext *c)
uint64_t ubCoeff
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
int srcH
Height of source luma/alpha planes.
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
#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...
ptrdiff_t uv_off
offset (in pixels) between u and v planes
const uint8_t ff_dither_8x8_128[9][8]
Definition: swscale.c:39
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:177
SwsAlphaBlend
uint8_t ** line
line buffer
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
int alpha
Flag for processing alpha channel.
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
int vChrFilterSize
Vertical filter size for chroma pixels.
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
#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
int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
Definition: hscale.c:281
int v_chr_sub_sample
vertical chroma subsampling factor
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
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:139
int cascaded_tmpStride[4]
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
Definition: yuv2rgb.c:81
SwsSlice * dst
Output slice.
#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.
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
void ff_sws_init_swscale_arm(SwsContext *c)
Definition: swscale.c:32
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]
uint64_t yOffset
enum AVPixelFormat dstFormat
Destination pixel format.
uint32_t dither32[8]
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
uint16_t * inv_gamma
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
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
float uint2float_lut[256]
static const uint16_t table[]
Definition: prosumer.c:206
uint64_t vRounder
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
int dstH
Height of destination luma/alpha planes.
int * dither_error[4]
#define src
Definition: vp8dsp.c:254
yuv2anyX_fn yuv2anyX
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:526
#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
const uint64_t ff_dither4[2]
Definition: swscale.c:32
uint64_t u_temp
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
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
int ff_init_filters(SwsContext *c)
Definition: slice.c:252
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
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
Definition: vscale.c:213
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
Definition: slice.c:119
yuv2packed1_fn yuv2packed1
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
simple assert() macros that are a bit more flexible than ISO C assert().
const uint8_t ff_dither_2x2_4[3][8]
Definition: output.c:39
uint8_t bits
Definition: vp3data.h:202
Slice plane.
uint64_t ugCoeff
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
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)
int chrDstW
Width of destination chroma planes.
const uint8_t ff_dither_4x4_16[5][8]
Definition: output.c:51
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
uint8_t * cascaded1_tmp[4]
#define MAX_SLICE_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)
int32_t alpMmxFilter[4 *MAX_FILTER_SIZE]
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
int hChrFilterSize
Horizontal filter size for chroma pixels.
int sliceH
number of lines
int16_t * xyzgamma
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
void ff_sws_init_swscale_ppc(SwsContext *c)
void ff_updateMMXDitherTables(SwsContext *c, int dstY)
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
static double lum(void *priv, double x, double y, int plane)
Definition: vf_fftfilt.c:95
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
#define CSHIFT
Definition: audiogen.c:72
uint8_t * formatConvBuffer
#define width
yuv2planar1_fn yuv2plane1
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
void(* readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
yuv2interleavedX_fn yuv2nv12cX
uint64_t vgCoeff
uint64_t uOffset
int32_t
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
#define s(width, name)
Definition: cbs_vp9.c:257
int available_lines
max number of lines that can be hold by this plane
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice *src, uint16_t *table)
initializes gamma conversion descriptor
Definition: gamma.c:58
SwsDither
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
struct SwsFilterDescriptor * desc
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
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
const uint8_t ff_dither_8x8_220[9][8]
Definition: output.c:84
double gamma_value
int srcColorspaceTable[4]
int dstW
Width of destination luma/alpha planes.
#define AV_PIX_FMT_FLAG_BAYER
The pixel format is following a Bayer pattern.
Definition: pixdesc.h:182
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
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
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.
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
int should_free_lines
flag to identify if there are dynamic allocated lines
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:374
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
int32_t lumMmxFilter[4 *MAX_FILTER_SIZE]
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
#define src1
Definition: h264pred.c:139
SwsFunc ff_getSwsFunc(SwsContext *c)
Return function pointer to fastest main scaler path function depending on architecture and available ...
Definition: swscale.c:583
int is_ring
flag to identify if this slice is a ring buffer
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:1886
void(* readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
int dstColorspaceTable[4]
void ff_get_unscaled_swscale_aarch64(SwsContext *c)
int width
Slice line width.
const AVClass * av_class
info on struct for av_log
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
static const int16_t alpha[]
Definition: ilbcdata.h:55
int warned_unuseable_bilinear
#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...
int chrDstH
Height of destination chroma planes.
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
struct SwsSlice * slice
static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes...
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
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.
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:679
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:113
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
void * instance
Filter instance data.
void ff_sws_init_swscale_x86(SwsContext *c)
Definition: swscale.c:394
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
const AVClass ff_sws_context_class
Definition: options.c:87
uint16_t * dstV
Definition: input.c:403
Contains misc utility macros and inline functions.
const uint8_t * chrDither8
void ff_sws_init_swscale_vsx(SwsContext *c)
Definition: swscale_vsx.c:2076
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
void ff_get_unscaled_swscale_ppc(SwsContext *c)
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:142
void ff_sws_init_swscale_aarch64(SwsContext *c)
Definition: swscale.c:32
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
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.
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int
yuv2packed2_fn yuv2packed2
Y , 8bpp.
Definition: pixfmt.h:74
double param[2]
Input parameters for scaling algorithms that need them.
common internal and external API header
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:75
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
#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.
int32_t chrMmxFilter[4 *MAX_FILTER_SIZE]
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
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.
struct SwsContext * cascaded_context[3]
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
uint64_t greenDither
uint16_t * gamma
SwsFunc swscale
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
uint8_t ** tmp
Tmp line buffer used by mmx code.
#define MAX_FILTER_SIZE
void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
pixel format definitions
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:373
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
int srcFormatBpp
Number of bits per pixel of the source pixel format.
uint64_t yCoeff
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
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.
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...
const uint8_t ff_dither_8x8_32[9][8]
Definition: output.c:59
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
int32_t input_rgb2yuv_table[16+40 *4]
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
const uint8_t ff_dither_2x2_8[3][8]
Definition: output.c:45
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT uint8_t const uint8_t const uint8_t const uint8_t int uint32_t * rgb2yuv
Definition: input.c:401
Definition: vf_vpp_qsv.c:155
#define av_always_inline
Definition: attributes.h:45
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)
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
SwsSlice * src
Source slice.
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:141
#define stride
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
int sliceY
index of first line
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
int chrSrcW
Width of source chroma planes.
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 local context
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
int depth
Number of bits in the component.
Definition: pixdesc.h:58
void ff_get_unscaled_swscale(SwsContext *c)
Set c->swscale to an unscaled converter if one exists for the specific source and destination formats...
int ff_free_filters(SwsContext *c)
Definition: slice.c:383
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
#define FILL(wfunc)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
uint32_t pal_yuv[256]
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
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 ...
uint64_t vOffset
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
int i
Definition: input.c:407
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
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)
#define AV_WL32(p, v)
Definition: intreadwrite.h:426