2 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
4 * This file is part of Libav.
6 * Libav 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.
11 * Libav 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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
30 #include "libavutil/avassert.h"
31 #include "libavutil/avutil.h"
32 #include "libavutil/common.h"
33 #include "libavutil/log.h"
34 #include "libavutil/pixfmt.h"
35 #include "libavutil/pixdesc.h"
37 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
39 #define FAST_BGR2YV12 // use 7-bit instead of 15-bit coefficients
41 #define MAX_FILTER_SIZE 256
44 #define ALT32_CORR (-1)
61 typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
62 int srcStride[], int srcSliceY, int srcSliceH,
63 uint8_t *dst[], int dstStride[]);
66 * Write one line of horizontally scaled data to planar output
67 * without any additional vertical scaling (or point-scaling).
69 * @param src scaled source data, 15bit for 8-10bit output,
70 * 19-bit for 16bit output (in int32_t)
71 * @param dest pointer to the output plane. For >8bit
72 * output, this is in uint16_t
73 * @param dstW width of destination in pixels
74 * @param dither ordered dither array of type int16_t and size 8
75 * @param offset Dither offset
77 typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
78 const uint8_t *dither, int offset);
81 * Write one line of horizontally scaled data to planar output
82 * with multi-point vertical scaling between input pixels.
84 * @param filter vertical luma/alpha scaling coefficients, 12bit [0,4096]
85 * @param src scaled luma (Y) or alpha (A) source data, 15bit for 8-10bit output,
86 * 19-bit for 16bit output (in int32_t)
87 * @param filterSize number of vertical input lines to scale
88 * @param dest pointer to output plane. For >8bit
89 * output, this is in uint16_t
90 * @param dstW width of destination pixels
91 * @param offset Dither offset
93 typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
94 const int16_t **src, uint8_t *dest, int dstW,
95 const uint8_t *dither, int offset);
98 * Write one line of horizontally scaled chroma to interleaved output
99 * with multi-point vertical scaling between input pixels.
101 * @param c SWS scaling context
102 * @param chrFilter vertical chroma scaling coefficients, 12bit [0,4096]
103 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
104 * 19-bit for 16bit output (in int32_t)
105 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
106 * 19-bit for 16bit output (in int32_t)
107 * @param chrFilterSize number of vertical chroma input lines to scale
108 * @param dest pointer to the output plane. For >8bit
109 * output, this is in uint16_t
110 * @param dstW width of chroma planes
112 typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
113 const int16_t *chrFilter,
115 const int16_t **chrUSrc,
116 const int16_t **chrVSrc,
117 uint8_t *dest, int dstW);
120 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
121 * output without any additional vertical scaling (or point-scaling). Note
122 * that this function may do chroma scaling, see the "uvalpha" argument.
124 * @param c SWS scaling context
125 * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
126 * 19-bit for 16bit output (in int32_t)
127 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
128 * 19-bit for 16bit output (in int32_t)
129 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
130 * 19-bit for 16bit output (in int32_t)
131 * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
132 * 19-bit for 16bit output (in int32_t)
133 * @param dest pointer to the output plane. For 16bit output, this is
135 * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
136 * to write into dest[]
137 * @param uvalpha chroma scaling coefficient for the second line of chroma
138 * pixels, either 2048 or 0. If 0, one chroma input is used
139 * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
140 * is set, it generates 1 output pixel). If 2048, two chroma
141 * input pixels should be averaged for 2 output pixels (this
142 * only happens if SWS_FLAG_FULL_CHR_INT is not set)
143 * @param y vertical line number for this output. This does not need
144 * to be used to calculate the offset in the destination,
145 * but can be used to generate comfort noise using dithering
146 * for some output formats.
148 typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
149 const int16_t *chrUSrc[2],
150 const int16_t *chrVSrc[2],
151 const int16_t *alpSrc, uint8_t *dest,
152 int dstW, int uvalpha, int y);
154 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
155 * output by doing bilinear scaling between two input lines.
157 * @param c SWS scaling context
158 * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
159 * 19-bit for 16bit output (in int32_t)
160 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
161 * 19-bit for 16bit output (in int32_t)
162 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
163 * 19-bit for 16bit output (in int32_t)
164 * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
165 * 19-bit for 16bit output (in int32_t)
166 * @param dest pointer to the output plane. For 16bit output, this is
168 * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
169 * to write into dest[]
170 * @param yalpha luma/alpha scaling coefficients for the second input line.
171 * The first line's coefficients can be calculated by using
173 * @param uvalpha chroma scaling coefficient for the second input line. The
174 * first line's coefficients can be calculated by using
176 * @param y vertical line number for this output. This does not need
177 * to be used to calculate the offset in the destination,
178 * but can be used to generate comfort noise using dithering
179 * for some output formats.
181 typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
182 const int16_t *chrUSrc[2],
183 const int16_t *chrVSrc[2],
184 const int16_t *alpSrc[2],
186 int dstW, int yalpha, int uvalpha, int y);
188 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
189 * output by doing multi-point vertical scaling between input pixels.
191 * @param c SWS scaling context
192 * @param lumFilter vertical luma/alpha scaling coefficients, 12bit [0,4096]
193 * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
194 * 19-bit for 16bit output (in int32_t)
195 * @param lumFilterSize number of vertical luma/alpha input lines to scale
196 * @param chrFilter vertical chroma scaling coefficients, 12bit [0,4096]
197 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
198 * 19-bit for 16bit output (in int32_t)
199 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
200 * 19-bit for 16bit output (in int32_t)
201 * @param chrFilterSize number of vertical chroma input lines to scale
202 * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
203 * 19-bit for 16bit output (in int32_t)
204 * @param dest pointer to the output plane. For 16bit output, this is
206 * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
207 * to write into dest[]
208 * @param y vertical line number for this output. This does not need
209 * to be used to calculate the offset in the destination,
210 * but can be used to generate comfort noise using dithering
211 * or some output formats.
213 typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
214 const int16_t **lumSrc, int lumFilterSize,
215 const int16_t *chrFilter,
216 const int16_t **chrUSrc,
217 const int16_t **chrVSrc, int chrFilterSize,
218 const int16_t **alpSrc, uint8_t *dest,
221 /* This struct should be aligned on at least a 32-byte boundary. */
222 typedef struct SwsContext {
224 * info on struct for av_log
226 const AVClass *av_class;
229 * Note that src, dst, srcStride, dstStride will be copied in the
230 * sws_scale() wrapper so they can be freely modified here.
233 int srcW; ///< Width of source luma/alpha planes.
234 int srcH; ///< Height of source luma/alpha planes.
235 int dstH; ///< Height of destination luma/alpha planes.
236 int chrSrcW; ///< Width of source chroma planes.
237 int chrSrcH; ///< Height of source chroma planes.
238 int chrDstW; ///< Width of destination chroma planes.
239 int chrDstH; ///< Height of destination chroma planes.
240 int lumXInc, chrXInc;
241 int lumYInc, chrYInc;
242 enum AVPixelFormat dstFormat; ///< Destination pixel format.
243 enum AVPixelFormat srcFormat; ///< Source pixel format.
244 int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
245 int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
247 int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
248 int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
249 int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
250 int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
251 int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
252 int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
253 double param[2]; ///< Input parameters for scaling algorithms that need them.
255 uint32_t pal_yuv[256];
256 uint32_t pal_rgb[256];
259 * @name Scaled horizontal lines ring buffer.
260 * The horizontal scaler keeps just enough scaled lines in a ring buffer
261 * so they may be passed to the vertical scaler. The pointers to the
262 * allocated buffers for each line are duplicated in sequence in the ring
263 * buffer to simplify indexing and avoid wrapping around between lines
264 * inside the vertical scaler code. The wrapping is done before the
265 * vertical scaler is called.
268 int16_t **lumPixBuf; ///< Ring buffer for scaled horizontal luma plane lines to be fed to the vertical scaler.
269 int16_t **chrUPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
270 int16_t **chrVPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
271 int16_t **alpPixBuf; ///< Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler.
272 int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer.
273 int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer.
274 int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
275 int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
276 int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
277 int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source.
280 uint8_t *formatConvBuffer;
283 * @name Horizontal and vertical filters.
284 * To better understand the following fields, here is a pseudo-code of
285 * their usage in filtering a horizontal line:
287 * for (i = 0; i < width; i++) {
289 * for (j = 0; j < filterSize; j++)
290 * dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
291 * dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
296 int16_t *hLumFilter; ///< Array of horizontal filter coefficients for luma/alpha planes.
297 int16_t *hChrFilter; ///< Array of horizontal filter coefficients for chroma planes.
298 int16_t *vLumFilter; ///< Array of vertical filter coefficients for luma/alpha planes.
299 int16_t *vChrFilter; ///< Array of vertical filter coefficients for chroma planes.
300 int32_t *hLumFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
301 int32_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
302 int32_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
303 int32_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
304 int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
305 int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
306 int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
307 int vChrFilterSize; ///< Vertical filter size for chroma pixels.
310 int lumMmx2FilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
311 int chrMmx2FilterCodeSize; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
312 uint8_t *lumMmx2FilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
313 uint8_t *chrMmx2FilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
317 int dstY; ///< Last destination vertical line output from last slice.
318 int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
319 void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
320 uint8_t *table_rV[256];
321 uint8_t *table_gU[256];
323 uint8_t *table_bU[256];
326 int contrast, brightness, saturation; // for sws_getColorspaceDetails
327 int srcColorspaceTable[4];
328 int dstColorspaceTable[4];
329 int srcRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (source image).
330 int dstRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
331 int yuv2rgb_y_offset;
333 int yuv2rgb_v2r_coeff;
334 int yuv2rgb_v2g_coeff;
335 int yuv2rgb_u2g_coeff;
336 int yuv2rgb_u2b_coeff;
338 #define RED_DITHER "0*8"
339 #define GREEN_DITHER "1*8"
340 #define BLUE_DITHER "2*8"
341 #define Y_COEFF "3*8"
342 #define VR_COEFF "4*8"
343 #define UB_COEFF "5*8"
344 #define VG_COEFF "6*8"
345 #define UG_COEFF "7*8"
346 #define Y_OFFSET "8*8"
347 #define U_OFFSET "9*8"
348 #define V_OFFSET "10*8"
349 #define LUM_MMX_FILTER_OFFSET "11*8"
350 #define CHR_MMX_FILTER_OFFSET "11*8+4*4*256"
351 #define DSTW_OFFSET "11*8+4*4*256*2" //do not change, it is hardcoded in the ASM
352 #define ESP_OFFSET "11*8+4*4*256*2+8"
353 #define VROUNDER_OFFSET "11*8+4*4*256*2+16"
354 #define U_TEMP "11*8+4*4*256*2+24"
355 #define V_TEMP "11*8+4*4*256*2+32"
356 #define Y_TEMP "11*8+4*4*256*2+40"
357 #define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48"
358 #define UV_OFF_PX "11*8+4*4*256*3+48"
359 #define UV_OFF_BYTE "11*8+4*4*256*3+56"
360 #define DITHER16 "11*8+4*4*256*3+64"
361 #define DITHER32 "11*8+4*4*256*3+80"
363 DECLARE_ALIGNED(8, uint64_t, redDither);
364 DECLARE_ALIGNED(8, uint64_t, greenDither);
365 DECLARE_ALIGNED(8, uint64_t, blueDither);
367 DECLARE_ALIGNED(8, uint64_t, yCoeff);
368 DECLARE_ALIGNED(8, uint64_t, vrCoeff);
369 DECLARE_ALIGNED(8, uint64_t, ubCoeff);
370 DECLARE_ALIGNED(8, uint64_t, vgCoeff);
371 DECLARE_ALIGNED(8, uint64_t, ugCoeff);
372 DECLARE_ALIGNED(8, uint64_t, yOffset);
373 DECLARE_ALIGNED(8, uint64_t, uOffset);
374 DECLARE_ALIGNED(8, uint64_t, vOffset);
375 int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
376 int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
377 int dstW; ///< Width of destination luma/alpha planes.
378 DECLARE_ALIGNED(8, uint64_t, esp);
379 DECLARE_ALIGNED(8, uint64_t, vRounder);
380 DECLARE_ALIGNED(8, uint64_t, u_temp);
381 DECLARE_ALIGNED(8, uint64_t, v_temp);
382 DECLARE_ALIGNED(8, uint64_t, y_temp);
383 int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
384 // alignment of these values is not necessary, but merely here
385 // to maintain the same offset across x8632 and x86-64. Once we
386 // use proper offset macros in the asm, they can be removed.
387 DECLARE_ALIGNED(8, ptrdiff_t, uv_off_px); ///< offset (in pixels) between u and v planes
388 DECLARE_ALIGNED(8, ptrdiff_t, uv_off_byte); ///< offset (in bytes) between u and v planes
389 DECLARE_ALIGNED(8, uint16_t, dither16)[8];
390 DECLARE_ALIGNED(8, uint32_t, dither32)[8];
392 const uint8_t *chrDither8, *lumDither8;
395 vector signed short CY;
396 vector signed short CRV;
397 vector signed short CBU;
398 vector signed short CGU;
399 vector signed short CGV;
400 vector signed short OY;
401 vector unsigned short CSHIFT;
402 vector signed short *vYCoeffsBank, *vCCoeffsBank;
406 DECLARE_ALIGNED(4, uint32_t, oy);
407 DECLARE_ALIGNED(4, uint32_t, oc);
408 DECLARE_ALIGNED(4, uint32_t, zero);
409 DECLARE_ALIGNED(4, uint32_t, cy);
410 DECLARE_ALIGNED(4, uint32_t, crv);
411 DECLARE_ALIGNED(4, uint32_t, rmask);
412 DECLARE_ALIGNED(4, uint32_t, cbu);
413 DECLARE_ALIGNED(4, uint32_t, bmask);
414 DECLARE_ALIGNED(4, uint32_t, cgu);
415 DECLARE_ALIGNED(4, uint32_t, cgv);
416 DECLARE_ALIGNED(4, uint32_t, gmask);
420 DECLARE_ALIGNED(8, uint64_t, sparc_coeffs)[10];
423 /* function pointers for swScale() */
424 yuv2planar1_fn yuv2plane1;
425 yuv2planarX_fn yuv2planeX;
426 yuv2interleavedX_fn yuv2nv12cX;
427 yuv2packed1_fn yuv2packed1;
428 yuv2packed2_fn yuv2packed2;
429 yuv2packedX_fn yuv2packedX;
431 /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
432 void (*lumToYV12)(uint8_t *dst, const uint8_t *src,
433 int width, uint32_t *pal);
434 /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
435 void (*alpToYV12)(uint8_t *dst, const uint8_t *src,
436 int width, uint32_t *pal);
437 /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
438 void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
439 const uint8_t *src1, const uint8_t *src2,
440 int width, uint32_t *pal);
443 * Functions to read planar input, such as planar RGB, and convert
444 * internally to Y/UV.
447 void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width);
448 void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
453 * Scale one horizontal line of input data using a bilinear filter
454 * to produce one line of output data. Compared to SwsContext->hScale(),
455 * please take note of the following caveats when using these:
456 * - Scaling is done using only 7bit instead of 14bit coefficients.
457 * - You can use no more than 5 input pixels to produce 4 output
458 * pixels. Therefore, this filter should not be used for downscaling
459 * by more than ~20% in width (because that equals more than 5/4th
460 * downscaling and thus more than 5 pixels input per 4 pixels output).
461 * - In general, bilinear filters create artifacts during downscaling
462 * (even when <20%), because one output pixel will span more than one
463 * input pixel, and thus some pixels will need edges of both neighbor
464 * pixels to interpolate the output pixel. Since you can use at most
465 * two input pixels per output pixel in bilinear scaling, this is
466 * impossible and thus downscaling by any size will create artifacts.
467 * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
468 * in SwsContext->flags.
471 void (*hyscale_fast)(struct SwsContext *c,
472 int16_t *dst, int dstWidth,
473 const uint8_t *src, int srcW, int xInc);
474 void (*hcscale_fast)(struct SwsContext *c,
475 int16_t *dst1, int16_t *dst2, int dstWidth,
476 const uint8_t *src1, const uint8_t *src2,
481 * Scale one horizontal line of input data using a filter over the input
482 * lines, to produce one (differently sized) line of output data.
484 * @param dst pointer to destination buffer for horizontally scaled
485 * data. If the number of bits per component of one
486 * destination pixel (SwsContext->dstBpc) is <= 10, data
487 * will be 15bpc in 16bits (int16_t) width. Else (i.e.
488 * SwsContext->dstBpc == 16), data will be 19bpc in
489 * 32bits (int32_t) width.
490 * @param dstW width of destination image
491 * @param src pointer to source data to be scaled. If the number of
492 * bits per component of a source pixel (SwsContext->srcBpc)
493 * is 8, this is 8bpc in 8bits (uint8_t) width. Else
494 * (i.e. SwsContext->dstBpc > 8), this is native depth
495 * in 16bits (uint16_t) width. In other words, for 9-bit
496 * YUV input, this is 9bpc, for 10-bit YUV input, this is
497 * 10bpc, and for 16-bit RGB or YUV, this is 16bpc.
498 * @param filter filter coefficients to be used per output pixel for
499 * scaling. This contains 14bpp filtering coefficients.
500 * Guaranteed to contain dstW * filterSize entries.
501 * @param filterPos position of the first input pixel to be used for
502 * each output pixel during scaling. Guaranteed to
503 * contain dstW entries.
504 * @param filterSize the number of input coefficients to be used (and
505 * thus the number of input pixels to be used) for
506 * creating a single output pixel. Is aligned to 4
507 * (and input coefficients thus padded with zeroes)
508 * to simplify creating SIMD code.
511 void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
512 const uint8_t *src, const int16_t *filter,
513 const int32_t *filterPos, int filterSize);
514 void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
515 const uint8_t *src, const int16_t *filter,
516 const int32_t *filterPos, int filterSize);
519 /// Color range conversion function for luma plane if needed.
520 void (*lumConvertRange)(int16_t *dst, int width);
521 /// Color range conversion function for chroma planes if needed.
522 void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
524 int needs_hcscale; ///< Set if there are chroma planes to be converted.
526 //FIXME check init (where 0)
528 SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c);
529 int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
530 int fullRange, int brightness,
531 int contrast, int saturation);
533 void ff_yuv2rgb_init_tables_altivec(SwsContext *c, const int inv_table[4],
534 int brightness, int contrast, int saturation);
535 void updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex,
536 int lastInLumBuf, int lastInChrBuf);
538 SwsFunc ff_yuv2rgb_init_mmx(SwsContext *c);
539 SwsFunc ff_yuv2rgb_init_vis(SwsContext *c);
540 SwsFunc ff_yuv2rgb_init_altivec(SwsContext *c);
541 SwsFunc ff_yuv2rgb_get_func_ptr_bfin(SwsContext *c);
542 void ff_bfin_get_unscaled_swscale(SwsContext *c);
544 const char *sws_format_name(enum AVPixelFormat format);
546 static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
548 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
550 return desc->comp[0].depth_minus1 == 15;
553 static av_always_inline int is9_OR_10BPS(enum AVPixelFormat pix_fmt)
555 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
557 return desc->comp[0].depth_minus1 == 8 || desc->comp[0].depth_minus1 == 9;
560 static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
562 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
564 return desc->flags & PIX_FMT_BE;
567 static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
569 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
571 return !(desc->flags & PIX_FMT_RGB) && desc->nb_components >= 2;
574 static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
576 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
578 return ((desc->flags & PIX_FMT_PLANAR) && isYUV(pix_fmt));
581 static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
583 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
585 return (desc->flags & PIX_FMT_RGB);
590 (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \
591 av_pix_fmt_descriptors[x].nb_components <= 2)
594 ((x) == AV_PIX_FMT_GRAY8 || \
595 (x) == AV_PIX_FMT_Y400A || \
596 (x) == AV_PIX_FMT_GRAY16BE || \
597 (x) == AV_PIX_FMT_GRAY16LE)
600 #define isRGBinInt(x) \
601 ((x) == AV_PIX_FMT_RGB48BE || \
602 (x) == AV_PIX_FMT_RGB48LE || \
603 (x) == AV_PIX_FMT_RGB32 || \
604 (x) == AV_PIX_FMT_RGB32_1 || \
605 (x) == AV_PIX_FMT_RGB24 || \
606 (x) == AV_PIX_FMT_RGB565BE || \
607 (x) == AV_PIX_FMT_RGB565LE || \
608 (x) == AV_PIX_FMT_RGB555BE || \
609 (x) == AV_PIX_FMT_RGB555LE || \
610 (x) == AV_PIX_FMT_RGB444BE || \
611 (x) == AV_PIX_FMT_RGB444LE || \
612 (x) == AV_PIX_FMT_RGB8 || \
613 (x) == AV_PIX_FMT_RGB4 || \
614 (x) == AV_PIX_FMT_RGB4_BYTE || \
615 (x) == AV_PIX_FMT_MONOBLACK || \
616 (x) == AV_PIX_FMT_MONOWHITE)
618 #define isBGRinInt(x) \
619 ((x) == AV_PIX_FMT_BGR48BE || \
620 (x) == AV_PIX_FMT_BGR48LE || \
621 (x) == AV_PIX_FMT_BGR32 || \
622 (x) == AV_PIX_FMT_BGR32_1 || \
623 (x) == AV_PIX_FMT_BGR24 || \
624 (x) == AV_PIX_FMT_BGR565BE || \
625 (x) == AV_PIX_FMT_BGR565LE || \
626 (x) == AV_PIX_FMT_BGR555BE || \
627 (x) == AV_PIX_FMT_BGR555LE || \
628 (x) == AV_PIX_FMT_BGR444BE || \
629 (x) == AV_PIX_FMT_BGR444LE || \
630 (x) == AV_PIX_FMT_BGR8 || \
631 (x) == AV_PIX_FMT_BGR4 || \
632 (x) == AV_PIX_FMT_BGR4_BYTE || \
633 (x) == AV_PIX_FMT_MONOBLACK || \
634 (x) == AV_PIX_FMT_MONOWHITE)
636 #define isAnyRGB(x) \
640 static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
642 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
644 return desc->nb_components == 2 || desc->nb_components == 4;
647 static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
649 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
651 return ((desc->nb_components >= 2 && !(desc->flags & PIX_FMT_PLANAR)) ||
652 pix_fmt == AV_PIX_FMT_PAL8);
655 static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
657 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
659 return (desc->nb_components >= 2 && (desc->flags & PIX_FMT_PLANAR));
662 static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
664 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
666 return ((desc->flags & (PIX_FMT_PLANAR | PIX_FMT_RGB)) == PIX_FMT_RGB);
669 static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
671 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
673 return ((desc->flags & (PIX_FMT_PLANAR | PIX_FMT_RGB)) ==
674 (PIX_FMT_PLANAR | PIX_FMT_RGB));
677 static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
679 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
681 return ((desc->flags & PIX_FMT_PAL) || (desc->flags & PIX_FMT_PSEUDOPAL) ||
682 pix_fmt == AV_PIX_FMT_Y400A);
685 extern const uint64_t ff_dither4[2];
686 extern const uint64_t ff_dither8[2];
688 extern const AVClass sws_context_class;
691 * Set c->swScale to an unscaled converter if one exists for the specific
692 * source and destination formats, bit depths, flags, etc.
694 void ff_get_unscaled_swscale(SwsContext *c);
696 void ff_swscale_get_unscaled_altivec(SwsContext *c);
699 * Return function pointer to fastest main scaler path function depending
700 * on architecture and available optimizations.
702 SwsFunc ff_getSwsFunc(SwsContext *c);
704 void ff_sws_init_input_funcs(SwsContext *c);
705 void ff_sws_init_output_funcs(SwsContext *c,
706 yuv2planar1_fn *yuv2plane1,
707 yuv2planarX_fn *yuv2planeX,
708 yuv2interleavedX_fn *yuv2nv12cX,
709 yuv2packed1_fn *yuv2packed1,
710 yuv2packed2_fn *yuv2packed2,
711 yuv2packedX_fn *yuv2packedX);
712 void ff_sws_init_swScale_altivec(SwsContext *c);
713 void ff_sws_init_swScale_mmx(SwsContext *c);
715 #endif /* SWSCALE_SWSCALE_INTERNAL_H */