22、音视频拉流与播放：实现RTMP/RTSP拉流播放器，处理网络抖动与缓冲策略。

说实话，拉流播放器这块，我踩过的坑比写过的代码还多。你想想看，一个播放器在本地跑得飞起，一上公网就卡成幻灯片，这种体验我太熟悉了。今天咱们就聊聊怎么把RTMP和RTSP的拉流播放器做扎实，重点解决网络抖动和缓冲策略这两个老大难问题。

22.1 拉流协议的选择与对比

先说说协议选型。RTMP和RTSP，这两个名字大家都不陌生，但实际用起来差别挺大。

特性	RTMP	RTSP
传输层	TCP（长连接）	TCP/UDP（RTP）
延迟	2-5秒（典型）	0.5-2秒（UDP模式）
抗丢包	强（TCP重传）	弱（UDP丢包不重传）
适用场景	直播、点播	监控、实时通信
防火墙友好	一般（1935端口）	较差（端口范围大）

我个人习惯是：公网直播用RTMP，局域网低延迟用RTSP。为什么？RTMP基于TCP，虽然延迟高一点，但网络抖动时不会丢帧，用户体验更稳定。RTSP走UDP的话，一旦网络波动，画面直接花掉，这在监控场景还能忍，直播就完全不行了。

22.2 拉流播放器的核心架构

一个靠谱的拉流播放器，内部其实是个流水线。我画了张图，你看一眼就明白了：

你看，整个流水线里，缓冲队列是核心枢纽。它既要吸收网络抖动，又要给解码器提供稳定的数据流。说白了，缓冲策略的好坏，直接决定了播放器的体验。

22.3 网络抖动检测与处理

网络抖动，说白了就是数据包到达时间忽快忽慢。我在项目里遇到过最夸张的情况：同一路RTMP流，有时候延迟200ms，有时候突然飙到3秒。如果不处理，播放器就会一会儿快进一会儿卡顿。

22.3.1 抖动检测算法

我常用的方法是滑动窗口RTT估算。代码实现起来其实不复杂：

class JitterDetector {
public:
    JitterDetector(int window_size = 50) 
        : window_size_(window_size) {}
    
    void AddSample(int64_t rtt_ms) {
        samples_.push_back(rtt_ms);
        if (samples_.size() > window_size_) {
            samples_.pop_front();
        }
        // 计算加权移动平均
        double sum = 0.0;
        double weight_sum = 0.0;
        int idx = 0;
        for (auto& s : samples_) {
            double w = 1.0 + idx * 0.1;  // 越新的样本权重越大
            sum += s * w;
            weight_sum += w;
            idx++;
        }
        avg_rtt_ = sum / weight_sum;
        
        // 计算抖动值（标准差）
        double var = 0.0;
        for (auto& s : samples_) {
            double diff = s - avg_rtt_;
            var += diff * diff;
        }
        jitter_ = std::sqrt(var / samples_.size());
    }
    
    double GetJitter() const { return jitter_; }
    double GetAvgRTT() const { return avg_rtt_; }
    
private:
    int window_size_;
    std::deque<int64_t> samples_;
    double avg_rtt_ = 0.0;
    double jitter_ = 0.0;
};

22.3.2 基于抖动的缓冲调整

检测到抖动之后，怎么调整缓冲？我总结了一套三级阈值策略：

抖动等级	抖动值范围	缓冲策略
低抖动	jitter < 50ms	保持当前缓冲深度，正常播放
中抖动	50ms ≤ jitter < 200ms	增加缓冲深度到1.5倍，降低播放速度5%
高抖动	jitter ≥ 200ms	缓冲深度翻倍，暂停播放直到缓冲满

嗯，这里要注意：降低播放速度不是直接改采样率，而是通过丢帧或重复帧来实现。音频这块尤其小心，直接变速会导致音调变化，听起来很怪。

22.4 缓冲策略的工程实现

缓冲策略，说白了就是在延迟和流畅之间找平衡。我见过很多新手直接把缓冲设成固定值，比如2秒。结果网络一波动，要么卡死要么延迟越来越大。

22.4.1 自适应缓冲队列

我推荐用环形缓冲区 + 水位线控制的方案。代码大概长这样：

class AdaptiveBuffer {
public:
    AdaptiveBuffer(size_t capacity = 300)  // 默认300帧
        : capacity_(capacity) {
        buffer_.resize(capacity_);
    }
    
    bool PushFrame(const MediaFrame& frame) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (IsFull()) {
            // 缓冲满了，根据策略决定是否丢帧
            if (drop_policy_ == DropPolicy::kDropOldest) {
                PopFrame();  // 丢掉最老的帧
            } else {
                return false;  // 阻塞等待
            }
        }
        buffer_[write_pos_] = frame;
        write_pos_ = (write_pos_ + 1) % capacity_;
        size_++;
        return true;
    }
    
    bool PopFrame(MediaFrame& frame) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (IsEmpty()) return false;
        
        frame = buffer_[read_pos_];
        read_pos_ = (read_pos_ + 1) % capacity_;
        size_--;
        return true;
    }
    
    // 动态调整缓冲深度
    void AdjustDepth(double target_ms) {
        size_t target_frames = target_ms / frame_duration_ms_;
        if (target_frames > capacity_) {
            capacity_ = target_frames * 1.2;  // 留20%余量
            buffer_.resize(capacity_);
        }
    }
    
private:
    std::vector<MediaFrame> buffer_;
    size_t read_pos_ = 0;
    size_t write_pos_ = 0;
    size_t size_ = 0;
    size_t capacity_;
    double frame_duration_ms_ = 33.0;  // 默认30fps
    DropPolicy drop_policy_ = DropPolicy::kDropOldest;
};

22.4.2 丢帧策略的选择

丢帧这事儿，说起来简单做起来难。我总结了几种策略：

• 丢旧帧（推荐）：缓冲区满时丢弃最老的帧。优点是延迟可控，缺点是画面会跳变。
• 丢新帧：丢弃最新的帧。优点是画面连续，缺点是延迟会越来越大。
• 关键帧保护：永远不丢I帧，只丢P/B帧。画面质量有保障，但实现复杂。

我个人习惯用丢旧帧 + 关键帧保护的组合。为什么？你想想看，用户宁可看到画面跳一下，也不愿意看到延迟越来越大。而且保护关键帧能保证画面不会花掉。

22.5 实战：RTMP拉流播放器核心代码

说了这么多理论，咱们来点实际的。下面是一个简化版的RTMP拉流播放器核心逻辑：

class RTMPPlayer {
public:
    bool Init(const std::string& url) {
        // 初始化FFmpeg
        avformat_network_init();
        
        // 打开RTMP流
        AVDictionary* opts = nullptr;
        av_dict_set(&opts, "rtmp_buffer_size", "1024", 0);
        av_dict_set(&opts, "rtmp_live", "live", 0);
        
        if (avformat_open_input(&fmt_ctx_, url.c_str(), nullptr, &opts) != 0) {
            return false;
        }
        
        // 查找流信息
        avformat_find_stream_info(fmt_ctx_, nullptr);
        
        // 初始化缓冲队列
        buffer_.reset(new AdaptiveBuffer(300));
        jitter_detector_.reset(new JitterDetector(50));
        
        return true;
    }
    
    void Start() {
        running_ = true;
        // 启动拉流线程
        pull_thread_ = std::thread([this]() { PullThreadFunc(); });
        // 启动播放线程
        play_thread_ = std::thread([this]() { PlayThreadFunc(); });
    }
    
private:
    void PullThreadFunc() {
        AVPacket pkt;
        while (running_) {
            int ret = av_read_frame(fmt_ctx_, &pkt);
            if (ret < 0) {
                // 读取失败，可能是网络问题
                HandleNetworkError();
                continue;
            }
            
            // 记录到达时间，用于抖动检测
            int64_t now = av_gettime_relative() / 1000;
            jitter_detector_->AddSample(now - last_pkt_time_);
            last_pkt_time_ = now;
            
            // 根据抖动调整缓冲深度
            double jitter = jitter_detector_->GetJitter();
            if (jitter > 200) {
                buffer_->AdjustDepth(3000);  // 增加到3秒
            } else if (jitter > 50) {
                buffer_->AdjustDepth(1500);  // 增加到1.5秒
            }
            
            // 推入缓冲队列
            MediaFrame frame = ConvertPacket(pkt);
            if (!buffer_->PushFrame(frame)) {
                // 缓冲满了，丢帧
                av_packet_unref(&pkt);
            }
        }
    }
    
    void PlayThreadFunc() {
        while (running_) {
            MediaFrame frame;
            if (buffer_->PopFrame(frame)) {
                // 解码并渲染
                DecodeAndRender(frame);
            } else {
                // 缓冲为空，等待
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
        }
    }
    
    void HandleNetworkError() {
        // 重连逻辑
        static int retry_count = 0;
        if (retry_count < 3) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            avformat_close_input(&fmt_ctx_);
            Init(current_url_);
            retry_count++;
        } else {
            // 彻底失败，通知上层
            OnError("Network unreachable");
        }
    }
    
    std::unique_ptr<AdaptiveBuffer> buffer_;
    std::unique_ptr<JitterDetector> jitter_detector_;
    AVFormatContext* fmt_ctx_ = nullptr;
    std::thread pull_thread_;
    std::thread play_thread_;
    std::atomic<bool> running_{false};
    std::string current_url_;
    int64_t last_pkt_time_ = 0;
};

22.6 性能优化与避坑指南

最后分享几个实战中遇到的坑，希望能帮你少走弯路：

• 内存拷贝要尽量减少：AVPacket和AVFrame的拷贝开销很大。我习惯用引用计数或者对象池来复用内存。
• 音频和视频的缓冲要分开：音频对延迟更敏感，视频对流畅度更敏感。混在一起处理，两边都做不好。
• 别忘了处理PTS：有些RTMP流的PTS是乱的，需要做重排序。我遇到过PTS回退的情况，如果不处理，画面会来回跳。
• 日志要分级：线上环境别打太多日志，否则I/O会成为瓶颈。我一般只在抖动超过阈值时才打WARN日志。

嗯，关于拉流播放器的实现，今天就聊到这儿。缓冲策略这块，说白了就是用空间换时间，用延迟换流畅。没有银弹，只有根据实际场景不断调优。