# 伪代码：每帧 0.2 ms 完成分类
def classify_frame(frame_yuv):
    # 1. 计算低分辨率统计量
    var_8x8 = variance(pool(frame_yuv, 8))
    edge_density = sobel(frame_yuv).mean()
    motion_mv = estimate_global_mv(frame_yuv, prev_frame)

    # 2. 规则树判断
    if var_8x8 < 12 and edge_density < 0.03:
        return "STATIC_TEXT"      # 文档/代码编辑器
    elif motion_mv > 4.0:
        return "HIGH_MOTION_VIDEO" # 视频播放/游戏
    else:
        return "MIXED_UI"          # 典型办公桌面

外层：场景级码率预算分配 (滑动窗口 2 s)
    ↓ 目标 bits/frame
内层：CTU 级 RDO-Q + λ 动态调整
    λ = λ_base * (1 + α * (buffer_fullness - 0.5))

每帧强制内插 CTU 数 = ceil(W * H / (64*64 * T))
刷新条带宽度  = max(2 CTU, ceil(W / (64 * T)))

// 伪代码：编码器内部每帧调用
void cir_plan_roi(Frame *f, EncoderContext *ctx) {
    // 1. 复用场景分类器的边缘图
    uint8_t *edge_map = ctx->scene_classifier.edge_map;

    // 2. 计算每行 CTU 的“重要性得分”
    for (int ctu_y = 0; ctu_y < f->ctu_h; ++ctu_y) {
        float score = 0;
        for (int ctu_x = 0; ctu_x < f->ctu_w; ++ctu_x)
            score += edge_map[ctu_y * f->ctu_w + ctu_x];
        row_importance[ctu_y] = score;
    }

    // 3. 按得分分配刷新配额 (总配额固定)
    allocate_refresh_quota(row_importance, f->ctu_h, TARGET_CTUS_PER_FRAME);
}

[采集] → [前处理: NV12→P010, 降噪] → [编码器: H.265/HEVC Main 444 10-bit]
    │                                                      │
    ├─ 场景分类器 (共享内存, 0 拷贝)                       ├─ CIR 决策模块
    └─ 码控反馈管道 (Ring Buffer, 1 ms 粒度)              └─ SEI 注入器
                                    ↓
                         [RTP/UDP + FEC (Reed-Solomon n=10,k=8)]
                                    ↓
                         [解码端: 硬解优先回退软解, 帧缓冲池 3 帧]
                                    ↓
                         [渲染: Vulkan/DirectX 12 零拷贝呈现]

// 编码器初始化：构建参考帧哈希索引
void build_hash_index(const Frame& ref, HashIndex& idx) {
    for (int ctu_y = 0; ctu_y < ref.ctu_h; ++ctu_y)
        for (int ctu_x = 0; ctu_x < ref.ctu_w; ++ctu_x) {
            uint64_t h = xxhash64(ref.get_ctu_pixels(ctu_x, ctu_y), 64*64);
            idx.buckets[h & 0xFFFF].push_back({ctu_x, ctu_y, h});
        }
}

// ME 过程：当前 CTU 查找候选
MV hash_me_search(const CTU& cur, const HashIndex& idx, const Frame& ref) {
    uint64_t h = xxhash64(cur.pixels, 64*64);
    auto& bucket = idx.buckets[h & 0xFFFF];
    MV best_mv = {0,0}; int best_sad = INT_MAX;

    for (auto& cand : bucket) {
        if (cand.full_hash == h) { // 全哈希命中 → 极高概率完全匹配
            return {cand.x - cur.x, cand.y - cur.y}; // 直接返回，跳过 SAD
        }
        // 哈希冲突或近似匹配 → 小范围 SAD 校验
        int sad = sad_64x64(cur, ref, cand.x, cand.y);
        if (sad < best_sad) { best_sad = sad; best_mv = {cand.x - cur.x, cand.y - cur.y}; }
    }
    // 兜底：触发 L2 精细搜索
    if (best_sad > EARLY_TERMINATE_TH) return tz_search(cur, ref, best_mv);
    return best_mv;
}

def post_process_mv_field(mv_field, ctu_size=64):
    # 1. 中值滤波去噪（3x3 窗口）
    mv_denoised = median_filter(mv_field, k=3)
    
    # 2. 连通域合并：相邻 CTU MV 差值 < 1 像素 → 强制合并为同一 Merge 候选
    labels = connected_components(mv_denoised, lambda a,b: abs(a-b) < 1.0)
    
    # 3. 为每个连通域生成统一 Merge MV，写入 CU 合并候选列表头部
    for label in unique(labels):
        merged_mv = median(mv_denoised[labels==label])
        write_merge_candidate_top(label, merged_mv)

// DPB 管理核心结构
typedef struct {
    FrameSlot slots[MAX_DPB_SIZE]; // 8~12 帧
    uint64_t  poc_base;            // 基准 POC
    uint32_t  valid_bitmap;        // 有效槽位位图
    // 关键字段：每帧记录“被哪些后续帧引用”
    uint32_t  ref_by_future[MAX_DPB_SIZE]; // bitmask of future POCs
} DPBManager;

// 编码新帧时：显式声明依赖
void encode_frame(Frame* cur, DPBManager* dpb, NetworkFeedback* fb) {
    // 1. 根据 NACK/丢包反馈，标记“受损参考帧”
    uint32_t damaged = fb->lost_poc_bitmap & dpb->valid_bitmap;
    
    // 2. 依赖选择策略：避开受损帧，优先用 LTR/健康短期帧
    RefPicList rpl = select_ref_list(dpb, damaged, cur->scene_type);
    
    // 3. 写入 Slice Header: ref_pic_list_modification 显式指定 POC
    cur->slice_header.rpl = rpl;
    
    // 4. 更新 DPB：当前帧将被谁引用（预测下一帧依赖）
    predict_future_dependency(cur, dpb);
}

// 自定义 SEI: recovery_point_ext
typedef struct {
    uint32_t recovery_poc;      // 目标恢复 POC
    uint8_t  exact_match_flag;  // 1=像素级精确恢复, 0=近似
    uint8_t  broken_link_flag;  // 1=参考链已断, 需全帧重建
    uint16_t valid_ctu_bitmap[]; // 位图指示哪些 CTU 已恢复 (CIR 场景)
} RecoveryPointExtSEI;

// 片段着色器：基于运动向量的时域隐藏 (GPU 并行)
layout(local_size_x = 16, local_size_y = 16) in;
layout(binding=0) uniform sampler2D last_good_frame;
layout(binding=1) uniform usampler2D mv_field; // 编码器下发的 MV 纹理
layout(binding=2, rgba8) uniform image2D output_frame;

void main() {
    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
    uvec2 mv  = texelFetch(mv_field, pos, 0).xy;
    vec2  src = vec2(pos) - vec2(mv) * (1.0/4.0); // 1/4 像素精度
    vec4  col = texture(last_good_frame, src / frame_size);
    
    // 边界保护：利用边缘检测掩码融合空域内插
    float edge = texture(edge_mask, pos).r;
    col = mix(col, spatial_inpaint(pos), smoothstep(0.3, 0.7, edge));
    
    imageStore(output_frame, pos, col);
}

// 统一句柄封装
struct UnifiedFrame {
    uint64_t  frame_id;          // 单调递增 ID
    VkImage   vk_image;          // Vulkan 采集/渲染
    VkDeviceMemory vk_mem;       // 绑定的显存
    CUeglFrame cuda_frame;       // CUDA/NVENC 编码视图
    VASurfaceID va_surface;      // VAAPI/Intel QSV 视图
    ID3D11Texture2D* d3d11_tex;  // DX11/NVENC/DXVA 视图
    // 同步原语
    VkSemaphore acquire_sem;     // 生产者释放
    VkSemaphore release_sem;     // 消费者释放
    uint64_t    timeline_value;  // Timeline Semaphore 值
};

[Swapchain Acquire] 
      │ VkSemaphore (Timeline=N)
      ▼
[VkCmdCopyImageToBuffer] → [VkBuffer (HOST_VISIBLE | DEVICE_LOCAL)]  // 可选：仅当编码器需 CPU 预处理
      │
      ├─→ [vkMapMemory] → [CPU Scene Classifier / HashME Index Build] // 0 拷贝读像素
      │
      └─→ [cudaImportExternalMemory] → [CUeglFrame] → [NVENC EncodePicture]
            │                                      │
            │                                      ▼
            │                              [Bitstream Buffer (CUDA Host Pinned Mem)]
            │                                      │
            ▼                                      ▼
      [VkQueueSubmit(Wait acquire_sem, Signal release_sem)]   [Async Copy to Network Ring Buffer]

// 每帧输出一行 JSONL，ELK/Grafana 直接入库
{
  "frame_id": 10245,
  "poc": 3072,
  "scene": "MIXED_UI",
  "qp": 28,
  "bits": 18432,
  "latency_us": {
    "acquire_gpu": 120,
    "scene_classify": 180,
    "hashme_build": 95,
    "me_search": 290,
    "rdo_encode": 1120,
    "cir_decision": 45,
    "sei_inject": 12,
    "bitstream_ready": 35,
    "network_enqueue": 8,
    "total_encode": 1905
  },
  "dpb_state": "LTR:2, ST:4, Damaged:0",
  "network_rtt_ms": 1.2,
  "fec_ratio": 0.18
}

# 编码耗时突增 > 3ms (P99)
histogram_quantile(0.99, rate(encoder_latency_total_us_bucket[1m])) > 3000

# CIR 刷新条带异常 (CTU数偏离理论值 > 20%)
abs(encoder_cir_ctus_actual - encoder_cir_ctus_theory) / encoder_cir_ctus_theory > 0.2

# DPB 受损帧累积 > 2 帧
encoder_dpb_damaged_count > 2