Go to the documentation of this file.
21 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
24 #include <stdatomic.h>
45 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
47 #define YUVRGB_TABLE_HEADROOM 512
48 #define YUVRGB_TABLE_LUMA_HEADROOM 512
50 #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
52 #define SWS_MAX_THREADS 8192
55 #define ALT32_CORR (-1)
70 #define RETCODE_USE_CASCADE -12345
79 typedef struct Range {
93 const int srcStride[],
int srcSliceY,
int srcSliceH,
94 uint8_t *
const dst[],
const int dstStride[]);
125 const int16_t **
src, uint8_t *dest,
int dstW,
145 const uint8_t *chrDither,
146 const int16_t *chrFilter,
148 const int16_t **chrUSrc,
149 const int16_t **chrVSrc,
150 uint8_t *dest,
int dstW);
182 const int16_t *chrUSrc[2],
183 const int16_t *chrVSrc[2],
184 const int16_t *alpSrc, uint8_t *dest,
185 int dstW,
int uvalpha,
int y);
215 const int16_t *chrUSrc[2],
216 const int16_t *chrVSrc[2],
217 const int16_t *alpSrc[2],
219 int dstW,
int yalpha,
int uvalpha,
int y);
247 const int16_t **lumSrc,
int lumFilterSize,
248 const int16_t *chrFilter,
249 const int16_t **chrUSrc,
250 const int16_t **chrVSrc,
int chrFilterSize,
251 const int16_t **alpSrc, uint8_t *dest,
281 const int16_t **lumSrc,
int lumFilterSize,
282 const int16_t *chrFilter,
283 const int16_t **chrUSrc,
284 const int16_t **chrVSrc,
int chrFilterSize,
285 const int16_t **alpSrc, uint8_t **dest,
292 const uint8_t *src3,
int width, uint32_t *pal,
299 const uint8_t *
src2,
const uint8_t *src3,
300 int width, uint32_t *pal,
void *opaque);
458 #define RGB2YUV_SHIFT 15
477 #define RED_DITHER "0*8"
478 #define GREEN_DITHER "1*8"
479 #define BLUE_DITHER "2*8"
480 #define Y_COEFF "3*8"
481 #define VR_COEFF "4*8"
482 #define UB_COEFF "5*8"
483 #define VG_COEFF "6*8"
484 #define UG_COEFF "7*8"
485 #define Y_OFFSET "8*8"
486 #define U_OFFSET "9*8"
487 #define V_OFFSET "10*8"
488 #define LUM_MMX_FILTER_OFFSET "11*8"
489 #define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
490 #define DSTW_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
491 #define ESP_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
492 #define VROUNDER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
493 #define U_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
494 #define V_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
495 #define Y_TEMP "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
496 #define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
497 #define UV_OFF_PX "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
498 #define UV_OFF_BYTE "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
499 #define DITHER16 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
500 #define DITHER32 "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
501 #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
535 vector
signed short CY;
536 vector
signed short CRV;
537 vector
signed short CBU;
538 vector
signed short CGU;
539 vector
signed short CGV;
540 vector
signed short OY;
541 vector
unsigned short CSHIFT;
542 vector
signed short *vYCoeffsBank, *vCCoeffsBank;
548 #define XYZ_GAMMA (2.6f)
549 #define RGB_GAMMA (2.2f)
603 int16_t *
dst,
int dstWidth,
604 const uint8_t *
src,
int srcW,
int xInc);
606 int16_t *dst1, int16_t *dst2,
int dstWidth,
607 const uint8_t *
src1,
const uint8_t *
src2,
643 const uint8_t *
src,
const int16_t *
filter,
644 const int32_t *filterPos,
int filterSize);
646 const uint8_t *
src,
const int16_t *
filter,
647 const int32_t *filterPos,
int filterSize);
697 "dither32 must be at the same offset as redDither + DITHER32_INT");
702 static_assert(offsetof(
SwsInternal, yuv2rgb_y_offset) == 40348,
703 "yuv2rgb_y_offset must be updated in x86 asm");
708 int fullRange,
int brightness,
711 int brightness,
int contrast,
int saturation);
731 return desc->comp[0].depth == 16;
738 return desc->comp[0].depth == 32;
745 return desc->comp[0].depth >= 9 &&
desc->comp[0].depth <= 14;
793 desc->nb_components <= 2 &&
853 return desc->comp[1].depth == 8;
943 for (
i = 0;
i <
desc->nb_components;
i++) {
944 if (!
desc->comp[
i].shift)
946 if ((
desc->comp[
i].shift +
desc->comp[
i].depth) & 0x7)
963 if (
desc->nb_components < 3)
966 return desc->comp[1].offset >
desc->comp[2].offset;
968 return desc->comp[1].plane >
desc->comp[2].plane;
1024 const uint8_t *
src,
int srcW,
int xInc);
1026 int dstWidth,
const uint8_t *
src1,
1027 const uint8_t *
src2,
int srcW,
int xInc);
1032 int dstWidth,
const uint8_t *
src,
1033 int srcW,
int xInc);
1035 int dstWidth,
const uint8_t *
src1,
1036 const uint8_t *
src2,
int srcW,
int xInc);
1039 const int srcStride[],
int srcSliceY,
int srcSliceH,
1040 uint8_t *
const dst[],
const int dstStride[]);
1043 int srcSliceY,
int srcSliceH,
int width,
1044 uint8_t *
dst,
int dstStride);
1047 const uint8_t *
src,
int src_stride,
int w,
int h);
1050 const uint8_t *
src,
int src_stride,
int w,
int h);
1053 int alpha,
int bits,
const int big_endian)
1055 uint8_t *ptr = plane +
stride * y;
1057 if (big_endian != HAVE_BIGENDIAN)
1060 for (
int j = 0; j <
width; j++)
1067 int alpha,
int bits,
const int big_endian,
int is_float)
1069 uint8_t *ptr = plane +
stride * y;
1071 uint32_t onef32 = 0x3f800000;
1073 v =
alpha ? onef32 : 0;
1076 if (big_endian != HAVE_BIGENDIAN)
1080 for (
int j = 0; j <
width; j++)
1087 #define MAX_SLICE_PLANES 4
1134 int srcW,
int lumY,
int lumH,
int chrY,
int chrH,
int relative);
1176 int nb_jobs,
int nb_threads);
1179 int srcSliceY,
int srcSliceH, uint8_t *
const dst[],
1180 const int dstStride[],
int dstSliceY,
int dstSliceH);
1184 #define MAX_LINES_AHEAD 4
void ff_hyscale_fast_mmxext(SwsInternal *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
int needs_hcscale
Set if there are chroma planes to be converted.
int32_t input_rgb2yuv_table[16+40 *4]
void ff_xyz12Torgb48(const SwsInternal *c, uint8_t *dst, int dst_stride, const uint8_t *src, int src_stride, int w, int h)
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 (...
AVPixelFormat
Pixel format.
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
const uint8_t ff_dither_8x8_128[9][8]
@ 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...
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
int sliceH
number of lines
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
uint8_t ** line
line buffer
unsigned int rgb0_scratch_allocated
@ 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...
const uint8_t ff_dither_8x8_220[9][8]
void ff_sws_init_output_funcs(SwsInternal *c, yuv2planar1_fn *yuv2plane1, yuv2planarX_fn *yuv2planeX, yuv2interleavedX_fn *yuv2nv12cX, yuv2packed1_fn *yuv2packed1, yuv2packed2_fn *yuv2packed2, yuv2packedX_fn *yuv2packedX, yuv2anyX_fn *yuv2anyX)
uint32_t lumConvertRange_coeff
int srcFormatBpp
Number of bits per pixel of the source pixel format.
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
uint8_t * cascaded_tmp[2][4]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
struct SwsFilterDescriptor * desc
uint8_t * formatConvBuffer
void ff_yuv2rgb_init_tables_ppc(SwsInternal *c, const int inv_table[4], int brightness, int contrast, int saturation)
int16_t xyz2rgb_matrix[3][4]
atomic_int stride_unaligned_warned
static IPT saturation(const CmsCtx *ctx, IPT ipt)
SwsFunc ff_yuv2rgb_init_x86(SwsInternal *c)
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
SwsPlane plane[MAX_SLICE_PLANES]
color planes
int color_conversion_warned
This structure describes decoded (raw) audio or video data.
@ 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...
int ff_sws_alphablendaway(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
av_cold void ff_sws_init_range_convert_aarch64(SwsInternal *c)
Struct which holds all necessary data for processing a slice.
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)
static const uint16_t table[]
planar1_YV12_fn lumToYV12
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
static const char rgb2yuv[]
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
int vChrFilterSize
Vertical filter size for chroma pixels.
#define AV_PIX_FMT_RGB32_1
void ff_sws_init_swscale_vsx(SwsInternal *c)
float uint2float_lut[256]
void(* filter)(uint8_t *src, int stride, int qscale)
int cascaded_tmpStride[2][4]
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Half2FloatTables * h2f_tables
int32_t lumMmxFilter[4 *MAX_FILTER_SIZE]
struct AVSliceThread AVSliceThread
void(* hcscale_fast)(SwsInternal *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
void ff_sws_init_scale(SwsInternal *c)
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
int chrDstH
Height of destination chroma planes.
enum AVPixelFormat fmt
planes pixel format
SwsSlice * src
Source slice.
int ff_sws_init_single_context(SwsContext *sws, SwsFilter *srcFilter, SwsFilter *dstFilter)
int chrDstW
Width of destination chroma planes.
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
void * instance
Filter instance data.
void ff_sws_init_input_funcs(SwsInternal *c, planar1_YV12_fn *lumToYV12, planar1_YV12_fn *alpToYV12, planar2_YV12_fn *chrToYV12, planarX_YV12_fn *readLumPlanar, planarX_YV12_fn *readAlpPlanar, planarX2_YV12_fn *readChrPlanar)
void ff_sws_init_swscale_x86(SwsInternal *c)
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
AVSliceThread * slicethread
void * input_opaque
Opaque data pointer passed to all input functions.
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
planarX_YV12_fn readAlpPlanar
const uint8_t ff_dither_2x2_8[3][8]
av_cold void ff_sws_init_range_convert_loongarch(SwsInternal *c)
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
int(* process)(SwsInternal *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH)
Function for processing input slice sliceH lines starting from line sliceY.
int h_chr_sub_sample
horizontal chroma subsampling factor
int dstColorspaceTable[4]
void ff_hyscale_fast_c(SwsInternal *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
const uint64_t ff_dither4[2]
const uint8_t ff_dither_8x8_73[9][8]
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
int ff_shuffle_filter_coefficients(SwsInternal *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
#define YUVRGB_TABLE_HEADROOM
void(* yuv2packed2_fn)(SwsInternal *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...
planar1_YV12_fn alpToYV12
const uint8_t ff_dither_8x8_32[9][8]
static enum AVPixelFormat pix_fmt
SwsContext * cascaded_context[3]
int width
Slice line width.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_yuv2rgb_c_init_tables(SwsInternal *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
uint8_t ** tmp
Tmp line buffer used by mmx code.
void ff_get_unscaled_swscale(SwsInternal *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
const AVClass ff_sws_context_class
@ 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 ...
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
void ff_sws_init_swscale_aarch64(SwsInternal *c)
#define AV_PIX_FMT_BGR32_1
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
void ff_sws_init_swscale_loongarch(SwsInternal *c)
int chrSrcH
Height of source chroma planes.
av_cold void ff_sws_init_range_convert(SwsInternal *c)
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width, uint32_t coeff, int64_t offset)
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
void ff_hcscale_fast_mmxext(SwsInternal *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
int16_t rgb2xyz_matrix[3][4]
uint32_t chrConvertRange_coeff
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
SwsFunc ff_yuv2rgb_init_ppc(SwsInternal *c)
Describe the class of an AVClass context structure.
int ff_init_slice_from_src(SwsSlice *s, uint8_t *const src[4], const int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH, int relative)
void(* planarX_YV12_fn)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opaque)
Unscaled conversion of arbitrary planar data (e.g.
static av_always_inline int isFloat16(enum AVPixelFormat pix_fmt)
int available_lines
max number of lines that can be hold by this plane
ptrdiff_t uv_off
offset (in pixels) between u and v planes
@ 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...
void(* hyScale)(SwsInternal *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...
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
void ff_sws_init_swscale_riscv(SwsInternal *c)
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
@ 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...
void ff_get_unscaled_swscale_ppc(SwsInternal *c)
void(* planarX2_YV12_fn)(uint8_t *dst, uint8_t *dst2, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opaque)
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
planarX_YV12_fn readLumPlanar
Functions to read planar input, such as planar RGB, and convert internally to Y/UV/A.
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
av_cold void ff_sws_init_range_convert_x86(SwsInternal *c)
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
int32_t chrMmxFilter[4 *MAX_FILTER_SIZE]
@ 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 ...
SwsFunc ff_yuv2rgb_init_loongarch(SwsInternal *c)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
void(* planar2_YV12_fn)(uint8_t *dst, uint8_t *dst2, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opaque)
Unscaled conversion of chroma plane to YV12 for horizontal scaler.
int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
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
int dstY
Last destination vertical line output from last slice.
yuv2packed2_fn yuv2packed2
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
int ff_range_add(RangeList *r, unsigned int start, unsigned int len)
static av_always_inline int isDataInHighBits(enum AVPixelFormat pix_fmt)
void(* yuv2packedX_fn)(SwsInternal *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...
static IPT relative(const CmsCtx *ctx, IPT ipt)
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
unsigned int xyz_scratch_allocated
SwsSlice * dst
Output slice.
#define DECLARE_ALIGNED(n, t, v)
void ff_sws_init_swscale_ppc(SwsInternal *c)
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
static void fillPlane16(uint8_t *plane, int stride, int width, int height, int y, int alpha, int bits, const int big_endian)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
atomic_int data_unaligned_warned
void(* planar1_YV12_fn)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opaque)
Unscaled conversion of luma/alpha plane to YV12 for horizontal scaler.
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
static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes chr pixel format conversion descriptor
int ff_init_vscale(SwsInternal *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
int ff_swscale(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[], int dstSliceY, int dstSliceH)
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
int hChrFilterSize
Horizontal filter size for chroma pixels.
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
static av_always_inline int isSwappedChroma(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
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
int ff_free_filters(SwsInternal *c)
int ff_init_filters(SwsInternal *c)
yuv2packed1_fn yuv2packed1
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)
#define AV_PIX_FMT_FLAG_BAYER
The pixel format is following a Bayer pattern.
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice *src, uint16_t *table)
initializes gamma conversion descriptor
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
void(* yuv2anyX_fn)(SwsInternal *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...
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
@ 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...
int32_t alpMmxFilter[4 *MAX_FILTER_SIZE]
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
unsigned int dst_slice_align
static SwsContext * sws[3]
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
@ 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...
const int32_t ff_yuv2rgb_coeffs[11][4]
#define i(width, name, range_min, range_max)
yuv2planarX_fn yuv2planeX
void ff_copyPlane(const uint8_t *src, int srcStride, int srcSliceY, int srcSliceH, int width, uint8_t *dst, int dstStride)
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
int should_free_lines
flag to identify if there are dynamic allocated lines
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 ...
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
int is_ring
flag to identify if this slice is a ring buffer
void(* lumConvertRange)(int16_t *dst, int width, uint32_t coeff, int64_t offset)
Color range conversion functions if needed.
void ff_updateMMXDitherTables(SwsInternal *c, int dstY)
int v_chr_sub_sample
vertical chroma subsampling factor
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
void(* yuv2packed1_fn)(SwsInternal *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...
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
int alpha
Flag for processing alpha channel.
const uint64_t ff_dither8[2]
void ff_sws_init_swscale_arm(SwsInternal *c)
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
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...
const uint8_t * chrDither8
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
SwsFunc convert_unscaled
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
void(* hyscale_fast)(SwsInternal *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.
void ff_init_vscale_pfn(SwsInternal *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
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
void ff_get_unscaled_swscale_aarch64(SwsInternal *c)
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
int warned_unuseable_bilinear
SwsFunc ff_yuv2rgb_get_func_ptr(SwsInternal *c)
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
int sliceY
index of first line
Filter graph, which represents a 'baked' pixel format conversion.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
planarX2_YV12_fn readChrPlanar
yuv2planar1_fn yuv2plane1
static double lum(void *priv, double x, double y, int plane)
static const int16_t alpha[]
planar2_YV12_fn chrToYV12
int(* SwsFunc)(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
av_cold void ff_sws_init_range_convert_riscv(SwsInternal *c)
int64_t lumConvertRange_offset
void(* hcScale)(SwsInternal *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
static const double coeff[2][5]
static SwsInternal * sws_internal(const SwsContext *sws)
int srcColorspaceTable[4]
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes lum pixel format conversion descriptor
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
void ff_get_unscaled_swscale_arm(SwsInternal *c)
void ff_rgb48Toxyz12(const SwsInternal *c, uint8_t *dst, int dst_stride, const uint8_t *src, int src_stride, int w, int h)
Main external API structure.
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
int chrSrcW
Width of source chroma planes.
void ff_update_palette(SwsInternal *c, const uint32_t *pal)
yuv2interleavedX_fn yuv2nv12cX
const uint8_t * lumDither8
const uint8_t ff_dither_4x4_16[5][8]
void ff_hcscale_fast_c(SwsInternal *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc)
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
int64_t chrConvertRange_offset
const uint8_t ff_dither_2x2_4[3][8]
yuv2packedX_fn yuv2packedX
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
@ 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...
static const uint8_t dither[8][8]