Go to the documentation of this file.
21 #ifndef SWSCALE_SWSCALE_INTERNAL_H
22 #define SWSCALE_SWSCALE_INTERNAL_H
24 #include <stdatomic.h>
42 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
44 #define YUVRGB_TABLE_HEADROOM 512
45 #define YUVRGB_TABLE_LUMA_HEADROOM 512
47 #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
50 #define ALT32_CORR (-1)
65 #define RETCODE_USE_CASCADE -12345
86 typedef struct Range {
100 int srcStride[],
int srcSliceY,
int srcSliceH,
101 uint8_t *
dst[],
int dstStride[]);
132 const int16_t **
src, uint8_t *dest,
int dstW,
152 const uint8_t *chrDither,
153 const int16_t *chrFilter,
155 const int16_t **chrUSrc,
156 const int16_t **chrVSrc,
157 uint8_t *dest,
int dstW);
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);
222 const int16_t *chrUSrc[2],
223 const int16_t *chrVSrc[2],
224 const int16_t *alpSrc[2],
226 int dstW,
int yalpha,
int uvalpha,
int y);
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,
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,
449 #define RGB2YUV_SHIFT 15
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
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;
545 #define XYZ_GAMMA (2.6f)
546 #define RGB_GAMMA (2.2f)
568 int width, uint32_t *pal,
void *opq);
571 int width, uint32_t *pal,
void *opq);
574 const uint8_t *
src1,
const uint8_t *
src2,
const uint8_t *src3,
575 int width, uint32_t *pal,
void *opq);
610 int16_t *
dst,
int dstWidth,
611 const uint8_t *
src,
int srcW,
int xInc);
613 int16_t *dst1, int16_t *dst2,
int dstWidth,
614 const uint8_t *
src1,
const uint8_t *
src2,
650 const uint8_t *
src,
const int16_t *
filter,
651 const int32_t *filterPos,
int filterSize);
653 const uint8_t *
src,
const int16_t *
filter,
654 const int32_t *filterPos,
int filterSize);
710 return desc->comp[0].depth == 16;
717 return desc->comp[0].depth == 32;
724 return desc->comp[0].depth >= 9 &&
desc->comp[0].depth <= 14;
772 desc->nb_components <= 2 &&
832 return desc->comp[1].depth == 8;
922 for (
i = 0;
i <
desc->nb_components;
i++) {
923 if (!
desc->comp[
i].shift)
925 if ((
desc->comp[
i].shift +
desc->comp[
i].depth) & 0x7)
942 if (
desc->nb_components < 3)
945 return desc->comp[1].offset >
desc->comp[2].offset;
947 return desc->comp[1].plane >
desc->comp[2].plane;
994 const uint8_t *
src,
int srcW,
int xInc);
996 int dstWidth,
const uint8_t *
src1,
997 const uint8_t *
src2,
int srcW,
int xInc);
1002 int dstWidth,
const uint8_t *
src,
1003 int srcW,
int xInc);
1005 int dstWidth,
const uint8_t *
src1,
1006 const uint8_t *
src2,
int srcW,
int xInc);
1009 int srcStride[],
int srcSliceY,
int srcSliceH,
1010 uint8_t *
dst[],
int dstStride[]);
1013 int srcSliceY,
int srcSliceH,
int width,
1014 uint8_t *
dst,
int dstStride);
1017 int alpha,
int bits,
const int big_endian)
1019 uint8_t *ptr = plane +
stride * y;
1021 if (big_endian != HAVE_BIGENDIAN)
1024 for (
int j = 0; j <
width; j++)
1031 int alpha,
int bits,
const int big_endian,
int is_float)
1033 uint8_t *ptr = plane +
stride * y;
1035 uint32_t onef32 = 0x3f800000;
1037 v =
alpha ? onef32 : 0;
1040 if (big_endian != HAVE_BIGENDIAN)
1044 for (
int j = 0; j <
width; j++)
1051 #define MAX_SLICE_PLANES 4
1139 int nb_jobs,
int nb_threads);
1142 #define MAX_LINES_AHEAD 4
static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
void ff_sws_init_swscale_ppc(SwsContext *c)
int lastInChrBuf
Last scaled horizontal chroma line from source in the ring buffer.
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...
int flags
Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc....
int vLumFilterSize
Vertical filter size for luma/alpha pixels.
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 (...
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
int(* process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH)
Function for processing input slice sliceH lines starting from line sliceY.
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...
AVPixelFormat
Pixel format.
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...
int chrSrcW
Width of source chroma planes.
static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
int sliceH
number of lines
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
uint8_t * formatConvBuffer
@ 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...
int dstW
Width of destination luma/alpha planes.
const uint8_t ff_dither_8x8_220[9][8]
void ff_sws_init_swscale_vsx(SwsContext *c)
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
uint8_t * cascaded1_tmp[4]
@ 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)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
int dstY
Last destination vertical line output from last slice.
void ff_sws_init_swscale_x86(SwsContext *c)
const uint8_t * chrDither8
int cascaded1_tmpStride[4]
void ff_sws_init_swscale_loongarch(SwsContext *c)
int32_t * hChrFilterPos
Array of horizontal filter starting positions for each dst[i] for chroma planes.
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
SwsPlane plane[MAX_SLICE_PLANES]
color planes
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 dstColorspaceTable[4]
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
int ff_rotate_slice(SwsSlice *s, int lum, int chr)
int16_t * vChrFilter
Array of vertical filter coefficients for chroma planes.
int32_t lumMmxFilter[4 *MAX_FILTER_SIZE]
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
int chrDstVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination i...
void ff_sws_init_input_funcs(SwsContext *c)
int16_t * vLumFilter
Array of vertical filter coefficients for luma/alpha planes.
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)
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[]
void ff_sws_init_scale(SwsContext *c)
const AVClass * av_class
info on struct for av_log
@ 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[]
#define AV_PIX_FMT_RGB32_1
yuv2planarX_fn yuv2planeX
void(* filter)(uint8_t *src, int stride, int qscale)
yuv2planar1_fn yuv2plane1
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
int nb_threads
Number of threads used for scaling.
int srcRange
0 = MPG YUV range, 1 = JPG YUV range (source image).
const uint8_t * lumDither8
void ff_get_unscaled_swscale_aarch64(SwsContext *c)
struct AVSliceThread AVSliceThread
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
uint8_t * cascaded_tmp[4]
enum AVPixelFormat fmt
planes pixel format
SwsSlice * src
Source slice.
unsigned int dst_slice_align
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.
yuv2interleavedX_fn yuv2nv12cX
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
void * instance
Filter instance data.
int(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
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...
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)
int16_t xyz2rgb_matrix[3][4]
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
const uint8_t ff_dither_2x2_8[3][8]
av_cold void ff_sws_init_range_convert_loongarch(SwsContext *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)
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
unsigned int rgb0_scratch_allocated
int hLumFilterSize
Horizontal filter size for luma/alpha pixels.
int h_chr_sub_sample
horizontal chroma subsampling factor
av_cold void ff_sws_init_range_convert_aarch64(SwsContext *c)
const uint64_t ff_dither4[2]
const uint8_t ff_dither_8x8_73[9][8]
av_cold void ff_sws_init_range_convert(SwsContext *c)
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
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)
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
enum AVPixelFormat srcFormat
Source pixel format.
ptrdiff_t uv_off
offset (in pixels) between u and v planes
int chrSrcH
Height of source chroma planes.
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
#define YUVRGB_TABLE_HEADROOM
void ff_get_unscaled_swscale_arm(SwsContext *c)
int lumMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
const uint8_t ff_dither_8x8_32[9][8]
static enum AVPixelFormat pix_fmt
int width
Slice line width.
void(* lumConvertRange)(int16_t *dst, int width)
Color range conversion function for luma plane if needed.
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
uint8_t ** tmp
Tmp line buffer used by mmx code.
#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 ...
void(* hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, const int16_t *filter, const int32_t *filterPos, int filterSize)
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
#define AV_PIX_FMT_BGR32_1
int32_t * vLumFilterPos
Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
enum AVPixelFormat dstFormat
Destination pixel format.
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode, int16_t *filter, int32_t *filterPos, int numSplits)
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
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
yuv2packed2_fn yuv2packed2
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
void ff_get_unscaled_swscale(SwsContext *c)
Set c->convert_unscaled to an unscaled converter if one exists for the specific source and destinatio...
Describe the class of an AVClass context structure.
void ff_sws_init_swscale_aarch64(SwsContext *c)
static av_always_inline int isFloat16(enum AVPixelFormat pix_fmt)
int available_lines
max number of lines that can be hold by this plane
@ SWS_ALPHA_BLEND_UNIFORM
SwsFunc convert_unscaled
Note that src, dst, srcStride, dstStride will be copied in the sws_scale() wrapper so they can be fre...
AVSliceThread * slicethread
@ 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...
uint8_t * lumMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
@ 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...
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
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
int16_t rgb2xyz_matrix[3][4]
@ 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 ...
int32_t alpMmxFilter[4 *MAX_FILTER_SIZE]
@ 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
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
void(* readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
@ 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)
int32_t * vChrFilterPos
Array of vertical filter starting positions for each dst[i] for chroma planes.
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
int sliceDir
Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
int chrSrcVSubSample
Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
int32_t * hLumFilterPos
Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
SwsSlice * dst
Output slice.
#define DECLARE_ALIGNED(n, t, v)
int ff_shuffle_filter_coefficients(SwsContext *c, int *filterPos, int filterSize, int16_t *filter, int dstW)
#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
int srcFormatBpp
Number of bits per pixel of the source pixel format.
int srcColorspaceTable[4]
struct SwsFilterDescriptor * desc
struct SwsContext ** slice_ctx
int srcH
Height of source luma/alpha planes.
int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)
initializes chr horizontal scaling descriptor
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
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...
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
static av_always_inline int is32BPS(enum AVPixelFormat pix_fmt)
static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)
int chrMmxextFilterCodeSize
Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
int16_t * hLumFilter
Array of horizontal filter coefficients for luma/alpha planes.
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
yuv2packedX_fn yuv2packedX
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 vChrFilterSize
Vertical filter size for chroma pixels.
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
@ 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...
int srcW
Width of source luma/alpha planes.
@ 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]
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.
#define i(width, name, range_min, range_max)
int dstRange
0 = MPG YUV range, 1 = JPG YUV range (destination image).
void ff_copyPlane(const uint8_t *src, int srcStride, int srcSliceY, int srcSliceH, int width, uint8_t *dst, int dstStride)
av_cold void ff_sws_init_range_convert_x86(SwsContext *c)
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
int16_t * hChrFilter
Array of horizontal filter coefficients for chroma planes.
void ff_sws_init_swscale_riscv(SwsContext *c)
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.
int ff_init_filters(SwsContext *c)
static av_always_inline int isFloat(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
int alpha
Flag for processing alpha channel.
const uint64_t ff_dither8[2]
@ SWS_ALPHA_BLEND_CHECKERBOARD
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
int chrDstH
Height of destination chroma planes.
unsigned int xyz_scratch_allocated
int ff_free_filters(SwsContext *c)
void ff_get_unscaled_swscale_ppc(SwsContext *c)
int32_t input_rgb2yuv_table[16+40 *4]
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...
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)
static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
int cascaded_tmpStride[4]
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
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...
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
void(* readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
int warned_unuseable_bilinear
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
int32_t chrMmxFilter[4 *MAX_FILTER_SIZE]
void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc)
static av_always_inline int isBayer16BPS(enum AVPixelFormat pix_fmt)
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
int sliceY
index of first line
void * input_opaque
Opaque data pointer passed to all input functions.
int hChrFilterSize
Horizontal filter size for chroma pixels.
int vChrDrop
Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user...
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
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.
static double lum(void *priv, double x, double y, int plane)
static const int16_t alpha[]
int chrDstHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination...
static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
atomic_int stride_unaligned_warned
int chrDstW
Width of destination chroma planes.
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.
yuv2packed1_fn yuv2packed1
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes lum pixel format conversion descriptor
void ff_updateMMXDitherTables(SwsContext *c, int dstY)
void ff_sws_init_swscale_arm(SwsContext *c)
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
struct SwsContext * cascaded_context[3]
float uint2float_lut[256]
void(* chrConvertRange)(int16_t *dst1, int16_t *dst2, int width)
Color range conversion function for chroma planes if needed.
void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
int chrSrcHSubSample
Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source imag...
uint8_t * chrMmxextFilterCode
Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
#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 dstH
Height of destination luma/alpha planes.
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.
const uint8_t ff_dither_4x4_16[5][8]
Half2FloatTables * h2f_tables
SwsFunc ff_yuv2rgb_init_loongarch(SwsContext *c)
const uint8_t ff_dither_2x2_4[3][8]
atomic_int data_unaligned_warned
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
int lastInLumBuf
Last scaled horizontal luma/alpha line from source in the ring buffer.
struct SwsContext * parent
@ 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...
ptrdiff_t uv_offx2
offset (in bytes) between u and v planes
int needs_hcscale
Set if there are chroma planes to be converted.
double param[2]
Input parameters for scaling algorithms that need them.
static const uint8_t dither[8][8]