^-^
音视频开发_YUV 编码 H264
最近更新：2024-09-23   |   字数总计：2k   |   阅读估时：9分钟   |   阅读量：次
  1. 两种创建高质量H.264视频
  2. CRF
    1. CRF值
    2. preset
    3. tune
    4. profile
    5. 兼容性
  3. Tips
  4. 关于x64的zerolatency
    1. zerolatency如何实现在线转码性能的提升？
      1. 编码延迟分析
      2. zerolatency起作用的位置
  5. 编码实践

两种创建高质量H.264视频

  1. CRF
  2. Two pass ABR

CRF

CRF值

  • 缺省23
  • 范围0~51
  • 数字越小质量越好，18视觉上无损，技术上有损

preset

  • 默认是medium
  • 按照编码速度降序：ultrafast、superfast、veryfast、faster、fast、medium – default preset、slow、slower、veryslow、placebo（这个没有用）
  • 编码速度越慢的会有更高的压缩效率

tune

  • 优化视觉的参数，可以理解为视频偏好
  • film（电影类型）、animation（动画片）、grain（颗粒感重）、stillimage（静态图片）、psnr（提高psnr）、ssim（提高ssim）、fastdecode（使解码速度更快）、zerolatency（零延迟，用于直播）

profile

  • 可以将你的输出限制到⼀个特定的 H.264 profile
  • baseline profile：基本画质（实时通信）
  • extended profile：进阶画质
  • main profile：主流画质（流媒体）
  • high profile：高级画质，在main的基础上增加了8x8内部预测、自定义量化、无损视频编码和更多YUV格式（广电、存储领域）
  • 相同配置下，hp比mp节省10%的码流量

兼容性

  • profile:v baseline会关闭很多高级特性，但是可以最大化的和目标播放设备兼容
  • Apple quick time仅支持baseline和main，因为quick time仅支持yuv420

Tips

  1. Two pass ABR比CRF可以更加精准控制目标文件大小，并不是更好的质量；
  2. placebo与 veryslow相⽐，它以极⾼的编码时间为代价换取了⼤概1%的视频质量提升，这是⼀种收益递减准则，veryslow 与 slower相⽐提升了3%；slower与slow相⽐提升了5%；slow与medium相⽐提升了5%~10%；
  3. 由于rgb->yuv转换的问题，无损传输可能看起来是有损的，如果转换到yuv444，那么仍然是无损的；
  4. x264目前不支持显卡加速编码，总的来说ffmpeg还不支持gpu；
  5. 需要加入-pix_fmt yuv420p来使输出h264支持Quick Time播放器；

关于x64的zerolatency

zerolatency如何实现在线转码性能的提升？

编码延迟分析
1
2
3
4
5
6
7
h->frames.i_delay = max(
    h->param.i_bframe,
    h->param.rc.i_lookahead
    ) + 
    h->i_thread_frames - 1
    + h->param.i_sync_lookahead
    + h->param.b_vfr_input
zerolatency起作用的位置
1
2
3
4
5
6
7
8
9
if(!strncasecmp(s,"zerolatency",11))
{
    param->rc.i_lookahead = 0;
    param->i_sync_lookahead = 0;
    param->i_bframe = 0;
    param->b_sliced_threads = 1;
    param->b_vfr_input = 0;
    param->rc.b_mb_tree = 0;
}
  • rc_lookahead, 最大250。编码器需要缓存满rc_lookahead个帧数据后，才会开始编码第一帧，所以值越大会增加编码延时，因此在实时中设置为0。
  • sync_lookahead, 最大250，设置用于线程预测的帧缓存大小，在第二遍及更多遍编码或基于分片线程时自动关闭，==0时关闭线程预测，可减小延迟，但是会减低性能。
  • bframes, I帧和P帧或两个P帧之间可用的最大连续B帧数量，默认3。B帧越多会显著提高压缩率，但是由于需要更多缓存帧数以及重排，会降低编码速度，增加编码延迟，实时时也设置为0；
  • sliced_threads，设置基于分片的线程，默认off，开启后压缩率和效率都会略低于默认，但没有编码延时。除非编码实时流或者对延迟较高要求一般情况下设置off。
  • vfr_input，开启时使用timebase和timestamps做码率控制，为0时，是固定帧率，使用fps做码率控制。
  • mb_tree，基于宏块树的码率控制。（对于每个MB，向前预测一定数量的帧，计算该MB被引用的次数，根据被引用次数的多少决定为该MB分配量化的QP值。该方法会生成临时的stats文件，记录了每个P帧每个MB被参考的情况。）使用mb_tree的方法能够节约大概30%的码率，但是会增加编码延迟，所以实时流中也关闭。

编码实践

  1. 具体编码函数
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    int encode(AVCodecContext* enc_ctx, AVFrame* frame, AVPacket* pkt, FILE* outfile)
    {
        int ret;
        if(frame)
            printf("Send frame %3"PRId64"\n", frame->pts);
        ret = avcodec_send_frame(enc_ctx, frame);
        if(ret < 0)
        {
            printf(stderr, "Error sending a frame for encoding\n");
            return -1;
        }
        while(ret >= 0)
        {
            ret = avcodec_receive_packet(enc_ctx, pkt);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                return 0;
            } else if (ret < 0) {
                fprintf(stderr, "Error encoding audio frame\n");
                return -1;
            }
            if(pkt->flags & AV_PKT_FLAG_KEY)
                printf("Write packet flags:%d pts:%3"PRId64" dts:%3"PRId64" (size:%5d)\n",
                   pkt->flags, pkt->pts, pkt->dts, pkt->size);
            if(!pkt->flags)
                printf("Write packet flags:%d pts:%3"PRId64" dts:%3"PRId64" (size:%5d)\n",
                   pkt->flags, pkt->pts, pkt->dts, pkt->size);
            fwrite(pkt->data, 1, pkt->size, outfile);
        }
        return 0;
    }
  2. 配置及分配空间
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    // 通过输入codec_name名称查找指定的编码器
    const AVCodec *codec = avcodec_find_encoder_by_name(codec_name);
    if(!codec)
    {
        fprintf(stderr, "Codec '%s' not found\n", codec_name);
        exit(1);
    }
    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if(!codec_ctx)
    {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }
    /*设置分辨率*/
    codec_ctx->width = 1280;    
    codec_ctx->height = 720;
    /*设置time base，注意timebase的正确设置，会影响码率的输出，即是AVFrame的pts的timebase需要和codec_ctx->time_base一致*/
    codec_ctx->time_base = (AVRational){1, 1000};//和AVFrame的pts相同，这样不需要做时间戳的转换
    codec_ctx->framerate = (AVRational){25,1};
    /*设置I帧间隔
    * 如果frame->pict_type设置为AV_PICTURE_TYPE_I,则忽略gop_size的设置，一直当做I帧进行编码
    */
    code_ctx->gop_size = 25;// I帧间隔
    code_ctx->max_b_frames = 2;// 如果不想包括B帧则设置为0
    code_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
    if (codec->id == AV_CODEC_ID_H264) {
        // 相关的参数可以参考libx264.c的 AVOption options
        // ultrafast all encode time:2270ms
        // medium all encode time:5815ms
        // veryslow all encode time:19836ms
        ret = av_opt_set(codec_ctx->priv_data, "preset", "medium", 0);
        if(ret != 0) {
            printf("av_opt_set preset failed\n");
        }
        ret = av_opt_set(codec_ctx->priv_data, "profile", "main", 0); // 默认是high
        if(ret != 0) {
            printf("av_opt_set profile failed\n");
        }
        ret = av_opt_set(codec_ctx->priv_data, "tune","zerolatency",0); // 直播是才使用该设置
    //        ret = av_opt_set(codec_ctx->priv_data, "tune","film",0); //  画质film
        if(ret != 0) {
            printf("av_opt_set tune failed\n");
        }
    }
    codec_ctx->bit_rate = 3000000;
    //    codec_ctx->rc_max_rate = 3000000;
    //    codec_ctx->rc_min_rate = 3000000;
    //    codec_ctx->rc_buffer_size = 2000000;
    //    codec_ctx->thread_count = 4;  // 开了多线程后也会导致帧输出延迟, 需要缓存thread_count帧后再编程。
    //    codec_ctx->thread_type = FF_THREAD_FRAME; // 并 设置为FF_THREAD_FRAME
        /* 对于H264 AV_CODEC_FLAG_GLOBAL_HEADER  设置则只包含I帧，此时sps pps需要从codec_ctx->extradata读取
         *  不设置则每个I帧都带 sps pps sei
         */
    //    codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; // 存本地文件时不要去设置
    /* 将codec_ctx和codec进行绑定 */
    ret = avcodec_open2(codec_ctx, codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
        exit(1);
    }
    printf("thread_count: %d, thread_type:%d\n", codec_ctx->thread_count, codec_ctx->thread_type);

    // 分配pkt和frame
    AVPacket *pkt = av_packet_alloc();
    if (!pkt) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    AVFrame *frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    // 为frame分配buffer
    frame->format = codec_ctx->pix_fmt;
    frame->width = codec_ctx->width;
    frame->height = codec_ctx->height;
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate the video frame data\n");
        exit(1);
    }
    // 计算出每一帧的数据 像素格式 * 宽 * 高
    // 1382400
    int frame_bytes = av_image_get_buffer_size(frame->format, frame->width,
                                                frame->height, 1);
    printf("frame_bytes %d\n", frame_bytes);
    uint8_t *yuv_buf = (uint8_t *)malloc(frame_bytes);
    if(!yuv_buf) {
        printf("yuv_buf malloc failed\n");
        return 1;
    }
    int64_t begin_time = get_time();
    int64_t end_time = begin_time;
    int64_t all_begin_time = get_time();
    int64_t all_end_time = all_begin_time;
    int64_t pts = 0;
    printf("start enode\n");
  3. 循环写入
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    for(;;)
    {
        memset(yuv_buf, 0, frame_bytes);
        size_t read_bytes = fread(yuv_buf, 1, frame_bytes, infile);
        if(read_bytes <= 0) {
            printf("read file finish\n");
            break;
        }
        /* 确保该frame可写, 如果编码器内部保持了内存参考计数，则需要重新拷贝一个备份
            目的是新写入的数据和编码器保存的数据不能产生冲突
        */
        int frame_is_writable = 1;
        if(av_frame_is_writable(frame) == 0){ // 测试写入
            printf("the frame can't write, buf:%p\n", frame->buf[0]);
            if(frame->buf && frame->buf[0]) // 打印reference-counted, 必须保证传入的是有效指针
                printf("ref_count1(frame) = %d\n", av_buffer_ger_ref_count(frame->buf[0]));
            frame_is_writable = 0;
        }
        ret = av_frame_make_writable(frame);
        if(frame_is_writable == 0) {  // 这里只是用来测试
            printf("av_frame_make_writable, buf:%p\n", frame->buf[0]);
            if(frame->buf && frame->buf[0])        // 打印referenc-counted，必须保证传入的是有效指针
                printf("ref_count2(frame) = %d\n", av_buffer_get_ref_count(frame->buf[0]));
        }
        if(ret != 0) {
            printf("av_frame_make_writable failed, ret = %d\n", ret);
            break;
        }
        int need_size = av_image_fill_arrays(frame->data,frame->linesize,yuv_buf,
                                frame->format,
                                frame->width,frame->height,1);
        if(need_size != frame_bytes){
            printf("av_image_fill_arrays failed, need_size:%d, frame_bytes:%d\n",
                    need_size, frame_bytes);
            break;
        }
        pts += 40;
        // 设置pts
        frame->pts = pts; // 使用采样率作为pts的单位，具体换算成秒 pts*1/采样率
        begin_time = get_time();
        ret = encode(codec_ctx, frame, pkt, outfile);
        end_time = get_time();
        printf("encode time:%lldms\n", end_time - begin_time);
        if(ret<0)
        {
            printf("encode failed\n");
            break;
        }
        /*冲刷解码器*/
        encode(codec_ctx, NULL, pkt, outfile);
        all_end_time = get_time();
        printf("all encode time:%lldms\n", all_end_time - all_begin_time);
    }
  4. 清理现场
    1
    2
    3
    4
    5
    if(yuv_buf)
        free(yuv_buf);
    av_frame_free(&frame);
    av_packet_free(&pkt);
    avcodec_free_context(&codec_ctx);
2023-12-06 该篇文章被 Cleofwine 归为分类: 音视频

上一篇：音视频开发_H264 和 AAC 合成 FLV 下一篇：音视频开发_H264 编码原理
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题