FFmpeg源码分析：SwsContext图像转换上下文
FFmpeg的libswscale模块提供图像缩放、图像格式转换功能。其中贯穿整个模块的是SwsContext结构体，方法包括sws_alloc_context分配、sws_init_context初始化、sws_getContext获取上下文、sws_get_cachedContext获取缓存，sws_freeContext释放上下文的方法。
1、SwsContext
SwsContext结构体位于libswscale模块的swscale_internal.h头文件，具体如下：
typedef struct SwsContext {
const AVClass *av_class;
SwsFunc swscale;
int srcW; // Width of source luma/alpha planes.
int srcH; // Height of source luma/alpha planes.
int dstH; // Height of destination luma/alpha planes.
int chrSrcW; // Width of source chroma planes.
int chrSrcH; // Height of source chroma planes.
int chrDstW; // Width of destination chroma planes.
int chrDstH; // Height of destination chroma planes.
// 级联上下文，可以把scaler分解为几步操作
struct SwsContext *cascaded_context[3];
int cascaded_tmpStride[4];
uint8_t *cascaded_tmp[4];
int cascaded1_tmpStride[4];
uint8_t *cascaded1_tmp[4];
int cascaded_mainindex;
double gamma_value;
int gamma_flag;
int is_internal_gamma;
uint16_t *gamma;
uint16_t *inv_gamma;
int numDesc;
int descIndex[2];
int numSlice;
struct SwsSlice *slice;
struct SwsFilterDescriptor *desc;
uint32_t pal_yuv[256];
uint32_t pal_rgb[256];
float uint2float_lut[256];
// 垂直缩放的环形缓冲区
int lastInLumBuf;
int lastInChrBuf;
uint8_t *formatConvBuffer;
int needAlpha;
// 水平/垂直滤波器
int16_t *hLumFilter;
int16_t *hChrFilter;
int16_t *vLumFilter;
int16_t *vChrFilter;
int32_t *hLumFilterPos;
int32_t *hChrFilterPos;
int32_t *vLumFilterPos;
int32_t *vChrFilterPos;
int hLumFilterSize;
int hChrFilterSize;
int vLumFilterSize;
int vChrFilterSize;
int canMMXEXTBeUsed;
int warned_unuseable_bilinear;
int dstY;
// 选择算法、优化、子采样的flag
int flags;
// 指向yuv->rgb表的起始位置
void *yuvTable;
// 表格包含C和SIMD指令
DECLARE_ALIGNED(16, int, table_gV)[256 + 2*YUVRGB_TABLE_HEADROOM];
uint8_t *table_rV[256 + 2*YUVRGB_TABLE_HEADROOM];
uint8_t *table_gU[256 + 2*YUVRGB_TABLE_HEADROOM];
uint8_t *table_bU[256 + 2*YUVRGB_TABLE_HEADROOM];
DECLARE_ALIGNED(16, int32_t, input_rgb2yuv_table)[16+40*4];
int *dither_error[4];
//颜色空间参数
int contrast, brightness, saturation;
int srcColorspaceTable[4];
int dstColorspaceTable[4];
int srcRange; // 0 = MPG YUV range, 1 = JPG YUV range
int dstRange; // 0 = MPG YUV range, 1 = JPG YUV range
const uint8_t *chrDither8, *lumDither8;
int use_mmx_vfilter;
int16_t *xyzgamma;
int16_t *rgbgamma;
int16_t *xyzgammainv;
int16_t *rgbgammainv;
int16_t xyz2rgb_matrix[3][4];
int16_t rgb2xyz_matrix[3][4];
//swscale()方法的函数指针
yuv2planar1_fn yuv2plane1;
yuv2planarX_fn yuv2planeX;
yuv2interleavedX_fn yuv2nv12cX;
yuv2packed1_fn yuv2packed1;
yuv2packed2_fn yuv2packed2;
yuv2packedX_fn yuv2packedX;
yuv2anyX_fn yuv2anyX;
void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2,
const uint8_t *src3, int width, uint32_t *pal);
void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2,
const uint8_t *src3, int width, uint32_t *pal);
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);
// 读取输入plane，比如RGB
void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
int width, int32_t *rgb2yuv);
void (*readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
// 使用bilinear滤波器进行缩放
void (*hyscale_fast)(struct SwsContext *c,
int16_t *dst, int dstWidth,
const uint8_t *src, int srcW, int xInc);
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);
// 使用滤波器进行水平缩放
void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
const uint8_t *src, const int16_t *filter,
const int32_t *filterPos, int filterSize);
void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
const uint8_t *src, const int16_t *filter,
const int32_t *filterPos, int filterSize);
// luma平面的色彩空间转换
void (*lumConvertRange)(int16_t *dst, int width);
// chroma平面的色彩空间转换
void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
int needs_hcscale;
SwsDither dither;
SwsAlphaBlend alphablend;
} SwsContext;2、sws_alloc_context
用于分配图像转换的上下文，首先是调用av_mallocz()分配结构体内存，然后赋值av_class，初始化默认options参数：
SwsContext *sws_alloc_context(void)
{
SwsContext *c = av_mallocz(sizeof(SwsContext));
av_assert0(offsetof(SwsContext, redDither) + DITHER32_INT == offsetof(SwsContext, dither32));
if (c) {
c->av_class = &ff_sws_context_class;
av_opt_set_defaults(c);
}
return c;
}3、sws_init_context
初始化图像转换的上下文，位于libswscale模块的utils.c。步骤包括：检查输入输出的像素格式是否支持；判断有没设置正确的滤波算法，如果没有就指定为SWS_BICUBIC算法；检查源图像宽高、目标图像宽高是否有效；获取图像转换函数；初始化滤波器。代码如下：
int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
SwsFilter *dstFilter)
{
......
// 检查是否支持输入输出像素格式
if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
if (!sws_isSupportedInput(srcFormat)) {
return AVERROR(EINVAL);
}
if (!sws_isSupportedOutput(dstFormat)) {
return AVERROR(EINVAL);
}
}
// 判断flags有没设置为其中一种算法
i = flags & (SWS_POINT |
SWS_AREA |
SWS_BILINEAR |
SWS_FAST_BILINEAR |
SWS_BICUBIC |
SWS_X |
SWS_GAUSS |
SWS_LANCZOS |
SWS_SINC |
SWS_SPLINE |
SWS_BICUBLIN);
// 如果没有设置算法，提供默认的算法
if (!i) {
if (dstW < srcW && dstH < srcH)
flags |= SWS_BICUBIC;
else if (dstW > srcW && dstH > srcH)
flags |= SWS_BICUBIC;
else
flags |= SWS_BICUBIC;
c->flags = flags;
} else if (i & (i - 1)) {
return AVERROR(EINVAL);
}
// 检查参数是否有效
if (srcW < 1 || srcH < 1 || dstW < 1 || dstH < 1) {
return AVERROR(EINVAL);
}
if (flags & SWS_FAST_BILINEAR) {
if (srcW < 8 || dstW < 8) {
flags ^= SWS_FAST_BILINEAR | SWS_BILINEAR;
c->flags = flags;
}
}
......
/* unscaled special cases */
if (unscaled && !usesHFilter && !usesVFilter &&
(c->srcRange == c->dstRange || isAnyRGB(dstFormat) ||
isFloat(srcFormat) || isFloat(dstFormat))){
ff_get_unscaled_swscale(c);
if (c->swscale) {
return 0;
}
}
// 获取swscale函数
c->swscale = ff_getSwsFunc(c);
// 初始化滤波器
return ff_init_filters(c);
nomem:
ret = AVERROR(ENOMEM);
fail:
.....
return ret;
}其中，ff_getSwsFunc()位于swscale.c，根据不同平台来初始化swscale：
SwsFunc ff_getSwsFunc(SwsContext *c)
{
sws_init_swscale(c);
if (ARCH_PPC)
ff_sws_init_swscale_ppc(c);
if (ARCH_X86)
ff_sws_init_swscale_x86(c);
if (ARCH_AARCH64)
ff_sws_init_swscale_aarch64(c);
if (ARCH_ARM)
ff_sws_init_swscale_arm(c);
return swscale;
}
ff_init_filters()负责对滤波器进行初始化，滤波器算法包括：均值滤波、双三次插值滤波、亮度双三次插值/色度双线性插值、双线性滤波、快速双线性滤波高斯滤波、正交相似变换滤波、最近邻滤波、正弦滤波、三次样本插值滤波、内部滤波。具体列表如下：
static const ScaleAlgorithm scale_algorithms[] = {
{ SWS_AREA, "area averaging", 1 },
{ SWS_BICUBIC, "bicubic", 4 },
{ SWS_BICUBLIN, "luma bicubic / chroma bilinear", -1 },
{ SWS_BILINEAR, "bilinear", 2 },
{ SWS_FAST_BILINEAR, "fast bilinear", -1 },
{ SWS_GAUSS, "Gaussian", 8 },
{ SWS_LANCZOS, "Lanczos", -1 },
{ SWS_POINT, "nearest neighbor / point", -1 },
{ SWS_SINC, "sinc", 20 },
{ SWS_SPLINE, "bicubic spline", 20 },
{ SWS_X, "experimental", 8 },
};4、sws_getContext
获取图像转换的上下文，首先设置相关参数，然后调用sws_init_context()来初始化上下文：
SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
int dstW, int dstH, enum AVPixelFormat dstFormat,
int flags, SwsFilter *srcFilter,
SwsFilter *dstFilter, const double *param)
{
SwsContext *c;
c = sws_alloc_set_opts(srcW, srcH, srcFormat,
dstW, dstH, dstFormat,
flags, param);
if (!c)
return NULL;
if (sws_init_context(c, srcFilter, dstFilter) < 0) {
sws_freeContext(c);
return NULL;
}
return c;
}5、sws_getCachedContext
获取缓存的图像转换上下文。首先校验参数是否一致，如果校验不通过就释放资源；然后判断上下文是否存在，如果存在直接复用，如不存在进行分配、初始化操作：
struct SwsContext *sws_getCachedContext(struct SwsContext *context, int srcW,
int srcH, enum AVPixelFormat srcFormat,
int dstW, int dstH,
enum AVPixelFormat dstFormat, int flags,
SwsFilter *srcFilter,
SwsFilter *dstFilter,
const double *param)
{
static const double default_param[2] = { SWS_PARAM_DEFAULT,
SWS_PARAM_DEFAULT };
int64_t src_h_chr_pos = -513, dst_h_chr_pos = -513,
src_v_chr_pos = -513, dst_v_chr_pos = -513;
if (!param)
param = default_param;
// 校验参数，如果不通过直接释放资源
if (context &&
(context->srcW != srcW ||
context->srcH != srcH ||
context->srcFormat != srcFormat ||
context->dstW != dstW ||
context->dstH != dstH ||
context->dstFormat != dstFormat ||
context->flags != flags ||
context->param[0] != param[0] ||
context->param[1] != param[1])) {
av_opt_get_int(context, "src_h_chr_pos", 0, &src_h_chr_pos);
av_opt_get_int(context, "src_v_chr_pos", 0, &src_v_chr_pos);
av_opt_get_int(context, "dst_h_chr_pos", 0, &dst_h_chr_pos);
av_opt_get_int(context, "dst_v_chr_pos", 0, &dst_v_chr_pos);
sws_freeContext(context);
context = NULL;
}
// 如果上下文不存在，进行分配、初始化操作
if (!context) {
if (!(context = sws_alloc_context()))
return NULL;
context->srcW = srcW;
context->srcH = srcH;
context->srcFormat = srcFormat;
context->dstW = dstW;
context->dstH = dstH;
context->dstFormat = dstFormat;
context->flags = flags;
context->param[0] = param[0];
context->param[1] = param[1];
av_opt_set_int(context, "src_h_chr_pos", src_h_chr_pos, 0);
av_opt_set_int(context, "src_v_chr_pos", src_v_chr_pos, 0);
av_opt_set_int(context, "dst_h_chr_pos", dst_h_chr_pos, 0);
av_opt_set_int(context, "dst_v_chr_pos", dst_v_chr_pos, 0);
if (sws_init_context(context, srcFilter, dstFilter) < 0) {
sws_freeContext(context);
return NULL;
}
}
return context;
}6、sws_freeContext
用于释放图像转换上下文，各种释放操作：
void sws_freeContext(SwsContext *c)
{
int i;
if (!c)
return;
for (i = 0; i < 4; i++)
av_freep(&c->dither_error[i]);
av_freep(&c->vLumFilter);
av_freep(&c->vChrFilter);
av_freep(&c->hLumFilter);
av_freep(&c->hChrFilter);
av_freep(&c->vLumFilterPos);
av_freep(&c->vChrFilterPos);
av_freep(&c->hLumFilterPos);
av_freep(&c->hChrFilterPos);
av_freep(&c->yuvTable);
av_freep(&c->formatConvBuffer);
sws_freeContext(c->cascaded_context[0]);
sws_freeContext(c->cascaded_context[1]);
sws_freeContext(c->cascaded_context[2]);
memset(c->cascaded_context, 0, sizeof(c->cascaded_context));
av_freep(&c->cascaded_tmp[0]);
av_freep(&c->cascaded1_tmp[0]);
av_freep(&c->gamma);
av_freep(&c->inv_gamma);
ff_free_filters(c);
av_free(c);
}