26 ffmpeg 使用libx265

跟h264和x264一样，h265的开源也有x265。FFMPEG用就是libx265。FFMPEG的h265编码用的是libx265，解码是自身提供的功能。这里跟h264一样。主要是分析ffmpeg如何使用libx264的，但是对于libx265主要细节没有涉及到，这也没那么简单。得先理清h265的相关标准协议才行。这还有很长一步路要走咯。

AVCodec ff_libx265_encoder = {
    .name             = "libx265",
    .long_name        = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_HEVC,
    .init             = libx265_encode_init,
    .init_static_data = libx265_encode_init_csp,
    .encode2          = libx265_encode_frame,
    .close            = libx265_encode_close,
    .priv_data_size   = sizeof(libx265Context),
    .priv_class       = &class,
    .defaults         = x265_defaults,
    .capabilities     = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,
};

先明确一样：AV_CODEC_ID_HEVC 和 AV_CODEC_ID_H265是一样的。

#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC

从结构体看，主要有三个函数：init，encode2和close。

libx265_encode_init

步骤清晰了，代码就简单了：

1. api 用x265_api_getapi来创建
2. parames x265api来alloc params，后对params进行设置。用了几种方式：
   api->param_default_preset，参数为ctx->preset, ctx->tune
   直接赋值，参数是avctx的一些参数，譬如avctx->width，avctx->height
   api->param_parse，参数为ctx->x265_opts
3. encoder_open，使用了parames。后根据flags来调用encoder_headers。

static av_cold int libx265_encode_init(AVCodecContext *avctx)
{
    libx265Context *ctx = avctx->priv_data;
    ctx->api = x265_api_get(av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth);

创建了api

    ctx->params = ctx->api->param_alloc();  

    // param_default_preset ctx->preset, ctx->tune
    ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune);

    // 直接赋值
    ctx->params->frameNumThreads = avctx->thread_count;
    ctx->params->fpsNum          = avctx->time_base.den;
    ctx->params->fpsDenom        = avctx->time_base.num * avctx->ticks_per_frame;
    ctx->params->sourceWidth     = avctx->width;
    ctx->params->sourceHeight    = avctx->height;
    ctx->params->bEnablePsnr     = !!(avctx->flags & AV_CODEC_FLAG_PSNR);

    if ((avctx->color_primaries <= AVCOL_PRI_BT2020 &&
         avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
        (avctx->color_trc <= AVCOL_TRC_BT2020_12 &&
         avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
        (avctx->colorspace <= AVCOL_SPC_BT2020_CL &&
         avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {

        ctx->params->vui.bEnableVideoSignalTypePresentFlag  = 1;
        ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;

        // x265 validates the parameters internally
        ctx->params->vui.colorPrimaries          = avctx->color_primaries;
        ctx->params->vui.transferCharacteristics = avctx->color_trc;
        ctx->params->vui.matrixCoeffs            = avctx->colorspace;
    }

    // param_parse sar
    if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
        char sar[12];
        int sar_num, sar_den;

        av_reduce(&sar_num, &sar_den,
                  avctx->sample_aspect_ratio.num,
                  avctx->sample_aspect_ratio.den, 65535);
        snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
        ctx->api->param_parse(ctx->params, "sar", sar);
    }

    switch (avctx->pix_fmt) {
    case AV_PIX_FMT_YUV420P:
    case AV_PIX_FMT_YUV420P10:
    case AV_PIX_FMT_YUV420P12:
        ctx->params->internalCsp = X265_CSP_I420;
        break;
    case AV_PIX_FMT_YUV422P:
    case AV_PIX_FMT_YUV422P10:
    case AV_PIX_FMT_YUV422P12:
        ctx->params->internalCsp = X265_CSP_I422;
        break;
    case AV_PIX_FMT_YUV444P:
    case AV_PIX_FMT_YUV444P10:
    case AV_PIX_FMT_YUV444P12:
        ctx->params->internalCsp = X265_CSP_I444;
        break;
    }

    // param_parse crf
    if (ctx->crf >= 0) {
        char crf[6];
        snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
        ctx->api->param_parse(ctx->params, "crf", crf)
    } else if (avctx->bit_rate > 0) {
        ctx->params->rc.bitrate         = avctx->bit_rate / 1000;
        ctx->params->rc.rateControlMode = X265_RC_ABR;
    }

    if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
        ctx->params->bRepeatHeaders = 1;

    // param_parse x265_opts
    if (ctx->x265_opts) {
        AVDictionary *dict    = NULL;
        AVDictionaryEntry *en = NULL;

        if (!av_dict_parse_string(&dict, ctx->x265_opts, "=", ":", 0)) {
            while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
                int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
            }
            av_dict_free(&dict);
        }
    }

对ctx->params来赋值。

    ctx->encoder = ctx->api->encoder_open(ctx->params);

    if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
        x265_nal *nal;
        int nnal;

        avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);

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

        memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
    }

    return 0;
}

用encoder_open调用，参数为ctx->params。

一个函数三步最多了，如果多于三步将复杂。自己写代码也将注意。

libx265_encode_frame

先看一个函数原型:
输入：AVCodecContext *avctx，const AVFrame *frame
输出：AVPacket *avpkt，int *got_packet_ptr

 /**
     * Encode data to an AVPacket.
     *
     * @param      avctx          codec context
     * @param      avpkt          output AVPacket (may contain a user-provided buffer)
     * @param[in]  frame          AVFrame containing the raw data to be encoded
     * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
     *                            non-empty packet was returned in avpkt.
     * @return 0 on success, negative error code on failure
     */
    int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
                   int *got_packet_ptr);

给一个AVFrame，出一个编码后的AVPacket。通过got_packet_ptr来标示。

encode三步骤，多喜欢三啦。

1. picture_init：根据params和pic来初始化x265pic
2. encoder_encode：正式编码，编码结果为nal和nnal，nnal为nal的个数。
3. 把编码结果nal的数据拷贝到pkt->data，pts，dts和pict_type赋值。

static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                                const AVFrame *pic, int *got_packet)
{
    libx265Context *ctx = avctx->priv_data;
    x265_picture x265pic;
    x265_picture x265pic_out = { 0 };
    x265_nal *nal;
    uint8_t *dst;
    int payload = 0;
    int nnal;
    int ret;
    int i;

    ctx->api->picture_init(ctx->params, &x265pic);

    if (pic) {
        for (i = 0; i < 3; i++) {
           x265pic.planes[i] = pic->data[i];
           x265pic.stride[i] = pic->linesize[i];
        }
        x265pic.pts      = pic->pts;
        x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
        x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ? X265_TYPE_I :
                            pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
                            pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
                            X265_TYPE_AUTO;
    }

初始化了一个x265_picture，先用params来init，后通过AVFrame来进行参数设置。

    ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
                                   pic ? &x265pic : NULL, &x265pic_out);

一切就绪，开始编码。x265pic_out 也是输出结果，使用了几个参数：pts，dts，sliceType。

    for (i = 0; i < nnal; i++)
        payload += nal[i].sizeBytes;
    ret = ff_alloc_packet(pkt, payload);

    dst = pkt->data;
    for (i = 0; i < nnal; i++) {
        memcpy(dst, nal[i].payload, nal[i].sizeBytes);
        dst += nal[i].sizeBytes;

        if (is_keyframe(nal[i].type))
            pkt->flags |= AV_PKT_FLAG_KEY;
    }

    pkt->pts = x265pic_out.pts;
    pkt->dts = x265pic_out.dts;

    switch (x265pic_out.sliceType) {
    case X265_TYPE_IDR:
    case X265_TYPE_I:
        avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
        break;
    case X265_TYPE_P:
        avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
        break;
    case X265_TYPE_B:
        avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
        break;
    }

    *got_packet = 1;
    return 0;
}

数据拷贝，参数赋值。最后给*got_packet = 1;说明编码成功。

咱们上面的代码都删除了结果码判断，一些提前返回给删除了。

libx265_encode_close

最好还剩下一个收尾操作。用param_free和encoder_close。

static av_cold int libx265_encode_close(AVCodecContext *avctx)
{
    libx265Context *ctx = avctx->priv_data;
   ctx->api->param_free(ctx->params);

    if (ctx->encoder)
        ctx->api->encoder_close(ctx->encoder);

    return 0;
}

翻x265源码时，发现是用C++来实现的，提供了C语言的接口，也没找到函数原型说明。当然看到函数名就明白了。x265的使用还是比较简单的，上面使用的函数不是很多，屏蔽了很多复杂的操作。