SVT-AV1接入ffmpeg说明

一 编译集成

Files · v2.3.0 · Alliance for Open Media / SVT-AV1 · GitLab

cd /SVT-AV1/Build/linux/

./build.sh

make install

GitHub - FFmpeg/FFmpeg: Mirror of https://git.ffmpeg.org/ffmpeg.git

./configure --enable-libsvtav1 --enable-gpl --extra-ldflags='-L/usr/local/lib' --extra-libs='-lSvtAv1Enc -lz -lm -lstdc++ -ldl -lpthread' --extra-cflags='-I/usr/local/include/'

make && make install

./ffmpeg -codecs|grep av1

DEV.L. av1 Alliance for Open Media AV1 (decoders: libdav1d av1 av1_cuvid ) (encoders: libsvtav1 )

二 SVT-AV1视频编码命令行

ffmpeg -i input.mp4 -c:v libsvtav1 -crf 30 -preset 4 -y output.mp4

三 ffmpeg 接入wrapper代码review

#include <stdint.h> //标准头文件

#include <EbSvtAv1ErrorCodes.h> //SVT编码错误信息头文件

#include <EbSvtAv1Enc.h> //SVT编码API头文件

//以下是ffmpeg自己的头文件

#include "libavutil/common.h"

#include "libavutil/frame.h"

#include "libavutil/imgutils.h"

#include "libavutil/opt.h"

#include "libavutil/pixdesc.h"

#include "libavutil/avassert.h"

typedef enum eos_status {

EOS_NOT_REACHED = 0,

EOS_SEND,

EOS_RECEIVED

} EOS_STATUS;

typedef struct SvtContext {

const AVClass *class;

EbSvtAv1EncConfiguration enc_params; //SVT-AV1编码器的配置参数

EbComponentType *svt_handle;//SVT-AV1 编码器的句柄

EbBufferHeaderType *in_buf; //输入缓冲区

int raw_size;//原始数据大

int max_tu_size;//最大传输单元大小

AVFrame *frame;//当前处理的视频帧

AVBufferPool *pool;//缓冲池，用于管理编码输出

EOS_STATUS eos_flag;//结束状态标志

//用户选项

int hierarchial_level; //层次预测级别

int la_depth; //前瞻深度

int enc_mode;//编码模式

int rc_mode ;// 码率控制模式

int scd;//场景变化监测

int qp;//固定量化参数

int tier;//操作点层级

int tile_columns;//tile列数

int tile_rows;//tile行数

} SvtContext;

static const struct {

EbErrorType eb_err; // SVT-AV1错误码

int av_err; // FFmpeg错误码

const char *desc; // 错误描述

} svt_errors[] = {

{ EB_ErrorNone, 0, "success" },

{ EB_ErrorInsufficientResources, AVERROR(ENOMEM), "insufficient resources" },

{ EB_ErrorUndefined, AVERROR(EINVAL), "undefined error" },

{ EB_ErrorInvalidComponent, AVERROR(EINVAL), "invalid component" },

{ EB_ErrorBadParameter, AVERROR(EINVAL), "bad parameter" },

{ EB_ErrorDestroyThreadFailed, AVERROR_EXTERNAL, "failed to destroy thread" },

{ EB_ErrorSemaphoreUnresponsive, AVERROR_EXTERNAL, "semaphore unresponsive" },

{ EB_ErrorDestroySemaphoreFailed, AVERROR_EXTERNAL, "failed to destroy semaphore"},

{ EB_ErrorCreateMutexFailed, AVERROR_EXTERNAL, "failed to create mutex" },

{ EB_ErrorMutexUnresponsive, AVERROR_EXTERNAL, "mutex unresponsive" },

{ EB_ErrorDestroyMutexFailed, AVERROR_EXTERNAL, "failed to destroy mutex" },

{ EB_NoErrorEmptyQueue, AVERROR(EAGAIN), "empty queue" },

};

static int svt_map_error(EbErrorType eb_err, const char **desc)

{

int i;

av_assert0(desc);

for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {

if (svt_errors[i].eb_err == eb_err) {

*desc = svt_errors[i].desc;

return svt_errors[i].av_err;

}

}

*desc = "unknown error";

return AVERROR_UNKNOWN;

}

static int svt_print_error(void *log_ctx, EbErrorType err,

const char *error_string)

{

const char *desc;

int ret = svt_map_error(err, &desc);

av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);

return ret;

}

static int alloc_buffer(EbSvtAV1EncConfiguration *config, SvtContext *svt_enc)

{

const int pack_mode_10bit = (config->encoder_bit_depth > 8) && (config->compressed_ten_bit_format == 0) ?1:0; //定一个变量，pack_mode_10bit, 用于判断是否需要对10位编码进行特殊处理

//如果编码器的位深大于8位，并且compressed_ten_bit_format. 为0， 则设置为1，表示需要特殊处理

//否则设置为0

const size_t luma_size_8bit = config->source_width * config->source_height 分别是输入视频的宽度和高度

1 << pack_mode_10bit 如果pack_mode_10bit 为1，则乘以2，否则乘以1，这用语计算10位编码时的额外数据大小

const size_t luma_size_10bit = (config->encoder_bit_depth > 8 && pack_mode_10bit == 0) ? luma_size_8bit: 0;

//计算10位亮度分量的大小

如果编码器的位深度大于8位，并且pack_mode_10bit， 为0，则使用与8位相同的大小，否则设置为0，表示不使用10位编码。

EbSvtIOFormat *in_data; //声明一个指向EbSvtIOFormat 的指针in_data, 用于表示输入数据的格式

svt_enc->raw_size = (luma_size_8bit + luma_size_10bit) * 3/2;

//对于YUV420格式，总大小为亮度分量大小乘以1.5

//如果同时支持8位和10位编码，则两者的大小相加。

//分配输入缓冲区

// 分配输入缓冲区
    svt_enc->in_buf           = av_mallocz(sizeof(*svt_enc->in_buf));
    if (!svt_enc->in_buf)
        return AVERROR(ENOMEM);

//为输入缓冲区的数据部分分配内存

svt_enc->in_buf->p_buffer = av_mallocz(sizeof(*in_data));
    if (!svt_enc->in_buf->p_buffer)
        return AVERROR(ENOMEM);

svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);

//设置输入缓冲区的大小为分配的内存大小，即sizeof(*svt_enc->in_buf)

return 0;

}

//下面这个函数，把ffmpeg的AVFrame 转为SVT-AV1的输入缓冲帧结构体 EbSvtIOFormat

static int read_in_data(EbSvtAV1EncConfiguration *param, const AVFrame *frame, EbBufferHeaderType *header_ptr)

{

EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;

ptrdiff_t linesizes[4];

size_t sizes[4];

int bytes_shift = param->encoder_bit_depth > 8 ?1:0;

int ret, frame_size;

for (int i = 0; i < 4; i++)

linesizes[i] = frame->linesize[i];

ret = av_image_fill_plane_sizes(sizes, frame->format, frame->height, linesizes);

if (ret < 0)

return ret;

frame_size = 0;

for (int i = 0; i < 4; i++) {

if (sizes[i] > INT_MAX - frame_size)

return AVERROR(EINVAL);

frame_size + sizes[i];

}

in_data->luma = frame->data[0];

in_data->cb = frame->data[1];

in_data->cr = frame->data[2];

in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);

in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);

in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);

header_ptr->n_filled_len = frame_size;

return 0;

}

static av_cold int eb_enc_init(AVCodecContext *avctx)

{

SvtContext *svt_enc = avctx->priv_data;

EbErrorType svt_ret;

int ret;

svt_enc->eos_flag = EOS_NOT_REASCHED;

svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params); //初始化svt_av1 编码handle

if (svt_ret != EB_ErrorNone)

return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");

ret = config_enc_params(&svt_env->enc_params, avctx);

svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);

svt_ret = svt_av1_enc_init(svt_enc->svt_handle); //初始化编码器

if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {

EbBufferHeaderType *headerPtr = NULL;

svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);

avctx->extradata_size = headerPtr->m_filled_len;

avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);

svt_ret = svt_av1_enc_stream_header_release(headerPtr);

}

svt_enc->frame = av_frame_alloc();

return alloc_buffer(&svt_enc->enc_params, svt_enc);

}

headerPtr->flags = 0;

headerPtr->p_app_private = NULL;

headerPtr->pts = frame->pts;

svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);

}

static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)

{ //将AVFrame 转成SVT-AV1的输入结构，send到编码器中

SvtContext *svt_enc = avctx->priv_data;

EbBufferHeaderType *headerPtr = svt_enc->in_buf;

int ret;

if (!frame) {

EbBufferHeaderType headerPtrLast;

if (svt_enc->eos_flag == EOS_SENT)

return 0;

headerPtrLast.n_alloc_len = 0;

headerPtrLast.n_filled_len = 0;

headerPtrLast.n_tick_count = 0;

headerPtrLast.p_app_private = NULL;

headerPtrLast.p_buffer = NULL;

headerPtrLast.flags = EB_BUFFERFLAG_EOS;

svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);

svt_enc->eos_flag = EOS_SENT;

return 0;

}

ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);

if (ret < 0)

return ret;

headerPtr->flags = 0;

headerPtr->p_app_private = NULL;

headerPtr->pts = frame->pts;

svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);

return 0;

}

static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)

{

SvtContext *svt_enc = avctx->priv_data;

EbBufferHeaderType *headerPtr;

AVFrame *frame = svt_enc->frame;

EbErrorType svt_ret;

AVBufferRef *ref;

int ret = 0, pict_type;

if (svt_enc->eos_flag == EOS_RECEIVED)

return AVERROR_EOF;

ret = ff_encode_get_frame(avctx, frame); //从编码队列获取一个帧

if (ret < 0 && ret != AVERROR_EOF)

return ret;

if (ret == AVERROR_EOF)

frame = NULL;

ret = eb_send_frame(avctx, frame); //发送到编码器里面

if (ret < 0)

return ret;

av_frame_unref(svt_enc->frame);

svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag); //获取编码好的视频

if (svt_ret == EB_NoErrorEmptyQueue)

return AVERROR(EAGAIN);

ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len); //获取AVPacket buffer数据

if (!ref) {

av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");

svt_av1_enc_release_out_buffer(&headerPtr);

return AVERROR(ENOMEM);

}

//构建一个新的AVPacket

pkt->buf = ref;

pkt->data = ref->data;

memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);

memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE); //数据存入AVPacket

pkt->size = headerPtr->n_filled_len;

pkt->pts = headerPtr->pts;

pkt->dts = headerPtr->dts;

switch (headerPtr->pic_type) {

case EB_AV1_KEY_PICTURE:

pkt->flags |= AV_PKT_FLAG_KEY;

// fall-through

case EB_AV1_INTRA_ONLY_PICTURE:

pict_type = AV_PICTURE_TYPE_I;

break;

case EB_AV1_INVALID_PICTURE:

pict_type = AV_PICTURE_TYPE_NONE;

break;

default:

pict_type = AV_PICTURE_TYPE_P;

break;

}

if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)

pkt->flags |= AV_PKT_FLAG_DISPOSABLE;

if (headerPtr->flags & EB_BUFFERFLAG_EOS)

svt_enc->eos_flag = EOS_RECEIVED;

ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);

svt_av1_enc_release_out_buffer(&headerPtr);

return 0;

}

static av_cold int eb_enc_close(AVCodecContext *avctx)

{ //关闭编码器

SvtContext *svt_enc = avctx->priv_data;

if (svt_enc->svt_handle) {

svt_av1_enc_deinit(svt_enc->svt_handle);

svt_av1_enc_deinit_handle(svt_enc->svt_handle);

}

if (svt_enc->in_buf) {

av_free(svt_enc->in_buf->p_buffer);

av_freep(&svt_enc->in_buf);

}

av_buffer_pool_uninit(&svt_enc->pool);

av_frame_free(&svt_enc->frame);

return 0;

}