从零理解实时视频渲染管线：纹理池、图像混合与合成输出

// lock_guard 是"自动上锁/解锁"的辅助工具：
// 它构造时自动 lock（上锁），离开作用域时自动 unlock（解锁）。
{
    std::lock_guard<std::mutex> lock(m_mutex); // 上锁，别的线程在外面等
    // ... 在这里安全地读写共享数据 ...
} // 离开这个花括号，lock_guard 析构，自动解锁

class TexturePool {
public:
    // 获取全局唯一实例（单例）
    static TexturePool& instance();

    // 生产者调用：把一帧纹理"推进"池子
    void updateTexture(const std::string& sourceId, ID3D11Texture2D* texture,
                       BufferStrategyType strategy = BufferStrategyType::SwapChain);

    // 消费者调用：从池子里"取走"最新一帧
    Microsoft::WRL::ComPtr<ID3D11Texture2D> acquireTexture(const std::string& sourceId);

    // 生命周期管理：删除某个源、清理超时未使用的纹理
    void removeSource(const std::string& sourceId);
    void cleanupUnused(long long currentTimeMs);

private:
    // 池节点：每个源对应一个缓冲 + 一个"最后访问时间"
    struct PoolNode {
        std::shared_ptr<ITextureBufferStrategy> buffer; // 具体的缓冲策略（见 3.3）
        long long lastAccessTime = 0;                   // 最后访问时间戳，用于超时回收
        BufferStrategyType strategyType;                // 用哪种策略
    };

    std::map<std::string, PoolNode> m_pool; // 键值对：id -> 节点
    std::mutex m_mutex;                     // 互斥锁，保护 m_pool 不被多线程同时改
};

class ITextureBufferStrategy {
public:
    virtual ~ITextureBufferStrategy() = default;
    virtual void push(ID3D11Texture2D* texture) = 0;                  // 存一帧
    virtual Microsoft::WRL::ComPtr<ID3D11Texture2D> peek() = 0;       // 取最新一帧
    virtual void clear() = 0;                                          // 清空
};

class SwapChainStrategy : public ITextureBufferStrategy {
public:
    void push(ID3D11Texture2D* texture) override {
        if (!texture) return;                       // 空指针直接返回，防止崩溃
        std::lock_guard<std::mutex> lock(m_mutex);  // 上锁
        m_frontBuffer = texture;                    // 直接覆盖，只保留最新一帧
    }

    ComPtr<ID3D11Texture2D> peek() override {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_frontBuffer;                       // 返回最新一帧
    }

    void clear() override {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_frontBuffer.Reset();                      // 释放底层纹理
    }

private:
    std::mutex m_mutex;
    ComPtr<ID3D11Texture2D> m_frontBuffer;          // 只存一个"前缓冲"
};

class RingBufferStrategy : public ITextureBufferStrategy {
public:
    RingBufferStrategy() {
        m_capacity = AppConfig::instance()->ringBufferSize(); // 从配置读取容量
        if (m_capacity < 1) m_capacity = 3;                   // 兜底：至少 3 帧
    }

    void push(ID3D11Texture2D* texture) override {
        if (!texture) return;
        std::lock_guard<std::mutex> lock(m_mutex);
        m_buffer.push_back(texture);             // 加到队尾
        if (m_buffer.size() > m_capacity) {      // 超过容量
            m_buffer.erase(m_buffer.begin());    // 删掉最旧的一帧
        }
    }

    ComPtr<ID3D11Texture2D> peek() override {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_buffer.empty()) return nullptr;    // 空则返回空指针
        return m_buffer.back();                  // 返回最新（队尾）的一帧
    }

    void clear() override {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_buffer.clear();                        // 清空所有帧
    }

private:
    std::mutex m_mutex;
    std::vector<ComPtr<ID3D11Texture2D>> m_buffer; // 存放多帧的动态数组
    size_t m_capacity;                              // 最大容量
};

void TexturePool::updateTexture(const std::string& sourceId,
                                ID3D11Texture2D* texture,
                                BufferStrategyType strategy) {
    if (sourceId.empty() || !texture) return;      // 参数校验，无效直接返回

    std::lock_guard<std::mutex> lock(m_mutex);     // 全程上锁，保护 m_pool
    long long now = QDateTime::currentMSecsSinceEpoch(); // 当前时间戳（毫秒）

    auto it = m_pool.find(sourceId);               // 在 map 里查找这个 id
    if (it == m_pool.end()) {                       // end() 表示"没找到"
        // 第一次见到这个源：新建一个节点
        PoolNode node;
        node.lastAccessTime = now;
        node.strategyType = strategy;
        if (strategy == BufferStrategyType::SwapChain) {
            node.buffer = std::make_shared<SwapChainStrategy>();   // 单缓冲
        } else {
            node.buffer = std::make_shared<RingBufferStrategy>();  // 环形缓冲
        }
        m_pool[sourceId] = node;                    // 把节点存进 map
        it = m_pool.find(sourceId);
    }

    if (it != m_pool.end() && it->second.buffer) {
        it->second.lastAccessTime = now;            // 更新最后访问时间
        it->second.buffer->push(texture);           // 真正把帧推进去
    }
}

ComPtr<ID3D11Texture2D> TexturePool::acquireTexture(const std::string& sourceId) {
    std::lock_guard<std::mutex> lock(m_mutex);
    auto it = m_pool.find(sourceId);
    if (it != m_pool.end() && it->second.buffer) {
        it->second.lastAccessTime = QDateTime::currentMSecsSinceEpoch(); // 更新访问时间
        return it->second.buffer->peek();   // 取最新一帧（安全拷贝）
    }
    return nullptr;                          // 没找到，返回空指针
}

void TexturePool::cleanupUnused(int64_t currentTimeMs) {
    std::lock_guard<std::mutex> lock(m_mutex);
    // 遍历 map，边遍历边删除（注意 it 的推进方式）
    for (auto it = m_pool.begin(); it != m_pool.end(); ) {
        if (currentTimeMs - it->second.lastAccessTime > 5000) { // 超过 5 秒没被访问
            it->second.buffer.reset();      // 释放底层 D3D 资源（防止显存泄漏）
            it = m_pool.erase(it);          // 从 map 中移除，并让 it 指向下一个
        } else {
            ++it;                            // 没超时，正常往后走
        }
    }
}

class SceneCompositor : public QObject {   // QObject 是 Qt 框架的基类，提供"信号/槽"机制（见 5.4）
    // ...只看关键部分
    struct RenderNode {          // "渲染节点"：一个源在画布上的摆放信息
        std::string sourceId;    // 对应哪个源
        float x, y, w, h;        // 位置 (x,y) 和尺寸 (w,h)
        float rotation;          // 旋转角度
        int zOrder;              // 层级（谁盖在谁上面）
        float opacity;           // 透明度
    };
    std::vector<RenderNode> m_renderList; // 渲染列表：一份"图层树"的快照

    std::mutex m_renderMutex;             // 专门保护 m_renderList 的锁

    // 离屏画布：GPU 里一张专门用来"画"的纹理，以及它的读/写接口
    Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_mainRTV;       // 写接口（画布）
    Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> m_mainSRV;     // 读接口
    Microsoft::WRL::ComPtr<ID3D11Texture2D> m_mainTex;              // 画布本体
    // ...
};

void SceneCompositor::syncRenderNodes() {
    std::lock_guard<std::mutex> lock(m_renderMutex); // 上锁，保护快照过程
    m_renderList.clear();                             // 清空旧的快照
    auto items = m_scene->getItems();                 // 拿到场景里所有"图层项"

    for (const auto& item : items) {                  // 遍历每个图层项
        auto source = item->getSource();              // 拿到这个图层背后的源
        if (source) {
            // ... 如果是动态源且有新帧，就把新帧推进纹理池
            if (source->hasNewFrame()) {              // hasNewFrame()：判断是否有新帧
                TexturePool::instance().updateTexture(source->getSourceId(), tex.Get(), strategy);
                source->markFrameProcessed();          // 标记"这帧我已处理过"
            }

            // 构造渲染节点，记录这个源的摆放信息
            RenderNode node;
            node.sourceId = source->getSourceId();
            Transform t = item->getTransform();        // Transform：位置/缩放/旋转的集合
            node.x = t.x; node.y = t.y; node.w = t.width; node.h = t.height;
            node.rotation = t.rotation;
            node.zOrder = t.zOrder;
            node.opacity = 1.0f;
            m_renderList.push_back(node);              // 加入快照列表
        }
    }

    // 按层级 zOrder 从小到大排序（小的先画，大的后画，后画的盖在上面）
    std::sort(m_renderList.begin(), m_renderList.end(),
              [](const RenderNode& a, const RenderNode& b){ return a.zOrder < b.zOrder; });
}

void SceneCompositor::renderToTexture() {
    auto& dx11 = DX11Context::instance();            // 拿到全局唯一的 D3D11 上下文（见 4.5）
    float clearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; // 清屏颜色：黑色（R=0,G=0,B=0,A=1）

    dx11.beginScene(m_mainRTV.Get(), clearColor);    // ① 清空画布为黑色，并设为当前渲染目标

    std::vector<RenderNode> localList;
    {
        std::lock_guard<std::mutex> lock(m_renderMutex);
        localList = m_renderList;                    // ② 在锁内再快照一份，避免绘制中列表被改
    }

    // ③ 计算"逻辑坐标 -> 物理坐标"的缩放系数
    //    逻辑画布是场景的原始尺寸（如 1920×1080），
    //    但为了性能，编辑模式下物理画布可能缩到 1280×720。
    float scaleX = (float)m_canvasW / m_logicalW;
    float scaleY = (float)m_canvasH / m_logicalH;

    // ④ 遍历每个节点，逐个贴图
    for (const auto& node : localList) {
        // 从纹理池取这个源的最新一帧
        Microsoft::WRL::ComPtr<ID3D11Texture2D> tex =
            TexturePool::instance().acquireTexture(node.sourceId);

        if (tex) {
            // 拿到纹理的"描述"（宽高、格式等），宽高为 0 就跳过
            D3D11_TEXTURE2D_DESC desc;
            tex->GetDesc(&desc);
            if (desc.Width == 0 || desc.Height == 0) continue;

            // 创建临时 SRV（读接口），让着色器能采样这张纹理
            // ...（略去创建代码）...
            Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> tempSRV;
            // ...

            // ⑤ 逻辑坐标换算成物理坐标（乘缩放系数）
            float renderX = node.x * scaleX;
            float renderY = node.y * scaleY;
            float renderW = node.w * scaleX;
            float renderH = node.h * scaleY;

            // ⑥ 调用 dx11.drawTexture 把这张纹理"贴"到画布上
            dx11.drawTexture(tempSRV.Get(),        // 要贴的纹理（读接口）
                             renderX, renderY,     // 贴到画布的哪个位置
                             renderW, renderH,     // 贴多大
                             node.rotation,        // 旋转角度
                             (float)m_canvasW, (float)m_canvasH); // 画布物理尺寸
        }
    }

    // ⑦ 解绑渲染目标（收尾，避免残留状态影响下一帧）
    ID3D11RenderTargetView* nullRTV[] = { nullptr };
    dx11.context()->OMSetRenderTargets(1, nullRTV, nullptr);
}

D3D11_BLEND_DESC bd = {};                              // 混合状态描述结构体
bd.RenderTarget[0].BlendEnable = TRUE;                 // 开启混合
bd.RenderTarget[0].SrcBlend  = D3D11_BLEND_SRC_ALPHA;       // 源因子 = 源像素的 Alpha
bd.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;  // 目标因子 = 1 - 源 Alpha
bd.RenderTarget[0].BlendOp   = D3D11_BLEND_OP_ADD;          // 混合运算 = 相加
// ...
m_device->CreateBlendState(&bd, &m_blendState);        // 创建这个混合状态对象

void DX11Context::drawTexture(ID3D11ShaderResourceView* srv,
                              float x, float y, float w, float h,
                              float rotation, float canvasW, float canvasH) {
    std::lock_guard<std::mutex> lock(m_mutex);       // 上锁，防止与别的 GPU 操作冲突
    if (!srv) return;

    m_context->PSSetShaderResources(0, 1, &srv);      // 把纹理的"读接口"交给像素着色器
    m_context->PSSetSamplers(0, 1, m_samplerLinear.GetAddressOf()); // 设置采样器（双线性）
    m_context->PSSetShader(m_ps.Get(), nullptr, 0);   // 绑定像素着色器（PS_Main）

    renderQuad(x, y, w, h, rotation, canvasW, canvasH); // 画一个矩形（顶点着色器干活）

    // 用完后解绑，防止影响后续
    ID3D11ShaderResourceView* nullSRV[] = { nullptr };
    m_context->PSSetShaderResources(0, 1, nullSRV);
}

// VS_Main：顶点着色器。输入一个顶点，输出它旋转后的位置。
PS_INPUT VS_Main(VS_INPUT input) {
    PS_INPUT output;

    // 1. 计算矩形中心点
    float centerX = x + w * 0.5;
    float centerY = y + h * 0.5;

    // 2. 计算当前顶点相对中心的偏移
    float localX = (input.pos.x - 0.5) * w;
    float localY = (input.pos.y - 0.5) * h;

    // 3. 角度转弧度（degrees * PI / 180）
    float rad = rotation * 0.0174532925f;
    float c = cos(rad);
    float s = sin(rad);

    // 4. 2D 旋转公式：绕中心旋转
    float rotatedX = localX * c - localY * s;
    float rotatedY = localX * s + localY * c;

    // 5. 移回绝对坐标
    float finalPixelX = centerX + rotatedX;
    float finalPixelY = centerY + rotatedY;

    // 6. 转成 NDC 坐标（-1 ~ 1，D3D 的标准坐标范围）
    float ndcX = (finalPixelX / canvasW) * 2.0f - 1.0f;
    float ndcY = 1.0f - (finalPixelY / canvasH) * 2.0f;

    output.pos = float4(ndcX, ndcY, 0.0f, 1.0f);
    output.tex = input.tex;     // 纹理坐标原样传给像素着色器
    return output;
}

Texture2D tex : register(t0);          // 声明：外部绑定的纹理
SamplerState samLinear : register(s0); // 声明：外部绑定的采样器

// PS_Main：像素着色器。输入插值后的纹理坐标，输出这个像素的颜色。
float4 PS_Main(PS_INPUT input) : SV_Target {
    return tex.Sample(samLinear, input.tex); // 采样纹理，得到该点的颜色
}

void SceneCompositor::renderLoop() {
    // ...（前面是初始化、垃圾回收、同步图层，略）...

    renderToTexture();                       // 先合成出 RGB 画面

    if (m_currentMode == CompositorMode::LiveRunning) { // 只有"直播模式"才走编码
        convertToYUVAndDownload();           // ② 编码输出（转 NV12 并下载）
    }

    downloadPreview();                       // ① 预览输出（转 QImage 并下载）
    TexturePool::instance().cleanupUnused(QDateTime::currentMSecsSinceEpoch()); // 顺手清理纹理池
}

void SceneCompositor::downloadPreview() {
    // ① 暴力节流：距离上次发送不足 33ms，直接丢弃本帧
    if (!s_previewLimiter.isValid()) {
        s_previewLimiter.start();            // 首次调用：启动计时器
    }
    if (s_previewLimiter.elapsed() < 33) {   // elapsed() 返回距上次过了多少毫秒
        return;                              // 不到 33ms，直接丢弃，减轻 UI 压力
    }
    s_previewLimiter.restart();              // 重置计时器，准备下一帧

    if (!m_previewStagingTex || !m_mainTex) return;  // 资源为空则返回

    // ② 把画布复制到 Staging（暂存）纹理
    DX11Context::instance().copyResource(m_previewStagingTex.Get(), m_mainTex.Get());

    // ③ mapRead：把 Staging 纹理映射到 CPU 可读的内存，回调里读数据
    DX11Context::instance().mapRead(m_previewStagingTex.Get(),
        [this](const D3D11_MAPPED_SUBRESOURCE& map){
            if (!map.pData) return;          // 映射失败则返回
            // 用这块 CPU 内存构造一张 QImage（Qt 的图片类型）
            QImage img((const uchar*)map.pData, m_canvasW, m_canvasH,
                       map.RowPitch, QImage::Format_ARGB32);
            QImage deepCopy = img.copy();    // 深拷贝一份（因为 map 很快会被释放）
            emit frameReady(deepCopy);       // 通过信号发给界面去显示（见 5.4）
        });
}

void SceneCompositor::convertToYUVAndDownload() {
    if (!m_mainSRV || !m_nv12Texture || !m_rtvY || !m_rtvUV) return;

    // ① 在 GPU 内，把 RGB 画布转成 NV12 纹理
    DX11Context::instance().convertRGBtoNV12(
        m_mainSRV.Get(),    // 输入：RGB 画布的读接口
        m_rtvY.Get(),       // 输出：Y 通道的写接口
        m_rtvUV.Get(),      // 输出：UV 通道的写接口
        desc.Width, desc.Height,
        conf.colorSpace, conf.colorRange, conf.downscaleFilter); // 色彩配置

    // ② 把 NV12 下载到 CPU，再交给回调
    downloadNV12ToCallback();
}

void DX11Context::convertRGBtoNV12(/* ...参数略... */) {
    std::lock_guard<std::mutex> lock(m_mutex);

    // ① 先解绑所有 RTV，防止"读写的纹理是同一块"导致冲突（读写冲突会黑屏）
    ID3D11RenderTargetView* nullRTV[] = { nullptr };
    m_context->OMSetRenderTargets(1, nullRTV, nullptr);

    // ② 更新颜色转换矩阵（决定用 BT.601 还是 BT.709，全范围还是限范围）
    updateColorMatrix(space, range, desc.Width, desc.Height);
    m_context->PSSetConstantBuffers(1, 1, m_colorBuffer.GetAddressOf());

    // ③ 关闭 Alpha 混合（格式转换不需要半透明混合）
    m_context->OMSetBlendState(m_blendStateDisabled.Get(), nullptr, 0xFFFFFFFF);

    // ④ 绑定输入 RGB 纹理
    m_context->PSSetShaderResources(0, 1, &inputTex);

    // ⑤ 画 Y 通道：用 PS_RGB_to_Y_Bilinear 着色器，渲染到 Y 的 RTV
    m_context->OMSetRenderTargets(1, &targetY, nullptr);
    m_context->PSSetShader(psY, nullptr, 0);
    renderQuad(0, 0, (float)targetW, (float)targetH, 0.0f, ...);

    // ⑥ 画 UV 通道：用 PS_RGB_to_UV_Bilinear 着色器，渲染到 UV 的 RTV（尺寸减半）
    m_context->OMSetRenderTargets(1, &targetUV, nullptr);
    m_context->PSSetShader(psUV, nullptr, 0);
    renderQuad(0, 0, (float)targetW/2, (float)targetH/2, 0.0f, ...);

    // ⑦ 恢复状态、解绑，避免影响后续
    // ...
}

// PS_RGB_to_Y_Bilinear：把采样到的 RGB 颜色转成亮度 Y
float4 PS_RGB_to_Y_Bilinear(PS_INPUT input) : SV_Target {
    float3 rgb = tex.Sample(samLinear, input.tex).rgb; // 采样得到 R,G,B
    float y = dot(rgb, yCoeff.rgb) + yCoeff.a;         // Y = 系数·RGB + 偏移
    return float4(y, 0, 0, 1);
}

// 声明在 SceneCompositor.h 里
signals:
    void frameReady(const QImage& image);        // "有一帧预览画面好了"
    void yuvFrameReady(const std::vector<uint8_t>& data, int width, int height, int64_t pts);
                                                 // "有一帧 YUV 数据好了"

// 类型定义：一个函数，参数是 (数据指针, 宽, 高, 时间戳)
using VideoFrameCallback = std::function<void(const uint8_t* data, int width, int height, int64_t pts)>;
void setVideoOutputCallback(VideoFrameCallback callback); // 外部注册回调

// 下载后：
emit yuvFrameReady(buffer, w, h, currentPts / 1000);      // 发信号给 Qt 侧
if (m_outputCallback) m_outputCallback(buffer.data(), w, h, currentPts); // 调用外部回调