12 - FFmpeg 编码 H264

---------------------------- 视频编码 ---------------------------- 
ffmpeg命令
    ffmpeg -s 768*432 -pix_fmt yuv420p -i hong.yuv -vcodec libx264 -b:v 4096k -bf 0 -g 10 -r 30 out1.h264
参数介绍:
    -s 指定视频大小
    -pix_fmt 指定图形颜色空间
    -b:v 指定视频平均码率
    -bf 指定B帧数目
    -g 指定两个l帧之间的间隔
    -r 指定视频帧率

---------------------------- 编码流程 ---------------------------- 
1、查找编码器 --- avcodec_find_encoder_by_name
2、创建编码器上下文 --- avcodec_alloc_context3
3、设置编码参数 --- avcode_open2
4、打开编码器 --- av_frame_alloc
5、读取yuv数据 --- av_image_get_buffer_size
6、开始编码 --- av_image_fill_arrays
8、写入编码数据 --- avcodec_send_frame + avcodec_receive_packet

方法一：

int writePacketCount = 0;
int encodeVideo(AVCodecContext *encoderCtx, AVFrame *frame, AVPacket *packet, FILE *dest_fp)
{
    int ret = avcodec_send_frame(encoderCtx, frame);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "send frame to encoder failed: %s\n", av_err2str(ret));
        return -1;
    }
    while (ret >= 0)
    {
        ret = avcodec_receive_packet(encoderCtx, packet);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
        {
            av_log(NULL, AV_LOG_INFO, "[int encodeVideo] -- AVERROR(EAGAIN) || AVERROR_EOF \n");
            return 0;
        }
        else if (ret < 0)
        {
            av_log(NULL, AV_LOG_ERROR, "encoder frame failed:%s\n", av_err2str(ret));
            return -1;
        }
        fwrite(packet->data, 1, packet->size, dest_fp);
        writePacketCount++;
        av_log(NULL, AV_LOG_INFO, "writePacketCount:%d\n", writePacketCount);
        av_packet_unref(packet);
    }
    return 0;
}

int YUVencodeH264(const char *inFileName, const char *outFileName, const char *encoderName, const char *videoSize)
{
    int ret = 0;
 
    /***************************************************************************************************/
    FILE *src_fp = fopen(inFileName, "rb");
    if (src_fp == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "open infile %s failed!\n", inFileName);
        ret = -1;
        goto end;
    }
    FILE *dest_fp = fopen(outFileName, "wb+");
    if (dest_fp == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "open outfile %s failed!\n", outFileName);
        ret = -1;
        goto end;
    }
    /***************************************************************************************************/
 
    int width = 0, height = 0;
    ret = av_parse_video_size(&width, &height, videoSize);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "parse video size failed:%s\n", av_err2str(ret));
        return -1;
    }
    av_log(NULL, AV_LOG_INFO, "getWidth:%d, getHeight:%d \n", width, height);
    enum AVPixelFormat pixFmt = AV_PIX_FMT_YUV420P;
    int fps = 24;
    AVCodec *encoder = avcodec_find_encoder_by_name(encoderName);
    if (encoder == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "find encoder %s failed\n", encoderName);
        return -1;
    }
    AVCodecContext *encoderCtx = avcodec_alloc_context3(encoder);
    if (encoderCtx == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "alloc encoder context!\n");
        return -1;
    }
    encoderCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    encoderCtx->pix_fmt = pixFmt;
    encoderCtx->width = width;
    encoderCtx->height = height;
    encoderCtx->time_base = (AVRational){1, fps};
    encoderCtx->bit_rate = 4096000;
    encoderCtx->max_b_frames = 0;
    encoderCtx->gop_size = 10;
    // 打开编码器
    ret = avcodec_open2(encoderCtx, encoder, NULL);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "open encoder failed:%s\n", av_err2str(ret));
        goto end;
    }
    AVFrame *frame = av_frame_alloc();
    int frameSize = av_image_get_buffer_size(pixFmt, width, height, 1);
    uint8_t *frameBuffer = av_malloc(frameSize);
    av_image_fill_arrays(frame->data, frame->linesize, frameBuffer, pixFmt, width, height, 1);
 
    frame->format = pixFmt;
    frame->width = width;
    frame->height = height;
 
    int pictureSize = width * height;
 
    AVPacket packet;
    av_init_packet(&packet);
 
    int readFrameCount = 0;
 
    while (fread(frameBuffer, 1, pictureSize * 3 / 2, src_fp) == pictureSize * 3 / 2)
    {
        // Y 1 | U 1/4 | V 1/4
        frame->data[0] = frameBuffer;
        frame->data[1] = frameBuffer + pictureSize;
        frame->data[2] = frameBuffer + pictureSize + pictureSize / 4;
        frame->pts = readFrameCount; // 帧的展示顺序
        readFrameCount++;
 
        av_log(NULL, AV_LOG_INFO, "readFrameCount:%d\n", readFrameCount);
        encodeVideo(encoderCtx, frame, &packet, dest_fp);
    }
    encodeVideo(encoderCtx, NULL, &packet, dest_fp);
end:
    if (encoderCtx)
    {
        avcodec_free_context(&encoderCtx);
    }
    if (src_fp)
    {
        fclose(src_fp);
    }
    if (dest_fp)
    {
        fclose(dest_fp);
    }
    if (frameBuffer)
    {
        av_freep(&frameBuffer);
    }
    return 0;
}

-----------------------------------------------------------------------------------------------------------------------------------------------------

方法二：

int64_t GetTime()
{
    // 获取当前的时间戳
    return av_gettime_relative() / 1000; // 换算成毫秒
}

int EncodeVideoInterface(AVCodecContext *encoderCtx, AVFrame *frame, AVPacket *packet, FILE *outfile, uint16_t *frameCount)
{
    if (frame)
    {
        av_log(NULL, AV_LOG_INFO, "[%s] Send frame pts %3ld frameCount:%d -- line:%d \n", __FUNCTION__, frame->pts, *frameCount, __LINE__);
        (*frameCount)++;
    }
    // 使用x264进行编码时，具体缓存帧是在x264源码进行，不会增加 avframe 应对 buffer 的 reference
    int ret = avcodec_send_frame(encoderCtx, frame);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] sending the frame to the encoder error! -- line:%d\n", __FUNCTION__, __LINE__);
 
        return -1;
    }
 
    while (ret >= 0)
    {
        ret = avcodec_receive_packet(encoderCtx, packet);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
        {
            return 0;
        }
        else if (ret < 0)
        {
            av_log(NULL, AV_LOG_ERROR, "[%s] encoding audio frame error! -- line:%d\n", __FUNCTION__, __LINE__);
            return -1;
        }
        // 判断有没有关键帧 - 这个例子没有设置关键帧
        if (packet->flags)
        {
            av_log(NULL, AV_LOG_INFO, "[%s] Write packet flags:%d pts:%3ld dts:%3ld (size:%5d) -- line:%d\n", __FUNCTION__, packet->flags, packet->pts, packet->dts, packet->size, __LINE__);
        }
        if (!packet->flags)
        {
            av_log(NULL, AV_LOG_INFO, "[%s] Write packet flags:%d pts:%3ld dts:%3ld (size:%5d) -- line:%d\n", __FUNCTION__, packet->flags, packet->pts, packet->dts, packet->size, __LINE__);
        }
        fwrite(packet->data, 1, packet->size, outfile);
    }
 
    return 0;
}

int EncodeVideo(const char *yuvFileName, const char *h264FileName, const char *encoderName)
{
    FILE *inFile = fopen(yuvFileName, "rb");
    FILE *outFile = fopen(h264FileName, "wb");
    if (inFile == NULL || outFile == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] open %s or %s file failed -- line:%d \n", __FUNCTION__, yuvFileName, h264FileName, __LINE__);
        goto _end;
    }
 
    // 查找指定的编码器
    AVCodec *encoder = avcodec_find_encoder_by_name(encoderName);
    if (encoder == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] Codec found error! -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    // 创建编码器上下文
    AVCodecContext *codecCtx = avcodec_alloc_context3(encoder);
    if (codecCtx == NULL)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] Conld not allocate video codec context -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    // 设置分辨率
    codecCtx->width = 1920;
    codecCtx->height = 1080;
 
    // 设置 time base
    codecCtx->time_base = (AVRational){1, 25};
    codecCtx->framerate = (AVRational){25, 1};
 
    // 设置 I 帧间隔
    // 如果 frame->pict_type 设置为 AV_PICTURE_TYPE_I,则忽略gop_size的设置，一直当做I帧进行编码
    codecCtx->gop_size = 25;    // I 帧的间隔 （每秒都有一个I帧）
    codecCtx->max_b_frames = 0; // 如果不想包含B帧则设置为0（直播一般都设置成0）
    codecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
 
    int ret;
    if (encoder->id == AV_CODEC_ID_H264)
    { // 相关的参数  libx264.c 的 AVOption options
        /** preset 预设是一系列参数的集合，这个集合能够在编码速度和压缩率之间做出一个权衡。
         * 一个编码速度稍慢的预设会提供更高的压缩效率(压缩效率是以文件大小来衡量的)。
         * 这就是说，假如你想得到一个指定大小的文件或者采用恒定比特率编码模式，你可以采用一个较慢的预设来获得更好的质量。
         * 同样的，对于恒定质量编码模式，你可以通过选择一个较慢的预设轻松地节省比特率。
         * 如果你很有耐心，通常的建议是使用最慢的预设。
         * 目前所有的预设按照编码速度降序排列为:
         * ultrafast superfast veryfast faster fast medium[default] preset slow slower veryslow
         * 默认为medium级别。
         */
        ret = av_opt_set(codecCtx->priv_data, "preset", "veryslow", 0);
        if (ret != 0)
        {
            av_log(NULL, AV_LOG_ERROR, "[%s] av_opt_set preset failed -- line:%d\n", __FUNCTION__, __LINE__);
        }
        /**
         * 所有的profile 包括:
         * 1. baseline profile: 基本画质。支持I/P 帧，只支持无交错(Progressive)和CAVLC;
         * 2. extended profile:进阶画质。支持I/P/B/SP/SI帧，只支持无交错(Progressive)和CAVLC;
         * 3. main profile:主流画质。提供I/P/B 帧，支持无交错(Progressive)和交错(Interlaced)，也支持CAVLC 和CABAC 的支持
         * 4. high profile:高级画质。在 main Profile 的基础上增加了8x8内部预测、自定义量化、无损视频编码和更多的 YUV 格式:
         */
        ret = av_opt_set(codecCtx->priv_data, "profile", "high", 0);
        if (ret != 0)
        {
            av_log(NULL, AV_LOG_ERROR, "[%s] av_opt_set profile failed -- line:%d\n", __FUNCTION__, __LINE__);
        }
        /** tune
         * tune 是 x264 中重要性仅次于preset的选项，它是视觉优化的参数，tune可以理解为视频偏好(或者视频类型),
         * tune不是一个单一的参数，而是由一组参数构成 -tune 来改变参数设置。当前的 tune包括:
         * film:电影类型，对视频的质量非常严格时使用该选项
         * animation:动画片，压缩的视频是动画片时使用该选项
         * grain:颗粒物很重，该选项适用于颗粒感很重的视频
         * stillimage:静态图像，该选项主要用于静止画面比较多的视频
         * psnr:提高psnr，该选项编码出来的视频psnr比较高
         * ssim:提高ssim，该选项编码出来的视频ssim比较高
         * fastdecode:快速解码，该选项有利于快速解码
         * zerolatency:零延迟，该选项主要用于视频直播
         **/
        ret = av_opt_set(codecCtx->priv_data, "tune", "film", 0);
        if (ret != 0)
        {
            av_log(NULL, AV_LOG_ERROR, "[%s] av_opt_set tune failed -- line:%d\n", __FUNCTION__, __LINE__);
        }
    }
    // 设置编码器参数
    codecCtx->bit_rate = 16 * 1024 * 1024; // 极高码率
 
    codecCtx->thread_count = 8; // 开了多线程后会导致帧输出延时，需要缓存 thread_count 帧后再编程
    codecCtx->thread_type = FF_THREAD_FRAME;
 
    // 对于 H264 AV_CODEC_FLAG_GLOBAL_HEADER 设置则只包含I帧，此时sps pps 需要从 codec_ctx->extradata 读取
    // 不设置则每一帧都带 sps pps sei
 
    // 将 codecCtx 和 codec 进行绑定
    ret = avcodec_open2(codecCtx, encoder, NULL);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] Could not open codec -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
    av_log(NULL, AV_LOG_INFO, "[%s] thread_count:%d, thread_type:%d -- line:%d\n", __FUNCTION__, codecCtx->thread_count, codecCtx->thread_type, __LINE__);
 
    AVPacket *packet = av_packet_alloc();
    if (!packet)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] packet alloc error! -- line:%d \n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    AVFrame *frame = av_frame_alloc();
    if (!frame)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] Could not allocate video frame -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    // 为 frame 分配 buffer
    frame->format = codecCtx->pix_fmt;
    frame->width = codecCtx->width;
    frame->height = codecCtx->height;
 
    // 为frame分配buffer
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] Could not allocate audio data buffers -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    // 计算出每一帧的数据 像素格式 * 宽 * 高
    int frameByteSize = av_image_get_buffer_size(frame->format, frame->width, frame->height, 1);
    av_log(NULL, AV_LOG_INFO, "[%s] frameByteSize: %d -- line:%d\n", __FUNCTION__, frameByteSize, __LINE__);
 
    uint8_t *yuvBuf = (uint8_t *)malloc(frameByteSize);
    if (!yuvBuf)
    {
        av_log(NULL, AV_LOG_ERROR, "[%s] yuvBuf malloc failed -- line:%d\n", __FUNCTION__, __LINE__);
        goto _end;
    }
 
    int64_t beginTime = GetTime();
    int64_t endTime = beginTime;
    int64_t allBeginTime = GetTime();
    int64_t allendTime = allBeginTime;
    int64_t pts = 0;
 
    av_log(NULL, AV_LOG_INFO, "\n[%s] ------------------------ start enode ------------------------ line:%d \n", __FUNCTION__, __LINE__);
    uint16_t frameCount = 0;
    while (1)
    {
        memset(yuvBuf, 0, frameByteSize);
        size_t readByteSize = fread(yuvBuf, 1, frameByteSize, inFile);
        if (readByteSize <= 0)
        {
            av_log(NULL, AV_LOG_INFO, "[%s] read file finish -- line:%d \n", __FUNCTION__, __LINE__);
            break;
        }
 
        if ((av_frame_make_writable(frame)) != 0)
        {
            av_log(NULL, AV_LOG_INFO, "[%s] Failed to make frame writable -- line:%d\n", __FUNCTION__, __LINE__);
            if (frame->buf && frame->buf[0])
            {
                av_log(NULL, AV_LOG_INFO, "[%s] frame buffer is not writable, ref_count = %d -- line:%d\n", __FUNCTION__, av_buffer_get_ref_count(frame->buf[0]), __LINE__);
            }
            goto _end;
        }
 
        int needSize = av_image_fill_arrays(frame->data, frame->linesize, yuvBuf, frame->format, frame->width, frame->height, 1);
        if (needSize != frameByteSize)
        {
            av_log(NULL, AV_LOG_INFO, "[%s] av_image_fill_array failed, needSize:%d, frame_bytes:%d\n", __FUNCTION__, needSize, frameByteSize);
            break;
        }
        pts += 40;
        // 设置 pts
        frame->pts = pts; // 使用采样率作为 pts 的单位，具体换算成秒 pts * 1 / 采样率
        beginTime = GetTime();
        ret = EncodeVideoInterface(codecCtx, frame, packet, outFile, &frameCount);
        if (ret < 0)
        {
            av_log(NULL, AV_LOG_ERROR, "[%s] encode failed -- line:%d\n", __FUNCTION__, __LINE__);
            break;
        }
        endTime = GetTime();
        av_log(NULL, AV_LOG_INFO, "[%s] The encoding time of this frame is: %ld ms -- line:%d\n", __FUNCTION__, endTime - beginTime, __LINE__);
    }
    /*冲刷编码器*/
    EncodeVideoInterface(codecCtx, NULL, packet, outFile, &frameCount);
 
_end:
    if (inFile)
    {
        fclose(inFile);
    }
    if (outFile)
    {
        fclose(outFile);
    }
    if (yuvBuf)
    {
        free(yuvBuf);
    }
    if (packet)
    {
        av_packet_free(&packet);
    }
    if (frame)
    {
        av_frame_free(&frame);
    }
    if (codecCtx)
    {
        avcodec_free_context(&codecCtx);
    }
    return ret;
}