#include <thread>
#include <iostream>

void DecodeThread() {
    for (int i = 0; i < 5; i++) {
        std::cout << "解码帧 " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main() {
    // 创建线程
    std::thread decoder(DecodeThread);
    
    std::cout << "主线程继续执行" << std::endl;
    
    // 等待线程结束
    decoder.join();
    
    std::cout << "所有线程结束" << std::endl;
    return 0;
}

#include <mutex>
#include <vector>

std::vector<AVFrame*> frame_queue;
std::mutex queue_mutex;  // 保护队列的锁

// 解码线程（生产者）
void Producer() {
    while (has_more_frames) {
        AVFrame* frame = DecodeOneFrame();
        
        // 加锁，保护共享队列
        queue_mutex.lock();
        frame_queue.push_back(frame);
        queue_mutex.unlock();
    }
}

// 主线程（消费者）
void Consumer() {
    while (!should_quit) {
        // 加锁，访问共享队列
        queue_mutex.lock();
        if (!frame_queue.empty()) {
            AVFrame* frame = frame_queue.front();
            frame_queue.erase(frame_queue.begin());
            queue_mutex.unlock();
            
            Render(frame);
        } else {
            queue_mutex.unlock();
            // 队列为空，等待一下
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
}

void Producer() {
    while (has_more_frames) {
        AVFrame* frame = DecodeOneFrame();
        
        {
            // 构造函数 lock，析构函数 unlock
            std::lock_guard<std::mutex> lock(queue_mutex);
            frame_queue.push_back(frame);
        }  // 离开作用域自动 unlock
        
        // 其他操作（无需锁保护）...
    }
}

#include <condition_variable>

std::vector<AVFrame*> frame_queue;
std::mutex queue_mutex;
std::condition_variable queue_cv;  // 条件变量

// 生产者
void Producer() {
    while (has_more_frames) {
        AVFrame* frame = DecodeOneFrame();
        
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            frame_queue.push_back(frame);
        }
        
        // 通知等待的消费者
        queue_cv.notify_one();  // 唤醒一个等待的线程
    }
}

// 消费者
void Consumer() {
    while (!should_quit) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        
        // 等待条件：队列非空
        // 如果条件不满足，自动 unlock 并阻塞；被唤醒后自动 lock
        queue_cv.wait(lock, []() {
            return !frame_queue.empty() || should_quit;
        });
        
        if (should_quit) break;
        
        AVFrame* frame = frame_queue.front();
        frame_queue.erase(frame_queue.begin());
        lock.unlock();  // 尽早 unlock
        
        Render(frame);
    }
}

std::queue<AVFrame*> queue;  // 一直增长直到内存耗尽

std::queue<AVFrame*> queue;
const size_t MAX_SIZE = 10;  // 最多缓存 10 帧

// 直接传递，无缓冲

#pragma once
#include <queue>
#include <mutex>
#include <condition_variable>
#include <atomic>

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

namespace live {

// 队列状态
enum class QueueState {
    OK,           // 正常
    Full,         // 队列满
    Empty,        // 队列为空
    Stopped       // 已停止
};

// 线程安全的帧队列
class FrameQueue {
public:
    explicit FrameQueue(size_t max_size = 3);
    ~FrameQueue();

    // 禁止拷贝（mutex 不可拷贝）
    FrameQueue(const FrameQueue&) = delete;
    FrameQueue& operator=(const FrameQueue&) = delete;

    // 生产者接口
    QueueState Push(AVFrame* frame, bool block = false);
    
    // 消费者接口
    AVFrame* Pop(bool block = true);
    
    // 查询状态
    size_t Size() const;
    bool Empty() const;
    bool Full() const;
    
    // 控制
    void Clear();
    void Stop();

private:
    std::queue<AVFrame*> queue_;
    const size_t max_size_;
    
    mutable std::mutex mutex_;
    std::condition_variable not_full_;   // 队列不满
    std::condition_variable not_empty_;  // 队列非空
    
    std::atomic<bool> stopped_{false};
};

} // namespace live

#include "frame_queue.h"
#include <iostream>

namespace live {

FrameQueue::FrameQueue(size_t max_size) : max_size_(max_size) {
    std::cout << "[FrameQueue] Created with max_size=" << max_size << std::endl;
}

FrameQueue::~FrameQueue() {
    Clear();
}

QueueState FrameQueue::Push(AVFrame* frame, bool block) {
    std::unique_lock<std::mutex> lock(mutex_);
    
    // 如果非阻塞且队列满，直接返回
    if (!block && queue_.size() >= max_size_) {
        return QueueState::Full;
    }
    
    // 等待队列不满（或停止）
    not_full_.wait(lock, [this]() {
        return queue_.size() < max_size_ || stopped_.load();
    });
    
    if (stopped_) {
        return QueueState::Stopped;
    }
    
    // 入队
    queue_.push(frame);
    size_t size = queue_.size();
    lock.unlock();
    
    // 通知等待的消费者
    not_empty_.notify_one();
    
    if (size >= max_size_) {
        return QueueState::Full;
    }
    return QueueState::OK;
}

AVFrame* FrameQueue::Pop(bool block) {
    std::unique_lock<std::mutex> lock(mutex_);
    
    // 如果非阻塞且队列为空，直接返回
    if (!block && queue_.empty()) {
        return nullptr;
    }
    
    // 等待队列非空（或停止）
    not_empty_.wait(lock, [this]() {
        return !queue_.empty() || stopped_.load();
    });
    
    if (stopped_ && queue_.empty()) {
        return nullptr;
    }
    
    // 出队
    AVFrame* frame = queue_.front();
    queue_.pop();
    lock.unlock();
    
    // 通知等待的生产者
    not_full_.notify_one();
    
    return frame;
}

size_t FrameQueue::Size() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return queue_.size();
}

bool FrameQueue::Empty() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return queue_.empty();
}

bool FrameQueue::Full() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return queue_.size() >= max_size_;
}

void FrameQueue::Clear() {
    std::lock_guard<std::mutex> lock(mutex_);
    while (!queue_.empty()) {
        AVFrame* frame = queue_.front();
        queue_.pop();
        av_frame_free(&frame);
    }
}

void FrameQueue::Stop() {
    stopped_.store(true);
    not_full_.notify_all();
    not_empty_.notify_all();
}

} // namespace live

std::condition_variable not_full_;   // 生产者等待
std::condition_variable not_empty_;  // 消费者等待

not_empty_.wait(lock, [this]() {
    return !queue_.empty() || stopped_.load();
});

queue_.push(frame);
lock.unlock();  // 操作完成后立即解锁
not_empty_.notify_one();

void FrameQueue::Stop() {
    stopped_.store(true);
    not_full_.notify_all();   // 唤醒所有等待的生产者
    not_empty_.notify_all();  // 唤醒所有等待的消费者
}

#include "frame_queue.h"
#include <thread>

live::FrameQueue queue(3);  // 最多缓存 3 帧

// 生产者线程
void Producer() {
    for (int i = 0; i < 10; i++) {
        AVFrame* frame = av_frame_alloc();
        // ... 填充帧数据 ...
        
        auto state = queue.Push(frame, true);  // 阻塞模式
        if (state == live::QueueState::Stopped) break;
        
        std::cout << "生产帧 " << i << "，队列大小=" << queue.Size() << std::endl;
    }
}

// 消费者线程
void Consumer() {
    int count = 0;
    while (count < 10) {
        AVFrame* frame = queue.Pop(true);  // 阻塞模式
        if (!frame) break;
        
        std::cout << "消费帧 " << count << std::endl;
        av_frame_free(&frame);
        count++;
    }
}

int main() {
    std::thread producer(Producer);
    std::thread consumer(Consumer);
    
    producer.join();
    consumer.join();
    
    return 0;
}

// 主线程等待队列有数据再开始渲染
while (queue.Empty() && !quit) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
}

// 主线程根据 PTS 控制渲染时间
int64_t pts_ms = frame->pts * av_q2d(time_base) * 1000;
int64_t now_ms = av_gettime() / 1000;
int64_t delay = pts_ms - now_ms;

if (delay > 0) {
    // 使用条件变量可中断的睡眠
    std::unique_lock<std::mutex> lock(sleep_mutex);
    sleep_cv.wait_for(lock, std::chrono::milliseconds(delay), 
                      [&]() { return should_quit; });
}

// SDL 事件处理放在渲染循环中，优先响应
while (SDL_PollEvent(&event)) {
    if (event.type == SDL_WINDOWEVENT) {
        if (event.window.event == SDL_WINDOWEVENT_MOVED) {
            // 窗口移动，继续渲染，不阻塞
        }
    }
}

// decoder_thread.h
#pragma once
#include "common/error.hpp"
#include <atomic>
#include <string>

class DecoderThread {
public:
    live::Error Start(const std::string& url);
    live::Error GetLastError() const;
    
private:
    void Run();
    std::atomic<live::ErrorCode> error_code_{live::ErrorCode::OK};
};

// decoder_thread.cpp
void DecoderThread::Run() {
    auto err = OpenInput(url_);
    if (err.IsError()) {
        error_code_.store(err.Code());  // 记录错误
        return;  // 线程结束
    }
    // ...
}

// main.cpp
if (decoder.GetLastError().IsError()) {
    std::cerr << "解码失败: " 
              << decoder.GetLastError().Message() << std::endl;
}

// decoder_thread.h
#pragma once
#include "live/frame_queue.h"
#include <thread>
#include <atomic>
#include <string>

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

namespace live {

struct DecoderConfig {
    std::string filename;
    size_t queue_max_size = 3;  // 默认3帧缓冲
};

class DecoderThread {
public:
    explicit DecoderThread(const DecoderConfig& config);
    ~DecoderThread();

    // 禁止拷贝
    DecoderThread(const DecoderThread&) = delete;
    DecoderThread& operator=(const DecoderThread&) = delete;

    // 启动和停止
    bool Start();
    void Stop();
    bool IsRunning() const { return running_.load(); }

    // 获取队列（供主线程消费）
    FrameQueue* GetFrameQueue() { return queue_.get(); }
    
    // 获取视频信息
    int GetWidth() const { return width_; }
    int GetHeight() const { return height_; }
    AVRational GetTimeBase() const { return time_base_; }

private:
    void Run();  // 线程主函数

    DecoderConfig config_;
    std::unique_ptr<FrameQueue> queue_;
    std::thread thread_;
    std::atomic<bool> running_{false};
    std::atomic<bool> should_stop_{false};

    // FFmpeg 上下文（线程内部使用）
    AVFormatContext* fmt_ctx_ = nullptr;
    AVCodecContext* codec_ctx_ = nullptr;
    int video_stream_idx_ = -1;
    
    // 视频信息
    int width_ = 0;
    int height_ = 0;
    AVRational time_base_{0, 1};
};

} // namespace live

// decoder_thread.cpp
#include "decoder_thread.h"
#include <iostream>

namespace live {

DecoderThread::DecoderThread(const DecoderConfig& config)
    : config_(config)
    , queue_(std::make_unique<FrameQueue>(config.queue_max_size)) {
}

DecoderThread::~DecoderThread() {
    Stop();
}

bool DecoderThread::Start() {
    // 打开文件（在主线程做，方便错误处理）
    int ret = avformat_open_input(&fmt_ctx_, config_.filename.c_str(), nullptr, nullptr);
    if (ret < 0) {
        char errbuf[256];
        av_strerror(ret, errbuf, sizeof(errbuf));
        std::cerr << "无法打开文件: " << errbuf << std::endl;
        return false;
    }

    ret = avformat_find_stream_info(fmt_ctx_, nullptr);
    if (ret < 0) {
        std::cerr << "无法获取流信息" << std::endl;
        avformat_close_input(&fmt_ctx_);
        return false;
    }

    // 查找视频流
    video_stream_idx_ = av_find_best_stream(fmt_ctx_, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    if (video_stream_idx_ < 0) {
        std::cerr << "未找到视频流" << std::endl;
        avformat_close_input(&fmt_ctx_);
        return false;
    }

    AVStream* stream = fmt_ctx_->streams[video_stream_idx_];
    time_base_ = stream->time_base;

    // 初始化解码器
    const AVCodec* codec = avcodec_find_decoder(stream->codecpar->codec_id);
    if (!codec) {
        std::cerr << "未找到解码器" << std::endl;
        avformat_close_input(&fmt_ctx_);
        return false;
    }

    codec_ctx_ = avcodec_alloc_context3(codec);
    avcodec_parameters_to_context(codec_ctx_, stream->codecpar);
    
    // 启用多线程解码
    codec_ctx_->thread_count = 4;
    codec_ctx_->thread_type = FF_THREAD_FRAME;

    ret = avcodec_open2(codec_ctx_, codec, nullptr);
    if (ret < 0) {
        std::cerr << "无法打开解码器" << std::endl;
        avcodec_free_context(&codec_ctx_);
        avformat_close_input(&fmt_ctx_);
        return false;
    }

    width_ = codec_ctx_->width;
    height_ = codec_ctx_->height;

    std::cout << "[Decoder] " << width_ << "x" << height_ 
              << ", queue_size=" << config_.queue_max_size << std::endl;

    // 启动线程
    running_.store(true);
    should_stop_.store(false);
    thread_ = std::thread(&DecoderThread::Run, this);

    return true;
}

void DecoderThread::Stop() {
    if (!running_.load()) return;

    std::cout << "[Decoder] Stopping..." << std::endl;
    
    should_stop_.store(true);
    queue_->Stop();  // 唤醒等待的线程

    if (thread_.joinable()) {
        thread_.join();
    }

    // 清理资源
    avcodec_free_context(&codec_ctx_);
    avformat_close_input(&fmt_ctx_);
    
    running_.store(false);
    std::cout << "[Decoder] Stopped" << std::endl;
}

void DecoderThread::Run() {
    std::cout << "[Decoder] Thread started" << std::endl;

    AVPacket* packet = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    int64_t frame_count = 0;

    // 解码循环
    while (!should_stop_.load()) {
        // 读取 packet
        int ret = av_read_frame(fmt_ctx_, packet);
        if (ret < 0) {
            break;  // 文件结束或错误
        }

        if (packet->stream_index != video_stream_idx_) {
            av_packet_unref(packet);
            continue;
        }

        // 发送 packet
        ret = avcodec_send_packet(codec_ctx_, packet);
        av_packet_unref(packet);

        if (ret < 0) {
            continue;
        }

        // 接收 frame
        while (ret >= 0) {
            ret = avcodec_receive_frame(codec_ctx_, frame);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                break;
            }
            if (ret < 0) {
                break;
            }

            // 复制 frame（解码器会重用内部缓冲区）
            AVFrame* cloned = av_frame_clone(frame);
            
            // 送入队列（阻塞模式）
            auto state = queue_->Push(cloned, true);
            if (state == QueueState::Stopped) {
                av_frame_free(&cloned);
                break;
            }

            frame_count++;
            if (frame_count % 30 == 0) {
                std::cout << "[Decoder] Decoded " << frame_count 
                          << " frames, queue=" << queue_->Size() << std::endl;
            }
        }

        if (should_stop_.load()) break;
    }

    // 刷新解码器
    avcodec_send_packet(codec_ctx_, nullptr);
    while (avcodec_receive_frame(codec_ctx_, frame) == 0) {
        AVFrame* cloned = av_frame_clone(frame);
        if (queue_->Push(cloned, true) == QueueState::Stopped) {
            av_frame_free(&cloned);
            break;
        }
    }

    std::cout << "[Decoder] Total decoded: " << frame_count << std::endl;

    av_frame_free(&frame);
    av_packet_free(&packet);
}

} // namespace live

// main.cpp
#include "live/frame_queue.h"
#include "decoder_thread.h"
#include <SDL2/SDL.h>
#include <iostream>
#include <chrono>

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

using namespace live;

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "用法: " << argv[0] << " <视频文件>" << std::endl;
        return 1;
    }

    // 1. 启动解码线程
    DecoderConfig config;
    config.filename = argv[1];
    config.queue_max_size = 3;  // 3帧缓冲

    DecoderThread decoder(config);
    if (!decoder.Start()) {
        return 1;
    }

    // 2. 初始化 SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "SDL 初始化失败: " << SDL_GetError() << std::endl;
        return 1;
    }

    SDL_Window* window = SDL_CreateWindow(
        "Live Player - Chapter 02 (Async)",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        decoder.GetWidth(), decoder.GetHeight(),
        SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);

    SDL_Renderer* renderer = SDL_CreateRenderer(
        window, -1,
        SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

    SDL_Texture* texture = SDL_CreateTexture(
        renderer,
        SDL_PIXELFORMAT_IYUV,
        SDL_TEXTUREACCESS_STREAMING,
        decoder.GetWidth(), decoder.GetHeight());

    // 3. 渲染循环
    int64_t start_time = av_gettime();
    int rendered_frames = 0;
    bool quit = false;

    std::cout << "[Main] Starting render loop" << std::endl;

    while (!quit) {
        // 处理事件（非阻塞）
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = true;
            }
            if (event.type == SDL_KEYDOWN) {
                if (event.key.keysym.sym == SDLK_ESCAPE) {
                    quit = true;
                }
            }
        }

        // 从队列取帧
        AVFrame* frame = decoder.GetFrameQueue()->Pop(false);  // 非阻塞
        
        if (frame) {
            // PTS 同步
            int64_t pts_us = frame->pts * av_q2d(decoder.GetTimeBase()) * 1000000;
            int64_t elapsed = av_gettime() - start_time;
            int64_t delay = pts_us - elapsed;

            if (delay > 0 && delay < 1000000) {  // 合理的延迟范围
                SDL_Delay(delay / 1000);  // 毫秒
            }

            // 渲染
            SDL_UpdateYUVTexture(
                texture, nullptr,
                frame->data[0], frame->linesize[0],
                frame->data[1], frame->linesize[1],
                frame->data[2], frame->linesize[2]);

            SDL_RenderClear(renderer);
            SDL_RenderCopy(renderer, texture, nullptr, nullptr);
            SDL_RenderPresent(renderer);

            rendered_frames++;
            av_frame_free(&frame);
        } else if (!decoder.IsRunning() && decoder.GetFrameQueue()->Empty()) {
            // 解码结束且队列为空
            break;
        } else {
            // 队列为空，等待一帧
            SDL_Delay(1);
        }
    }

    // 4. 清理
    std::cout << "[Main] Rendered " << rendered_frames << " frames" << std::endl;

    decoder.Stop();

    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    std::cout << "[Main] Exit" << std::endl;
    return 0;
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(async-player VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(PkgConfig REQUIRED)
pkg_check_modules(FFMPEG REQUIRED
    libavformat libavcodec libavutil)
find_package(SDL2 REQUIRED)

add_executable(async-player
    src/main.cpp
    src/decoder_thread.cpp
    src/frame_queue.cpp
)

target_include_directories(async-player PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/include
    ${FFMPEG_INCLUDE_DIRS}
    ${SDL2_INCLUDE_DIRS}
)

target_link_libraries(async-player
    ${FFMPEG_LIBRARIES}
    SDL2::SDL2
    pthread
)

mkdir build && cd build
cmake .. && make -j4
./async-player ../test.mp4

// 正确顺序
quit = true;           // 1. 设置退出标志
decoder.Stop();        // 2. 停止解码线程（内部会 join）
SDL_Quit();            // 3. 清理 SDL

// 调试打印
std::cout << "Queue size: " << queue->Size() << std::endl;
std::cout << "Decoder running: " << decoder.IsRunning() << std::endl;

AVFrame* frame = queue->Pop();
if (frame) {
    Render(frame);
    av_frame_free(&frame);  // 不要忘记！
}

int64_t delay = pts_us - elapsed;
if (delay > 0 && delay < 500000) {  // 上限 500ms
    SDL_Delay(delay / 1000);
}
// delay < 0 表示落后，立即渲染（丢帧追赶）

std::cout << "[T" << std::this_thread::get_id() << "] Message" << std::endl;

# 第三章目标
./player http://example.com/video.mp4