┌─────────────────────────────────────┐
│         全局调度中心 (GSLB)          │  ← 实时采集全网带宽、延迟、负载、健康度
├─────────────────────────────────────┤
│  华东区调度  │  华南区调度  │  海外调度  │  ← 按运营商/省份/ASN 粒度聚合
├─────────────────────────────────────┤
│   边缘节点集群 (Edge Cluster)        │  ← 节点内负载均衡、熔断、预热
└─────────────────────────────────────┘

┌──────────────┐     ┌──────────────────┐     ┌────────────────────┐
│  信令/调度层  │────▶│  协议网关集群     │────▶│  边缘节点 / 回源层  │
│  (Session    │     │  - WebRTC SFU    │     │  - Origin Server   │
│   Manager)   │     │  - LL-HLS Packager│    │  - Multi-CDN       │
└──────────────┘     └──────────────────┘     └────────────────────┘
        ▲                     ▲                        ▲
        │                     │                        │
        ▼                     ▼                        ▼
┌──────────────────────────────────────────────────────────────┐
│                    可观测与决策中台                            │
│  - 实时 QoE 指标采集  - 切换策略引擎  - 多 CDN 调度策略下发     │
└──────────────────────────────────────────────────────────────┘

-- nginx.conf 核心片段：基于实时健康度的加权随机路由
local cjson = require "cjson.safe"
local resty_chash = require "resty.chash"
local shared_health = ngx.shared.health_dict  -- 共享内存存节点健康分

local function pick_upstream(host)
    local nodes = shared_health:get_keys(0)  -- 获取当前可用节点列表
    if not nodes or #nodes == 0 then
        return nil, "no healthy node"
    end
    -- 权重 = 基础权重 * 健康分(0.0-1.0) * (1 - 负载因子)
    local weights = {}
    for _, node in ipairs(nodes) do
        local h = shared_health:get(node) or 1.0
        local load = get_node_load_factor(node)  -- 通过 sidecar 上报
        weights[node] = h * (1 - load)
    end
    -- 一致性哈希 + 权重平滑，保证同一 Session 粘性
    local picker = resty_chash:new(weights)
    return picker:find(host .. ngx.var.remote_addr)
end

-- access 阶段执行
local upstream, err = pick_upstream(ngx.var.host)
if not upstream then
    ngx.log(ngx.ERR, "schedule failed: ", err)
    return ngx.exit(503)
end
ngx.var.upstream_target = upstream

graph LR
    A[编码器输出] --> B{分层编码器}
    B --> C[基础层 Base Layer<br/>H.264/HEVC/AV1]
    B --> D[增强层 Enhancement Layer<br/>LCEVC / Scalable VP9]
    C --> E[WebRTC: Simulcast L1/L2/L3]
    C --> F[LL-HLS: Part Duration 200ms]
    D --> G[WebRTC: FEC FlexFEC-03]
    D --> H[LL-HLS: 冗余 Part (PARITY=3)]
    E & F & G & H --> I[边缘统一缓存<br/>CMAF Chunk]
    I --> J[端侧自适应解码器]

# 伪代码：核心决策函数 (每 200ms 运行一次)
def select_bitrate_and_protocol(state):
    # state: {bw_est, rtt, loss, buffer_sec, current_proto, current_br, latency_sensitivity}
    
    # 1. 带宽预测：EWMA + Kalman Filter 融合
    bw_pred = kalman_predict(state.bw_est_history)
    
    # 2. 计算各候选 (proto, bitrate) 的效用函数
    best_util, best_choice = -inf, None
    for proto in ['webrtc', 'llhls']:
        for br in BITRATE_LADDER[proto]:
            # 基础效用：QoE = α*log(br) - β*rebuffer - γ*latency
            qoe_base = alpha * math.log(br) - beta * predict_rebuffer(br, bw_pred, state.buffer_sec)
            
            # 延迟敏感度加成 (互动环节 latency_sensitivity=1.0)
            latency_bonus = gamma * (MAX_LATENCY[proto] - EXPECTED_LATENCY[proto]) * state.latency_sensitivity
            
            # 协议切换惩罚 (防抖)
            switch_penalty = SWITCH_COST if proto != state.current_proto else 0
            
            # 弱网鲁棒性加成 (LL-HLS 在高丢包下更稳)
            robustness_bonus = delta * (1 - state.loss) if proto == 'llhls' else 0
            
            util = qoe_base + latency_bonus - switch_penalty + robustness_bonus
            
            if util > best_util:
                best_util, best_choice = util, (proto, br)
    
    return best_choice

┌─────────────────────────────────────────────────────────────┐
│                    Unified Player Core                        │
│  ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │ WebRTC Engine│  │ LL-HLS Engine│  │  Shared Buffer Pool│  │
│  │ (libwebrtc/  │  │ (hls.js /    │  │  (CMAF fMP4 Boxes) │  │
│  │  WASM build) │  │  native AV)  │  │  RefCount + Ring   │  │
│  └──────┬───────┘  └──────┬───────┘  └─────────┬──────────┘  │
│         │                 │                      │            │
│         └─────────────────┼──────────────────────┘            │
│                           ▼                                   │
│              ┌────────────────────────┐                       │
│              │  Protocol Abstraction  │  ← 统一接口: load/play/pause/switch
│              │  Layer (PAL)           │     onStats/onError/onSwitch
│              └───────────┬────────────┘                       │
│                          ▼                                    │
│              ┌────────────────────────┐                       │
│              │  Render Pipeline       │  ← VideoFrame/ AudioBuffer 统一格式
│              │  (WebGL / VideoElement │     支持 WebCodecs / MediaStream
│              │   / AudioWorklet)      │                       │
│              └────────────────────────┘                       │
└─────────────────────────────────────────────────────────────┘

// C++ 核心结构 (编译为 WASM / 原生库共用)
struct CMAFSample {
    uint64_t pts_us;           // 统一时间基 (微秒)
    uint32_t duration_us;
    uint8_t* payload;          // 指向 SharedArrayBuffer / dmabuf / CVPixelBuffer
    size_t size;
    bool is_keyframe;
    CodecType codec;           // H264/HEVC/AV1/VP9
    CryptoInfo crypto;         // CENC subsample 加密信息
    uint32_t ref_count;        // 原子引用计数
    
    // 零拷贝转移所有权
    CMAFSample* retain() { atomic_fetch_add(&ref_count, 1); return this; }
    void release() { if (atomic_fetch_sub(&ref_count, 1) == 1) dealloc(); }
};

// 环形缓冲区：生产者(WebRTC Depacketizer / LL-HLS Demuxer) -> 消费者(Decoder)
class LockFreeRingBuffer {
    std::atomic<size_t> head_, tail_;
    CMAFSample* slots_[CAPACITY];  // CAPACITY = 2^n
public:
    bool push(CMAFSample* s) { /* CAS head */ }
    CMAFSample* pop() { /* CAS tail */ }
};

# .gitlab-ci.yml 片段：混沌测试阶段
chaos_validation:
  stage: validate
  image: chaos-mesh/chaosctl:latest
  script:
    - chaosctl create -f chaos/experiment-webinar-peak.yaml  # 定义 5万并发+单AZ故障
    - sleep 300  # 观测窗口
    - |
      python3 scripts/verify_slo.py 
        --prom-url $PROM_URL 
        --slo-config slo/webinar.yaml 
        --exit-on-violation
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule" || $FORCE_CHAOS
  timeout: 30m

objectives:
  - name: "join_success_rate"
    sli: "sum(rate(webinar_join_success_total[1m])) / sum(rate(webinar_join_attempt_total[1m]))"
    target: 0.995
    window: "5m"
  - name: "switch_success_rate"
    sli: "sum(rate(protocol_switch_success_total[1m])) / sum(rate(protocol_switch_attempt_total[1m]))"
    target: 0.99
  - name: "p95_startup_latency"
    sli: "histogram_quantile(0.95, rate(webinar_startup_latency_bucket[5m]))"
    target: 2.0  # seconds

# 伪代码：每 5 分钟运行一次的成本优化控制器
def cost_optimizer():
    # 1. 拉取各厂商实时省份级报价 (API/爬虫/合同解析)
    quotes = fetch_realtime_quotes()  # {cdn: {province: {price_95, price_gb, commit_gb}}}
    
    # 2. 计算当前小时各省份 CEB
    ceb_map = {}
    for cdn, provinces in quotes.items():
        for prov, q in provinces.items():
            traffic = get_traffic_last_hour(prov, cdn)
            qoe = get_qoe_score_last_hour(prov, cdn)
            ceb = (q['price_gb'] * traffic) / (traffic * qoe + 1e-6)
            ceb_map[(cdn, prov)] = ceb
    
    # 3. 构建线性规划问题：最小化总成本 s.t. 容量约束、SLA 约束
    #    变量: x_{cdn, prov} = 流量分配比例
    #    约束: sum(x) = 1; x_{cdn, prov} <= max_capacity_{cdn, prov}; latency_p95 < 2s
    from ortools.linear_solver import pywraplp
    solver = pywraplp.Solver.CreateSolver('GLOP')
    # ... 建模求解 ...
    
    # 4. 平滑下发新权重 (指数移动平均，防震荡)
    new_weights = smooth_transition(current_weights, optimal_weights, alpha=0.3)
    push_to_gslb(new_weights)
    
    # 5. 记录审计日志
    audit_log("cost_optimization", {"old": current_weights, "new": new_weights, "est_saving": est_saving})

┌──────────────┐     ┌─────────────────────┐     ┌──────────────────┐
│  海外主讲端   │────▶│  海外入口节点        │────▶│  跨境专线/加速通道 │
│  (WebRTC)    │     │  (Media Relay Only) │     │  (无日志、无存储)  │
└──────────────┘     └─────────────────────┘     └────────┬─────────┘
                                                          │
                                                          ▼
┌──────────────┐     ┌─────────────────────┐     ┌──────────────────┐
│  国内观众端   │◀───│  国内边缘集群        │◀───│  国内合规入口     │
│  (LL-HLS)    │     │  (转码/录制/分发)    │     │  (终止 TLS、解密) │
└──────────────┘     └─────────────────────┘     └──────────────────┘
                                                          │
                                                          ▼
                                                ┌──────────────────┐
                                                │  合规存储 (OSS)  │
                                                │  - KMS 自带密钥  │
                                                │  - WORM 合规锁   │
                                                └──────────────────┘