音视频

VideoRecorder 类详解

头文件部分

1
2
3
4
5
6
7
8
9
// 构造函数
VideoRecorder(QObject* parent = nullptr, AVFormatContext **ofmt_ctx = nullptr);

// 变量
void run() override;
bool flage = false;
AVFormatContext *fmt_ctx = NULL; // 输入上下文
AVFormatContext **ofmt_ctx = NULL; // 输出上下文
QObject *parent = NULL;

源文件部分

采集视频的具体步骤分为9步，涉及以下变量：

1
2
3
4
5
6
7
AVPacket pkt; // 音频包
AVPacket *H264pkt = av_packet_alloc();
AVCodecContext *dec_ctx = NULL;
AVCodecContext *H264_Codec_ctx = NULL;
AVFrame *frame = av_frame_alloc();
AVPacket *newpkt = av_packet_alloc();
const char* outFilename = "output.mp4"; // 输出文件

步骤 1：打开视频设备

1
open_device(&fmt_ctx)

步骤 2：打开视频解码器

1
open_video_decoder(fmt_ctx, &dec_ctx)

步骤 3：配置视频编码器并打开

1
open_video_encoder(&H264_Codec_ctx, dec_ctx)

步骤 4：创建输出流

1
2
3
// 创建输出流
AVStream *outStream = avformat_new_stream(*ofmt_ctx, NULL);
avcodec_parameters_from_context(outStream->codecpar, H264_Codec_ctx); // 同样这里也是输出视频流的相关信息

步骤 5：配置图像重采样上下文

1
2
3
4
// 图像格式转换上下文
SwsContext* pImgConvertCtx = sws_getContext(dec_ctx->width, dec_ctx->height,
                                            dec_ctx->pix_fmt, dec_ctx->width, dec_ctx->height,
                                            AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

步骤 6：写头文件

1
2
3
// 写头文件
CallbackFun writehead = std::bind(&MainWindow::Main_avformat_write_header, static_cast<MainWindow *>(parent), *ofmt_ctx, nullptr);
writehead();

步骤 7：配置视频数据存储容器 pFrameYUV

1
2
3
4
5
6
7
8
// 初始化帧编号
int64_t pts = 0;

AVFrame *pFrameYUV = av_frame_alloc();
pFrameYUV->format = AV_PIX_FMT_YUV420P;
pFrameYUV->width = dec_ctx->width;
pFrameYUV->height = dec_ctx->height;
av_frame_get_buffer(pFrameYUV, 0);

步骤 8：读取数据并写入文件

1
// 使用 av_read_frame() 读取音频数据，并写入文件

步骤 9：释放分配的空间

1
2
3
4
5
6
7
8
9
// 释放缓冲区的数据和相关上下文
if(frame) av_frame_free(&frame);
if(pFrameYUV) av_frame_free(&pFrameYUV);
if(newpkt) av_packet_free(&newpkt);

sws_freeContext(pImgConvertCtx);

// 关闭设备并释放 fmt_ctx 资源
avformat_close_input(&fmt_ctx);

open_device(&fmt_ctx)的具体实现

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
int VideoRecorder::open_device(AVFormatContext **fmt_ctx){
    const AVInputFormat * iformat = NULL;  // 音视频捕获格式
    AVDictionary *options = NULL;
    QString devicename;  // 音视频设备名称

    // 注册音视频设备
    avdevice_register_all();

    // 获取音视频格式
    iformat = av_find_input_format("dshow");

    // 获取当前音视频设备的描述名称
    // if (avdevice_list_input_sources(iformat, NULL, NULL, &device_list) >= 0) {
    //     for (int i = 0; i < device_list->nb_devices; i++) {
    //         qDebug() << "Device: " << device_list->devices[i]->device_description << Qt::endl;
    //         if(i == 1) devicename = "audio=" + QString(device_list->devices[i]->device_description);
    //     }
    // }

    // video=USB2.0 HD UVC WebCam 摄像头设备名称 || audio=麦克风阵列 (Realtek(R) Audio) 麦克风设备名称
    // 可以用冒号video="Camera":audio="Microphone" 进行同时使用
    devicename = "video=USB2.0 HD UVC WebCam";

    av_dict_set(&options, "video_size", "1280x720", 0);
    // av_dict_set(&options, "pixel_fmt", "yuv420p", 0);
    av_dict_set(&options, "framerate", "30", 0);

    // 打开视频流设备 并初始化上下文
    if(avformat_open_input(fmt_ctx, devicename.toUtf8(), iformat, &options) < 0){
        // av_strerror(ret, errors, 1024);
        // qDebug() << "Failed to open audio device: " << ret << errors;
        return 0;
    };
    return 1;
}

open_video_decoder(fmt_ctx, &dec_ctx)的具体实现

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
int VideoRecorder::open_video_decoder(AVFormatContext *fmt_ctx, AVCodecContext **dec_ctx){
    const AVCodec *dec;
    int ret;

    if((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0){
        qDebug() << "无法获取流信息! " << ret;
        return 0;
    };

    // 选择视频流
    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
    if(ret < 0){
        qDebug() << "无法找到视频流 " << ret;
        return 0;
    }

    int video_stream_index = ret;

    // 创建解码器上下文,并初始化上下文
    *dec_ctx = avcodec_alloc_context3(dec);
    if(!*dec_ctx) return 0;
    avcodec_parameters_to_context(*dec_ctx, fmt_ctx->streams[video_stream_index]->codecpar);

    // 打开解码器
    if((ret = avcodec_open2(*dec_ctx, dec, nullptr)) < 0){
        qDebug() << "解码器打开失败! " << ret;
        return 0;
    };

    return 1;
}

open_video_encoder(&H264_Codec_ctx, dec_ctx)的具体实现

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
int VideoRecorder::open_video_encoder(AVCodecContext **H264_Codec_ctx, AVCodecContext *dec_ctx){
    AVDictionary *options = NULL;

    av_dict_set(&options, "preset", "superfast", 0);
    av_dict_set(&options, "tune", "zerolatency", 0);  // 实现实时编码

    const AVCodec *H264_Codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if(!H264_Codec){
        qDebug() << "未找到H264编码器!";
        return 0;
    }

    *H264_Codec_ctx = avcodec_alloc_context3(H264_Codec);

    // 设置编码器格式
    (*H264_Codec_ctx)->codec_id = AV_CODEC_ID_H264; // option
    (*H264_Codec_ctx)->codec_type = AVMEDIA_TYPE_VIDEO; // option
    (*H264_Codec_ctx)->pix_fmt = AV_PIX_FMT_YUV420P;

    // 设置SPS/PPS
    (*H264_Codec_ctx)->profile = FF_PROFILE_H264_HIGH_444; // 压缩等级
    (*H264_Codec_ctx)->level = 50; // 质量等级为5.0

    // 设置分辨率
    (*H264_Codec_ctx)->width = dec_ctx->width;
    (*H264_Codec_ctx)->height = dec_ctx->height;

    // 设置GOP
    (*H264_Codec_ctx)->gop_size = 250;
    (*H264_Codec_ctx)->keyint_min = 25; // 最小插入I帧的帧数 在网络丢帧时用于恢复 option

    // 设置B帧数据可减小码流
    (*H264_Codec_ctx)->max_b_frames = 3; // 可连续的最大B帧数量 option
    (*H264_Codec_ctx)->has_b_frames = 1; // 指示编码器是否生成 B 帧以及解码器是否需要处理 B 帧 option

    // 设置参考帧数量可提升还原度
    (*H264_Codec_ctx)->refs = 3; // option

    // 设置帧率
    (*H264_Codec_ctx)->time_base.num = 1

;
    (*H264_Codec_ctx)->time_base.den = 30;

    // 设置比特率
    (*H264_Codec_ctx)->bit_rate = 3420000;

    // 打开编码器
    if((avcodec_open2(*H264_Codec_ctx, H264_Codec, &options)) < 0){
        qDebug() << "H264 编码器打开失败!";
        return 0;
    }

    return 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
31
32
33
34
35
36
while(flage && av_read_frame(fmt_ctx, &pkt) == 0){
    int ret = avcodec_send_packet(dec_ctx, &pkt);
    if(ret < 0) return;

    while(ret >= 0){
        ret = avcodec_receive_frame(dec_ctx, frame);
        if(ret < 0){
            if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) break;
            return;
        }
        sws_scale(pImgConvertCtx, (const unsigned char* const*)frame->data, frame->linesize, 0, dec_ctx->height, pFrameYUV->data, pFrameYUV->linesize);

        ret = avcodec_send_frame(H264_Codec_ctx, pFrameYUV);
        if(ret < 0) return;

        while(ret >= 0){
            ret = avcodec_receive_packet(H264_Codec_ctx, H264pkt);
            if(ret < 0){
                if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) break;
                return;
            }

            // 编码后PTS、DTS赋值
            H264pkt->pts = H264pkt->dts = pts * (*ofmt_ctx)->streams[video_stream_index]->time_base.den / (*ofmt_ctx)->streams[video_stream_index]->time_base.num / 30;
            H264pkt->stream_index = video_stream_index;

            CallbackFun write = std::bind(&MainWindow::Main_av_interleaved_write_frame, static_cast<MainWindow *>(parent), *ofmt_ctx, H264pkt);
            write();

            pts++;
            av_packet_unref(H264pkt);
        }
        av_frame_unref(frame);
    }
    av_packet_unref(&pkt); // Free the packet data after each read
}

说些什么吧！

valine