┌─────────────┐   ┌──────────────┐   ┌────────────────┐   ┌──────────────┐
│  屏幕采集   │──▶│  内容感知引擎 │──▶│ 编码模式决策器  │──▶│ 混合编码执行器 │
│  (DXGI/管道)│   │  (文本检测)   │   │ (动态切换策略)  │   │ (H.264/SCC)   │
└─────────────┘   └──────────────┘   └────────────────┘   └──────────────┘
                           ▲                   │                    │
                           │                   ▼                    ▼
                    ┌──────────────┐   ┌────────────────┐   ┌──────────────┐
                    │  场景分类器  │   │ 码率/延迟控制器 │   │ 网络自适应模块 │
                    │ (静态/动态)  │   │ (RTC/ABR策略)   │   │ (丢包/抖动)   │
                    └──────────────┘   └────────────────┘   └──────────────┘

# 伪代码：推理流程
def text_detect_lite(frame_rgb: np.ndarray) -> List[TextBox]:
    # 1. 预处理：短边缩放至 640，保持长宽比，填充至 640x640
    inp, ratio, pad = preprocess(frame_rgb, target_size=640)
    
    # 2. ONNX Runtime / TensorRT 推理
    prob_map = session.run(['prob_map'], {'input': inp})[0]  # [1, 1, 160, 160]
    
    # 3. 后处理：阈值二值化 + 轮廓提取 + 多边形拟合 + 坐标映射回原图
    boxes = postprocess(prob_map[0,0], ratio, pad, 
                        thresh=0.3, box_thresh=0.6, unclip_ratio=1.5)
    
    # 4. 过滤：面积 < 100px 丢弃，长宽比 > 10 视为分隔线而非文本
    return [box for box in boxes if box.area > 100 and box.aspect_ratio < 10]

// 伪代码：CTU 级模式选择
enum CodecMode { MODE_SCC, MODE_VIDEO, MODE_SKIP };

CodecMode select_mode(const CTU& ctu, const TextMap& text_map, 
                      const MotionInfo& mv, const RateControl& rc) {
    float text_ratio = text_map.overlap_ratio(ctu.rect);
    float motion_cost = mv.sad_cost(ctu.rect);
    float lambda = rc.get_lambda();  // 率失真坡度
    
    // 核心决策函数：最小化 R-D 代价
    // J = D + λ·R
    float cost_scc   = estimate_rd_cost(ctu, MODE_SCC,   text_ratio, motion_cost);
    float cost_video = estimate_rd_cost(ctu, MODE_VIDEO, text_ratio, motion_cost);
    
    // 迟滞机制：防止相邻 CTU 模式频繁翻转
    if (prev_mode == MODE_SCC && cost_video < cost_scc * 0.92f) return MODE_VIDEO;
    if (prev_mode == MODE_VIDEO && cost_scc < cost_video * 0.92f) return MODE_SCC;
    
    return (cost_scc < cost_video) ? MODE_SCC : MODE_VIDEO;
}

# 指数移动平均平滑文本占比
text_ratio_ema = 0.7 * text_ratio_ema + 0.3 * curr_frame_text_ratio
# 仅当 EMA 跨越阈值且持续 N 帧才触发全帧模式切换
if text_ratio_ema > 0.65 and stable_frames > 5: 
    global_mode = SCC_DOMINANT
elif text_ratio_ema < 0.35 and stable_frames > 5:
    global_mode = VIDEO_DOMINANT

GPU 纹理 (DXGI Shared Handle) 
    → CUDA 互操作 (cudaGraphicsRegisterResource) 
    → 文本检测预处理 (CUDA Kernel: NHWC→NCHW, 归一化) 
    → 推理 (TensorRT INT8) 
    → 后处理 (CPU, 多线程轮廓提取) 
    → 共享内存环形缓冲区 (TextBox 列表) 
    → 编码器线程读取 → CTU 模式映射表生成

// 双队列 RC 策略
typedef struct {
    RateControl scc_rc;    // 目标码率 60%，QP 上限 28
    RateControl video_rc;  // 目标码率 40%，QP 上限 36
    float alpha;           // 动态权重，随 text_ratio_ema 调整
} HybridRC;

void hybrid_rc_update(HybridRC* hrc, int frame_size, float text_ratio) {
    hrc->alpha = clamp(0.3 + 0.7 * text_ratio, 0.2, 0.8);
    hrc->scc_rc.target_bitrate   = total_bitrate * hrc->alpha;
    hrc->video_rc.target_bitrate = total_bitrate * (1 - hrc->alpha);
    // 各自独立 PID 控制，避免相互干扰
}

// SEI Payload 结构 (注册 user_data_unregistered, UUID: 0xA1B2C3D4...)
typedef struct {
    uint8_t  sei_type;           // 0x01: CTU Mode Map
    uint16_t frame_width_ctu;    // 宽度 (CTU 单位)
    uint16_t frame_height_ctu;   // 高度 (CTU 单位)
    uint8_t  ctu_size_log2;      // 5=32x32, 6=64x64
    uint32_t crc32;              // 数据校验
    // 位流数据：1 bit/CTU (0=VIDEO, 1=SCC), 行优先打包，字节对齐填充 0
    uint8_t  mode_bitmap[];      // size = ceil(frame_width_ctu * frame_height_ctu / 8)
} SEI_ScreenContentModeMap;

// 伪代码：每帧调度决策入口
ScheduleDecision schedule_frame(FrameTask& task, SystemLoad& load) {
    // 1. 估算各设备耗时 (基于历史滑动窗口 + 当前频率/温度)
    float t_gpu_enc   = load.gpu.estimate(task.enc_params);
    float t_npu_det   = load.npu.estimate(task.det_params);
    float t_cpu_fallback = load.cpu.estimate(task.enc_params); // 兜底
    
    // 2. 约束检查：硬性截止时间
    const float DEADLINE = 18.0f; // ms, 留 2ms 网络发送余量
    
    // 3. 评分函数：能耗优先 + 截止时间满足度
    // Score = w1 * (1/energy) + w2 * (deadline - latency) / deadline
    auto score = [&](Device d, float lat, float pwr) {
        if (lat > DEADLINE) return -INF; // 硬约束
        return 0.6f * (1.0f / pwr) + 0.4f * (DEADLINE - lat) / DEADLINE;
    };
    
    // 4. 枚举组合 (编码设备 x 检测设备)，选最优
    // 典型组合：[GPU编码 + NPU检测] > [DSP编码 + GPU检测] > [CPU编码 + CPU检测]
    Device best_enc = CPU, best_det = CPU; float best_sc = -INF;
    for (auto enc_dev : {GPU, DSP, CPU}) {
        for (auto det_dev : {NPU, GPU, CPU}) {
            if (enc_dev == det_dev && !load.can_share(enc_dev)) continue; // 资源冲突
            float sc = score(enc_dev, t_enc[enc_dev], power[enc_dev]) 
                     + score(det_dev, t_det[det_dev], power[det_dev]);
            if (sc > best_sc) { best_sc = sc; best_enc = enc_dev; best_det = det_dev; }
        }
    }
    return {best_enc, best_det, best_sc > 0};
}

+------------------+      DMABUF / VkExternalMemory      +------------------+
|  采集 (DXGI/V4L2) |  --------------------------------->  |  文本检测 (NPU)   |
|  生产者: GPU Tex  |  (零拷贝, 仅同步 Fence)             |  消费者: NPU Tensor|
+------------------+                                     +------------------+
        |                                                        |
        | DMABUF Export                                          | DMABUF Export (结果图/元数据)
        v                                                        v
+------------------+      DMABUF / VkExternalMemory      +------------------+
|  编码器 (GPU/DSP) |  <---------------------------------  |  模式决策 (CPU)   |
|  消费者: Enc Input|  (零拷贝, 导入为 VkBuffer/OMX Buffer) |  生产者: Mode Map  |
+------------------+                                     +------------------+

RTP Header (PT=100 H.264)
  |-- Extension: LayerID (1 bit: 0=BL, 1=EL) + DependencyID (2 bit)
  |-- Payload: [BL NALUs] [EL1 NALUs] [EL2 NALUs] (按依赖顺序排列)

// 伪代码：语义感知带宽分配
func (s *Sender) UpdateBitrateAllocation(estimate BandwidthEstimate) {
    // 1. 基础分配
    totalTarget := estimate.TargetBitrate
    
    // 2. 语义权重 (来自编码器实时统计)
    textRatio := s.encoder.GetTextRatioEMA() // 0.0 ~ 1.0
    motionRatio := s.encoder.GetMotionRatioEMA()
    
    // 3. 非线性映射：文本优先保障，视频弹性收缩
    // BL 码率下限 = 总带宽 * (0.3 + 0.5 * textRatio)
    blMin := totalTarget * (0.3 + 0.5 * textRatio)
    // EL2 码率上限 = 总带宽 * (0.4 * (1 - textRatio) * (1 - motionRatio))
    el2Max := totalTarget * 0.4 * (1 - textRatio) * (1 - motionRatio)
    
    // 4. 约束求解 (线性规划/贪心)
    s.encoder.SetTargetBitrate(BL, clamp(blMin, 0.2*totalTarget, 0.7*totalTarget))
    s.encoder.SetTargetBitrate(EL1, totalTarget * 0.2)
    s.encoder.SetTargetBitrate(EL2, clamp(el2Max, 0.05*totalTarget, 0.3*totalTarget))
}

屏幕帧 
  → [隐私检测模型] (YOLOX-Nano / 2ms) 
  → [敏感区域掩码生成] (矩形/多边形) 
  → [策略引擎] (企业策略: 模糊/马赛克/黑块/水印/阻断) 
  → [编码器 ROI 处理] (QP+10 强制模糊 / 插入替代图片) 
  → 码流输出

// SFU 转发决策伪代码
func (s *SFU) ForwardScreenTrack(subscriber *Subscriber, track *ScreenTrack) {
    // 1. 订阅端能力探测 (SDP / Client Hint)
    caps := subscriber.GetCapabilities()
    
    // 2. 分层订阅决策
    layers := track.GetLayers() // BL, EL1, EL2
    targetLayers := selectLayers(caps, subscriber.BandwidthEstimate, subscriber.CPU)
    
    // 3. 关键优化：模式图 SEI 透传 & 重写
    //    - 若订阅端支持增强解码：透传原始 SEI
    //    - 若仅支持标准解码：注入 "强制模糊补偿" SEI 或直接丢弃 SCC 块 (由 SFU 侧模拟转码)
    
    // 4. 关键帧请求聚合
    //    - 合并多订阅端 PLI/NACK，单次向上游请求 IDR/GDR
    //    - 支持 "Partial IDR" (仅刷新文本区域 CTU)，降低上游编码压力
    
    // 5. 录制归档适配
    //    - 输出标准 MP4 (fMP4)，注入 `stbl` 侧 `uuid` box 存储模式图元数据
    //    - 提供 "播放器 SDK" 解析模式图，实现归档回放时文本锐度复现
}

graph LR
    A[实时指标流] --> B(流式计算引擎 Flink/RisingWave)
    B --> C{规则引擎 / ML 异常检测}
    C -- 编码延迟飙升 --> D[动作: 降分辨率/降帧率/切CPU编码]
    C -- 文本锐度下降 --> E[动作: 提升SCC权重/降QP/请求关键帧]
    C -- 模式切换抖动 --> F[动作: 增大迟滞阈值/启用MRF平滑]
    C -- 显存不足 --> G[动作: 驱逐非活跃会话/压缩Buffer池]
    D & E & F & G --> H[下发控制指令到网关/客户端]
    H --> A