while (av_read_frame(fmt_ctx, packet) >= 0) {      // 1. 读取数据
    // 处理窗口事件 ↓↓↓
    SDL_Event e;
    while (SDL_PollEvent(&e)) {                      // 2. 处理事件
        if (e.type == SDL_QUIT) goto cleanup;
    }
    
    if (packet->stream_index == video_stream_idx) {
        avcodec_send_packet(codec_ctx, packet);      // 3. 送入解码器
        while (avcodec_receive_frame(codec_ctx, frame) == 0) {
            // 同步
            int64_t pts_us = frame->pts * av_q2d(video_stream->time_base) * 1000000;
            int64_t elapsed = av_gettime() - start_time;
            if (pts_us > elapsed) av_usleep(pts_us - elapsed);  // 4. 等待
            
            // 渲染 ↓↓↓
            SDL_UpdateYUVTexture(texture, nullptr, ...);       // 5. 更新纹理
            SDL_RenderClear(renderer);
            SDL_RenderCopy(renderer, texture, nullptr, nullptr);
            SDL_RenderPresent(renderer);                       // 6. 显示
        }
    }
}

// 不要这样做：凭感觉优化
// "我觉得解码很慢，我要优化它"

// 应该这样做：测量后再优化
// "测量显示解码耗时30ms，目标是16ms，需要优化"

#include <chrono>

// 获取当前时间点
auto start = std::chrono::high_resolution_clock::now();

// ... 执行需要测量的代码 ...

auto end = std::chrono::high_resolution_clock::now();

// 计算耗时（微秒）
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
// duration 的单位是微秒 (μs)，1ms = 1000μs

#include <chrono>
#include <deque>
#include <numeric>

// 简单的性能监控器
class DecodeProfiler {
public:
    void Start() {
        start_time_ = std::chrono::high_resolution_clock::now();
    }
    
    void End() {
        auto end = std::chrono::high_resolution_clock::now();
        auto us = std::chrono::duration_cast<std::chrono::microseconds>(
            end - start_time_).count();
        
        // 保存最近30帧的耗时
        decode_times_.push_back(us);
        if (decode_times_.size() > 30) {
            decode_times_.pop_front();
        }
    }
    
    // 获取平均解码耗时（微秒）
    int64_t AverageUs() const {
        if (decode_times_.empty()) return 0;
        int64_t sum = std::accumulate(decode_times_.begin(), decode_times_.end(), 0LL);
        return sum / decode_times_.size();
    }
    
    // 获取最大耗时
    int64_t MaxUs() const {
        if (decode_times_.empty()) return 0;
        return *std::max_element(decode_times_.begin(), decode_times_.end());
    }
    
    // 打印统计信息
    void PrintStats() const {
        int64_t avg = AverageUs();
        int64_t max = MaxUs();
        double fps = 1000000.0 / avg;  // 理论最大帧率
        
        printf("[性能] 平均解码: %ldμs (%.1f fps), 最大: %ldμs\n", 
               avg, fps, max);
    }
    
private:
    std::chrono::time_point<std::chrono::high_resolution_clock> start_time_;
    std::deque<int64_t> decode_times_;
};

DecodeProfiler profiler;

while (av_read_frame(fmt_ctx, packet) >= 0) {
    if (packet->stream_index == video_stream_idx) {
        profiler.Start();  // ← 开始计时
        
        avcodec_send_packet(codec_ctx, packet);
        while (avcodec_receive_frame(codec_ctx, frame) == 0) {
            // 解码完成
        }
        
        profiler.End();    // ← 结束计时
        
        // 每30帧打印一次统计
        if (decode_count_ % 30 == 0) {
            profiler.PrintStats();
        }
        
        // 渲染...
    }
    av_packet_unref(packet);
}

// profiler_player.cpp - 带性能分析的播放器
#include <SDL2/SDL.h>
#include <stdio.h>
#include <chrono>
#include <deque>
#include <numeric>

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

class PerformanceMonitor {
public:
    struct Stats {
        int64_t decode_us;
        int64_t render_us;
        int64_t total_us;
    };
    
    void StartDecode() {
        decode_start_ = Now();
    }
    
    void EndDecode() {
        decode_end_ = Now();
    }
    
    void StartRender() {
        render_start_ = Now();
    }
    
    void EndRender() {
        render_end_ = Now();
    }
    
    void RecordFrame() {
        Stats s;
        s.decode_us = DurationUs(decode_start_, decode_end_);
        s.render_us = DurationUs(render_start_, render_end_);
        s.total_us = s.decode_us + s.render_us;
        
        stats_.push_back(s);
        if (stats_.size() > 30) stats_.pop_front();
        
        frame_count_++;
        if (frame_count_ % 30 == 0) {
            PrintStats();
        }
    }
    
    void PrintStats() const {
        if (stats_.empty()) return;
        
        int64_t avg_decode = 0, avg_render = 0, max_total = 0;
        for (const auto& s : stats_) {
            avg_decode += s.decode_us;
            avg_render += s.render_us;
            max_total = std::max(max_total, s.total_us);
        }
        avg_decode /= stats_.size();
        avg_render /= stats_.size();
        
        double decode_fps = 1000000.0 / avg_decode;
        double total_fps = 1000000.0 / (avg_decode + avg_render);
        
        printf("\n========== 性能统计 (最近%d帧) ==========\n", (int)stats_.size());
        printf("解码: %4ld μs (%.1f fps)\n", avg_decode, decode_fps);
        printf("渲染: %4ld μs\n", avg_render);
        printf("总计: %4ld μs (%.1f fps)\n", avg_decode + avg_render, total_fps);
        printf("最大: %4ld μs\n", max_total);
        printf("========================================\n\n");
    }
    
private:
    using Clock = std::chrono::high_resolution_clock;
    using TimePoint = std::chrono::time_point<Clock>;
    
    TimePoint Now() { return Clock::now(); }
    
    int64_t DurationUs(TimePoint start, TimePoint end) {
        return std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
    }
    
    TimePoint decode_start_, decode_end_;
    TimePoint render_start_, render_end_;
    std::deque<Stats> stats_;
    int frame_count_ = 0;
};

int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "用法: %s <视频文件>\n", argv[0]);
        return 1;
    }

    // ... 初始化代码（省略，与第三章相同）...
    
    AVFormatContext* fmt_ctx = nullptr;
    avformat_open_input(&fmt_ctx, argv[1], nullptr, nullptr);
    avformat_find_stream_info(fmt_ctx, nullptr);
    
    int video_stream_idx = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    AVStream* video_stream = fmt_ctx->streams[video_stream_idx];
    
    const AVCodec* codec = avcodec_find_decoder(video_stream->codecpar->codec_id);
    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    avcodec_parameters_to_context(codec_ctx, video_stream->codecpar);
    avcodec_open2(codec_ctx, codec, nullptr);

    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Profiler Player",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        codec_ctx->width, codec_ctx->height, SDL_WINDOW_SHOWN);
    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,
        codec_ctx->width, codec_ctx->height);

    AVPacket* packet = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    PerformanceMonitor monitor;
    int64_t start_time = av_gettime();

    while (av_read_frame(fmt_ctx, packet) >= 0) {
        SDL_Event e;
        while (SDL_PollEvent(&e)) {
            if (e.type == SDL_QUIT) goto cleanup;
        }

        if (packet->stream_index == video_stream_idx) {
            monitor.StartDecode();
            
            avcodec_send_packet(codec_ctx, packet);
            while (avcodec_receive_frame(codec_ctx, frame) == 0) {
                monitor.EndDecode();
                
                // 同步
                int64_t pts_us = frame->pts * av_q2d(video_stream->time_base) * 1000000;
                int64_t elapsed = av_gettime() - start_time;
                if (pts_us > elapsed) av_usleep(pts_us - elapsed);

                // 渲染
                monitor.StartRender();
                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);
                monitor.EndRender();
                
                monitor.RecordFrame();
            }
        }
        av_packet_unref(packet);
    }

cleanup:
    // ... 清理代码 ...
    av_frame_free(&frame);
    av_packet_free(&packet);
    avcodec_free_context(&codec_ctx);
    avformat_close_input(&fmt_ctx);
    SDL_Quit();
    return 0;
}

# 编译
g++ -std=c++14 -O2 profiler_player.cpp -o profiler_player \
    $(pkg-config --cflags --libs libavformat libavcodec libavutil sdl2)

# 运行
./profiler_player test.mp4

// 在性能统计中加入预算检查
void CheckBudget(int64_t total_us) {
    const int64_t BUDGET_30FPS = 33333;  // 33.3ms = 33333μs
    const int64_t BUDGET_60FPS = 16667;  // 16.7ms = 16667μs
    
    if (total_us > BUDGET_30FPS) {
        printf("⚠️ 警告：超过30fps预算！(%ldμs > %ldμs)\n", total_us, BUDGET_30FPS);
    } else if (total_us > BUDGET_60FPS) {
        printf("✓ 满足30fps，但无法满足60fps\n");
    } else {
        printf("✓ 满足60fps\n");
    }
}

class FrameTypeProfiler {
public:
    void RecordFrame(char pict_type, int64_t decode_us) {
        switch (pict_type) {
            case 'I': iframe_times_.push_back(decode_us); break;
            case 'P': pframe_times_.push_back(decode_us); break;
            case 'B': bframe_times_.push_back(decode_us); break;
        }
        
        // 保持最近30个样本
        if (iframe_times_.size() > 30) iframe_times_.pop_front();
        if (pframe_times_.size() > 30) pframe_times_.pop_front();
        if (bframe_times_.size() > 30) bframe_times_.pop_front();
    }
    
    void PrintStats() const {
        printf("\n========== 帧类型解码统计 ==========\n");
        printf("I帧: %s\n", FormatStats(iframe_times_).c_str());
        printf("P帧: %s\n", FormatStats(pframe_times_).c_str());
        printf("B帧: %s\n", FormatStats(bframe_times_).c_str());
        printf("====================================\n\n");
    }
    
private:
    std::deque<int64_t> iframe_times_;
    std::deque<int64_t> pframe_times_;
    std::deque<int64_t> bframe_times_;
    
    std::string FormatStats(const std::deque<int64_t>& times) const {
        if (times.empty()) return "无数据";
        
        int64_t sum = 0, max_val = 0;
        for (auto t : times) {
            sum += t;
            max_val = std::max(max_val, t);
        }
        int64_t avg = sum / times.size();
        
        char buf[128];
        snprintf(buf, sizeof(buf), "平均%4ldμs, 最大%4ldμs, 样本%d",
                 avg, max_val, (int)times.size());
        return buf;
    }
};

// 使用方式
FrameTypeProfiler ft_profiler;

while (avcodec_receive_frame(codec_ctx, frame) == 0) {
    auto end = std::chrono::high_resolution_clock::now();
    auto decode_us = std::chrono::duration_cast<std::chrono::microseconds>(
        end - decode_start).count();
    
    // frame->pict_type 表示帧类型：AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B
    char type = av_get_picture_type_char((AVPictureType)frame->pict_type);
    ft_profiler.RecordFrame(type, decode_us);
    
    if (++frame_count % 90 == 0) {  // 每90帧打印一次
        ft_profiler.PrintStats();
    }
}

// 默认情况下，FFmpeg 可能已经启用了多线程
// 检查实际的解码线程数
printf("解码线程数: %d\n", codec_ctx->thread_count);

// lag_experiment.cpp - 卡顿实验
#include <SDL2/SDL.h>
#include <chrono>
#include <thread>

// 模拟不同耗时的解码
void SimulateDecode(int ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}

int main(int argc, char* argv[]) {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Lag Experiment",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        640, 480, SDL_WINDOW_RESIZABLE);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
    
    // 读取命令行参数：模拟解码耗时（毫秒）
    int decode_time_ms = 50;  // 默认50ms
    if (argc > 1) {
        decode_time_ms = atoi(argv[1]);
    }
    
    printf("模拟解码耗时: %dms\n", decode_time_ms);
    printf("尝试拖动窗口，观察流畅度...\n");
    
    bool running = true;
    int frame_count = 0;
    auto last_event_check = std::chrono::high_resolution_clock::now();
    
    while (running) {
        // ===== 模拟解码 =====
        auto decode_start = std::chrono::high_resolution_clock::now();
        SimulateDecode(decode_time_ms);
        auto decode_end = std::chrono::high_resolution_clock::now();
        
        // ===== 模拟渲染 =====
        SDL_SetRenderDrawColor(renderer, 
            (frame_count * 5) % 255,  // 变化颜色
            100, 100, 255);
        SDL_RenderClear(renderer);
        SDL_RenderPresent(renderer);
        
        // ===== 处理事件 =====
        auto event_start = std::chrono::high_resolution_clock::now();
        SDL_Event e;
        int events_processed = 0;
        while (SDL_PollEvent(&e)) {
            events_processed++;
            if (e.type == SDL_QUIT) running = false;
            if (e.type == SDL_WINDOWEVENT) {
                auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
                    event_start - last_event_check).count();
                if (e.window.event == SDL_WINDOWEVENT_MOVED) {
                    printf("窗口移动事件，响应延迟: %ld ms\n", latency);
                }
            }
        }
        last_event_check = event_start;
        
        auto total_us = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::high_resolution_clock::now() - decode_start).count();
        
        if (++frame_count % 30 == 0) {
            printf("帧%d: 解码%dms, 处理%d个事件, 总耗时%.1fms, 理论%.1f fps\n",
                   frame_count, decode_time_ms, events_processed,
                   total_us / 1000.0, 1000000.0 / total_us);
        }
    }
    
    SDL_Quit();
    return 0;
}

# 编译
g++ -std=c++14 lag_experiment.cpp -o lag_experiment $(pkg-config --cflags --libs sdl2)

# 运行不同耗时的版本
./lag_experiment 10   # 模拟10ms解码
./lag_experiment 50   # 模拟50ms解码
./lag_experiment 100  # 模拟100ms解码

// 简化的帧队列实现
class FrameQueue {
public:
    static constexpr size_t MAX_SIZE = 5;  // 最多缓冲5帧
    
    void Push(AVFrame* frame) {
        std::unique_lock<std::mutex> lock(mutex_);
        // 队列满时等待
        not_full_.wait(lock, [this] { return queue_.size() < MAX_SIZE; });
        
        queue_.push(frame);
        not_empty_.notify_one();
    }
    
    AVFrame* Pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        // 队列空时等待
        not_empty_.wait(lock, [this] { return !queue_.empty(); });
        
        AVFrame* frame = queue_.front();
        queue_.pop();
        not_full_.notify_one();
        return frame;
    }
    
private:
    std::queue<AVFrame*> queue_;
    std::mutex mutex_;
    std::condition_variable not_empty_;
    std::condition_variable not_full_;
};

# 基本用法：记录程序运行时的性能数据
perf record -g ./player test.mp4

# 查看统计结果
perf report

# 1. 安装火焰图工具
git clone https://github.com/brendangregg/FlameGraph.git

# 2. 记录性能数据（带调用栈）
perf record -g --call-graph=dwarf ./player test.mp4
# 按 Ctrl+C 停止录制

# 3. 生成火焰图
perf script | ./FlameGraph/stackcollapse-perf.pl | \
    ./FlameGraph/flamegraph.pl > flamegraph.svg

# 4. 浏览器查看
firefox flamegraph.svg

# 查看播放器进程的CPU占用
top -p $(pgrep player)

# 或
htop -p $(pgrep player)

auto start = std::chrono::high_resolution_clock::now();
// ... 解码操作 ...
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);