编码与格式 / 系统课时
解码帧队列
解码帧队列
本课实现一个有容量上限的解码帧队列,用它连接解码线程与渲染线程。队列既要在无帧时阻塞播放端,也要在缓存已满时限制解码端,从而维持稳定的播放节奏。
学习目标
- 理解帧队列为什么必须同时支持“空等待”和“满等待”
- 实现携带时间戳、持续时间和序列号的线程安全帧缓存
- 掌握结束、跳转和退出时的帧释放与线程唤醒规则
帧队列与数据包队列的差异
数据包队列主要缓冲压缩数据,而帧队列保存已经解码、占用内存更大的音视频帧。它通常必须设置较小的容量,否则解码线程会不断提前工作,造成内存增长和播放延迟。
帧队列还需要保存 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(©);
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 时,等待中的线程应立即返回中止状态。
按自己的节奏,确认真正理解。