音视频

音视频录制的多线程实现

主要类

  • AudioRecorder：音频采集线程
  • VideoRecorder：视频采集线程
  • MainWindow：控制音频和视频的采集

AudioRecorder 类详解

头文件部分

  • 构造函数：

    1
    AudioRecorder(QObject *parent = nullptr, AVFormatContext **ofmt_ctx = nullptr);

  • 主要变量：

    • bool flage = false; // 用于控制采集的开始与结束
    • AVFormatContext *fmt_ctx = NULL; // 输入上下文
    • AVFormatContext **ofmt_ctx = NULL; // 输出上下文
    • QObject *parent = NULL; // 用于回调函数

源文件部分

采集音频的具体步骤可以分为10个步骤，使用到的变量有：

  • AVPacket pkt;：音频包
  • int nb_samples = 22050;：每帧样本数
  • SwrContext *swr_ctx = nullptr;：重采样上下文
  • uint8_t **src_data = nullptr; uint8_t **dst_data = nullptr;：音频数据缓冲区
  • AVCodecContext *codec_ctx = nullptr;：编码上下文
  • AVCodecContext *dec_ctx = nullptr;：解码上下文
  • AVFrame *frame = av_frame_alloc();：音频帧
  • AVAudioFifo* fifo = nullptr;：音频FIFO缓冲区
  • const char* outFilename = "output.mp4";：输出文件名

音频采集步骤

  1. 打开设备

    1
    open_device(&fmt_ctx);

  2. 查找并打开音频解码器

    1
    open_Audio_decoder(fmt_ctx, &dec_ctx);

  3. 打开AAC编码器

    1
    open_encoder(&codec_ctx);

  4. 建立FIFO缓冲区

    1
    fifo = init_audio_fifo(codec_ctx->sample_fmt, codec->ch_layout.nb_channels);

  5. 配置重采样上下文（如果需要，根据编码器的输入要求）

    1
    init_resampler(codec_ctx, &swr_ctx, &src_data, &dst_data);

  6. 创建输出流

    1
    AVStream *outStream = avformat_new_stream(*ofmt_ctx, NULL);

  7. 写头文件（通过回调方式）

为了确保音频流和视频流都创建好后再写入头文件，我采用了回调函数的方式。FFmpeg在写入头文件时要求所有流都已经创建好，因此我们通过回调机制确保音频流和视频流的创建顺序。

回调函数的实现

在代码中，我们定义了一个回调函数别名，并将其与MainWindow的Main_avformat_write_header方法绑定，确保在合适的时机调用该函数来写入头文件。

1
2
3
4
5
6
7
// 定义回调函数别名，绑定到 MainWindow::Main_avformat_write_header 方法
CallbackFun writehead = std::bind(&MainWindow::Main_avformat_write_header, 
                                   static_cast<MainWindow *>(parent), 
                                   *ofmt_ctx, nullptr);

// 调用回调函数执行写入头文件操作
writehead();

解释

  • std::bind：该方法将MainWindow::Main_avformat_write_header函数与parent（MainWindow）对象绑定，并传入必要的参数。
  • 通过回调的方式，只有在音频和视频流都准备好后才会调用Main_avformat_write_header方法进行头文件写入，确保FFmpeg正确地写入头文件。

为什么要使用回调

FFmpeg的avformat_write_header()函数要求在写入文件头之前，所有流都必须被创建并初始化。因此，在创建音频和视频流后，我们通过回调函数来确保头文件的写入时机是正确的。

  1. 配置解码后数据的frame容器及音频帧
1
2
3
4
5
6
7
8
9
//获取frame_size
const int frame_size = codec_ctx->frame_size;
// 初始化帧编号
int64_t pts = 0;

frame->nb_samples = dec_ctx->frame_size;
frame->sample_rate = dec_ctx->sample_rate;
frame->ch_layout = dec_ctx->ch_layout;
frame->format = dec_ctx->sample_fmt;

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

  2. 释放分配的空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 释放缓冲区的数据和相关上下文
if(src_data){
    av_freep(&src_data[0]);
    av_freep(&src_data);
}
if(dst_data){
    av_freep(&dst_data[0]);
    av_freep(&dst_data);
}
if(swr_ctx)swr_free(&swr_ctx);
if(frame)av_frame_free(&frame);
if(newpkt)av_packet_free(&newpkt);
if(fifo)av_audio_fifo_free(fifo);

// close device and Release fmt_ctx resources 关闭设备并释放上下文
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
int AudioRecorder::open_device(AVFormatContext **fmt_ctx) {
    const AVInputFormat * iformat = NULL;  // 音视频捕获格式
    AVDictionary *options = NULL;
    QString devicename;  // 音视频设备名称

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

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

    // 获取当前音频设备的描述名称
    devicename = "audio=麦克风阵列 (Realtek(R) Audio)";

    if (avformat_open_input(fmt_ctx, devicename.toUtf8(), iformat, &options) < 0) {
        return 0;  // 打开设备失败
    }
    return 1;  // 成功打开设备
}

open_Audio_decoder() 的具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int AudioRecorder::open_Audio_decoder(AVFormatContext **fmt_ctx) {
    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_AAC);
    if (!codec) {
        qDebug() << "音频解码器未找到";
        return 0;  // 未找到解码器
    }
    
    // 打开音频解码器
    if (avcodec_open2(dec_ctx, codec, nullptr) < 0) {
        qDebug() << "无法打开解码器";
        return 0;
    }
    
    return 1;  // 成功打开解码器
}

open_encoder() 的具体实现

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
int AudioRecorder::open_encoder(AVCodecContext **codec_ctx) {
    AVDictionary *options = NULL;
    const AVCodec *codec = avcodec_find_encoder_by_name("libfdk_aac");
    if (!codec) {
        qDebug() << "编码器 libfdk_aac 未找到";
        return 0;
    }

    // 分配编码器上下文
    *codec_ctx = avcodec_alloc_context3(codec);
    if (!*codec_ctx) {
        qDebug() << "编码器上下文分配失败";
        return 0;
    }

    // 设置编码器参数
    AVChannelLayout ch_layout;
    av_channel_layout_default(&ch_layout, 2);  // 立体声布局
    (*codec_ctx)->sample_rate = 48000;  // 采样率
    (*codec_ctx)->sample_fmt = AV_SAMPLE_FMT_S16;  // 样本格式
    (*codec_ctx)->bit_rate = 128000;  // 比特率
    if (av_channel_layout_copy(&(*codec_ctx)->ch_layout, &ch_layout) < 0) {
        qDebug() << "设置通道布局失败";
        return 0;
    }

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

    return 1;  // 成功打开编码器
}

FIFO缓冲区实现

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
AVAudioFifo* AudioRecorder::init_audio_fifo(AVSampleFormat sample_fmt, int channels) {
    AVAudioFifo* fifo = av_audio_fifo_alloc(sample_fmt, channels, 1);
    if (!fifo) {
        qDebug() << "无法分配FIFO缓冲区";
        return nullptr;
    }
    return fifo;
}

int AudioRecorder::write_to_fifo(AVAudioFifo* fifo, const uint8_t** data, int nb_samples) {
    int ret = av_audio_fifo_write(fifo, (void**)data, nb_samples);
    if (ret < nb_samples) {
        qDebug() << "写入FIFO失败";
        return -1;
    }
    return 0;  // 成功写入
}

int AudioRecorder::read_from_fifo(AVAudioFifo* fifo, uint8_t** data, int frame_size) {
    int ret = av_audio_fifo_read(fifo, (void**)data, frame_size);
    if (ret < frame_size) {
        qDebug() << "从FIFO读取失败";
        return -1;
    }
    return 0;  // 成功读取
}

init_resampler() 的具体实现

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
int AudioRecorder::init_resampler(AVCodecContext *codec_ctx, SwrContext **swr_ctx, uint8_t ***src_data, uint8_t ***dst_data) {
    *swr_ctx = swr_alloc();
    AVChannelLayout in_ch_layout;
    av_channel_layout_default(&in_ch_layout, 2);  // 立体声布局

    // 配置重采样上下文
    swr_alloc_set_opts2(swr_ctx,
                        &codec_ctx->ch_layout,          // 输出通道布局
                        codec_ctx->sample_fmt,          // 输出采样格式
                        codec_ctx->sample_rate,         // 输出采样率
                        &in_ch_layout,                 // 输入通道布局
                        AV_SAMPLE_FMT_S16,              // 输入采样格式
                        48000,                         // 输入采样率
                        0, nullptr);

    if (!*swr_ctx || swr_init(*swr_ctx) < 0) {
        qDebug() << "重采样初始化失败";
        return 0;
    }

    // 创建输入输出缓冲区
    av_samples_alloc_array_and_samples(src_data, nullptr, in_ch_layout.nb_channels, 22050, AV_SAMPLE_FMT_S16, 0);
    av_samples_alloc_array_and_samples(dst_data, nullptr, 2, 22050, codec_ctx->sample_fmt, 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
//开始获取音频帧数据，并进行转换
   while (flage && av_read_frame(fmt_ctx, &pkt) == 0) {
       // qDebug() << "pkt size: " << pkt.size;
       // qDebug() << "pkt data: " << pkt.data << Qt::endl;

       //内存拷贝
       //memcpy(src_data[0], pkt.data, pkt.size); //只使用第一个缓冲区
       //如果有需要在写入文件之前进行重采样
       //swr_convert(swr_ctx, dst_data, nb_samples, src_data, nb_samples);
       int ret = avcodec_send_packet(dec_ctx, &pkt);
       if(ret < 0){
           qDebug() << "向解码器发送数据包失败!";
           return;
       }
       while(ret >= 0){
           ret = avcodec_receive_frame(dec_ctx, frame);
           if(ret < 0){
               if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
                   break;
               }
               qDebug() << "Error, decoding video frame";
               return;
           }
           // memcpy(src_data[0], frame->data, 22300);
           // swr_convert(swr_ctx, dst_data, nb_samples, src_data, nb_samples);

           //将样本数据写入 FIFO
           write_to_fifo(fifo, (const uint8_t**)frame->data, nb_samples);
           while (av_audio_fifo_size(fifo) >= frame_size) {
               read_from_fifo(fifo, frame->data, frame_size);
               frame->nb_samples = codec_ctx->frame_size;
               frame->pts = pts;
               ret = avcodec_send_frame(codec_ctx, frame);
               if(ret < 0){
                   qDebug() << "向编码器发送数据包失败!";
                   return;
               }
               while(ret >= 0){
                   ret = avcodec_receive_packet(codec_ctx, newpkt);
                   if(ret < 0){
                       if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
                           break;
                       }
                       qDebug() << "Error, encoding video frame";
                       return;
                   }
                   newpkt->pts = newpkt->dts = pts;
                   newpkt->stream_index = audio_stream_index;
                   //av_interleaved_write_frame(*ofmt_ctx, newpkt);
                   CallbackFun write = std::bind(&MainWindow::Main_av_interleaved_write_frame, static_cast<MainWindow *>(parent), *ofmt_ctx, newpkt);
                   write();
                   av_packet_unref(newpkt);
               }
               pts += frame_size;
           }
           av_frame_unref(frame);
       }
       av_packet_unref(&pkt); // Free the packet data after each read
   }

说些什么吧！

valine