#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <iostream>

// 编码器初始化流程
class X264Encoder {
public:
    bool Init(int width, int height, int fps, int bitrate_kbps) {
        // 1. 查找编码器
        const AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec) {
            std::cerr << "[Encoder] x264 not found. "
                      << "Build FFmpeg with --enable-libx264" << std::endl;
            return false;
        }
        
        // 2. 分配编码器上下文
        ctx_ = avcodec_alloc_context3(codec);
        if (!ctx_) {
            std::cerr << "[Encoder] Failed to alloc context" << std::endl;
            return false;
        }
        
        // 3. 配置基本参数
        ctx_>width = width;
        ctx_>height = height;
        ctx_>time_base = {1, fps};        // 时间基：1/fps
        ctx_>framerate = {fps, 1};       // 帧率
        ctx_>pix_fmt = AV_PIX_FMT_YUV420P;  // 像素格式
        ctx_>gop_size = fps;             // GOP 大小 = 1秒（I帧间隔）
        
        // 4. 配置码率
        ctx_>bit_rate = bitrate_kbps * 1000;  // bps
        ctx_>rc_buffer_size = bitrate_kbps * 1000;
        
        // 5. x264 特定选项
        AVDictionary* opts = nullptr;
        
        // preset: 速度与质量权衡
        av_dict_set(&opts, "preset", "fast", 0);
        // ultrafast, superfast, veryfast, faster, fast, medium, slow, slower
        
        // tune: 针对特定场景优化
        av_dict_set(&opts, "tune", "zerolatency", 0);
        // film: 电影内容
        // animation: 动画
        // grain: 保留颗粒
        // stillimage: 静态图像
        // psnr: 优化 PSNR
        // ssim: 优化 SSIM
        // fastdecode: 快速解码
        // zerolatency: 零延迟（直播）
        
        // profile: 兼容性
        av_dict_set(&opts, "profile", "baseline", 0);
        // baseline: 基本，兼容性最好
        // main: 主要
        // high: 高级，压缩率最好
        
        // 6. 打开编码器
        int ret = avcodec_open2(ctx_, codec, &opts);
        av_dict_free(&opts);
        
        if (ret < 0) {
            char errbuf[256];
            av_strerror(ret, errbuf, sizeof(errbuf));
            std::cerr << "[Encoder] Failed to open codec: " << errbuf << std::endl;
            return false;
        }
        
        std::cout << "[Encoder] x264 initialized: " << width << "x" << height
                  << " @ " << fps << "fps, " << bitrate_kbps << "kbps"
                  << std::endl;
        return true;
    }
    
    ~X264Encoder() {
        if (ctx_) {
            avcodec_free_context(&ctx_);
        }
    }

private:
    AVCodecContext* ctx_ = nullptr;
};

// 编码一帧 YUV 数据
bool EncodeFrame(AVCodecContext* ctx, AVFrame* frame, 
                 std::vector<uint8_t>& output) {
    // 1. 发送帧到编码器
    int ret = avcodec_send_frame(ctx, frame);
    if (ret < 0) {
        std::cerr << "[Encoder] Failed to send frame" << std::endl;
        return false;
    }
    
    // 2. 接收编码后的包
    AVPacket* pkt = av_packet_alloc();
    while (ret >= 0) {
        ret = avcodec_receive_packet(ctx, pkt);
        if (ret == AVERROR(EAGAIN)) {
            // 需要更多输入
            break;
        } else if (ret == AVERROR_EOF) {
            // 编码结束
            break;
        } else if (ret < 0) {
            std::cerr << "[Encoder] Error encoding" << std::endl;
            av_packet_free(&pkt);
            return false;
        }
        
        // 3. 保存编码数据
        output.insert(output.end(), pkt->data, pkt->data + pkt->size);
        
        // 4. 检查是否为关键帧
        bool is_keyframe = (pkt->flags & AV_PKT_FLAG_KEY) != 0;
        if (is_keyframe) {
            std::cout << "[Encoder] I-frame: " << pkt->size << " bytes" << std::endl;
        }
        
        av_packet_unref(pkt);
    }
    
    av_packet_free(&pkt);
    return true;
}

// 冲刷编码器（获取缓存中的帧）
bool FlushEncoder(AVCodecContext* ctx, std::vector<uint8_t>& output) {
    // 发送 nullptr 表示没有更多输入
    avcodec_send_frame(ctx, nullptr);
    
    AVPacket* pkt = av_packet_alloc();
    int ret = 0;
    while (ret >= 0) {
        ret = avcodec_receive_packet(ctx, pkt);
        if (ret == AVERROR_EOF) {
            break;
        }
        if (ret < 0) {
            break;
        }
        output.insert(output.end(), pkt->data, pkt->data + pkt->size);
        av_packet_unref(pkt);
    }
    av_packet_free(&pkt);
    return true;
}

#include <cstdio>
#include <vector>

// 生成测试 YUV 帧（渐变色）
void GenerateTestFrame(uint8_t* yuv, int width, int height, int frame_num) {
    int y_size = width * height;
    int uv_size = y_size / 4;
    
    // Y 分量：水平渐变
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int idx = y * width + x;
            // 渐变 + 动画效果
            yuv[idx] = (x * 255 / width + frame_num * 2) % 256;
        }
    }
    
    // U/V 分量：固定值（灰色）
    memset(yuv + y_size, 128, uv_size * 2);
}

int main(int argc, char* argv[]) {
    const int width = 1280;
    const int height = 720;
    const int fps = 30;
    const int bitrate = 4000;  // kbps
    const int duration_sec = 5;
    
    // 初始化编码器
    X264Encoder encoder;
    if (!encoder.Init(width, height, fps, bitrate)) {
        return 1;
    }
    
    // 打开输出文件
    FILE* outfile = fopen("output.h264", "wb");
    if (!outfile) {
        std::cerr << "[Encoder] Failed to open output file" << std::endl;
        return 1;
    }
    
    // 分配 YUV 帧
    AVFrame* frame = av_frame_alloc();
    frame->format = AV_PIX_FMT_YUV420P;
    frame->width = width;
    frame->height = height;
    av_frame_get_buffer(frame, 32);
    
    // 编码循环
    int total_frames = fps * duration_sec;
    for (int i = 0; i < total_frames; i++) {
        // 生成测试帧
        GenerateTestFrame(frame->data[0], width, height, i);
        frame->pts = i;  // 时间戳
        
        // 编码
        std::vector<uint8_t> encoded;
        if (EncodeFrame(encoder.ctx_, frame, encoded)) {
            fwrite(encoded.data(), 1, encoded.size(), outfile);
        }
        
        // 打印进度
        if (i % fps == 0) {
            std::cout << "[Encoder] Progress: " << i / fps << "/" 
                      << duration_sec << " sec" << std::endl;
        }
    }
    
    // 冲刷
    std::vector<uint8_t> remaining;
    FlushEncoder(encoder.ctx_, remaining);
    fwrite(remaining.data(), 1, remaining.size(), outfile);
    
    // 清理
    av_frame_free(&frame);
    fclose(outfile);
    
    std::cout << "[Encoder] Done. Output: output.h264" << std::endl;
    return 0;
}

// 1-2秒一个 GOP，平衡压缩率和恢复速度
int gop_size = fps * 2;      // 最大 GOP：2秒（60帧@30fps）
int keyint_min = fps / 2;    // 最小 GOP：0.5秒（15帧@30fps）

// 场景切换检测
int scene_threshold = 40;    // 0-100，越高越不容易触发

// 关闭 open GOP（直播必须）
// Open GOP 允许参考其他 GOP 的帧，压缩率高但不适合直播
bool open_gop = false;

// x264 参数映射
AVDictionary* opts = nullptr;
av_dict_set(&opts, "keyint", "60", 0);        // 最大关键帧间隔
av_dict_set(&opts, "min-keyint", "15", 0);    // 最小关键帧间隔
av_dict_set(&opts, "sc_threshold", "40", 0);  // 场景切换阈值
av_dict_set(&opts, "open_gop", "0", 0);       // 禁用 open GOP

// 直播禁用 B 帧（降低延迟、提高兼容性）
av_dict_set(&opts, "bf", "0", 0);  // 无 B 帧

// 点播可启用（提高压缩率）
av_dict_set(&opts, "bf", "3", 0);  // 3 个连续 B 帧

// VBV（Video Buffering Verifier）控制码率突发
// 直播推荐小 buffer，降低延迟
av_dict_set(&opts, "vbv-bufsize", "4000", 0);   // buffer 大小（kbits）
av_dict_set(&opts, "vbv-maxrate", "4000", 0);   // 最大突发码率（kbits）

// 与 CBR 配合
codec_ctx->rc_buffer_size = 4 * 1000 * 1000;  // 4 Mbit

// CBR 配置
ctx->bit_rate = 4 * 1000 * 1000;      // 目标码率：4 Mbps
ctx->rc_min_rate = 4 * 1000 * 1000;   // 最小码率：4 Mbps
ctx->rc_max_rate = 4 * 1000 * 1000;   // 最大码率：4 Mbps
ctx->rc_buffer_size = 4 * 1000 * 1000; // 缓冲区大小

AVDictionary* opts = nullptr;
av_dict_set(&opts, "nal-hrd", "cbr", 0);  // 启用 CBR 模式
av_dict_set(&opts, "tune", "zerolatency", 0);  // 零延迟

// VBR 配置
ctx->bit_rate = 4 * 1000 * 1000;      // 平均码率：4 Mbps
ctx->rc_min_rate = 0;                  // 最小不限制
ctx->rc_max_rate = 8 * 1000 * 1000;   // 最大：8 Mbps

AVDictionary* opts = nullptr;
// 默认就是 VBR 模式，无需额外设置

// CRF 配置（不需要设置 bit_rate）
AVDictionary* opts = nullptr;
av_dict_set(&opts, "crf", "23", 0);  // CRF 值：0-51

// 0 = 无损
// 17-18 = 视觉上无损
// 23 = 默认（平衡）
// 28 = 可接受质量
// 51 = 最差

// include/live/video_encoder.h
#pragma once
#include <string>
#include <functional>
#include <memory>
#include <vector>

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

namespace live {

// 码率控制模式
enum class RateControlMode {
    CBR,   // 恒定码率（直播）
    VBR,   // 可变码率（点播）
    CRF,   // 恒定质量（存档）
};

// 编码器类型
enum class EncoderType {
    X264,           // 软件编码
    VIDEOTOOLBOX,   // macOS 硬件
    NVENC,          // NVIDIA 硬件
    VAAPI,          // Linux 硬件
};

// 编码器配置
struct EncoderConfig {
    int width = 1280;
    int height = 720;
    int fps = 30;
    int bitrate = 4 * 1000 * 1000;  // bps
    
    // === 关键帧控制（直播必需）===
    int gop_size = 60;              // 最大 GOP（2秒@30fps）
    int keyint_min = 15;            // 最小 GOP（0.5秒@30fps）
    int scene_threshold = 40;       // 场景切换检测阈值
    bool open_gop = false;          // 直播必须禁用 open GOP
    
    // === 码率控制高级选项 ===
    int vbv_buffer = 100;           // VBV buffer (ms)
    int vbv_maxrate = 0;            // 最大突发码率（0=与bitrate相同）
    int rc_lookahead = 0;           // 直播推荐 0，降低延迟
    
    // === B帧控制 ===
    int max_b_frames = 0;           // 直播禁用 B 帧
    int ref_frames = 1;             // 参考帧数
    
    int crf = 23;                   // CRF 质量（CRF 模式）
    RateControlMode rc_mode = RateControlMode::CBR;
    EncoderType type = EncoderType::X264;
    std::string preset = "fast";    // x264 preset
    std::string tune = "zerolatency";
};

// 编码回调
using OnEncodedPacket = std::function<void(
    const uint8_t* data,     // 编码数据
    size_t size,             // 数据大小
    int64_t pts,             // 时间戳
    bool keyframe            // 是否关键帧
)>;

class VideoEncoder {
public:
    explicit VideoEncoder(const EncoderConfig& config);
    ~VideoEncoder();

    // 初始化
    bool Init();
    
    // 编码一帧（YUV420P）
    // frame: 输入帧，nullptr 表示冲刷
    bool Encode(AVFrame* frame);
    
    // 设置编码回调
    void SetCallback(OnEncodedPacket cb) { on_packet_ = cb; }
    
    // 获取信息
    int GetWidth() const { return config_.width; }
    int GetHeight() const { return config_.height; }
    int GetFPS() const { return config_.fps; }
    
    // 统计信息
    struct Stats {
        uint64_t frames_encoded = 0;
        uint64_t bytes_encoded = 0;
        uint64_t keyframes = 0;
        double avg_bitrate = 0;
    };
    Stats GetStats() const { return stats_; }

private:
    EncoderConfig config_;
    const AVCodec* codec_ = nullptr;
    AVCodecContext* ctx_ = nullptr;
    OnEncodedPacket on_packet_;
    Stats stats_;
    int64_t start_time_ = 0;
};

} // namespace live

// src/video_encoder.cpp
#include "live/video_encoder.h"
#include <iostream>
#include <string>

namespace live {

VideoEncoder::VideoEncoder(const EncoderConfig& config)
    : config_(config) {
}

VideoEncoder::~VideoEncoder() {
    if (ctx_) {
        // 冲刷编码器
        Encode(nullptr);
        avcodec_free_context(&ctx_);
    }
}

bool VideoEncoder::Init() {
    // 选择编码器
    AVCodecID codec_id = AV_CODEC_ID_H264;
    
    switch (config_.type) {
        case EncoderType::X264:
            codec_ = avcodec_find_encoder_by_name("libx264");
            break;
        case EncoderType::VIDEOTOOLBOX:
            codec_ = avcodec_find_encoder_by_name("h264_videotoolbox");
            break;
        case EncoderType::NVENC:
            codec_ = avcodec_find_encoder_by_name("h264_nvenc");
            break;
        case EncoderType::VAAPI:
            codec_ = avcodec_find_encoder_by_name("h264_vaapi");
            break;
    }
    
    if (!codec_) {
        std::cerr << "[Encoder] Codec not found, fallback to libx264" <> std::endl;
        codec_ = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec_) {
            std::cerr << "[Encoder] No H.264 encoder available" <> std::endl;
            return false;
        }
    }
    
    // 分配上下文
    ctx_ = avcodec_alloc_context3(codec_);
    if (!ctx_) {
        std::cerr << "[Encoder] Failed to alloc context" <> std::endl;
        return false;
    }
    
    // 基本参数
    ctx_>width = config_.width;
    ctx_>height = config_.height;
    ctx_>time_base = {1, config_.fps};
    ctx_>framerate = {config_.fps, 1};
    ctx_>pix_fmt = AV_PIX_FMT_YUV420P;
    ctx_>gop_size = config_.gop_size;
    
    // 码率控制
    AVDictionary* opts = nullptr;
    
    switch (config_.rc_mode) {
        case RateControlMode::CBR:
            ctx_>bit_rate = config_.bitrate;
            ctx_>rc_min_rate = config_.bitrate;
            ctx_>rc_max_rate = config_.bitrate;
            ctx_>rc_buffer_size = config_.bitrate;
            av_dict_set(&opts, "nal-hrd", "cbr", 0);
            break;
            
        case RateControlMode::VBR:
            ctx_>bit_rate = config_.bitrate;
            ctx_>rc_min_rate = config_.bitrate / 2;
            ctx_>rc_max_rate = config_.bitrate * 2;
            break;
            
        case RateControlMode::CRF:
            // CRF 模式不设置 bit_rate
            av_dict_set(&opts, "crf", std::to_string(config_.crf).c_str(), 0);
            break;
    }
    
    // x264 特有选项
    if (config_.type == EncoderType::X264) {
        av_dict_set(&opts, "preset", config_.preset.c_str(), 0);
        av_dict_set(&opts, "tune", config_.tune.c_str(), 0);
    }
    
    // 打开编码器
    int ret = avcodec_open2(ctx_, codec_, &opts);
    av_dict_free(&opts);
    
    if (ret < 0) {
        char errbuf[256];
        av_strerror(ret, errbuf, sizeof(errbuf));
        std::cerr << "[Encoder] Failed to open codec: " << errbuf << std::endl;
        return false;
    }
    
    start_time_ = av_gettime();
    
    std::cout << "[Encoder] Initialized: " << config_.width << "x" << config_.height
              << " @ " << config_.fps << "fps, ";
    
    switch (config_.rc_mode) {
        case RateControlMode::CBR:
            std::cout << "CBR " << config_.bitrate / 1000000 << "Mbps";
            break;
        case RateControlMode::VBR:
            std::cout << "VBR " << config_.bitrate / 1000000 << "Mbps";
            break;
        case RateControlMode::CRF:
            std::cout << "CRF " << config_.crf;
            break;
    }
    std::cout << std::endl;
    
    return true;
}

bool VideoEncoder::Encode(AVFrame* frame) {
    if (!ctx_) return false;
    
    // 发送帧到编码器
    int ret = avcodec_send_frame(ctx_, frame);
    if (ret < 0 && ret != AVERROR_EOF) {
        return false;
    }
    
    // 接收编码后的包
    AVPacket* pkt = av_packet_alloc();
    while (ret >= 0) {
        ret = avcodec_receive_packet(ctx_, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            break;
        }
        if (ret < 0) {
            break;
        }
        
        // 更新统计
        stats_.frames_encoded++;
        stats_.bytes_encoded += pkt->size;
        bool is_keyframe = (pkt->flags & AV_PKT_FLAG_KEY) != 0;
        if (is_keyframe) {
            stats_.keyframes++;
        }
        
        // 计算平均码率
        int64_t elapsed = av_gettime() - start_time_;
        if (elapsed > 0) {
            stats_.avg_bitrate = stats_.bytes_encoded * 8.0 * 1000000.0 / elapsed;
        }
        
        // 回调
        if (on_packet_) {
            on_packet_(pkt->data, pkt->size, pkt->pts, is_keyframe);
        }
        
        av_packet_unref(pkt);
    }
    av_packet_free(&pkt);
    
    return true;
}

} // namespace live

// 编码器初始化时记录基准时间
int64_t base_pts_us = av_gettime();  // 微秒

// 每帧编码时计算 pts
int64_t CalculatePTS() {
    int64_t now_us = av_gettime();
    int64_t elapsed_ms = (now_us - base_pts_us) / 1000;  // 转毫秒
    
    // 视频：90kHz 时间基
    return elapsed_ms * 90 / 1000;
}

// 音频：按采样点计算
int64_t CalculateAudioPTS(int64_t sample_count, int sample_rate) {
    return sample_count * 1000 / sample_rate;  // 毫秒
}

// 视频
static int64_t frame_count = 0;
int64_t pts = frame_count * (90000 / fps);  // 假设恒定帧率
frame_count++;

// 问题：如果实际帧率波动，音画会不同步

class TimestampGenerator {
public:
    void Init(int video_fps, int audio_sample_rate) {
        base_us_ = av_gettime();
        video_fps_ = video_fps;
        audio_sample_rate_ = audio_sample_rate;
    }
    
    int64_t GetVideoPTS() {
        int64_t elapsed_ms = (av_gettime() - base_us_) / 1000;
        return elapsed_ms * 90 / 1000;  // 90kHz
    }
    
    int64_t GetAudioPTS(int samples) {
        audio_samples_ += samples;
        return audio_samples_ * 1000 / audio_sample_rate_;  // 毫秒
    }
    
private:
    int64_t base_us_ = 0;
    int video_fps_ = 30;
    int audio_sample_rate_ = 48000;
    int64_t audio_samples_ = 0;
};

#include <librtmp/rtmp.h>
#include <string>
#include <iostream>

class RTMPPublisher {
public:
    bool Connect(const std::string& url) {
        rtmp_ = RTMP_Alloc();
        RTMP_Init(rtmp_);
        
        // 解析 URL
        if (!RTMP_SetupURL(rtmp_, (char*)url.c_str())) {
            std::cerr << "[RTMP] Failed to setup URL" << std::endl;
            return false;
        }
        
        // 启用写模式（推流）
        RTMP_EnableWrite(rtmp_);
        
        // 连接服务器
        if (!RTMP_Connect(rtmp_, nullptr)) {
            std::cerr << "[RTMP] Failed to connect" << std::endl;
            return false;
        }
        
        // 连接流
        if (!RTMP_ConnectStream(rtmp_, 0)) {
            std::cerr << "[RTMP] Failed to connect stream" << std::endl;
            return false;
        }
        
        std::cout << "[RTMP] Connected to " << url << std::endl;
        connected_ = true;
        return true;
    }
    
    bool SendVideo(const uint8_t* data, size_t size, int64_t pts, bool keyframe) {
        if (!connected_) return false;
        
        auto tag = CreateVideoTag(data, size, pts, keyframe);
        
        RTMPPacket packet;
        RTMPPacket_Reset(&packet);
        RTMPPacket_Alloc(&packet, tag.size());
        
        memcpy(packet.m_body, tag.data(), tag.size());
        packet.m_packetType = 0x09;  // 视频
        packet.m_nChannel = 0x04;    // 视频通道
        packet.m_nTimeStamp = pts;
        packet.m_hasAbsTimestamp = 0;
        packet.m_nBodySize = tag.size();
        packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
        
        int ret = RTMP_SendPacket(rtmp_, &packet, 0);
        RTMPPacket_Free(&packet);
        
        return ret > 0;
    }
    
    void Disconnect() {
        if (rtmp_) {
            RTMP_Close(rtmp_);
            RTMP_Free(rtmp_);
            rtmp_ = nullptr;
        }
        connected_ = false;
    }
    
    ~RTMPPublisher() {
        Disconnect();
    }

private:
    RTMP* rtmp_ = nullptr;
    bool connected_ = false;
};

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <rtmp_url>" << std::endl;
        std::cerr << "Example: rtmp://localhost/live/stream" << std::endl;
        return 1;
    }
    
    std::string rtmp_url = argv[1];
    
    // 初始化编码器
    live::EncoderConfig config;
    config.width = 1280;
    config.height = 720;
    config.fps = 30;
    config.bitrate = 4 * 1000 * 1000;  // 4 Mbps
    config.rc_mode = live::RateControlMode::CBR;
    config.preset = "fast";
    
    live::VideoEncoder encoder(config);
    if (!encoder.Init()) {
        return 1;
    }
    
    // 连接 RTMP
    RTMPPublisher publisher;
    if (!publisher.Connect(rtmp_url)) {
        return 1;
    }
    
    // 设置编码回调
    encoder.SetCallback([&publisher](const uint8_t* data, size_t size,
                                        int64_t pts, bool keyframe) {
        if (!publisher.SendVideo(data, size, pts, keyframe)) {
            std::cerr << "[RTMP] Failed to send video" << std::endl;
        }
    });
    
    // 分配测试帧
    AVFrame* frame = av_frame_alloc();
    frame->format = AV_PIX_FMT_YUV420P;
    frame->width = config.width;
    frame->height = config.height;
    av_frame_get_buffer(frame, 32);
    
    // 推流循环
    std::cout << "[Main] Starting stream..." << std::endl;
    int64_t frame_count = 0;
    int64_t start_time = av_gettime();
    
    while (frame_count < 30 * 60) {  // 推流 1 分钟
        // 生成测试帧
        GenerateTestFrame(frame->data[0], config.width, config.height, frame_count);
        frame->pts = frame_count;
        
        // 编码并推流
        encoder.Encode(frame);
        
        frame_count++;
        
        // 控制帧率
        int64_t expected_time = start_time + (frame_count * 1000000LL / config.fps);
        int64_t now = av_gettime();
        if (expected_time > now) {
            av_usleep(expected_time - now);
        }
        
        // 打印统计
        if (frame_count % 30 == 0) {
            auto stats = encoder.GetStats();
            std::cout << "[Main] " << frame_count / 30 << "s, "
                      << "frames=" << stats.frames_encoded << ", "
                      << "bitrate=" << std::fixed << std::setprecision(2)
                      << stats.avg_bitrate / 1000000.0 << " Mbps"
                      << std::endl;
        }
    }
    
    // 冲刷
    encoder.Encode(nullptr);
    
    // 清理
    av_frame_free(&frame);
    publisher.Disconnect();
    
    std::cout << "[Main] Stream finished" << std::endl;
    return 0;
}

// 启用多线程
AVDictionary* opts = nullptr;
av_dict_set(&opts, "threads", "4", 0);  // 使用 4 线程

// 或者自动检测
av_dict_set(&opts, "threads", "0", 0);  // 0 = 自动

// 硬编码零拷贝流程
摄像头 → GPU 内存
    ↓
GPU 编码（NVENC/VideoToolbox）
    ↓
GPU 内存直接封装 → RTMP
（无需复制到 CPU 内存）

av_dict_set(&opts, "tune", "zerolatency", 0);
av_dict_set(&opts, "profile", "baseline", 0);  // 无 B 帧
ctx->gop_size = config.fps;  // 1 秒一个 I 帧

// 直播推荐配置
preset = "veryfast"  // 速度优先
rc_mode = CBR        // 恒定码率
gop_size = fps * 2   // 2 秒一个 I 帧