写一个ffmpeg异步解码代码

好的，我可以回答这个问题。以下是一个简单的异步解码代码示例：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <chrono>
#include <atomic>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
}

std::mutex queue_mutex;
std::condition_variable queue_cv;
std::queue<AVPacket*> packet_queue;
std::atomic<bool> stop_decode(false);

void decode_thread(AVCodecContext* codec_ctx, AVFrame* frame) {
    while (!stop_decode) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        queue_cv.wait(lock, []{ return !packet_queue.empty(); });
        AVPacket* packet = packet_queue.front();
        packet_queue.pop();
        lock.unlock();

        int ret = avcodec_send_packet(codec_ctx, packet);
        if (ret < 0) {
            std::cerr << "Error sending packet to decoder: " << av_err2str(ret) << std::endl;
            av_packet_free(&packet);
            continue;
        }

        while (ret >= 0) {
            ret = avcodec_receive_frame(codec_ctx, frame);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                break;
            } else if (ret < 0) {
                std::cerr << "Error receiving frame from decoder: " << av_err2str(ret) << std::endl;
                break;
            }

            // Do something with the decoded frame here

            av_frame_unref(frame);
        }

        av_packet_free(&packet);
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <input_file>" << std::endl;
        return 1;
    }

    av_register_all();
    avcodec_register_all();

    AVFormatContext* format_ctx = nullptr;
    int ret = avformat_open_input(&format_ctx, argv[1], nullptr, nullptr);
    if (ret < 0) {
        std::cerr << "Error opening input file: " << av_err2str(ret) << std::endl;
        return 1;
    }

    ret = avformat_find_stream_info(format_ctx, nullptr);
    if (ret < 0) {
        std::cerr << "Error finding stream info: " << av_err2str(ret) << std::endl;
        avformat_close_input(&format_ctx);
        return 1;
    }

    AVCodec* codec = nullptr;
    int stream_idx = av_find_best_stream(format_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
    if (stream_idx < 0) {
        std::cerr << "Error finding video stream: " << av_err2str(stream_idx) << std::endl;
        avformat_close_input(&format_ctx);
        return 1;
    }

    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        std::cerr << "Error allocating codec context" << std::endl;
        avformat_close_input(&format_ctx);
        return 1;
    }

    ret = avcodec_parameters_to_context(codec_ctx, format_ctx->streams[stream_idx]->codecpar);
    if (ret < 0) {
        std::cerr << "Error setting codec parameters: " << av_err2str(ret) << std::endl;
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&format_ctx);
        return 1;
    }

    ret = avcodec_open2(codec_ctx, codec, nullptr);
    if (ret < 0) {
        std::cerr << "Error opening codec: " << av_err2str(ret) << std::endl;
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&format_ctx);
        return 1;
    }

    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        std::cerr << "Error allocating frame" << std::endl;
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&format_ctx);
        return 1;
    }

    std::thread decode_thread(decode_thread, codec_ctx, frame);

    AVPacket packet;
    av_init_packet(&packet);

    while (av_read_frame(format_ctx, &packet) >= 0) {
        if (packet.stream_index == stream_idx) {
            AVPacket* packet_copy = av_packet_clone(&packet);
            if (!packet_copy) {
                std::cerr << "Error cloning packet" << std::endl;
                break;
            }

            std::unique_lock<std::mutex> lock(queue_mutex);
            packet_queue.push(packet_copy);
            lock.unlock();
            queue_cv.notify_one();
        }

        av_packet_unref(&packet);
    }

    stop_decode = true;
    queue_cv.notify_one();
    decode_thread.join();

    av_frame_free(&frame);
    avcodec_free_context(&codec_ctx);
    avformat_close_input(&format_ctx);

    return 0;
}

这个代码使用了一个单独的线程来异步解码视频帧。它首先打开输入文件并找到视频流，然后创建一个解码器并打开它。然后它启动一个解码线程，该线程等待 AVPacket 对象的队列，然后将它们发送到解码器进行解码。解码器将解码后的帧发送回主线程，主线程可以在那里对它们进行处理。最后，它清理并关闭所有对象。