FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
swscale_internal.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
23 
24 #include "config.h"
25 #include "version.h"
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avutil.h"
29 #include "libavutil/common.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/log.h"
32 #include "libavutil/pixfmt.h"
33 #include "libavutil/pixdesc.h"
35 
36 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
37 
38 #define YUVRGB_TABLE_HEADROOM 512
39 #define YUVRGB_TABLE_LUMA_HEADROOM 512
40 
41 #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
42 
43 #define DITHER1XBPP
44 
45 #if HAVE_BIGENDIAN
46 #define ALT32_CORR (-1)
47 #else
48 #define ALT32_CORR 1
49 #endif
50 
51 #if ARCH_X86_64
52 # define APCK_PTR2 8
53 # define APCK_COEF 16
54 # define APCK_SIZE 24
55 #else
56 # define APCK_PTR2 4
57 # define APCK_COEF 8
58 # define APCK_SIZE 16
59 #endif
60 
61 #define RETCODE_USE_CASCADE -12345
62 
63 struct SwsContext;
64 
65 typedef enum SwsDither {
73 } SwsDither;
74 
75 typedef enum SwsAlphaBlend {
81 
82 typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
83  int srcStride[], int srcSliceY, int srcSliceH,
84  uint8_t *dst[], int dstStride[]);
85 
86 /**
87  * Write one line of horizontally scaled data to planar output
88  * without any additional vertical scaling (or point-scaling).
89  *
90  * @param src scaled source data, 15 bits for 8-10-bit output,
91  * 19 bits for 16-bit output (in int32_t)
92  * @param dest pointer to the output plane. For >8-bit
93  * output, this is in uint16_t
94  * @param dstW width of destination in pixels
95  * @param dither ordered dither array of type int16_t and size 8
96  * @param offset Dither offset
97  */
98 typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
99  const uint8_t *dither, int offset);
100 
101 /**
102  * Write one line of horizontally scaled data to planar output
103  * with multi-point vertical scaling between input pixels.
104  *
105  * @param filter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
106  * @param src scaled luma (Y) or alpha (A) source data, 15 bits for
107  * 8-10-bit output, 19 bits for 16-bit output (in int32_t)
108  * @param filterSize number of vertical input lines to scale
109  * @param dest pointer to output plane. For >8-bit
110  * output, this is in uint16_t
111  * @param dstW width of destination pixels
112  * @param offset Dither offset
113  */
114 typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
115  const int16_t **src, uint8_t *dest, int dstW,
116  const uint8_t *dither, int offset);
117 
118 /**
119  * Write one line of horizontally scaled chroma to interleaved output
120  * with multi-point vertical scaling between input pixels.
121  *
122  * @param c SWS scaling context
123  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
124  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit
125  * output, 19 bits for 16-bit output (in int32_t)
126  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit
127  * output, 19 bits for 16-bit output (in int32_t)
128  * @param chrFilterSize number of vertical chroma input lines to scale
129  * @param dest pointer to the output plane. For >8-bit
130  * output, this is in uint16_t
131  * @param dstW width of chroma planes
132  */
134  const int16_t *chrFilter,
135  int chrFilterSize,
136  const int16_t **chrUSrc,
137  const int16_t **chrVSrc,
138  uint8_t *dest, int dstW);
139 
140 /**
141  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
142  * output without any additional vertical scaling (or point-scaling). Note
143  * that this function may do chroma scaling, see the "uvalpha" argument.
144  *
145  * @param c SWS scaling context
146  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
147  * 19 bits for 16-bit output (in int32_t)
148  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
149  * 19 bits for 16-bit output (in int32_t)
150  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
151  * 19 bits for 16-bit output (in int32_t)
152  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
153  * 19 bits for 16-bit output (in int32_t)
154  * @param dest pointer to the output plane. For 16-bit output, this is
155  * uint16_t
156  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
157  * to write into dest[]
158  * @param uvalpha chroma scaling coefficient for the second line of chroma
159  * pixels, either 2048 or 0. If 0, one chroma input is used
160  * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
161  * is set, it generates 1 output pixel). If 2048, two chroma
162  * input pixels should be averaged for 2 output pixels (this
163  * only happens if SWS_FLAG_FULL_CHR_INT is not set)
164  * @param y vertical line number for this output. This does not need
165  * to be used to calculate the offset in the destination,
166  * but can be used to generate comfort noise using dithering
167  * for some output formats.
168  */
169 typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
170  const int16_t *chrUSrc[2],
171  const int16_t *chrVSrc[2],
172  const int16_t *alpSrc, uint8_t *dest,
173  int dstW, int uvalpha, int y);
174 /**
175  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
176  * output by doing bilinear scaling between two input lines.
177  *
178  * @param c SWS scaling context
179  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
180  * 19 bits for 16-bit output (in int32_t)
181  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
182  * 19 bits for 16-bit output (in int32_t)
183  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
184  * 19 bits for 16-bit output (in int32_t)
185  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
186  * 19 bits for 16-bit output (in int32_t)
187  * @param dest pointer to the output plane. For 16-bit output, this is
188  * uint16_t
189  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
190  * to write into dest[]
191  * @param yalpha luma/alpha scaling coefficients for the second input line.
192  * The first line's coefficients can be calculated by using
193  * 4096 - yalpha
194  * @param uvalpha chroma scaling coefficient for the second input line. The
195  * first line's coefficients can be calculated by using
196  * 4096 - uvalpha
197  * @param y vertical line number for this output. This does not need
198  * to be used to calculate the offset in the destination,
199  * but can be used to generate comfort noise using dithering
200  * for some output formats.
201  */
202 typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
203  const int16_t *chrUSrc[2],
204  const int16_t *chrVSrc[2],
205  const int16_t *alpSrc[2],
206  uint8_t *dest,
207  int dstW, int yalpha, int uvalpha, int y);
208 /**
209  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
210  * output by doing multi-point vertical scaling between input pixels.
211  *
212  * @param c SWS scaling context
213  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
214  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
215  * 19 bits for 16-bit output (in int32_t)
216  * @param lumFilterSize number of vertical luma/alpha input lines to scale
217  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
218  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
219  * 19 bits for 16-bit output (in int32_t)
220  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
221  * 19 bits for 16-bit output (in int32_t)
222  * @param chrFilterSize number of vertical chroma input lines to scale
223  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
224  * 19 bits for 16-bit output (in int32_t)
225  * @param dest pointer to the output plane. For 16-bit output, this is
226  * uint16_t
227  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
228  * to write into dest[]
229  * @param y vertical line number for this output. This does not need
230  * to be used to calculate the offset in the destination,
231  * but can be used to generate comfort noise using dithering
232  * or some output formats.
233  */
234 typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
235  const int16_t **lumSrc, int lumFilterSize,
236  const int16_t *chrFilter,
237  const int16_t **chrUSrc,
238  const int16_t **chrVSrc, int chrFilterSize,
239  const int16_t **alpSrc, uint8_t *dest,
240  int dstW, int y);
241 
242 /**
243  * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
244  * output by doing multi-point vertical scaling between input pixels.
245  *
246  * @param c SWS scaling context
247  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
248  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
249  * 19 bits for 16-bit output (in int32_t)
250  * @param lumFilterSize number of vertical luma/alpha input lines to scale
251  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
252  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
253  * 19 bits for 16-bit output (in int32_t)
254  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
255  * 19 bits for 16-bit output (in int32_t)
256  * @param chrFilterSize number of vertical chroma input lines to scale
257  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
258  * 19 bits for 16-bit output (in int32_t)
259  * @param dest pointer to the output planes. For 16-bit output, this is
260  * uint16_t
261  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
262  * to write into dest[]
263  * @param y vertical line number for this output. This does not need
264  * to be used to calculate the offset in the destination,
265  * but can be used to generate comfort noise using dithering
266  * or some output formats.
267  */
268 typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
269  const int16_t **lumSrc, int lumFilterSize,
270  const int16_t *chrFilter,
271  const int16_t **chrUSrc,
272  const int16_t **chrVSrc, int chrFilterSize,
273  const int16_t **alpSrc, uint8_t **dest,
274  int dstW, int y);
275 
276 struct SwsSlice;
277 struct SwsFilterDescriptor;
278 
279 /* This struct should be aligned on at least a 32-byte boundary. */
280 typedef struct SwsContext {
281  /**
282  * info on struct for av_log
283  */
285 
286  /**
287  * Note that src, dst, srcStride, dstStride will be copied in the
288  * sws_scale() wrapper so they can be freely modified here.
289  */
291  int srcW; ///< Width of source luma/alpha planes.
292  int srcH; ///< Height of source luma/alpha planes.
293  int dstH; ///< Height of destination luma/alpha planes.
294  int chrSrcW; ///< Width of source chroma planes.
295  int chrSrcH; ///< Height of source chroma planes.
296  int chrDstW; ///< Width of destination chroma planes.
297  int chrDstH; ///< Height of destination chroma planes.
300  enum AVPixelFormat dstFormat; ///< Destination pixel format.
301  enum AVPixelFormat srcFormat; ///< Source pixel format.
302  int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
303  int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
305  int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
306  int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
307  int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
308  int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
309  int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
310  int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
311  double param[2]; ///< Input parameters for scaling algorithms that need them.
312 
313  /* The cascaded_* fields allow spliting a scaler task into multiple
314  * sequential steps, this is for example used to limit the maximum
315  * downscaling factor that needs to be supported in one scaler.
316  */
323 
324  double gamma_value;
327  uint16_t *gamma;
328  uint16_t *inv_gamma;
329 
330  int numDesc;
331  int descIndex[2];
332  int numSlice;
333  struct SwsSlice *slice;
335 
336  uint32_t pal_yuv[256];
337  uint32_t pal_rgb[256];
338 
339  /**
340  * @name Scaled horizontal lines ring buffer.
341  * The horizontal scaler keeps just enough scaled lines in a ring buffer
342  * so they may be passed to the vertical scaler. The pointers to the
343  * allocated buffers for each line are duplicated in sequence in the ring
344  * buffer to simplify indexing and avoid wrapping around between lines
345  * inside the vertical scaler code. The wrapping is done before the
346  * vertical scaler is called.
347  */
348  //@{
349  int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
350  int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
351  int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
352  int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source.
353  //@}
354 
357 
358  /**
359  * @name Horizontal and vertical filters.
360  * To better understand the following fields, here is a pseudo-code of
361  * their usage in filtering a horizontal line:
362  * @code
363  * for (i = 0; i < width; i++) {
364  * dst[i] = 0;
365  * for (j = 0; j < filterSize; j++)
366  * dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
367  * dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
368  * }
369  * @endcode
370  */
371  //@{
372  int16_t *hLumFilter; ///< Array of horizontal filter coefficients for luma/alpha planes.
373  int16_t *hChrFilter; ///< Array of horizontal filter coefficients for chroma planes.
374  int16_t *vLumFilter; ///< Array of vertical filter coefficients for luma/alpha planes.
375  int16_t *vChrFilter; ///< Array of vertical filter coefficients for chroma planes.
376  int32_t *hLumFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
377  int32_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
378  int32_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
379  int32_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
380  int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
381  int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
382  int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
383  int vChrFilterSize; ///< Vertical filter size for chroma pixels.
384  //@}
385 
386  int lumMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
387  int chrMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
388  uint8_t *lumMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
389  uint8_t *chrMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
390 
393 
394  int dstY; ///< Last destination vertical line output from last slice.
395  int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
396  void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
397  // alignment ensures the offset can be added in a single
398  // instruction on e.g. ARM
403  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
404 #define RY_IDX 0
405 #define GY_IDX 1
406 #define BY_IDX 2
407 #define RU_IDX 3
408 #define GU_IDX 4
409 #define BU_IDX 5
410 #define RV_IDX 6
411 #define GV_IDX 7
412 #define BV_IDX 8
413 #define RGB2YUV_SHIFT 15
414 
415  int *dither_error[4];
416 
417  //Colorspace stuff
418  int contrast, brightness, saturation; // for sws_getColorspaceDetails
421  int srcRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (source image).
422  int dstRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
425  int srcXYZ;
426  int dstXYZ;
437 
438 #define RED_DITHER "0*8"
439 #define GREEN_DITHER "1*8"
440 #define BLUE_DITHER "2*8"
441 #define Y_COEFF "3*8"
442 #define VR_COEFF "4*8"
443 #define UB_COEFF "5*8"
444 #define VG_COEFF "6*8"
445 #define UG_COEFF "7*8"
446 #define Y_OFFSET "8*8"
447 #define U_OFFSET "9*8"
448 #define V_OFFSET "10*8"
449 #define LUM_MMX_FILTER_OFFSET "11*8"
450 #define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
451 #define DSTW_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
452 #define ESP_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
453 #define VROUNDER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
454 #define U_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
455 #define V_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
456 #define Y_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
457 #define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
458 #define UV_OFF_PX "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
459 #define UV_OFF_BYTE "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
460 #define DITHER16 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
461 #define DITHER32 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
462 #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
463 
464  DECLARE_ALIGNED(8, uint64_t, redDither);
467 
468  DECLARE_ALIGNED(8, uint64_t, yCoeff);
469  DECLARE_ALIGNED(8, uint64_t, vrCoeff);
470  DECLARE_ALIGNED(8, uint64_t, ubCoeff);
471  DECLARE_ALIGNED(8, uint64_t, vgCoeff);
472  DECLARE_ALIGNED(8, uint64_t, ugCoeff);
473  DECLARE_ALIGNED(8, uint64_t, yOffset);
474  DECLARE_ALIGNED(8, uint64_t, uOffset);
475  DECLARE_ALIGNED(8, uint64_t, vOffset);
478  int dstW; ///< Width of destination luma/alpha planes.
479  DECLARE_ALIGNED(8, uint64_t, esp);
480  DECLARE_ALIGNED(8, uint64_t, vRounder);
481  DECLARE_ALIGNED(8, uint64_t, u_temp);
482  DECLARE_ALIGNED(8, uint64_t, v_temp);
483  DECLARE_ALIGNED(8, uint64_t, y_temp);
485  // alignment of these values is not necessary, but merely here
486  // to maintain the same offset across x8632 and x86-64. Once we
487  // use proper offset macros in the asm, they can be removed.
488  DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
489  DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
490  DECLARE_ALIGNED(8, uint16_t, dither16)[8];
491  DECLARE_ALIGNED(8, uint32_t, dither32)[8];
492 
494 
495 #if HAVE_ALTIVEC
496  vector signed short CY;
497  vector signed short CRV;
498  vector signed short CBU;
499  vector signed short CGU;
500  vector signed short CGV;
501  vector signed short OY;
502  vector unsigned short CSHIFT;
503  vector signed short *vYCoeffsBank, *vCCoeffsBank;
504 #endif
505 
507 
508 /* pre defined color-spaces gamma */
509 #define XYZ_GAMMA (2.6f)
510 #define RGB_GAMMA (2.2f)
511  int16_t *xyzgamma;
512  int16_t *rgbgamma;
513  int16_t *xyzgammainv;
514  int16_t *rgbgammainv;
515  int16_t xyz2rgb_matrix[3][4];
516  int16_t rgb2xyz_matrix[3][4];
517 
518  /* function pointers for swscale() */
526 
527  /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
528  void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
529  int width, uint32_t *pal);
530  /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
531  void (*alpToYV12)(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 chroma planes to YV12 for horizontal scaler.
534  void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
535  const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
536  int width, uint32_t *pal);
537 
538  /**
539  * Functions to read planar input, such as planar RGB, and convert
540  * internally to Y/UV/A.
541  */
542  /** @{ */
544  void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
545  int width, int32_t *rgb2yuv);
547  /** @} */
548 
549  /**
550  * Scale one horizontal line of input data using a bilinear filter
551  * to produce one line of output data. Compared to SwsContext->hScale(),
552  * please take note of the following caveats when using these:
553  * - Scaling is done using only 7 bits instead of 14-bit coefficients.
554  * - You can use no more than 5 input pixels to produce 4 output
555  * pixels. Therefore, this filter should not be used for downscaling
556  * by more than ~20% in width (because that equals more than 5/4th
557  * downscaling and thus more than 5 pixels input per 4 pixels output).
558  * - In general, bilinear filters create artifacts during downscaling
559  * (even when <20%), because one output pixel will span more than one
560  * input pixel, and thus some pixels will need edges of both neighbor
561  * pixels to interpolate the output pixel. Since you can use at most
562  * two input pixels per output pixel in bilinear scaling, this is
563  * impossible and thus downscaling by any size will create artifacts.
564  * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
565  * in SwsContext->flags.
566  */
567  /** @{ */
569  int16_t *dst, int dstWidth,
570  const uint8_t *src, int srcW, int xInc);
572  int16_t *dst1, int16_t *dst2, int dstWidth,
573  const uint8_t *src1, const uint8_t *src2,
574  int srcW, int xInc);
575  /** @} */
576 
577  /**
578  * Scale one horizontal line of input data using a filter over the input
579  * lines, to produce one (differently sized) line of output data.
580  *
581  * @param dst pointer to destination buffer for horizontally scaled
582  * data. If the number of bits per component of one
583  * destination pixel (SwsContext->dstBpc) is <= 10, data
584  * will be 15 bpc in 16 bits (int16_t) width. Else (i.e.
585  * SwsContext->dstBpc == 16), data will be 19bpc in
586  * 32 bits (int32_t) width.
587  * @param dstW width of destination image
588  * @param src pointer to source data to be scaled. If the number of
589  * bits per component of a source pixel (SwsContext->srcBpc)
590  * is 8, this is 8bpc in 8 bits (uint8_t) width. Else
591  * (i.e. SwsContext->dstBpc > 8), this is native depth
592  * in 16 bits (uint16_t) width. In other words, for 9-bit
593  * YUV input, this is 9bpc, for 10-bit YUV input, this is
594  * 10bpc, and for 16-bit RGB or YUV, this is 16bpc.
595  * @param filter filter coefficients to be used per output pixel for
596  * scaling. This contains 14bpp filtering coefficients.
597  * Guaranteed to contain dstW * filterSize entries.
598  * @param filterPos position of the first input pixel to be used for
599  * each output pixel during scaling. Guaranteed to
600  * contain dstW entries.
601  * @param filterSize the number of input coefficients to be used (and
602  * thus the number of input pixels to be used) for
603  * creating a single output pixel. Is aligned to 4
604  * (and input coefficients thus padded with zeroes)
605  * to simplify creating SIMD code.
606  */
607  /** @{ */
608  void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
609  const uint8_t *src, const int16_t *filter,
610  const int32_t *filterPos, int filterSize);
611  void (*hcScale)(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  /** @} */
615 
616  /// Color range conversion function for luma plane if needed.
617  void (*lumConvertRange)(int16_t *dst, int width);
618  /// Color range conversion function for chroma planes if needed.
619  void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
620 
621  int needs_hcscale; ///< Set if there are chroma planes to be converted.
622 
624 
626 } SwsContext;
627 //FIXME check init (where 0)
628 
630 int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
631  int fullRange, int brightness,
632  int contrast, int saturation);
633 void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4],
634  int brightness, int contrast, int saturation);
635 
637  int lastInLumBuf, int lastInChrBuf);
638 
640 
643 
645 {
646  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
647  av_assert0(desc);
648  return desc->comp[0].depth == 16;
649 }
650 
652 {
653  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
654  av_assert0(desc);
655  return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
656 }
657 
659 {
660  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
661  av_assert0(desc);
662  return desc->flags & AV_PIX_FMT_FLAG_BE;
663 }
664 
666 {
667  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
668  av_assert0(desc);
669  return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
670 }
671 
673 {
674  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
675  av_assert0(desc);
676  return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
677 }
678 
680 {
681  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
682  av_assert0(desc);
683  return (desc->flags & AV_PIX_FMT_FLAG_RGB);
684 }
685 
687 {
688  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
689  av_assert0(desc);
690  return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
691  !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
692  desc->nb_components <= 2 &&
693  pix_fmt != AV_PIX_FMT_MONOBLACK &&
694  pix_fmt != AV_PIX_FMT_MONOWHITE;
695 }
696 
698 {
699  return pix_fmt == AV_PIX_FMT_RGB48BE ||
700  pix_fmt == AV_PIX_FMT_RGB48LE ||
701  pix_fmt == AV_PIX_FMT_RGB32 ||
702  pix_fmt == AV_PIX_FMT_RGB32_1 ||
703  pix_fmt == AV_PIX_FMT_RGB24 ||
704  pix_fmt == AV_PIX_FMT_RGB565BE ||
705  pix_fmt == AV_PIX_FMT_RGB565LE ||
706  pix_fmt == AV_PIX_FMT_RGB555BE ||
707  pix_fmt == AV_PIX_FMT_RGB555LE ||
708  pix_fmt == AV_PIX_FMT_RGB444BE ||
709  pix_fmt == AV_PIX_FMT_RGB444LE ||
710  pix_fmt == AV_PIX_FMT_RGB8 ||
711  pix_fmt == AV_PIX_FMT_RGB4 ||
712  pix_fmt == AV_PIX_FMT_RGB4_BYTE ||
713  pix_fmt == AV_PIX_FMT_RGBA64BE ||
714  pix_fmt == AV_PIX_FMT_RGBA64LE ||
715  pix_fmt == AV_PIX_FMT_MONOBLACK ||
716  pix_fmt == AV_PIX_FMT_MONOWHITE;
717 }
718 
720 {
721  return pix_fmt == AV_PIX_FMT_BGR48BE ||
722  pix_fmt == AV_PIX_FMT_BGR48LE ||
723  pix_fmt == AV_PIX_FMT_BGR32 ||
724  pix_fmt == AV_PIX_FMT_BGR32_1 ||
725  pix_fmt == AV_PIX_FMT_BGR24 ||
726  pix_fmt == AV_PIX_FMT_BGR565BE ||
727  pix_fmt == AV_PIX_FMT_BGR565LE ||
728  pix_fmt == AV_PIX_FMT_BGR555BE ||
729  pix_fmt == AV_PIX_FMT_BGR555LE ||
730  pix_fmt == AV_PIX_FMT_BGR444BE ||
731  pix_fmt == AV_PIX_FMT_BGR444LE ||
732  pix_fmt == AV_PIX_FMT_BGR8 ||
733  pix_fmt == AV_PIX_FMT_BGR4 ||
734  pix_fmt == AV_PIX_FMT_BGR4_BYTE ||
735  pix_fmt == AV_PIX_FMT_BGRA64BE ||
736  pix_fmt == AV_PIX_FMT_BGRA64LE ||
737  pix_fmt == AV_PIX_FMT_MONOBLACK ||
738  pix_fmt == AV_PIX_FMT_MONOWHITE;
739 }
740 
742 {
743  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
744  av_assert0(desc);
745  return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
746 }
747 
749 {
750  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
751  av_assert0(desc);
752  return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
753  pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
754 }
755 
757 {
758  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
759  av_assert0(desc);
760  if (pix_fmt == AV_PIX_FMT_PAL8)
761  return 1;
762  return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
763 }
764 
766 {
767  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
768  av_assert0(desc);
769  return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
770  pix_fmt == AV_PIX_FMT_PAL8 ||
771  pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
772 }
773 
775 {
776  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
777  av_assert0(desc);
778  return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
779 }
780 
782 {
783  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
784  av_assert0(desc);
786 }
787 
789 {
790  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
791  av_assert0(desc);
792  return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
794 }
795 
797 {
798  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
799  av_assert0(desc);
800  return (desc->flags & AV_PIX_FMT_FLAG_PAL) || (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL);
801 }
802 
803 extern const uint64_t ff_dither4[2];
804 extern const uint64_t ff_dither8[2];
805 
806 extern const uint8_t ff_dither_2x2_4[3][8];
807 extern const uint8_t ff_dither_2x2_8[3][8];
808 extern const uint8_t ff_dither_4x4_16[5][8];
809 extern const uint8_t ff_dither_8x8_32[9][8];
810 extern const uint8_t ff_dither_8x8_73[9][8];
811 extern const uint8_t ff_dither_8x8_128[9][8];
812 extern const uint8_t ff_dither_8x8_220[9][8];
813 
814 extern const int32_t ff_yuv2rgb_coeffs[11][4];
815 
816 extern const AVClass ff_sws_context_class;
817 
818 /**
819  * Set c->swscale to an unscaled converter if one exists for the specific
820  * source and destination formats, bit depths, flags, etc.
821  */
826 
827 /**
828  * Return function pointer to fastest main scaler path function depending
829  * on architecture and available optimizations.
830  */
832 
846 
847 void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
848  const uint8_t *src, int srcW, int xInc);
849 void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
850  int dstWidth, const uint8_t *src1,
851  const uint8_t *src2, int srcW, int xInc);
852 int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
853  int16_t *filter, int32_t *filterPos,
854  int numSplits);
855 void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
856  int dstWidth, const uint8_t *src,
857  int srcW, int xInc);
858 void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
859  int dstWidth, const uint8_t *src1,
860  const uint8_t *src2, int srcW, int xInc);
861 
862 /**
863  * Allocate and return an SwsContext.
864  * This is like sws_getContext() but does not perform the init step, allowing
865  * the user to set additional AVOptions.
866  *
867  * @see sws_getContext()
868  */
870  int dstW, int dstH, enum AVPixelFormat dstFormat,
871  int flags, const double *param);
872 
874  int srcStride[], int srcSliceY, int srcSliceH,
875  uint8_t *dst[], int dstStride[]);
876 
877 static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
878  int alpha, int bits, const int big_endian)
879 {
880  int i, j;
881  uint8_t *ptr = plane + stride * y;
882  int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
883  for (i = 0; i < height; i++) {
884 #define FILL(wfunc) \
885  for (j = 0; j < width; j++) {\
886  wfunc(ptr+2*j, v);\
887  }
888  if (big_endian) {
889  FILL(AV_WB16);
890  } else {
891  FILL(AV_WL16);
892  }
893  ptr += stride;
894  }
895 }
896 
897 #define MAX_SLICE_PLANES 4
898 
899 /// Slice plane
900 typedef struct SwsPlane
901 {
902  int available_lines; ///< max number of lines that can be hold by this plane
903  int sliceY; ///< index of first line
904  int sliceH; ///< number of lines
905  uint8_t **line; ///< line buffer
906  uint8_t **tmp; ///< Tmp line buffer used by mmx code
907 } SwsPlane;
908 
909 /**
910  * Struct which defines a slice of an image to be scaled or an output for
911  * a scaled slice.
912  * A slice can also be used as intermediate ring buffer for scaling steps.
913  */
914 typedef struct SwsSlice
915 {
916  int width; ///< Slice line width
917  int h_chr_sub_sample; ///< horizontal chroma subsampling factor
918  int v_chr_sub_sample; ///< vertical chroma subsampling factor
919  int is_ring; ///< flag to identify if this slice is a ring buffer
920  int should_free_lines; ///< flag to identify if there are dynamic allocated lines
921  enum AVPixelFormat fmt; ///< planes pixel format
922  SwsPlane plane[MAX_SLICE_PLANES]; ///< color planes
923 } SwsSlice;
924 
925 /**
926  * Struct which holds all necessary data for processing a slice.
927  * A processing step can be a color conversion or horizontal/vertical scaling.
928  */
929 typedef struct SwsFilterDescriptor
930 {
931  SwsSlice *src; ///< Source slice
932  SwsSlice *dst; ///< Output slice
933 
934  int alpha; ///< Flag for processing alpha channel
935  void *instance; ///< Filter instance data
936 
937  /// Function for processing input slice sliceH lines starting from line sliceY
938  int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
940 
941 // warp input lines in the form (src + width*i + j) to slice format (line[i][j])
942 // relative=true means first line src[x][0] otherwise first line is src[x][lum/crh Y]
943 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);
944 
945 // Initialize scaler filter descriptor chain
947 
948 // Free all filter data
950 
951 /*
952  function for applying ring buffer logic into slice s
953  It checks if the slice can hold more @lum lines, if yes
954  do nothing otherwise remove @lum least used lines.
955  It applies the same procedure for @chr lines.
956 */
957 int ff_rotate_slice(SwsSlice *s, int lum, int chr);
958 
959 /// initializes gamma conversion descriptor
961 
962 /// initializes lum pixel format conversion descriptor
964 
965 /// initializes lum horizontal scaling descriptor
966 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
967 
968 /// initializes chr pixel format conversion descriptor
970 
971 /// initializes chr horizontal scaling descriptor
972 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
973 
975 
976 /// initializes vertical scaling descriptors
978 
979 /// setup vertical scaler functions
980 void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX,
981  yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
982  yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);
983 
984 //number of extra lines to process
985 #define MAX_LINES_AHEAD 4
986 
987 #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
int plane
Definition: avisynth_c.h:422
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:2241
const uint64_t ff_dither8[2]
int chrBufIndex
Index in ring buffer of the last scaled horizontal chroma line from source.
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)
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
const char * s
Definition: avisynth_c.h:768
static enum AVPixelFormat pix_fmt
static float alpha(float a)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2337
int chrSrcH
Height of source chroma planes.
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
uint64_t y_temp
#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:220
static void fn() rgb2yuv(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], int16_t *rgb[3], ptrdiff_t s, int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], const int16_t yuv_offset[8])
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:64
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:85
const char * desc
Definition: nvenc.c:60
SwsAlphaBlend alphablend
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:765
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:219
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:116
int16_t * rgbgammainv
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.
uint64_t redDither
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Convenience header that includes libavutil's core.
int16_t * xyzgammainv
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:119
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:151
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
#define src
Definition: vp8dsp.c:254
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:88
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:114
int srcH
Height of source luma/alpha planes.
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:86
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...
void(* yuv2interleavedX_fn)(struct SwsContext *c, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest, int dstW)
Write one line of horizontally scaled chroma to interleaved output with multi-point vertical scaling ...
ptrdiff_t uv_off
offset (in pixels) between u and v planes
uint8_t bits
Definition: crc.c:296
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
void(* readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
#define av_cold
Definition: attributes.h:82
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:173
SwsAlphaBlend
uint8_t ** line
line buffer
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
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:111
int vChrFilterSize
Vertical filter size for chroma pixels.
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...
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:217
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:150
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.
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)
Definition: cfhd.c:80
int cascaded_tmpStride[4]
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:113
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
Definition: yuv2rgb.c:72
SwsSlice * dst
Output slice.
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:104
#define height
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
static int flags
Definition: log.c:57
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
int16_t rgb2xyz_matrix[3][4]
uint64_t yOffset
int(* process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH)
Function for processing input slice sliceH lines starting from line sliceY.
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:410
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:250
uint64_t vRounder
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
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]
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...
yuv2anyX_fn yuv2anyX
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:534
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:341
const uint64_t ff_dither4[2]
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:249
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
static const struct endianess table[]
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
Definition: vscale.c:206
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
Slice plane.
uint64_t ugCoeff
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
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:160
uint8_t * cascaded1_tmp[4]
#define MAX_SLICE_PLANES
SwsPlane plane[MAX_SLICE_PLANES]
color planes
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
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)
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
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 (...
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:74
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:89
#define CSHIFT
Definition: audiogen.c:72
uint8_t * formatConvBuffer
#define width
yuv2planar1_fn yuv2plane1
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
yuv2interleavedX_fn yuv2nv12cX
uint64_t vgCoeff
uint64_t uOffset
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
Definition: pixdesc.h:158
int32_t
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 table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
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
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.
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
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
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:178
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:159
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:118
uint8_t * cascaded_tmp[4]
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
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:340
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:84
#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:592
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:1831
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
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
int warned_unuseable_bilinear
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:338
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(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
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)
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:670
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:121
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:384
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
Contains misc utility macros and inline functions.
const uint8_t * chrDither8
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:115
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:153
int lumBufIndex
Index in ring buffer of the last scaled horizontal luma/alpha line from source.
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:72
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
int
yuv2packed2_fn yuv2packed2
void(* readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
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...
double param[2]
Input parameters for scaling algorithms that need them.
common internal and external API header
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...
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:71
static double c[64]
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...
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:110
#define AV_WL16(p, v)
Definition: intreadwrite.h:417
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:87
enum AVPixelFormat fmt
planes pixel format
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...
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(* 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 ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
pixel format definitions
void ff_updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex, int lastInLumBuf, int lastInChrBuf)
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:339
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.
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
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:120
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
#define av_always_inline
Definition: attributes.h:39
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:152
#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.
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:377
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...
#define FILL(wfunc)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
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(* 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...
uint64_t vOffset
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
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:218
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)