FFmpeg
swscale_internal.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
23 
24 #include <stdatomic.h>
25 
26 #include "config.h"
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/frame.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/log.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/pixfmt.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/slicethread.h"
38 #include "libavutil/half2float.h"
39 
40 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
41 
42 #define YUVRGB_TABLE_HEADROOM 512
43 #define YUVRGB_TABLE_LUMA_HEADROOM 512
44 
45 #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
46 
47 #define DITHER1XBPP
48 
49 #if HAVE_BIGENDIAN
50 #define ALT32_CORR (-1)
51 #else
52 #define ALT32_CORR 1
53 #endif
54 
55 #if ARCH_X86_64
56 # define APCK_PTR2 8
57 # define APCK_COEF 16
58 # define APCK_SIZE 24
59 #else
60 # define APCK_PTR2 4
61 # define APCK_COEF 8
62 # define APCK_SIZE 16
63 #endif
64 
65 #define RETCODE_USE_CASCADE -12345
66 
67 struct SwsContext;
68 
69 typedef enum SwsDither {
77 } SwsDither;
78 
79 typedef enum SwsAlphaBlend {
85 
86 typedef struct Range {
87  unsigned int start;
88  unsigned int len;
89 } Range;
90 
91 typedef struct RangeList {
93  unsigned int nb_ranges;
95 } RangeList;
96 
97 int ff_range_add(RangeList *r, unsigned int start, unsigned int len);
98 
99 typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
100  int srcStride[], int srcSliceY, int srcSliceH,
101  uint8_t *dst[], int dstStride[]);
102 
103 /**
104  * Write one line of horizontally scaled data to planar output
105  * without any additional vertical scaling (or point-scaling).
106  *
107  * @param src scaled source data, 15 bits for 8-10-bit output,
108  * 19 bits for 16-bit output (in int32_t)
109  * @param dest pointer to the output plane. For >8-bit
110  * output, this is in uint16_t
111  * @param dstW width of destination in pixels
112  * @param dither ordered dither array of type int16_t and size 8
113  * @param offset Dither offset
114  */
115 typedef void (*yuv2planar1_fn)(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 data to planar output
120  * with multi-point vertical scaling between input pixels.
121  *
122  * @param filter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
123  * @param src scaled luma (Y) or alpha (A) source data, 15 bits for
124  * 8-10-bit output, 19 bits for 16-bit output (in int32_t)
125  * @param filterSize number of vertical input lines to scale
126  * @param dest pointer to output plane. For >8-bit
127  * output, this is in uint16_t
128  * @param dstW width of destination pixels
129  * @param offset Dither offset
130  */
131 typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
132  const int16_t **src, uint8_t *dest, int dstW,
133  const uint8_t *dither, int offset);
134 
135 /**
136  * Write one line of horizontally scaled chroma to interleaved output
137  * with multi-point vertical scaling between input pixels.
138  *
139  * @param dstFormat destination pixel format
140  * @param chrDither ordered dither array of type uint8_t and size 8
141  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
142  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit
143  * output, 19 bits for 16-bit output (in int32_t)
144  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit
145  * output, 19 bits for 16-bit output (in int32_t)
146  * @param chrFilterSize number of vertical chroma input lines to scale
147  * @param dest pointer to the output plane. For >8-bit
148  * output, this is in uint16_t
149  * @param dstW width of chroma planes
150  */
152  const uint8_t *chrDither,
153  const int16_t *chrFilter,
154  int chrFilterSize,
155  const int16_t **chrUSrc,
156  const int16_t **chrVSrc,
157  uint8_t *dest, int dstW);
158 
159 /**
160  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
161  * output without any additional vertical scaling (or point-scaling). Note
162  * that this function may do chroma scaling, see the "uvalpha" argument.
163  *
164  * @param c SWS scaling context
165  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
166  * 19 bits for 16-bit output (in int32_t)
167  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
168  * 19 bits for 16-bit output (in int32_t)
169  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
170  * 19 bits for 16-bit output (in int32_t)
171  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
172  * 19 bits for 16-bit output (in int32_t)
173  * @param dest pointer to the output plane. For 16-bit output, this is
174  * uint16_t
175  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
176  * to write into dest[]
177  * @param uvalpha chroma scaling coefficient for the second line of chroma
178  * pixels, either 2048 or 0. If 0, one chroma input is used
179  * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
180  * is set, it generates 1 output pixel). If 2048, two chroma
181  * input pixels should be averaged for 2 output pixels (this
182  * only happens if SWS_FLAG_FULL_CHR_INT is not set)
183  * @param y vertical line number for this output. This does not need
184  * to be used to calculate the offset in the destination,
185  * but can be used to generate comfort noise using dithering
186  * for some output formats.
187  */
188 typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
189  const int16_t *chrUSrc[2],
190  const int16_t *chrVSrc[2],
191  const int16_t *alpSrc, uint8_t *dest,
192  int dstW, int uvalpha, int y);
193 /**
194  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
195  * output by doing bilinear scaling between two input lines.
196  *
197  * @param c SWS scaling context
198  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
199  * 19 bits for 16-bit output (in int32_t)
200  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
201  * 19 bits for 16-bit output (in int32_t)
202  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
203  * 19 bits for 16-bit output (in int32_t)
204  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
205  * 19 bits for 16-bit output (in int32_t)
206  * @param dest pointer to the output plane. For 16-bit output, this is
207  * uint16_t
208  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
209  * to write into dest[]
210  * @param yalpha luma/alpha scaling coefficients for the second input line.
211  * The first line's coefficients can be calculated by using
212  * 4096 - yalpha
213  * @param uvalpha chroma scaling coefficient for the second input line. The
214  * first line's coefficients can be calculated by using
215  * 4096 - uvalpha
216  * @param y vertical line number for this output. This does not need
217  * to be used to calculate the offset in the destination,
218  * but can be used to generate comfort noise using dithering
219  * for some output formats.
220  */
221 typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
222  const int16_t *chrUSrc[2],
223  const int16_t *chrVSrc[2],
224  const int16_t *alpSrc[2],
225  uint8_t *dest,
226  int dstW, int yalpha, int uvalpha, int y);
227 /**
228  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
229  * output by doing multi-point vertical scaling between input pixels.
230  *
231  * @param c SWS scaling context
232  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
233  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
234  * 19 bits for 16-bit output (in int32_t)
235  * @param lumFilterSize number of vertical luma/alpha input lines to scale
236  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
237  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
238  * 19 bits for 16-bit output (in int32_t)
239  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
240  * 19 bits for 16-bit output (in int32_t)
241  * @param chrFilterSize number of vertical chroma input lines to scale
242  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
243  * 19 bits for 16-bit output (in int32_t)
244  * @param dest pointer to the output plane. For 16-bit output, this is
245  * uint16_t
246  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
247  * to write into dest[]
248  * @param y vertical line number for this output. This does not need
249  * to be used to calculate the offset in the destination,
250  * but can be used to generate comfort noise using dithering
251  * or some output formats.
252  */
253 typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
254  const int16_t **lumSrc, int lumFilterSize,
255  const int16_t *chrFilter,
256  const int16_t **chrUSrc,
257  const int16_t **chrVSrc, int chrFilterSize,
258  const int16_t **alpSrc, uint8_t *dest,
259  int dstW, int y);
260 
261 /**
262  * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
263  * output by doing multi-point vertical scaling between input pixels.
264  *
265  * @param c SWS scaling context
266  * @param lumFilter vertical luma/alpha scaling coefficients, 12 bits [0,4096]
267  * @param lumSrc scaled luma (Y) source data, 15 bits for 8-10-bit output,
268  * 19 bits for 16-bit output (in int32_t)
269  * @param lumFilterSize number of vertical luma/alpha input lines to scale
270  * @param chrFilter vertical chroma scaling coefficients, 12 bits [0,4096]
271  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
272  * 19 bits for 16-bit output (in int32_t)
273  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
274  * 19 bits for 16-bit output (in int32_t)
275  * @param chrFilterSize number of vertical chroma input lines to scale
276  * @param alpSrc scaled alpha (A) source data, 15 bits for 8-10-bit output,
277  * 19 bits for 16-bit output (in int32_t)
278  * @param dest pointer to the output planes. For 16-bit output, this is
279  * uint16_t
280  * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
281  * to write into dest[]
282  * @param y vertical line number for this output. This does not need
283  * to be used to calculate the offset in the destination,
284  * but can be used to generate comfort noise using dithering
285  * or some output formats.
286  */
287 typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
288  const int16_t **lumSrc, int lumFilterSize,
289  const int16_t *chrFilter,
290  const int16_t **chrUSrc,
291  const int16_t **chrVSrc, int chrFilterSize,
292  const int16_t **alpSrc, uint8_t **dest,
293  int dstW, int y);
294 
295 struct SwsSlice;
296 struct SwsFilterDescriptor;
297 
298 /* This struct should be aligned on at least a 32-byte boundary. */
299 typedef struct SwsContext {
300  /**
301  * info on struct for av_log
302  */
304 
306 
309  int *slice_err;
311 
312  // values passed to current sws_receive_slice() call
315 
316  /**
317  * Note that src, dst, srcStride, dstStride will be copied in the
318  * sws_scale() wrapper so they can be freely modified here.
319  */
321  int srcW; ///< Width of source luma/alpha planes.
322  int srcH; ///< Height of source luma/alpha planes.
323  int dstH; ///< Height of destination luma/alpha planes.
324  int chrSrcW; ///< Width of source chroma planes.
325  int chrSrcH; ///< Height of source chroma planes.
326  int chrDstW; ///< Width of destination chroma planes.
327  int chrDstH; ///< Height of destination chroma planes.
330  enum AVPixelFormat dstFormat; ///< Destination pixel format.
331  enum AVPixelFormat srcFormat; ///< Source pixel format.
332  int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
333  int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
335  int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
336  int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
337  int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
338  int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
339  int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
340  int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
341  int nb_threads; ///< Number of threads used for scaling
342  double param[2]; ///< Input parameters for scaling algorithms that need them.
343 
346 
348 
349  /* The cascaded_* fields allow spliting a scaler task into multiple
350  * sequential steps, this is for example used to limit the maximum
351  * downscaling factor that needs to be supported in one scaler.
352  */
355  uint8_t *cascaded_tmp[4];
357  uint8_t *cascaded1_tmp[4];
359 
360  double gamma_value;
363  uint16_t *gamma;
364  uint16_t *inv_gamma;
365 
366  int numDesc;
367  int descIndex[2];
368  int numSlice;
369  struct SwsSlice *slice;
371 
372  uint32_t pal_yuv[256];
373  uint32_t pal_rgb[256];
374 
375  float uint2float_lut[256];
376 
377  /**
378  * @name Scaled horizontal lines ring buffer.
379  * The horizontal scaler keeps just enough scaled lines in a ring buffer
380  * so they may be passed to the vertical scaler. The pointers to the
381  * allocated buffers for each line are duplicated in sequence in the ring
382  * buffer to simplify indexing and avoid wrapping around between lines
383  * inside the vertical scaler code. The wrapping is done before the
384  * vertical scaler is called.
385  */
386  //@{
387  int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
388  int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
389  //@}
390 
393 
394  /**
395  * @name Horizontal and vertical filters.
396  * To better understand the following fields, here is a pseudo-code of
397  * their usage in filtering a horizontal line:
398  * @code
399  * for (i = 0; i < width; i++) {
400  * dst[i] = 0;
401  * for (j = 0; j < filterSize; j++)
402  * dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
403  * dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
404  * }
405  * @endcode
406  */
407  //@{
408  int16_t *hLumFilter; ///< Array of horizontal filter coefficients for luma/alpha planes.
409  int16_t *hChrFilter; ///< Array of horizontal filter coefficients for chroma planes.
410  int16_t *vLumFilter; ///< Array of vertical filter coefficients for luma/alpha planes.
411  int16_t *vChrFilter; ///< Array of vertical filter coefficients for chroma planes.
412  int32_t *hLumFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
413  int32_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
414  int32_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
415  int32_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
416  int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
417  int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
418  int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
419  int vChrFilterSize; ///< Vertical filter size for chroma pixels.
420  //@}
421 
422  int lumMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
423  int chrMmxextFilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
424  uint8_t *lumMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
425  uint8_t *chrMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
426 
429 
430  int dstY; ///< Last destination vertical line output from last slice.
431  int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
432  void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
433  // alignment ensures the offset can be added in a single
434  // instruction on e.g. ARM
436  uint8_t *table_rV[256 + 2*YUVRGB_TABLE_HEADROOM];
437  uint8_t *table_gU[256 + 2*YUVRGB_TABLE_HEADROOM];
438  uint8_t *table_bU[256 + 2*YUVRGB_TABLE_HEADROOM];
439  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
440 #define RY_IDX 0
441 #define GY_IDX 1
442 #define BY_IDX 2
443 #define RU_IDX 3
444 #define GU_IDX 4
445 #define BU_IDX 5
446 #define RV_IDX 6
447 #define GV_IDX 7
448 #define BV_IDX 8
449 #define RGB2YUV_SHIFT 15
450 
451  int *dither_error[4];
452 
453  //Colorspace stuff
454  int contrast, brightness, saturation; // for sws_getColorspaceDetails
457  int srcRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (source image).
458  int dstRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
461  int srcXYZ;
462  int dstXYZ;
473 
474 #define RED_DITHER "0*8"
475 #define GREEN_DITHER "1*8"
476 #define BLUE_DITHER "2*8"
477 #define Y_COEFF "3*8"
478 #define VR_COEFF "4*8"
479 #define UB_COEFF "5*8"
480 #define VG_COEFF "6*8"
481 #define UG_COEFF "7*8"
482 #define Y_OFFSET "8*8"
483 #define U_OFFSET "9*8"
484 #define V_OFFSET "10*8"
485 #define LUM_MMX_FILTER_OFFSET "11*8"
486 #define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
487 #define DSTW_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
488 #define ESP_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
489 #define VROUNDER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
490 #define U_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
491 #define V_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
492 #define Y_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
493 #define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
494 #define UV_OFF_PX "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
495 #define UV_OFF_BYTE "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
496 #define DITHER16 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
497 #define DITHER32 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
498 #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
499 
500  DECLARE_ALIGNED(8, uint64_t, redDither);
503 
504  DECLARE_ALIGNED(8, uint64_t, yCoeff);
505  DECLARE_ALIGNED(8, uint64_t, vrCoeff);
506  DECLARE_ALIGNED(8, uint64_t, ubCoeff);
507  DECLARE_ALIGNED(8, uint64_t, vgCoeff);
508  DECLARE_ALIGNED(8, uint64_t, ugCoeff);
509  DECLARE_ALIGNED(8, uint64_t, yOffset);
510  DECLARE_ALIGNED(8, uint64_t, uOffset);
511  DECLARE_ALIGNED(8, uint64_t, vOffset);
514  int dstW; ///< Width of destination luma/alpha planes.
515  DECLARE_ALIGNED(8, uint64_t, esp);
516  DECLARE_ALIGNED(8, uint64_t, vRounder);
517  DECLARE_ALIGNED(8, uint64_t, u_temp);
518  DECLARE_ALIGNED(8, uint64_t, v_temp);
519  DECLARE_ALIGNED(8, uint64_t, y_temp);
521  // alignment of these values is not necessary, but merely here
522  // to maintain the same offset across x8632 and x86-64. Once we
523  // use proper offset macros in the asm, they can be removed.
524  DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
525  DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
526  DECLARE_ALIGNED(8, uint16_t, dither16)[8];
527  DECLARE_ALIGNED(8, uint32_t, dither32)[8];
528 
529  const uint8_t *chrDither8, *lumDither8;
530 
531 #if HAVE_ALTIVEC
532  vector signed short CY;
533  vector signed short CRV;
534  vector signed short CBU;
535  vector signed short CGU;
536  vector signed short CGV;
537  vector signed short OY;
538  vector unsigned short CSHIFT;
539  vector signed short *vYCoeffsBank, *vCCoeffsBank;
540 #endif
541 
543 
544 /* pre defined color-spaces gamma */
545 #define XYZ_GAMMA (2.6f)
546 #define RGB_GAMMA (2.2f)
547  int16_t *xyzgamma;
548  int16_t *rgbgamma;
549  int16_t *xyzgammainv;
550  int16_t *rgbgammainv;
551  int16_t xyz2rgb_matrix[3][4];
552  int16_t rgb2xyz_matrix[3][4];
553 
554  /* function pointers for swscale() */
562 
563  /// Opaque data pointer passed to all input functions.
565 
566  /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
567  void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
568  int width, uint32_t *pal, void *opq);
569  /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
570  void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
571  int width, uint32_t *pal, void *opq);
572  /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
573  void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
574  const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
575  int width, uint32_t *pal, void *opq);
576 
577  /**
578  * Functions to read planar input, such as planar RGB, and convert
579  * internally to Y/UV/A.
580  */
581  /** @{ */
582  void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv,
583  void *opq);
584  void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
585  int width, int32_t *rgb2yuv, void *opq);
586  void (*readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv,
587  void *opq);
588  /** @} */
589 
590  /**
591  * Scale one horizontal line of input data using a bilinear filter
592  * to produce one line of output data. Compared to SwsContext->hScale(),
593  * please take note of the following caveats when using these:
594  * - Scaling is done using only 7 bits instead of 14-bit coefficients.
595  * - You can use no more than 5 input pixels to produce 4 output
596  * pixels. Therefore, this filter should not be used for downscaling
597  * by more than ~20% in width (because that equals more than 5/4th
598  * downscaling and thus more than 5 pixels input per 4 pixels output).
599  * - In general, bilinear filters create artifacts during downscaling
600  * (even when <20%), because one output pixel will span more than one
601  * input pixel, and thus some pixels will need edges of both neighbor
602  * pixels to interpolate the output pixel. Since you can use at most
603  * two input pixels per output pixel in bilinear scaling, this is
604  * impossible and thus downscaling by any size will create artifacts.
605  * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
606  * in SwsContext->flags.
607  */
608  /** @{ */
609  void (*hyscale_fast)(struct SwsContext *c,
610  int16_t *dst, int dstWidth,
611  const uint8_t *src, int srcW, int xInc);
612  void (*hcscale_fast)(struct SwsContext *c,
613  int16_t *dst1, int16_t *dst2, int dstWidth,
614  const uint8_t *src1, const uint8_t *src2,
615  int srcW, int xInc);
616  /** @} */
617 
618  /**
619  * Scale one horizontal line of input data using a filter over the input
620  * lines, to produce one (differently sized) line of output data.
621  *
622  * @param dst pointer to destination buffer for horizontally scaled
623  * data. If the number of bits per component of one
624  * destination pixel (SwsContext->dstBpc) is <= 10, data
625  * will be 15 bpc in 16 bits (int16_t) width. Else (i.e.
626  * SwsContext->dstBpc == 16), data will be 19bpc in
627  * 32 bits (int32_t) width.
628  * @param dstW width of destination image
629  * @param src pointer to source data to be scaled. If the number of
630  * bits per component of a source pixel (SwsContext->srcBpc)
631  * is 8, this is 8bpc in 8 bits (uint8_t) width. Else
632  * (i.e. SwsContext->dstBpc > 8), this is native depth
633  * in 16 bits (uint16_t) width. In other words, for 9-bit
634  * YUV input, this is 9bpc, for 10-bit YUV input, this is
635  * 10bpc, and for 16-bit RGB or YUV, this is 16bpc.
636  * @param filter filter coefficients to be used per output pixel for
637  * scaling. This contains 14bpp filtering coefficients.
638  * Guaranteed to contain dstW * filterSize entries.
639  * @param filterPos position of the first input pixel to be used for
640  * each output pixel during scaling. Guaranteed to
641  * contain dstW entries.
642  * @param filterSize the number of input coefficients to be used (and
643  * thus the number of input pixels to be used) for
644  * creating a single output pixel. Is aligned to 4
645  * (and input coefficients thus padded with zeroes)
646  * to simplify creating SIMD code.
647  */
648  /** @{ */
649  void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
650  const uint8_t *src, const int16_t *filter,
651  const int32_t *filterPos, int filterSize);
652  void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
653  const uint8_t *src, const int16_t *filter,
654  const int32_t *filterPos, int filterSize);
655  /** @} */
656 
657  /// Color range conversion function for luma plane if needed.
658  void (*lumConvertRange)(int16_t *dst, int width);
659  /// Color range conversion function for chroma planes if needed.
660  void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
661 
662  int needs_hcscale; ///< Set if there are chroma planes to be converted.
663 
665 
667 
668  // scratch buffer for converting packed rgb0 sources
669  // filled with a copy of the input frame + fully opaque alpha,
670  // then passed as input to further conversion
671  uint8_t *rgb0_scratch;
673 
674  // scratch buffer for converting XYZ sources
675  // filled with the input converted to rgb48
676  // then passed as input to further conversion
677  uint8_t *xyz_scratch;
678  unsigned int xyz_scratch_allocated;
679 
680  unsigned int dst_slice_align;
683 
685 } SwsContext;
686 //FIXME check init (where 0)
687 
689 int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
690  int fullRange, int brightness,
691  int contrast, int saturation);
692 void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4],
693  int brightness, int contrast, int saturation);
694 
696 
698 
702 
704 {
706  av_assert0(desc);
707  return desc->comp[0].depth == 16;
708 }
709 
711 {
713  av_assert0(desc);
714  return desc->comp[0].depth == 32;
715 }
716 
718 {
720  av_assert0(desc);
721  return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
722 }
723 
725 {
727  av_assert0(desc);
728  return desc->flags & AV_PIX_FMT_FLAG_BE;
729 }
730 
732 {
734  av_assert0(desc);
735  return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
736 }
737 
739 {
741  av_assert0(desc);
742  return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
743 }
744 
745 /*
746  * Identity semi-planar YUV formats. Specifically, those are YUV formats
747  * where the second and third components (U & V) are on the same plane.
748  */
750 {
752  av_assert0(desc);
753  return (isPlanarYUV(pix_fmt) && desc->comp[1].plane == desc->comp[2].plane);
754 }
755 
757 {
759  av_assert0(desc);
760  return (desc->flags & AV_PIX_FMT_FLAG_RGB);
761 }
762 
764 {
766  av_assert0(desc);
767  return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
768  !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
769  desc->nb_components <= 2 &&
772 }
773 
775 {
776  return pix_fmt == AV_PIX_FMT_RGB48BE ||
794 }
795 
797 {
798  return pix_fmt == AV_PIX_FMT_BGR48BE ||
816 }
817 
819 {
821  av_assert0(desc);
822  return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
823 }
824 
826 {
828  av_assert0(desc);
829  return desc->comp[1].depth == 8;
830 }
831 
833 {
835  av_assert0(desc);
836  return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
838 }
839 
841 {
843  av_assert0(desc);
844  return desc->flags & AV_PIX_FMT_FLAG_FLOAT;
845 }
846 
848 {
850  av_assert0(desc);
851  return (desc->flags & AV_PIX_FMT_FLAG_FLOAT) && desc->comp[0].depth == 16;
852 }
853 
855 {
857  av_assert0(desc);
858  if (pix_fmt == AV_PIX_FMT_PAL8)
859  return 1;
860  return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
861 }
862 
864 {
866  av_assert0(desc);
867  return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
870 }
871 
873 {
875  av_assert0(desc);
876  return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
877 }
878 
880 {
882  av_assert0(desc);
884 }
885 
887 {
889  av_assert0(desc);
890  return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
892 }
893 
895 {
896  switch (pix_fmt) {
897  case AV_PIX_FMT_PAL8:
899  case AV_PIX_FMT_BGR8:
900  case AV_PIX_FMT_GRAY8:
902  case AV_PIX_FMT_RGB8:
903  return 1;
904  default:
905  return 0;
906  }
907 }
908 
909 /*
910  * Identity formats where the data is in the high bits, and the low bits are shifted away.
911  */
913 {
914  int i;
916  av_assert0(desc);
918  return 0;
919  for (i = 0; i < desc->nb_components; i++) {
920  if (!desc->comp[i].shift)
921  return 0;
922  if ((desc->comp[i].shift + desc->comp[i].depth) & 0x7)
923  return 0;
924  }
925  return 1;
926 }
927 
928 /*
929  * Identity formats where the chroma planes are swapped (CrCb order).
930  */
932 {
934  av_assert0(desc);
935  if (!isYUV(pix_fmt))
936  return 0;
937  if ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) && desc->nb_components < 4)
938  return 0;
939  if (desc->nb_components < 3)
940  return 0;
942  return desc->comp[1].offset > desc->comp[2].offset;
943  else
944  return desc->comp[1].plane > desc->comp[2].plane;
945 }
946 
947 extern const uint64_t ff_dither4[2];
948 extern const uint64_t ff_dither8[2];
949 
950 extern const uint8_t ff_dither_2x2_4[3][8];
951 extern const uint8_t ff_dither_2x2_8[3][8];
952 extern const uint8_t ff_dither_4x4_16[5][8];
953 extern const uint8_t ff_dither_8x8_32[9][8];
954 extern const uint8_t ff_dither_8x8_73[9][8];
955 extern const uint8_t ff_dither_8x8_128[9][8];
956 extern const uint8_t ff_dither_8x8_220[9][8];
957 
958 extern const int32_t ff_yuv2rgb_coeffs[11][4];
959 
960 extern const AVClass ff_sws_context_class;
961 
962 /**
963  * Set c->convert_unscaled to an unscaled converter if one exists for the
964  * specific source and destination formats, bit depths, flags, etc.
965  */
970 
972 
988 
989 void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
990  const uint8_t *src, int srcW, int xInc);
991 void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
992  int dstWidth, const uint8_t *src1,
993  const uint8_t *src2, int srcW, int xInc);
994 int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
995  int16_t *filter, int32_t *filterPos,
996  int numSplits);
997 void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
998  int dstWidth, const uint8_t *src,
999  int srcW, int xInc);
1000 void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
1001  int dstWidth, const uint8_t *src1,
1002  const uint8_t *src2, int srcW, int xInc);
1003 
1004 /**
1005  * Allocate and return an SwsContext.
1006  * This is like sws_getContext() but does not perform the init step, allowing
1007  * the user to set additional AVOptions.
1008  *
1009  * @see sws_getContext()
1010  */
1012  int dstW, int dstH, enum AVPixelFormat dstFormat,
1013  int flags, const double *param);
1014 
1015 int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[],
1016  int srcStride[], int srcSliceY, int srcSliceH,
1017  uint8_t *dst[], int dstStride[]);
1018 
1019 static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
1020  int alpha, int bits, const int big_endian)
1021 {
1022  int i, j;
1023  uint8_t *ptr = plane + stride * y;
1024  int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
1025  for (i = 0; i < height; i++) {
1026 #define FILL(wfunc) \
1027  for (j = 0; j < width; j++) {\
1028  wfunc(ptr+2*j, v);\
1029  }
1030  if (big_endian) {
1031  FILL(AV_WB16);
1032  } else {
1033  FILL(AV_WL16);
1034  }
1035  ptr += stride;
1036  }
1037 #undef FILL
1038 }
1039 
1040 static inline void fillPlane32(uint8_t *plane, int stride, int width, int height, int y,
1041  int alpha, int bits, const int big_endian, int is_float)
1042 {
1043  int i, j;
1044  uint8_t *ptr = plane + stride * y;
1045  uint32_t v;
1046  uint32_t onef32 = 0x3f800000;
1047  if (is_float)
1048  v = alpha ? onef32 : 0;
1049  else
1050  v = alpha ? 0xFFFFFFFF>>(32-bits) : (1<<(bits-1));
1051 
1052  for (i = 0; i < height; i++) {
1053 #define FILL(wfunc) \
1054  for (j = 0; j < width; j++) {\
1055  wfunc(ptr+4*j, v);\
1056  }
1057  if (big_endian) {
1058  FILL(AV_WB32);
1059  } else {
1060  FILL(AV_WL32);
1061  }
1062  ptr += stride;
1063  }
1064 #undef FILL
1065 }
1066 
1067 
1068 #define MAX_SLICE_PLANES 4
1069 
1070 /// Slice plane
1071 typedef struct SwsPlane
1072 {
1073  int available_lines; ///< max number of lines that can be hold by this plane
1074  int sliceY; ///< index of first line
1075  int sliceH; ///< number of lines
1076  uint8_t **line; ///< line buffer
1077  uint8_t **tmp; ///< Tmp line buffer used by mmx code
1078 } SwsPlane;
1079 
1080 /**
1081  * Struct which defines a slice of an image to be scaled or an output for
1082  * a scaled slice.
1083  * A slice can also be used as intermediate ring buffer for scaling steps.
1084  */
1085 typedef struct SwsSlice
1086 {
1087  int width; ///< Slice line width
1088  int h_chr_sub_sample; ///< horizontal chroma subsampling factor
1089  int v_chr_sub_sample; ///< vertical chroma subsampling factor
1090  int is_ring; ///< flag to identify if this slice is a ring buffer
1091  int should_free_lines; ///< flag to identify if there are dynamic allocated lines
1092  enum AVPixelFormat fmt; ///< planes pixel format
1093  SwsPlane plane[MAX_SLICE_PLANES]; ///< color planes
1094 } SwsSlice;
1095 
1096 /**
1097  * Struct which holds all necessary data for processing a slice.
1098  * A processing step can be a color conversion or horizontal/vertical scaling.
1099  */
1100 typedef struct SwsFilterDescriptor
1101 {
1102  SwsSlice *src; ///< Source slice
1103  SwsSlice *dst; ///< Output slice
1104 
1105  int alpha; ///< Flag for processing alpha channel
1106  void *instance; ///< Filter instance data
1107 
1108  /// Function for processing input slice sliceH lines starting from line sliceY
1109  int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
1111 
1112 // warp input lines in the form (src + width*i + j) to slice format (line[i][j])
1113 // relative=true means first line src[x][0] otherwise first line is src[x][lum/crh Y]
1114 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);
1115 
1116 // Initialize scaler filter descriptor chain
1118 
1119 // Free all filter data
1121 
1122 /*
1123  function for applying ring buffer logic into slice s
1124  It checks if the slice can hold more @lum lines, if yes
1125  do nothing otherwise remove @lum least used lines.
1126  It applies the same procedure for @chr lines.
1127 */
1128 int ff_rotate_slice(SwsSlice *s, int lum, int chr);
1129 
1130 /// initializes gamma conversion descriptor
1132 
1133 /// initializes lum pixel format conversion descriptor
1135 
1136 /// initializes lum horizontal scaling descriptor
1137 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
1138 
1139 /// initializes chr pixel format conversion descriptor
1141 
1142 /// initializes chr horizontal scaling descriptor
1143 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
1144 
1146 
1147 /// initializes vertical scaling descriptors
1149 
1150 /// setup vertical scaler functions
1152  yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
1153  yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);
1154 
1155 void ff_sws_slice_worker(void *priv, int jobnr, int threadnr,
1156  int nb_jobs, int nb_threads);
1157 
1158 //number of extra lines to process
1159 #define MAX_LINES_AHEAD 4
1160 
1161 //shuffle filter and filterPos for hyScale and hcScale filters in avx2
1162 int ff_shuffle_filter_coefficients(SwsContext *c, int* filterPos, int filterSize, int16_t *filter, int dstW);
1163 #endif /* SWSCALE_SWSCALE_INTERNAL_H */
isBayer
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:818
ff_sws_init_swscale_ppc
void ff_sws_init_swscale_ppc(SwsContext *c)
Definition: swscale_altivec.c:238
SwsContext::is_internal_gamma
int is_internal_gamma
Definition: swscale_internal.h:362
SwsContext::lastInChrBuf
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
Definition: swscale_internal.h:388
yuv2packed2_fn
void(* yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2], const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing bilinear scalin...
Definition: swscale_internal.h:221
SwsContext::flags
int flags
Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc....
Definition: swscale_internal.h:431
SwsContext::vLumFilterSize
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
Definition: swscale_internal.h:418
SwsContext::saturation
int saturation
Definition: swscale_internal.h:454
SwsContext::vOffset
uint64_t vOffset
Definition: swscale_internal.h:511
yuv2planar1_fn
void(* yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output without any additional vertical scaling (...
Definition: swscale_internal.h:115
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
Definition: yuv2rgb.c:776
SwsFilterDescriptor::process
int(* process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH)
Function for processing input slice sliceH lines starting from line sliceY.
Definition: swscale_internal.h:1109
yuv2packed1_fn
void(* yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc, const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc, uint8_t *dest, int dstW, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output without any additional v...
Definition: swscale_internal.h:188
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_dither_8x8_128
const uint8_t ff_dither_8x8_128[9][8]
Definition: swscale.c:36
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:139
SwsContext::chrSrcW
int chrSrcW
Width of source chroma planes.
Definition: swscale_internal.h:324
isPlanarRGB
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:886
SwsPlane::sliceH
int sliceH
number of lines
Definition: swscale_internal.h:1075
ff_sws_slice_worker
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: swscale.c:1216
isRGB
static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:756
Half2FloatTables
Definition: half2float.h:27
isPacked
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:863
SwsPlane::line
uint8_t ** line
line buffer
Definition: swscale_internal.h:1076
r
const char * r
Definition: vf_curves.c:126
SWS_ALPHA_BLEND_NONE
@ SWS_ALPHA_BLEND_NONE
Definition: swscale_internal.h:80
SwsContext::formatConvBuffer
uint8_t * formatConvBuffer
Definition: swscale_internal.h:391
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:197
SwsContext::dstW
int dstW
Width of destination luma/alpha planes.
Definition: swscale_internal.h:514
ff_dither_8x8_220
const uint8_t ff_dither_8x8_220[9][8]
Definition: output.c:84
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
mem_internal.h
ff_sws_init_swscale_vsx
void ff_sws_init_swscale_vsx(SwsContext *c)
Definition: swscale_vsx.c:2077
SwsContext::dstFormatBpp
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
Definition: swscale_internal.h:332
SwsContext::cascaded1_tmp
uint8_t * cascaded1_tmp[4]
Definition: swscale_internal.h:357
SwsContext::rgbgamma
int16_t * rgbgamma
Definition: swscale_internal.h:548
SWS_DITHER_BAYER
@ SWS_DITHER_BAYER
Definition: swscale_internal.h:72
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:434
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:129
isPlanarYUV
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:738
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2858
SwsContext::dstY
int dstY
Last destination vertical line output from last slice.
Definition: swscale_internal.h:430
ff_sws_init_swscale_x86
void ff_sws_init_swscale_x86(SwsContext *c)
Definition: swscale.c:450
sws_alloc_set_opts
struct SwsContext * sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, const double *param)
Allocate and return an SwsContext.
Definition: utils.c:2059
SwsContext::cascaded_mainindex
int cascaded_mainindex
Definition: swscale_internal.h:358
SwsContext::alphablend
SwsAlphaBlend alphablend
Definition: swscale_internal.h:666
src1
const pixel * src1
Definition: h264pred_template.c:421
SwsContext::chrDither8
const uint8_t * chrDither8
Definition: swscale_internal.h:529
SwsContext::cascaded1_tmpStride
int cascaded1_tmpStride[4]
Definition: swscale_internal.h:356
SwsContext::yOffset
uint64_t yOffset
Definition: swscale_internal.h:509
SwsContext::vrCoeff
uint64_t vrCoeff
Definition: swscale_internal.h:505
RangeList::ranges_allocated
int ranges_allocated
Definition: swscale_internal.h:94
ff_sws_init_swscale_loongarch
void ff_sws_init_swscale_loongarch(SwsContext *c)
Definition: swscale_init_loongarch.c:27
SwsContext::hChrFilterPos
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
Definition: swscale_internal.h:413
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
SwsSlice::plane
SwsPlane plane[MAX_SLICE_PLANES]
color planes
Definition: swscale_internal.h:1093
SwsContext::xyz_scratch
uint8_t * xyz_scratch
Definition: swscale_internal.h:677
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale_internal.h:74
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
SwsContext::ubCoeff
uint64_t ubCoeff
Definition: swscale_internal.h:506
SwsContext::dstColorspaceTable
int dstColorspaceTable[4]
Definition: swscale_internal.h:456
isGray
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:763
ff_rotate_slice
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
Definition: slice.c:119
SwsContext::vChrFilter
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
Definition: swscale_internal.h:411
SwsContext::lumMmxFilter
int32_t lumMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:512
SWS_ALPHA_BLEND_NB
@ SWS_ALPHA_BLEND_NB
Definition: swscale_internal.h:83
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: alphablend.c:23
SwsContext::chrDstVSubSample
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
Definition: swscale_internal.h:338
ff_sws_init_input_funcs
void ff_sws_init_input_funcs(SwsContext *c)
SwsContext::vLumFilter
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
Definition: swscale_internal.h:410
ff_init_slice_from_src
int ff_init_slice_from_src(SwsSlice *s, uint8_t *src[4], int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH, int relative)
Definition: slice.c:147
SwsFilterDescriptor
Struct which holds all necessary data for processing a slice.
Definition: swscale_internal.h:1100
yuv2planeX
static void FUNC() yuv2planeX(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Definition: swscale_ppc_template.c:84
table
static const uint16_t table[]
Definition: prosumer.c:205
ff_sws_init_scale
void ff_sws_init_scale(SwsContext *c)
Definition: swscale.c:589
SwsContext::av_class
const AVClass * av_class
info on struct for av_log
Definition: swscale_internal.h:303
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:68
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:433
SwsContext::yuv2planeX
yuv2planarX_fn yuv2planeX
Definition: swscale_internal.h:556
SwsContext::redDither
uint64_t redDither
Definition: swscale_internal.h:500
SwsContext::yuv2plane1
yuv2planar1_fn yuv2plane1
Definition: swscale_internal.h:555
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
SwsContext::nb_threads
int nb_threads
Number of threads used for scaling.
Definition: swscale_internal.h:341
SwsContext::srcRange
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
Definition: swscale_internal.h:457
CY
@ CY
Definition: vf_vpp_qsv.c:160
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
SwsContext::lumDither8
const uint8_t * lumDither8
Definition: swscale_internal.h:529
ff_get_unscaled_swscale_aarch64
void ff_get_unscaled_swscale_aarch64(SwsContext *c)
Definition: swscale_unscaled.c:124
SwsContext::needAlpha
int needAlpha
Definition: swscale_internal.h:392
SwsContext::xyzgamma
int16_t * xyzgamma
Definition: swscale_internal.h:547
SwsContext::pal_rgb
uint32_t pal_rgb[256]
Definition: swscale_internal.h:373
AVSliceThread
struct AVSliceThread AVSliceThread
Definition: slicethread.h:22
SwsContext::yuv2anyX
yuv2anyX_fn yuv2anyX
Definition: swscale_internal.h:561
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
SwsContext::cascaded_tmp
uint8_t * cascaded_tmp[4]
Definition: swscale_internal.h:355
SwsSlice::fmt
enum AVPixelFormat fmt
planes pixel format
Definition: swscale_internal.h:1092
SwsFilterDescriptor::src
SwsSlice * src
Source slice.
Definition: swscale_internal.h:1102
SwsContext::dst_slice_align
unsigned int dst_slice_align
Definition: swscale_internal.h:680
Range::start
unsigned int start
Definition: swscale_internal.h:87
SwsContext::alpToYV12
void(* alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opq)
Unscaled conversion of alpha plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:570
SwsContext::src0Alpha
int src0Alpha
Definition: swscale_internal.h:459
SwsContext::yuv2nv12cX
yuv2interleavedX_fn yuv2nv12cX
Definition: swscale_internal.h:557
SwsDither
SwsDither
Definition: swscale_internal.h:69
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:703
SwsFilterDescriptor::instance
void * instance
Filter instance data.
Definition: swscale_internal.h:1106
SwsFunc
int(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: swscale_internal.h:99
SwsContext::yuvTable
void * yuvTable
Definition: swscale_internal.h:432
yuv2anyX_fn
void(* yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t **dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to YUV/RGB output by doing multi-point vertical scaling...
Definition: swscale_internal.h:287
SwsContext::use_mmx_vfilter
int use_mmx_vfilter
Definition: swscale_internal.h:542
SwsContext::hcscale_fast
void(* hcscale_fast)(struct SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
Definition: swscale_internal.h:612
SwsContext::rgbgammainv
int16_t * rgbgammainv
Definition: swscale_internal.h:550
SwsContext::src_v_chr_pos
int src_v_chr_pos
Definition: swscale_internal.h:465
SwsContext::xyz2rgb_matrix
int16_t xyz2rgb_matrix[3][4]
Definition: swscale_internal.h:551
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
Range::len
unsigned int len
Definition: swscale_internal.h:88
ff_hyscale_fast_c
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
Definition: hscale_fast_bilinear.c:23
ff_dither_2x2_8
const uint8_t ff_dither_2x2_8[3][8]
Definition: output.c:45
ff_hcscale_fast_c
void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
Definition: hscale_fast_bilinear.c:38
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:717
SwsContext::rgb0_scratch_allocated
unsigned int rgb0_scratch_allocated
Definition: swscale_internal.h:672
SwsContext::hLumFilterSize
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
Definition: swscale_internal.h:416
SwsContext::srcBpc
int srcBpc
Definition: swscale_internal.h:334
SwsSlice::h_chr_sub_sample
int h_chr_sub_sample
horizontal chroma subsampling factor
Definition: swscale_internal.h:1088
SwsContext::gamma_value
double gamma_value
Definition: swscale_internal.h:360
SwsContext::dstXYZ
int dstXYZ
Definition: swscale_internal.h:462
SwsContext::lumYInc
int lumYInc
Definition: swscale_internal.h:329
ff_dither4
const uint64_t ff_dither4[2]
Definition: swscale.c:33
ff_dither_8x8_73
const uint8_t ff_dither_8x8_73[9][8]
Definition: output.c:71
ff_sws_init_range_convert
av_cold void ff_sws_init_range_convert(SwsContext *c)
Definition: swscale.c:532
SwsContext::dither_error
int * dither_error[4]
Definition: swscale_internal.h:451
MAX_FILTER_SIZE
#define MAX_FILTER_SIZE
Definition: swscale_internal.h:45
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
ff_hcscale_fast_mmxext
void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
SwsContext::table_gV
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:435
SwsContext::srcFormat
enum AVPixelFormat srcFormat
Source pixel format.
Definition: swscale_internal.h:331
av_cold
#define av_cold
Definition: attributes.h:90
SwsContext::uv_off
ptrdiff_t uv_off
offset (in pixels) between u and v planes
Definition: swscale_internal.h:524
SwsContext::chrSrcH
int chrSrcH
Height of source chroma planes.
Definition: swscale_internal.h:325
SwsContext::table_bU
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:438
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition: swscale_internal.h:42
SwsContext::dst_slice_height
int dst_slice_height
Definition: swscale_internal.h:314
ff_get_unscaled_swscale_arm
void ff_get_unscaled_swscale_arm(SwsContext *c)
Definition: swscale_unscaled.c:183
SwsContext::lumMmxextFilterCodeSize
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
Definition: swscale_internal.h:422
SwsContext::dither
SwsDither dither
Definition: swscale_internal.h:664
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale_internal.h:73
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
SwsContext::ugCoeff
uint64_t ugCoeff
Definition: swscale_internal.h:508
SwsContext::brightness
int brightness
Definition: swscale_internal.h:454
ff_dither_8x8_32
const uint8_t ff_dither_8x8_32[9][8]
Definition: output.c:59
CSHIFT
#define CSHIFT
Definition: audiogen.c:72
SwsSlice::width
int width
Slice line width.
Definition: swscale_internal.h:1087
SwsContext::lumConvertRange
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
Definition: swscale_internal.h:658
bits
uint8_t bits
Definition: vp3data.h:128
ff_yuv2rgb_init_x86
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
Definition: yuv2rgb.c:68
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SwsPlane::tmp
uint8_t ** tmp
Tmp line buffer used by mmx code.
Definition: swscale_internal.h:1077
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
ff_sws_context_class
const AVClass ff_sws_context_class
Definition: options.c:88
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:87
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
SwsContext::hcScale
void(* hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale_internal.h:652
ff_init_vscale_pfn
void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX, yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2, yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx)
setup vertical scaler functions
Definition: vscale.c:257
SwsContext::contrast
int contrast
Definition: swscale_internal.h:454
SwsContext::lumXInc
int lumXInc
Definition: swscale_internal.h:328
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:435
SwsContext::vLumFilterPos
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
Definition: swscale_internal.h:414
SwsContext::vRounder
uint64_t vRounder
Definition: swscale_internal.h:516
SwsContext::dstFormat
enum AVPixelFormat dstFormat
Destination pixel format.
Definition: swscale_internal.h:330
ff_init_hscaler_mmxext
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
SwsContext::yuv2rgb_y_offset
int yuv2rgb_y_offset
Definition: swscale_internal.h:467
SwsContext::dst_slice_start
int dst_slice_start
Definition: swscale_internal.h:313
isSemiPlanarYUV
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:749
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
SwsContext::slice_err
int * slice_err
Definition: swscale_internal.h:309
SwsContext::yuv2packed2
yuv2packed2_fn yuv2packed2
Definition: swscale_internal.h:559
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale_internal.h:70
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
ff_get_unscaled_swscale
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Definition: swscale_unscaled.c:1974
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_sws_init_swscale_aarch64
void ff_sws_init_swscale_aarch64(SwsContext *c)
Definition: swscale.c:204
SwsContext::xyzgammainv
int16_t * xyzgammainv
Definition: swscale_internal.h:549
isFloat16
static av_always_inline int isFloat16(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:847
SwsPlane::available_lines
int available_lines
max number of lines that can be hold by this plane
Definition: swscale_internal.h:1073
SWS_ALPHA_BLEND_UNIFORM
@ SWS_ALPHA_BLEND_UNIFORM
Definition: swscale_internal.h:81
SwsContext::yuv2rgb_v2g_coeff
int yuv2rgb_v2g_coeff
Definition: swscale_internal.h:470
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
SwsContext::gamma_flag
int gamma_flag
Definition: swscale_internal.h:361
SwsContext::dstBpc
int dstBpc
Definition: swscale_internal.h:334
SwsContext::convert_unscaled
SwsFunc convert_unscaled
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
Definition: swscale_internal.h:320
SwsContext::slicethread
AVSliceThread * slicethread
Definition: swscale_internal.h:307
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
SwsContext::lumMmxextFilterCode
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
Definition: swscale_internal.h:424
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:76
RangeList
Definition: swscale_internal.h:91
NB_SWS_DITHER
@ NB_SWS_DITHER
Definition: swscale_internal.h:76
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:196
SwsPlane
Slice plane.
Definition: swscale_internal.h:1071
SwsContext::greenDither
uint64_t greenDither
Definition: swscale_internal.h:501
SwsContext::blueDither
uint64_t blueDither
Definition: swscale_internal.h:502
RangeList::nb_ranges
unsigned int nb_ranges
Definition: swscale_internal.h:93
ff_init_desc_hscale
int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)
initializes lum horizontal scaling descriptor
Definition: hscale.c:144
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
SwsContext::rgb2xyz_matrix
int16_t rgb2xyz_matrix[3][4]
Definition: swscale_internal.h:552
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:84
SwsContext::alpMmxFilter
int32_t alpMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:520
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
SwsContext::yuv2rgb_v2r_coeff
int yuv2rgb_v2r_coeff
Definition: swscale_internal.h:469
ff_init_desc_no_chr
int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
Definition: hscale.c:281
SwsContext::dst_h_chr_pos
int dst_h_chr_pos
Definition: swscale_internal.h:464
Range
Definition: vf_colorbalance.c:38
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
SwsContext::readChrPlanar
void(* readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
Definition: swscale_internal.h:584
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
ff_range_add
int ff_range_add(RangeList *r, unsigned int start, unsigned int len)
Definition: utils.c:2551
isDataInHighBits
static av_always_inline int isDataInHighBits(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:912
SwsContext::vChrFilterPos
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
Definition: swscale_internal.h:415
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:724
SwsContext::sliceDir
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
Definition: swscale_internal.h:340
SwsContext::src_ranges
RangeList src_ranges
Definition: swscale_internal.h:347
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
SwsContext::chrSrcVSubSample
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
Definition: swscale_internal.h:336
SwsContext::yuv2rgb_u2g_coeff
int yuv2rgb_u2g_coeff
Definition: swscale_internal.h:471
SwsContext::hLumFilterPos
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
Definition: swscale_internal.h:412
SwsFilterDescriptor::dst
SwsSlice * dst
Output slice.
Definition: swscale_internal.h:1103
ff_shuffle_filter_coefficients
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
Definition: utils.c:266
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
fillPlane16
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
Definition: swscale_internal.h:1019
usePal
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:894
SwsContext::v_temp
uint64_t v_temp
Definition: swscale_internal.h:518
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:832
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:130
SwsContext::srcFormatBpp
int srcFormatBpp
Number of bits per pixel of the source pixel format.
Definition: swscale_internal.h:333
SwsContext::srcColorspaceTable
int srcColorspaceTable[4]
Definition: swscale_internal.h:455
SwsContext::desc
struct SwsFilterDescriptor * desc
Definition: swscale_internal.h:370
SwsContext::slice_ctx
struct SwsContext ** slice_ctx
Definition: swscale_internal.h:308
SwsContext::srcH
int srcH
Height of source luma/alpha planes.
Definition: swscale_internal.h:322
srcSliceH
return srcSliceH
Definition: yuv2rgb_template.c:87
ff_init_desc_chscale
int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)
initializes chr horizontal scaling descriptor
Definition: hscale.c:250
isYUV
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:731
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:124
ff_init_desc_cfmt_convert
int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes chr pixel format conversion descriptor
Definition: hscale.c:235
SwsAlphaBlend
SwsAlphaBlend
Definition: swscale_internal.h:79
SwsContext::hyScale
void(* hyScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Scale one horizontal line of input data using a filter over the input lines, to produce one (differen...
Definition: swscale_internal.h:649
frame.h
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:132
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:678
SwsContext::uOffset
uint64_t uOffset
Definition: swscale_internal.h:510
is32BPS
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:710
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
SwsContext::dither32
uint32_t dither32[8]
Definition: swscale_internal.h:527
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:432
isBGRinInt
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:796
ff_yuv2rgb_init_ppc
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)
Definition: yuv2rgb_altivec.c:535
SwsContext::chrMmxextFilterCodeSize
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
Definition: swscale_internal.h:423
SwsContext::hLumFilter
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
Definition: swscale_internal.h:408
isSwappedChroma
static av_always_inline int isSwappedChroma(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:931
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
SwsContext::yuv2packedX
yuv2packedX_fn yuv2packedX
Definition: swscale_internal.h:560
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
SwsContext::vChrFilterSize
int vChrFilterSize
Vertical filter size for chroma pixels.
Definition: swscale_internal.h:419
SwsContext::y_temp
uint64_t y_temp
Definition: swscale_internal.h:519
fillPlane32
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)
Definition: swscale_internal.h:1040
slicethread.h
half2float.h
AV_PIX_FMT_FLAG_BAYER
#define AV_PIX_FMT_FLAG_BAYER
The pixel format is following a Bayer pattern.
Definition: pixdesc.h:152
ff_init_gamma_convert
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice *src, uint16_t *table)
initializes gamma conversion descriptor
Definition: gamma.c:58
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:198
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
SwsContext::frame_src
AVFrame * frame_src
Definition: swscale_internal.h:344
SwsContext::srcW
int srcW
Width of source luma/alpha planes.
Definition: swscale_internal.h:321
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
SwsContext::yuv2rgb_u2b_coeff
int yuv2rgb_u2b_coeff
Definition: swscale_internal.h:472
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
ff_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:48
log.h
SwsContext::nb_slice_ctx
int nb_slice_ctx
Definition: swscale_internal.h:310
SwsContext::readLumPlanar
void(* readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
Functions to read planar input, such as planar RGB, and convert internally to Y/UV/A.
Definition: swscale_internal.h:582
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
SwsContext::dither16
uint16_t dither16[8]
Definition: swscale_internal.h:526
SwsContext::dstRange
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
Definition: swscale_internal.h:458
SwsContext::numSlice
int numSlice
Definition: swscale_internal.h:368
src2
const pixel * src2
Definition: h264pred_template.c:422
common.h
SwsSlice::should_free_lines
int should_free_lines
flag to identify if there are dynamic allocated lines
Definition: swscale_internal.h:1091
av_always_inline
#define av_always_inline
Definition: attributes.h:49
yuv2interleavedX_fn
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 ...
Definition: swscale_internal.h:151
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
SwsSlice::is_ring
int is_ring
flag to identify if this slice is a ring buffer
Definition: swscale_internal.h:1090
len
int len
Definition: vorbis_enc_data.h:426
SwsContext::hChrFilter
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
Definition: swscale_internal.h:409
SwsSlice::v_chr_sub_sample
int v_chr_sub_sample
vertical chroma subsampling factor
Definition: swscale_internal.h:1089
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
SwsSlice
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
Definition: swscale_internal.h:1085
ff_init_filters
int ff_init_filters(SwsContext *c)
Definition: slice.c:248
isFloat
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:840
RangeList::ranges
Range * ranges
Definition: swscale_internal.h:92
SwsContext::chrYInc
int chrYInc
Definition: swscale_internal.h:329
stride
#define stride
Definition: h264pred_template.c:537
SwsContext::slice
struct SwsSlice * slice
Definition: swscale_internal.h:369
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
SwsFilterDescriptor::alpha
int alpha
Flag for processing alpha channel.
Definition: swscale_internal.h:1105
SwsContext::srcXYZ
int srcXYZ
Definition: swscale_internal.h:461
pixfmt.h
ff_dither8
const uint64_t ff_dither8[2]
Definition: swscale.c:37
SwsContext::yuv2rgb_y_coeff
int yuv2rgb_y_coeff
Definition: swscale_internal.h:468
SWS_ALPHA_BLEND_CHECKERBOARD
@ SWS_ALPHA_BLEND_CHECKERBOARD
Definition: swscale_internal.h:82
SwsContext::numDesc
int numDesc
Definition: swscale_internal.h:366
SwsContext::table_rV
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:436
SwsContext::chrDstH
int chrDstH
Height of destination chroma planes.
Definition: swscale_internal.h:327
SwsContext::xyz_scratch_allocated
unsigned int xyz_scratch_allocated
Definition: swscale_internal.h:678
ff_free_filters
int ff_free_filters(SwsContext *c)
Definition: slice.c:388
ff_get_unscaled_swscale_ppc
void ff_get_unscaled_swscale_ppc(SwsContext *c)
Definition: yuv2yuv_altivec.c:187
SwsContext::input_rgb2yuv_table
int32_t input_rgb2yuv_table[16+40 *4]
Definition: swscale_internal.h:439
yuv2planarX_fn
void(* yuv2planarX_fn)(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output with multi-point vertical scaling between...
Definition: swscale_internal.h:131
ff_sws_init_output_funcs
void ff_sws_init_output_funcs(SwsContext *c, yuv2planar1_fn *yuv2plane1, yuv2planarX_fn *yuv2planeX, yuv2interleavedX_fn *yuv2nv12cX, yuv2packed1_fn *yuv2packed1, yuv2packed2_fn *yuv2packed2, yuv2packedX_fn *yuv2packedX, yuv2anyX_fn *yuv2anyX)
SwsContext::inv_gamma
uint16_t * inv_gamma
Definition: swscale_internal.h:364
MAX_SLICE_PLANES
#define MAX_SLICE_PLANES
Definition: swscale_internal.h:1068
isPackedRGB
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:879
SwsContext::cascaded_tmpStride
int cascaded_tmpStride[4]
Definition: swscale_internal.h:354
SwsContext::table_gU
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
Definition: swscale_internal.h:437
yuv2packedX_fn
void(* yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing multi-point ver...
Definition: swscale_internal.h:253
SwsContext::frame_dst
AVFrame * frame_dst
Definition: swscale_internal.h:345
SwsContext::chrXInc
int chrXInc
Definition: swscale_internal.h:328
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
SwsContext::dst0Alpha
int dst0Alpha
Definition: swscale_internal.h:460
SwsContext::readAlpPlanar
void(* readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
Definition: swscale_internal.h:586
SwsContext::warned_unuseable_bilinear
int warned_unuseable_bilinear
Definition: swscale_internal.h:428
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
SwsContext::chrMmxFilter
int32_t chrMmxFilter[4 *MAX_FILTER_SIZE]
Definition: swscale_internal.h:513
ff_hyscale_fast_mmxext
void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
SwsContext::yCoeff
uint64_t yCoeff
Definition: swscale_internal.h:504
desc
const char * desc
Definition: libsvtav1.c:83
isBayer16BPS
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:825
ff_init_vscale
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
Definition: vscale.c:213
SwsPlane::sliceY
int sliceY
index of first line
Definition: swscale_internal.h:1074
SwsContext::input_opaque
void * input_opaque
Opaque data pointer passed to all input functions.
Definition: swscale_internal.h:564
SwsContext::hChrFilterSize
int hChrFilterSize
Horizontal filter size for chroma pixels.
Definition: swscale_internal.h:417
SwsContext::vChrDrop
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
Definition: swscale_internal.h:339
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:113
util_altivec.h
SwsContext::u_temp
uint64_t u_temp
Definition: swscale_internal.h:517
SwsContext::chrToYV12
void(* chrToYV12)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opq)
Unscaled conversion of chroma planes to YV12 for horizontal scaler.
Definition: swscale_internal.h:573
lum
static double lum(void *priv, double x, double y, int plane)
Definition: vf_fftfilt.c:106
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
SwsContext::pal_yuv
uint32_t pal_yuv[256]
Definition: swscale_internal.h:372
SwsContext::chrDstHSubSample
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
Definition: swscale_internal.h:337
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale_internal.h:71
isRGBinInt
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:774
SwsContext::rgb0_scratch
uint8_t * rgb0_scratch
Definition: swscale_internal.h:671
SwsContext::stride_unaligned_warned
atomic_int stride_unaligned_warned
Definition: swscale_internal.h:681
SwsContext::chrDstW
int chrDstW
Width of destination chroma planes.
Definition: swscale_internal.h:326
SwsContext::vgCoeff
uint64_t vgCoeff
Definition: swscale_internal.h:507
int32_t
int32_t
Definition: audioconvert.c:56
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
SwsContext::lumToYV12
void(* lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opq)
Unscaled conversion of luma plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:567
SwsContext::src_h_chr_pos
int src_h_chr_pos
Definition: swscale_internal.h:463
SwsContext::yuv2packed1
yuv2packed1_fn yuv2packed1
Definition: swscale_internal.h:558
ff_init_desc_fmt_convert
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes lum pixel format conversion descriptor
Definition: hscale.c:127
SwsContext::gamma
uint16_t * gamma
Definition: swscale_internal.h:363
ff_updateMMXDitherTables
void ff_updateMMXDitherTables(SwsContext *c, int dstY)
ff_sws_init_swscale_arm
void ff_sws_init_swscale_arm(SwsContext *c)
Definition: swscale.c:33
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:872
SwsContext::cascaded_context
struct SwsContext * cascaded_context[3]
Definition: swscale_internal.h:353
SwsContext::descIndex
int descIndex[2]
Definition: swscale_internal.h:367
SwsContext::uint2float_lut
float uint2float_lut[256]
Definition: swscale_internal.h:375
FILL
#define FILL(wfunc)
SwsContext::chrConvertRange
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
Definition: swscale_internal.h:660
SwsContext::dst_v_chr_pos
int dst_v_chr_pos
Definition: swscale_internal.h:466
ff_yuv2rgb_init_tables_ppc
void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
Definition: yuv2rgb_altivec.c:598
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale_internal.h:75
int
int
Definition: ffmpeg_filter.c:156
SwsContext
Definition: swscale_internal.h:299
SwsContext::chrSrcHSubSample
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
Definition: swscale_internal.h:335
SwsContext::chrMmxextFilterCode
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
Definition: swscale_internal.h:425
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:131
SwsContext::dstH
int dstH
Height of destination luma/alpha planes.
Definition: swscale_internal.h:323
SwsContext::esp
uint64_t esp
Definition: swscale_internal.h:515
SwsContext::canMMXEXTBeUsed
int canMMXEXTBeUsed
Definition: swscale_internal.h:427
SwsContext::hyscale_fast
void(* hyscale_fast)(struct SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
Scale one horizontal line of input data using a bilinear filter to produce one line of output data.
Definition: swscale_internal.h:609
ff_dither_4x4_16
const uint8_t ff_dither_4x4_16[5][8]
Definition: output.c:51
SwsContext::h2f_tables
Half2FloatTables * h2f_tables
Definition: swscale_internal.h:684
ff_yuv2rgb_init_loongarch
SwsFunc ff_yuv2rgb_init_loongarch(SwsContext *c)
Definition: swscale_init_loongarch.c:63
ff_dither_2x2_4
const uint8_t ff_dither_2x2_4[3][8]
Definition: output.c:39
SwsContext::data_unaligned_warned
atomic_int data_unaligned_warned
Definition: swscale_internal.h:682
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:854
SwsContext::lastInLumBuf
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
Definition: swscale_internal.h:387
SwsContext::parent
struct SwsContext * parent
Definition: swscale_internal.h:305
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:138
SwsContext::uv_offx2
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
Definition: swscale_internal.h:525
SwsContext::needs_hcscale
int needs_hcscale
Set if there are chroma planes to be converted.
Definition: swscale_internal.h:662
SwsContext::param
double param[2]
Input parameters for scaling algorithms that need them.
Definition: swscale_internal.h:342
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:58