C++多线程在Linux下处理实时音视频流

在Linux下使用C++多线程处理实时音视频流是一个复杂的任务，但可以通过以下步骤来实现：

1. 引入必要的头文件

首先，你需要包含一些必要的头文件来使用多线程和音视频处理库。

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <semaphore.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libavutil/samplefmt.h>
#include <libavutil/timestamp.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>

2. 初始化音视频处理库

使用FFmpeg库来处理音视频流。

av_register_all();

AVFormatContext* format_context = nullptr;
AVCodecContext* codec_context = nullptr;
AVCodec* codec = nullptr;
AVPacket packet;
AVFrame* frame = nullptr;
AVFrame* rgb_frame = nullptr;
SwsContext* sws_ctx = nullptr;

// 打开输入文件
if (avformat_open_input(&format_context, "input.mp4", nullptr, nullptr) < 0) {
    std::cerr << "Could not open input file" << std::endl;
    return -1;
}

// 获取流信息
if (avformat_find_stream_info(format_context, nullptr) < 0) {
    std::cerr << "Could not find stream information" << std::endl;
    return -1;
}

// 找到视频流
int video_stream_index = -1;
for (unsigned int i = 0; i < format_context->nb_streams; i++) {
    if (format_context->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
        video_stream_index = i;
        break;
    }
}

if (video_stream_index == -1) {
    std::cerr << "Could not find video stream in input file" << std::endl;
    return -1;
}

// 打开解码器
codec = avcodec_find_decoder(format_context->streams[video_stream_index]->codecpar->codec_id);
if (!codec) {
    std::cerr << "Unsupported codec!" << std::endl;
    return -1;
}

codec_context = avcodec_alloc_context3(codec);
if (!codec_context) {
    std::cerr << "Could not allocate video codec context" << std::endl;
    return -1;
}

if (avcodec_parameters_to_context(codec_context, format_context->streams[video_stream_index]->codecpar) < 0) {
    std::cerr << "Error converting codec parameters to context" << std::endl;
    return -1;
}

if (avcodec_open2(codec_context, codec, nullptr) < 0) {
    std::cerr << "Could not open codec" << std::endl;
    return -1;
}

// 分配解码后的帧
frame = av_frame_alloc();
if (!frame) {
    std::cerr << "Could not allocate video frame" << std::endl;
    return -1;
}

frame->format = codec_context->pix_fmt;
frame->width = codec_context->width;
frame->height = codec_context->height;

if (av_image_alloc(frame->data, frame->linesize, codec_context->width, codec_context->height, frame->format, 32) < 0) {
    std::cerr << "Could not allocate raw picture buffer" << std::endl;
    return -1;
}

// 打开输出文件
FILE* output_file = fopen("output.mp4", "wb");
if (!output_file) {
    std::cerr << "Could not open output file" << std::endl;
    return -1;
}

AVIOContext* io_context = avio_alloc_context(output_file, 0, 0, 1024 * 1024, nullptr, nullptr, nullptr);
if (!io_context) {
    std::cerr << "Could not allocate I/O context" << std::endl;
    return -1;
}

AVFormatContext* output_format_context = avformat_alloc_context();
if (!output_format_context) {
    std::cerr << "Could not allocate output format context" << std::endl;
    return -1;
}
output_format_context->pb = io_context;
output_format_context->oformat = av_guess_format("mp4", nullptr, nullptr);
if (!output_format_context->oformat) {
    std::cerr << "Could not guess output format" << std::endl;
    return -1;
}

AVStream* output_stream = avformat_new_stream(output_format_context, output_format_context->oformat);
if (!output_stream) {
    std::cerr << "Could not allocate output stream" << std::endl;
    return -1;
}
output_stream->codecpar->codec_id = output_format_context->oformat->codecs[0].id;
output_stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
output_stream->codecpar->width = codec_context->width;
output_stream->codecpar->height = codec_context->height;
output_stream->codecpar->bit_rate = codec_context->bit_rate;
output_stream->codecpar->time_base = (AVRational){1, 25};
output_stream->codecpar->framerate = (AVRational){25, 1};
output_stream->codecpar->gop_size = 10;
output_stream->codecpar->max_b_frames = 1;
output_stream->codecpar->pix_fmt = AV_PIX_FMT_YUV420P;

if (avformat_write_header(output_format_context, nullptr) < 0) {
    std::cerr << "Error writing output header" << std::endl;
    return -1;
}

3. 多线程处理

使用多线程来处理音视频流的解码和编码。

std::queue<AVPacket> input_queue;
std::mutex queue_mutex;
std::condition_variable queue_cv;
bool done = false;

void decode_thread() {
    while (true) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        queue_cv.wait(lock, [] { return !input_queue.empty() || done; });
        if (done && input_queue.empty()) {
            break;
        }
        AVPacket packet = input_queue.front();
        input_queue.pop();
        lock.unlock();

        avcodec_send_packet(codec_context, &packet);
        while (avcodec_receive_frame(codec_context, frame) == 0) {
            sws_scale(sws_ctx, (const uint8_t* const*)frame->data, frame->linesize, 0, codec_context->height,
                      rgb_frame->data, rgb_frame->linesize);

            AVPacket encoded_packet;
            av_init_packet(&encoded_packet);
            encoded_packet.data = rgb_frame->data[0];
            encoded_packet.size = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, codec_context->width, codec_context->height, 1);
            encoded_packet.stream_index = output_stream->index;

            avcodec_send_packet(output_codec_context, &encoded_packet);
            while (avcodec_receive_frame(output_codec_context, output_frame) == 0) {
                av_packet_unref(&encoded_packet);
                av_frame_unref(output_frame);
            }
        }
    }
}

void encode_thread() {
    while (true) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        queue_cv.wait(lock, [] { return !input_queue.empty() || done; });
        if (done && input_queue.empty()) {
            break;
        }
        AVPacket packet = input_queue.front();
        input_queue.pop();
        lock.unlock();

        avcodec_send_packet(output_codec_context, &packet);
        while (avcodec_receive_frame(output_codec_context, output_frame) == 0) {
            // 处理编码后的帧
        }
    }
}

int main() {
    std::thread decode_t(decode_thread);
    std::thread encode_t(encode_thread);

    // 读取输入数据并推入队列
    while (true) {
        // 读取输入数据
        AVPacket packet;
        av_init_packet(&packet);
        packet.data = nullptr;
        packet.size = 0;

        // 读取数据到packet
        if (av_read_frame(format_context, &packet) < 0) {
            break;
        }

        std::lock_guard<std::mutex> lock(queue_mutex);
        input_queue.push(packet);
        lock.unlock();
        queue_cv.notify_one();
    }

    done = true;
    queue_cv.notify_all();

    decode_t.join();
    encode_t.join();

    // 释放资源
    av_packet_unref(&packet);
    av_frame_free(&frame);
    av_frame_free(&rgb_frame);
    sws_freeContext(sws_ctx);
    avcodec_close(codec_context);
    avformat_close_input(&format_context);
    fclose(output_file);
    avio_closep(&io_context);
    avformat_free_context(output_format_context);

    return 0;
}

4. 编译和运行

确保你已经安装了FFmpeg库，并使用以下命令编译代码：

g++ -o音视频处理音视频流音视频处理音视频流.cpp -lavcodec -lavformat -lavutil -lswscale -lswresample

然后运行编译后的程序：

./音视频处理音视频流

这个示例代码展示了如何使用C++多线程处理实时音视频流。你需要根据具体需求进行调整和优化。