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