论播放器的自我修养——客户端篇

RinzePlayer/
├─ main.cpp                    // 入口：QApplication + MainWindow 装配
├─ core/       MediaController            // 播放编排中枢（唯一对外控制面）
├─ demux/      Demux                      // FFmpeg 解封装线程 + 低延迟参数配置
├─ decode/     DecodeBase（抽象）          // 解码基类：线程/队列/序列号/EOF
│           ├─ DecodeVideo   // FFmpeg filter graph + libplacebo(Vulkan) 路径
│           ├─ DecodeAudio
│           └─ DecodeSubtitle
├─ renderer/   VideoPlayer / AudioPlayer  // 帧消费：节奏控制 / PCM 写入
│           ├─ VideoRenderData / SubRenderData // 渲染数据 + 原子双缓冲
│           ├─ VideoRenderer // QQuickFramebufferObject::Renderer（QML FBO 版，当前未接线）
│           └─ VideoWindow   // QML FBO item，当前未接线
├─ clock/      GlobalClock + Clock        // 三时钟（音频/视频/外部）+ 主时钟
├─ streaming/  StreamManager              // 协议识别 / 退避重连 / 缓冲监控
├─ utils/      SPSCBuffer / SPSCQueue     // 无锁环形队列（字节型 / 模板型）
│           └─ AtomicDoubleBuffer // 状态位双缓冲
├─ audioeffects/ AudioEffect（抽象）        // 效果器基类 + 工厂
│           ├─ AudioMixer    // 效果器链容器（混音器）
│           └─ effects/ equalizer · graphiceq · reverb
├─ visualizer/ FFT 频谱 + 粒子着色器
├─ ui/         MainWindow / VideoWidget / HoverControlBar / PiPWindow
│           └─ VideoWidget // QOpenGLWidget：纹理上传 / 变换 / 字幕叠加 / 运动向量
└─ resource/   shader.vert·frag（视频）· motion_vector.vert·geom·frag（运动向量）
             · visualizer_spectrum.* · visualizer_particle.*

[帧队列]->[VideoPlayer 节奏与数据准备]->[原子双缓冲发布]->[Qt 排队到 GUI 线程]->[VideoWidget::paintGL 上传纹理]->[FBO 上屏]

    // 关闭流管理器
    m_streamManager->close();

    bool ok = true;
    ok &= m_demux->uninit();
    ok &= m_decodeAudio->uninit();
    ok &= m_decodeVideo->uninit();
    ok &= m_decodeSubtitl->uninit();
    ok &= m_audioPlayer->uninit();
    ok &= m_videoPlayer->uninit();
    clearPktQ(m_pktAudioBuf);
    clearPktQ(m_pktVideoBuf);
    clearPktQ(m_pktSubtitleBuf);
    clearFrmQ(m_frmAudioBuf);
    clearFrmQ(m_frmVideoBuf);
    clearFrmQ(m_frmSubtitleBuf);
    DeviceStatus::instance().setHaveAudio(false);
    DeviceStatus::instance().setHaveVideo(false);
    GlobalClock::instance().reset();
    setOpened(false);
    m_currentVideoStream = {-1, -1};
    m_currentAudioStream = {-1, -1};
    m_currentSubtitleStream = {-1, -1};
    setPaused(true);
    setDuration(0);
    setProgress(0);
    PlaybackStats::instance().reset();
    qDebug() << "关闭";
    emit chaptersInfoUpdate();
    return ok;

/**
 * @brief 切换暂停状态
 *
 * 同时驱动视频播放器、音频播放器与全局时钟，随后更新 m_paused；
 * 若同步处于激活状态，会把本次操作（含当前位置）上报给 SyncManager。
 */
void MediaController::togglePaused() {
    if (!m_opened) {
        return;
    }
    m_videoPlayer->togglePaused();
    m_audioPlayer->togglePaused();
    GlobalClock::instance().togglePaused();
    setPaused(!m_paused);

    // Sync hook
    if (m_syncManager && m_syncManager->isSyncing()) {
        double pos = getCurrentTime();
        if (m_paused) {
            m_syncManager->onLocalPause(pos);
        } else {
            m_syncManager->onLocalPlay(pos);
        }
        if (m_roomSession) {
            // 事件已由 Server 统一记录
        }
    }
}

/**
 * @brief 执行一次 seek，不做任何上报
 * @param ts 目标位置（秒）或相对偏移
 * @param rel 相对偏移模式：0 表示绝对定位并夹到 [0, duration]，非 0 表示相对跳转
 */
void MediaController::seekInternal(double ts, double rel) {
    if (!m_opened) return;
    double safeTs = ts;
    if (rel == 0.0) {
        safeTs = std::max(0.0, std::min(safeTs, static_cast<double>(m_duration)));
    }
    m_demux->seekBySec(safeTs, rel);
}

/**
 * @brief 用户发起的 seek
 * @param ts 目标位置（秒）或相对偏移
 * @param rel 相对偏移模式，含义同 seekInternal
 * @note 只有绝对定位（rel 为 0）且同步激活时才上报，快进快退传 ±5 因此不会扩散
 */
void MediaController::seekBySec(double ts, double rel) {
    seekInternal(ts, rel);
    // 只对用户主动的绝对 seek 广播
    if (rel == 0.0 && m_syncManager && m_syncManager->isSyncing()) {
        double safeTs = std::max(0.0, std::min(ts, static_cast<double>(m_duration)));
        m_syncManager->onLocalSeek(safeTs);
    }
}

[Demux]->[Decode]->[Render]

/**
 * @brief 启动读包线程
 * @note 幂等：线程已在运行时直接返回
 */
void Demux::start() {
    if (m_thread.joinable()) {
        return; // 已经在运行了
    }
    m_stop.store(false, std::memory_order_relaxed);
    m_thread = std::thread([this]() {
        demuxLoop();
    });
}

if (m_needSeek.load(std::memory_order_acquire)) {
          	seekAllPktQueue();
            int streamIdx = m_isMainDemux ? -1 : (m_usedVIdx != -1) ? m_usedVIdx.load()
                                             : (m_usedAIdx != -1)   ? m_usedAIdx.load()
                                                                    : m_usedSIdx.load();
            double time_base = streamIdx == -1 ? 1.0 / AV_TIME_BASE : av_q2d(m_formatCtx->streams[streamIdx]->time_base);
            double target = m_seekTs / time_base;
            int64_t seekMin = m_seekRel > 0.0 ? static_cast<int64_t>(target - m_seekRel * AV_TIME_BASE + 2) : INT64_MIN;
            int64_t seekMax = m_seekRel < 0.0 ? static_cast<int64_t>(target - m_seekRel * AV_TIME_BASE - 2) : INT64_MAX;
            int ret = avformat_seek_file(m_formatCtx, streamIdx, seekMin, target, seekMax,
                                         m_usedVIdx == -1 ? AVSEEK_FLAG_ANY : 0);
            if (ret < 0) {
                qDebug() << "seek出错";
            }
            emitRealSeekTs = m_isMainDemux;
            m_needSeek.store(false, std::memory_order_release);
        }

[先清理包]->[更新流id]->[计算时间基]->[计算目标seekms{包括理论min，max}]->
[调用]avformat_seek_file(m_formatCtx, streamIdx, seekMin, target, seekMax,
                                         m_usedVIdx == -1 ? AVSEEK_FLAG_ANY : 0);
[Seek完毕：] needseek原子变量置false m_needSeek.store(false, std::memory_order_release);

	pkt = av_packet_alloc();
        int ret = av_read_frame(m_formatCtx, pkt);
        if (ret < 0) {
            if (ret == AVERROR_EOF && !m_isEOF) { // EOF
                Q_ASSERT(pkt->data == NULL && pkt->size == 0);
                pushVideoPkt(pkt);
                pkt = av_packet_alloc();
                pushSubtitlePkt(pkt);
                pkt = av_packet_alloc();
                pushAudioPkt(pkt);
                pkt = nullptr;
                qDebug() << "解复用EOF";
                m_isEOF = true;
            } else if (ret != AVERROR_EOF) { // error
                qDebug() << "解复用出错";
                goto end;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            continue;
        } else {
            m_isEOF = false;
        }

├─ decode/     
|			|- DecodeBase（抽象）          // 解码基类：线程/队列/序列号/EOF
│           ├─ DecodeVideo   // FFmpeg filter graph + libplacebo(Vulkan) 路径
│           ├─ DecodeAudio
│           └─ DecodeSubtitle

	// 错误处理已省略。
	m_streamIdx = stream->index;
    m_codecCtx = avcodec_alloc_context3(nullptr);
    if (!m_codecCtx) {
        qDebug() << "解码器上下文分配失败";
        return false;
    }

    int ret = avcodec_parameters_to_context(m_codecCtx, stream->codecpar);
    if (ret < 0) {
        avcodec_free_context(&m_codecCtx);
    }

    m_codec = avcodec_find_decoder(stream->codecpar->codec_id);
    if (!m_codec) {
        qDebug() << "无合适的解码器";
        return false;
    }

    m_codecCtx->pkt_timebase = stream->time_base;
    m_codecCtx->codec_id = m_codec->id;

    // 设置低延迟标志
    if (m_lowLatencyMode) {
        m_codecCtx->flags |= AV_CODEC_FLAG_LOW_DELAY;
    }


    ret = avcodec_open2(m_codecCtx, m_codec, &opts);
    av_dict_free(&opts);

    if (!pktBuf) {
        qDebug() << "无效pkt队列";
        return false;
    }
    if (!frmBuf) {
        qDebug() << "无效frm队列";
        return false;
    }

    m_pktBuf = pktBuf;
    m_frmBuf = frmBuf;
    m_time_base = stream->time_base;
    m_isEOF = false;
    m_serial = 0;
    return true;

void DecodeBase::start() {
    if (!m_initialized || m_thread.joinable()) {
        return; // 已经在运行了
    }
    m_stop.store(false, std::memory_order_relaxed);
    m_thread = std::thread([this]() {
        decodingLoop();
    });
}

renderer/   VideoPlayer / AudioPlayer  // 帧消费：节奏控制 / PCM 写入
│           ├─ VideoRenderer 			// QML FBO 版渲染实现（当前未接线）
│           ├─ VideoWindow   			// QML FBO item（当前未接线）
│           └─ VideoRenderData / SubRenderData // 渲染数据 + 原子双缓冲
ui/         VideoWidget                     // QOpenGLWidget：纹理上传 / 变换 / 字幕叠加（实际使用）

struct VideoRenderData {
    enum PixFormat {
        // 可直接上传opengl，通过GLPara获取参数
        NONE = -1,
        RGB_PACKED,
        RGBA_PACKED,

        // 以下类型每个分量独占一个平面
        RGB_PLANAR,
        RGBA_PLANAR,
        Y,
        YA,
        YUV,
        YUVA,
    };

    /**
     * 用于直接上传OpengGL的参数
     * 依次为：internalformat，format，type
     */
    inline static std::map<AVPixelFormat, std::array<unsigned int, 3>> GLParaMap{
        {AV_PIX_FMT_RGB24, {GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE}},                        ///< packed RGB 8:8:8, 24bpp, RGBRGB...
        {AV_PIX_FMT_BGR24, {GL_RGB8, GL_BGR, GL_UNSIGNED_BYTE}},                        ///< packed RGB 8:8:8, 24bpp, BGRBGR...
        {AV_PIX_FMT_BGR8, {GL_R3_G3_B2, GL_RGB, GL_UNSIGNED_BYTE_2_3_3_REV}},           
       // 很多种色彩类型，省略了
    };

    AVFrmItem frmItem;
    double renderedTime; // 实际渲染到FBO的时间(相对现实时间，秒)

    PixFormat pixFormat = PixFormat::NONE;
    
    // 视频信息用于UI显示
    QString pixelFormatName;
    QString colorRangeName;
    QString colorSpaceName;

    // 每个分量按Y|YA|YUV|YUVA|RGB|RGBA的顺序依次排列
    std::vector<std::vector<uint16_t>> dst16{4};
    uint8_t componentBitSize[4]{0, 0, 0, 0}; // 分量的大小(bit)
    // 以下三个数组为OpenGL初始化和更新纹理使用
    std::array<unsigned int, 3> GLParaArr[4]{};
    QSize componentSizeArr[4]{};
    uint8_t *dataArr[4]{};
    int linesizeArr[4]{}; // 每行实际存储的像素数 = [有效 + 填充]
    int alignment = 1;    // 内存中每个像素行起始处的对齐要求(1,2,4,8)
    
    // 更新每一帧的像素数据（sws_scale转换）
    void updateFrameData();
    void reset();
    void updateGLParaArr(VideoRenderData::PixFormat fmt);


    VideoRenderData() { reset(); }
    ~VideoRenderData() {
        if (!frmItem.frm) {
            av_frame_free(&frmItem.frm);
        }
    }
};

enum PixFormat {
        // 可直接上传opengl，通过GLPara获取参数
        NONE = -1,
        RGB_PACKED,
        RGBA_PACKED,

        // 以下类型每个分量独占一个平面
        RGB_PLANAR,
        RGBA_PLANAR,
        Y,
        YA,
        YUV,
        YUVA,
    };

  std::array<unsigned int, 3> GLParaArr[4]{};
    QSize componentSizeArr[4]{};
    uint8_t *dataArr[4]{};
    int linesizeArr[4]{}; // 每行实际存储的像素数 = [有效 + 填充]
    int alignment = 1;    // 内存中每个像素行起始处的对齐要求(1,2,4,8)

    /**
     * @brief 由像素格式描述推导渲染数据的格式分类
     * @param desc 像素格式描述
     * @return 平面型像素格式分类
     * @note 该函数用于辅助updateFrm函数，使用时确保排除了RGB_PACKED,RGBA_PACKED，每个平面都是独立的
     */
    VideoRenderData::PixFormat desc2PixFormat(const AVPixFmtDescriptor *desc) {
        if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
            return (desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? VideoRenderData::RGBA_PLANAR : VideoRenderData::RGB_PLANAR;
        }

        if (desc->flags & AV_PIX_FMT_FLAG_ALPHA) {
            return desc->nb_components == 2 ? VideoRenderData::YA : VideoRenderData::YUVA;
        }

        return desc->nb_components == 1 ? VideoRenderData::Y : VideoRenderData::YUV;
    }

    /**
     * @brief 把色彩空间枚举转成可读文本
     * @param colorSpace AVColorSpace 取值
     * @return 名称字符串，未收录的取值返回 "Unknown"
     * @note 当前调用点在 updateFormat() 中被注释掉，保留备用
     */
    const char* colorSpaceToString(int colorSpace) {
        switch(colorSpace) {
            case AVCOL_SPC_RGB: return "RGB";
            case AVCOL_SPC_BT709: return "BT.709";
            case AVCOL_SPC_UNSPECIFIED: return "Unspecified";
            case AVCOL_SPC_BT470BG: return "BT.470BG";
            case AVCOL_SPC_SMPTE170M: return "SMPTE 170M";
            case AVCOL_SPC_SMPTE240M: return "SMPTE 240M";
            case AVCOL_SPC_YCGCO: return "YCGCO";
            case AVCOL_SPC_BT2020_NCL: return "BT.2020 NCL";
            case AVCOL_SPC_BT2020_CL: return "BT.2020 CL";
            case AVCOL_SPC_SMPTE2085: return "SMPTE 2085";
            case AVCOL_SPC_CHROMA_DERIVED_NCL: return "Chroma Derived NCL";
            case AVCOL_SPC_CHROMA_DERIVED_CL: return "Chroma Derived CL";
            case AVCOL_SPC_ICTCP: return "ICTCP";
            default: return "Unknown";
        }
    }

    if (GLParaMap.find(avFmt) != GLParaMap.end()) {
        pixFormat = (flags & AV_PIX_FMT_FLAG_ALPHA) ? PixFormat::RGBA_PACKED : PixFormat::RGB_PACKED;
        GLParaArr[0] = GLParaMap[avFmt];
        componentSizeArr[0] = {frm->width, frm->height};
        dataArr[0] = frm->data[0];
        int bytes_per_pixel = (av_get_padded_bits_per_pixel(desc) / 8);
        linesizeArr[0] = frm->linesize[0] / bytes_per_pixel;
        alignment = getAlignment(dataArr[0], linesizeArr[0] * bytes_per_pixel, frm->linesize[0]);
        return;
    }

    if (flags & AV_PIX_FMT_FLAG_BE || flags & AV_PIX_FMT_FLAG_BAYER ||
        flags & AV_PIX_FMT_FLAG_BITSTREAM || flags & AV_PIX_FMT_FLAG_PAL ||
        flags & AV_PIX_FMT_FLAG_XYZ) {
        splitFrameComponentsToPlanes(desc);
        updateGLParaArr(pixFormat);
        return;
    }

            for (int j = 0; j < desc->nb_components; ++j) {
                for (auto &x : dst16[j])
                    x <<= (16 - desc->comp[j].depth); // 从[0,2^bits-1)映射到[0,2^16-1),精度比纯数学方法稍差
            }

            if (!(desc->flags & AV_PIX_FMT_FLAG_RGB) && (i == 1 || i == 2)) {
                componentSizeArr[i] = {AV_CEIL_RSHIFT(frm->width, desc->log2_chroma_w), AV_CEIL_RSHIFT(frm->height, desc->log2_chroma_h)};
            }

    for (int y = 0; y < height; ++y) {
        void *line_ptr = (uint8_t *)plane_ptr + y * width * dst_element_size;
        av_read_image_line2(line_ptr, frmData, linesize, desc, 0, y, c, width, read_pal_component, dst_element_size);
    }

    m_videoRenderData.write([&](VideoRenderData &renData, [[maybe_unused]] int idx) -> bool {
        m_lastVideoFrameInterval = nowVideoFrameInterval;
        renData.updateFormat(videoFrmitem);
        return true;
    }, false);

    AVFrmItem tmpItem;
    bool peekOk = m_frmBuf->peekFirst(tmpItem);

    nowTime = getRelativeSeconds();
    if (!peekOk || nowTime <= m_renderTime + getDuration(nowVideoFrameInterval, qMakePair(tmpItem.pts, tmpItem.duration))) {
        m_videoRenderData.release();
        m_subRenderData.release();
        emit renderDataReady(&m_videoRenderData, &m_subRenderData);
    } else {
        PlaybackStats::instance().droppedFrameCount++;
    }

    double diff = GlobalClock::instance().videoPts() - GlobalClock::instance().getMainPts();
    double syncThreshold = std::max(0.004, std::min(0.01, delay));
    if (!std::isnan(diff) && std::abs(diff) < maxFrameDuration) {
        if (diff <= -syncThreshold) { // 落后太多，尝试直接播放
            PlaybackStats::instance().lateFrameCount++;
            delay = std::max(0.0, delay + diff);
        } else if (diff >= syncThreshold) { // 领先太多
            PlaybackStats::instance().earlyFrameCount++;
            delay = delay + (delay > 0.1 ? diff : delay);
        }
    }

using VideoDoubleBuf = AtomicDoubleBuffer<VideoRenderData>;
using SubtitleDoubleBuf = AtomicDoubleBuffer<SubRenderData>;

    /**
     * 原子状态位:
     * bit 0: latest_idx (0 或 1) -> 标记哪一个是最新写完的
     * bit 1: buf0_busy  (1 为忙) -> 读线程正在读 buffers[0]
     * bit 2: buf1_busy  (1 为忙) -> 读线程正在读 buffers[1]
     * bit 3: empty      (0 为空) -> 两个buffers都没准备好
     */

    // 如果读线程正锁着要写的那个，则“等一会”
    while (m_state.load(std::memory_order_acquire) & targetBusyBit) {
        std::this_thread::yield();
    }

void VideoWidget::updateRenderData(VideoDoubleBuf *vidData, SubtitleDoubleBuf *subData) {
    m_vidData = vidData;
    m_subData = subData;
    update();
}

    auto uploadTexture = [&](int pos, GLenum textureOffset) {
        glActiveTexture(GL_TEXTURE0 + textureOffset);
        glBindTexture(GL_TEXTURE_2D, m_texArr[textureOffset]);
        glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
        glPixelStorei(GL_UNPACK_ROW_LENGTH, linesizeArr[pos]); // 一行存储的像素个数 [用于显示的像素个数] + [用于填充的像素个数(这部分需要丢弃)]
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                        componentSizeArr[pos].width(), componentSizeArr[pos].height(),
                        GLParaArr[pos][1], GLParaArr[pos][2],
                        dataArr[pos]);
    };

struct AVPktItem {
    AVPacket *pkt = nullptr;
    int serial = 0;
};

struct AVFrmItem {
    AVFrame *frm = nullptr;
    AVSubtitle sub{};
    int width{0}, height{0}; // 目前仅用于表示字幕的分辨率大小
    int serial = 0;
    double pts = INVALID_DOUBLE;
    double duration = INVALID_DOUBLE;
};

clock/      GlobalClock + Clock        // 三时钟（音频/视频/外部）+ 主时钟

void Clock::setClock(double pts, double time) {
    m_updatePts = pts;
    m_updateTime = time;
}

void Clock::setClock(double pts) {
    setClock(pts, getRelativeSeconds());
}

double Clock::getPts() {
    if (m_paused) {
        return m_updatePts;
    } else {
        return m_updatePts + (getRelativeSeconds() - m_updateTime) * m_speed;
    }
}

double getRelativeSeconds() {
    auto nowTime = std::chrono::steady_clock::now();
    // Target 时间点约莫是系统启动时间点
    return std::chrono::duration<double>(nowTime.time_since_epoch()).count();
}

void Clock::setSpeed(double newSpeed) {
    setClock(getPts()); // 保证从时钟更新起点 到 当前时间点都是以这个速度运行的
    m_speed = newSpeed;
}

void Clock::togglePaused() {
    setClock(getPts());
    m_paused = !m_paused;
}

GlobalClock::GlobalClock()
    : m_mainClockType(ClockType::AUDIO),
      m_audioClk(ClockType::AUDIO), m_videoClk(ClockType::VIDEO),
      m_externalClk(ClockType::EXTERNAL), m_maxFrameDuration(10.0) {
}

double GlobalClock::getMainPts() {
    switch (m_mainClockType) {
    case ClockType::AUDIO:
        return m_audioClk.getPts();
    case ClockType::VIDEO:
        return m_videoClk.getPts();
    case ClockType::EXTERNAL:
        return m_externalClk.getPts();
    default:
        return INVALID_DOUBLE;
    }
}

        GlobalClock::instance().reset();
        // 有音频时主时钟为Audio，否则为Video
        GlobalClock::instance().setMainClockType(haveAudio ? ClockType::AUDIO : ClockType::VIDEO);

void Clock::syncToClock(Clock &clk) {
    double nowPts = getPts();
    double newPts = clk.getPts();
    if (!std::isnan(newPts) && (std::isnan(nowPts) || std::abs(newPts - nowPts) > 10.0)) {
        setClock(newPts);
    }
}

void GlobalClock::reset() {
    m_videoClk.setClock(INVALID_DOUBLE);
    m_audioClk.setClock(INVALID_DOUBLE);
    m_externalClk.setClock(INVALID_DOUBLE);
    m_videoClk.m_speed = m_audioClk.m_speed = m_externalClk.m_speed = 1.0;
    m_videoClk.m_paused = m_audioClk.m_paused = m_externalClk.m_paused = false;
}

    double offsetPts = buffer->readAvailable() / bytesPerSec; // 未播的时间
    GlobalClock::instance().setAudioClk(nextPtr - offsetPts);

    // 更新视频时钟
    GlobalClock::instance().setVideoClk(videoFrmitem.pts);
    GlobalClock::instance().syncExternalClk(ClockType::VIDEO);

            double seekedPts = pkt->pts * av_q2d(m_formatCtx->streams[pkt->stream_index]->time_base);
            // 提前设置一下时钟，能比较好的避免出现视频pts先更新且落后与音频，导致视频疯狂更新，然后音频再更新，导致视频领先与音频，最后导致视频变卡一会儿
            GlobalClock::instance().setAudioClk(seekedPts);
            GlobalClock::instance().setVideoClk(seekedPts);
            emit seeked(seekedPts);

    double diff = GlobalClock::instance().videoPts() - GlobalClock::instance().getMainPts();
    double syncThreshold = std::max(0.004, std::min(0.01, delay));

int MediaController::getCurrentTime() const {
    double ptsSecond = GlobalClock::instance().getMainPts();
    int res = std::isnan(ptsSecond) ? 0 : static_cast<int>(ptsSecond);
    // 确保时间在0到duration范围内
    return std::max(0, std::min(res, m_duration));
}

StreamProtocol StreamManager::detectProtocol(const QUrl& url) {
    QString scheme = url.scheme().toLower();
    QString path = url.path().toLower();

    if (scheme == "rtmp" || scheme == "rtmps" || scheme == "rtmpte" || scheme == "rtmpt") {
        return StreamProtocol::RTMP;
    } else if (scheme == "rtsp" || scheme == "rtsps") {
        return StreamProtocol::RTSP;
    } else if (path.endsWith(".m3u8") || scheme == "http" || scheme == "https") {
        // HLS 通常是 m3u8，也可能是 http/https 直播流
        return StreamProtocol::HLS;
    } else if (url.isLocalFile() || scheme.isEmpty()) {
        return StreamProtocol::LocalFile;
    }
    return StreamProtocol::Unknown;
}

bool StreamManager::open(const QUrl& url) {
    m_currentUrl = url;
    m_stats.reset();
    m_stats.url = url.toString();
    m_stats.protocol = detectProtocol(url);
    ...
    setState(StreamState::Connecting);
    m_stats.connectionAttempts++;
    m_backoff->reset();
    m_connectTimer.start();

    // 缓冲监控启动
    m_bufferMonitorTimer->start();

    return true;
}

        ok &= m_demux->init(openPath.toUtf8().constData(), true);
        if (!ok) {
            ...
            m_streamManager->onDemuxError("Failed to initialize demux for: " + openPath);
            close();
            return false;
        }

        m_streamManager->onDemuxConnected();

void StreamManager::setState(StreamState state) {
    if (m_stats.state == state) return;

    StreamState oldState = m_stats.state;
    m_stats.state = state;
    ...
    emit stateChanged(oldState, state);

    // 处理状态变化的特殊逻辑
    if (state == StreamState::Buffering) {
        emit bufferingStarted();
    } else if (oldState == StreamState::Buffering && 
               (state == StreamState::Playing || state == StreamState::Paused)) {
        emit bufferingEnded();
    }

    if (state == StreamState::Connected) {
        emit connected();
    } else if (state == StreamState::Error) {
        emit error(m_stats.lastErrorMsg);
    }
}

void StreamManager::onDemuxConnected() {
    m_backoff->onSuccess();
    setState(StreamState::Connected);

    // 检查是否需要缓冲
    if (m_config.preBufferSizeMB > 0) {
        setState(StreamState::Buffering);
    } else {
        emit readyToPlay();
    }

    updateStatsFromDemux();
}

void StreamManager::startReconnect() {
    if (m_backoff->hasReachedMaxRetries()) {
        m_stats.lastErrorMsg = "Maximum retry attempts reached";
        setState(StreamState::Error);
        emit connectionFailed(m_stats.lastErrorMsg);
        return;
    }

    setState(StreamState::Reconnecting);
    emit reconnecting(m_backoff->getRetryCount() + 1, m_config.maxRetryCount);

    m_backoff->onFailure();
    m_backoff->scheduleNextRetry([this]() {
        performReconnect();
    });
}

void StreamManager::performReconnect() {
    if (m_isShuttingDown) return;
    ...
    setState(StreamState::Connecting);
    m_stats.connectionAttempts++;

    // 实际重连逻辑应该触发Demux重新连接
    if (m_demux) {
        // 这里可以添加实际重连调用
    }
}

void StreamManager::onDemuxError(const QString& error) {
    ...
    if (m_stats.protocol == StreamProtocol::LocalFile) {
        setState(StreamState::Error);
    } else {
        // 网络流错误，尝试重连
        startReconnect();
    }
}

double StreamManager::calculateEstimatedBufferMB() {
    ...
    if (m_stats.bitrateKbps > 0) {
        // 按 bitrate 估算，假设缓冲了 0.5秒的数据
        double bits = m_stats.bitrateKbps * 500.0;
        estimatedMB = bits / (8.0 * 1024.0 * 1024.0);
    } else {
        // 默认预估值
        estimatedMB = m_config.preBufferSizeMB;
    }

    return estimatedMB;
}

    // 检查是否需要缓冲
    bool needsBuffer = !hasEnoughBuffer();
    if (needsBuffer && !m_stats.isBuffering && m_stats.state == StreamState::Playing) {
        m_stats.isBuffering = true;
        setState(StreamState::Buffering);
    } else if (!needsBuffer && m_stats.isBuffering) {
        m_stats.isBuffering = false;
        if (m_stats.state == StreamState::Buffering) {
            setState(StreamState::Playing);
        }
    }

void StreamManager::seek(double positionSec) {
    m_debounce->debounce("seek", [this, positionSec]() {
        qDebug() << "Seek to:" << positionSec << "s";
        if (m_demux) {
            m_demux->seekBySec(positionSec, 0.0);
        }
    });
}

struct StreamingConfig {
    // 指数退避参数
    double initialIntervalMs = 1000.0;        // 初始重试间隔(ms)
    double backoffFactor = 2.0;              // 退避因子
    double maxIntervalMs = 30000.0;          // 最大重试间隔(ms)
    int maxRetryCount = 5;                  // 最大重试次数

    // 缓冲配置 (MB)
    double preBufferSizeMB = 2.0;           // 预缓冲大小
    double minBufferThresholdMB = 0.5;      // 最小缓冲阈值

    // 播放控制防抖(ms)
    int debounceTimeMs = 300;               // 防抖间隔

    // 目标延迟(秒) - 尽量控制
    double maxLatencySec = 3.0;
};