编码与格式 / 系统课时

解码帧队列

解码帧队列

本课实现一个有容量上限的解码帧队列,用它连接解码线程与渲染线程。队列既要在无帧时阻塞播放端,也要在缓存已满时限制解码端,从而维持稳定的播放节奏。

学习目标

  • 理解帧队列为什么必须同时支持“空等待”和“满等待”
  • 实现携带时间戳、持续时间和序列号的线程安全帧缓存
  • 掌握结束、跳转和退出时的帧释放与线程唤醒规则

帧队列与数据包队列的差异

数据包队列主要缓冲压缩数据,而帧队列保存已经解码、占用内存更大的音视频帧。它通常必须设置较小的容量,否则解码线程会不断提前工作,造成内存增长和播放延迟。

帧队列还需要保存 pts、帧持续时间和播放序列号。渲染线程取出帧后,会用这些元数据与主时钟比较,决定立即显示、延迟显示或丢弃过期帧。

解码帧队列的数据流与双向阻塞

有界队列的工作机制

当队列未满时,解码线程复制 AVFrame 并写入队尾;达到容量上限后,生产者在 writable 条件变量上等待。渲染线程取走一帧后释放一个槽位,再唤醒等待中的解码线程。

当队列为空时,渲染线程在 readable 条件变量上等待。正常解码结束后调用 finish,剩余帧仍可播放;播放器退出时调用 abort,生产者和消费者都要立即停止。

完整实现

下面的示例把队列容量设为 2。生产者连续写入 3 帧时,第三次写入可能短暂等待,直到消费者取走一帧并释放槽位。

cpp
#include <chrono>
#include <condition_variable>
#include <deque>
#include <iostream>
#include <mutex>
#include <stdexcept>
#include <thread>

extern "C" {
#include <libavutil/frame.h>
#include <libavutil/pixfmt.h>
}

enum class FrameResult {
    Ok,
    Finished,
    Aborted
};

struct FrameItem {
    AVFrame* frame = nullptr;
    double pts = 0.0;
    double duration = 0.0;
    int serial = 0;
};

class FrameQueue {
public:
    explicit FrameQueue(std::size_t capacity) : capacity_(capacity) {
        if (capacity_ == 0) {
            throw std::invalid_argument("capacity must be greater than zero");
        }
    }

    ~FrameQueue() {
        abort();
        flush();
    }

    bool push(const AVFrame* source, double pts, double duration, int serial) {
        AVFrame* copy = av_frame_clone(source);
        if (copy == nullptr) {
            return false;
        }

        // 固定容量形成反压,避免解码线程无限提前。
        std::unique_lock<std::mutex> lock(mutex_);
        writable_.wait(lock, [this] {
            return aborted_ || finished_ || frames_.size() < capacity_;
        });

        if (aborted_ || finished_) {
            av_frame_free(&copy);
            return false;
        }

        frames_.push_back(FrameItem{copy, pts, duration, serial});
        readable_.notify_one();
        return true;
    }

    FrameResult pop(FrameItem& output) {
        std::unique_lock<std::mutex> lock(mutex_);
        // 空队列时休眠,直到新帧、结束或中止事件到达。
        readable_.wait(lock, [this] {
            return aborted_ || finished_ || !frames_.empty();
        });

        if (aborted_) {
            return FrameResult::Aborted;
        }

        if (!frames_.empty()) {
            output = frames_.front();
            frames_.pop_front();
            // 取走一帧后释放槽位,唤醒可能阻塞的解码线程。
            writable_.notify_one();
            return FrameResult::Ok;
        }

        return FrameResult::Finished;
    }

    void finish() {
        // 正常结束只关闭写入,不丢弃尚未播放的帧。
        std::lock_guard<std::mutex> lock(mutex_);
        finished_ = true;
        readable_.notify_all();
        writable_.notify_all();
    }

    void abort() {
        std::lock_guard<std::mutex> lock(mutex_);
        aborted_ = true;
        readable_.notify_all();
        writable_.notify_all();
    }

    void flush() {
        std::lock_guard<std::mutex> lock(mutex_);
        while (!frames_.empty()) {
            FrameItem item = frames_.front();
            frames_.pop_front();
            av_frame_free(&item.frame);
        }
        writable_.notify_all();
    }

private:
    const std::size_t capacity_;
    std::deque<FrameItem> frames_;
    std::mutex mutex_;
    std::condition_variable readable_;
    std::condition_variable writable_;
    bool finished_ = false;
    bool aborted_ = false;
};

int main() {
    FrameQueue queue(2);

    std::thread consumer([&queue] {
        while (true) {
            FrameItem item;
            FrameResult result = queue.pop(item);

            if (result == FrameResult::Ok) {
                std::cout << "render pts=" << item.pts
                          << ", serial=" << item.serial << '\n';
                av_frame_free(&item.frame);
                std::this_thread::sleep_for(std::chrono::milliseconds(20));
                continue;
            }

            std::cout << (result == FrameResult::Finished
                              ? "frame queue finished"
                              : "frame queue aborted")
                      << '\n';
            break;
        }
    });

    std::thread producer([&queue] {
        for (int index = 0; index < 3; ++index) {
            AVFrame* frame = av_frame_alloc();
            if (frame == nullptr) {
                queue.abort();
                return;
            }

            // 创建最小的引用计数缓冲区,确保 av_frame_clone 可用。
            frame->format = AV_PIX_FMT_GRAY8;
            frame->width = 16;
            frame->height = 16;
            if (av_frame_get_buffer(frame, 32) < 0) {
                av_frame_free(&frame);
                queue.abort();
                return;
            }

            double pts = index * 0.04;
            if (!queue.push(frame, pts, 0.04, 1)) {
                av_frame_free(&frame);
                queue.abort();
                return;
            }
            av_frame_free(&frame);
        }
        queue.finish();
    });

    producer.join();
    consumer.join();
    return 0;
}

编译并运行:

bash
g++ -std=c++17 frame_queue.cpp -o frame_queue $(pkg-config --cflags --libs libavutil) -pthread
./frame_queue

预期输出:

text
render pts=0, serial=1
render pts=0.04, serial=1
render pts=0.08, serial=1
frame queue finished

播放控制中的关键边界

队列容量不宜直接按“帧数越多越好”设计。视频帧通常占用大量内存,容量过大会增加跳转响应时间;容量过小则容易因解码抖动导致播放端频繁等待。实践中应结合分辨率、帧率和允许的缓冲时长确定上限。

发生 seek 时,应让旧序列帧失效。常见做法是增加 serial,清空队列后写入新序列的帧;渲染线程发现帧的 serial 与当前播放序列不一致时直接丢弃,避免显示跳转前的画面。

验收检查

运行示例后应确认三点:帧始终按 pts 顺序取出;容量满时程序不会忙等;调用 finish 后能够播放完剩余帧并正常退出。将 finish 改为 abort 时,等待中的线程应立即返回中止状态。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

解码帧队列

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通