┌─────────────────────────────────────────────────────────────────┐
│                      智能视频会议系统全景架构                      │
├─────────────────────────────────────────────────────────────────┤
│  接入层          │  信令/调度层        │  媒体处理层              │
│  ┌──────────┐    │  ┌──────────────┐  │  ┌──────────────────┐  │
│  │ WebRTC   │◄───┤  │ 信令网关集群  │  │  │ 中心 MCU 集群    │  │
│  │ SDK/客户端│    │  │ (集群/分片)   │  │  │ (混流/录制/旁路) │  │
│  └──────────┘    │  └──────┬───────┘  │  └────────┬─────────┘  │
│                  │         │          │           │            │
│  ┌──────────┐    │  ┌──────▼───────┐  │  ┌────────▼─────────┐  │
│  │ RTMP/SRT │◄───┤  │ 智能调度中台  │──┼─►│ 边缘媒体节点池    │  │
│  │ 推流网关  │    │  │ (多CDN/边缘)  │  │  │ (转码/封装/加密)  │  │
│  └──────────┘    │  └──────────────┘  │  └────────┬─────────┘  │
│                  │                    │           │            │
│                  │  ┌──────────────┐  │  ┌────────▼─────────┐  │
│                  │  │ 观看端 SDK   │  │  │ 多 CDN 融合分发网 │  │
│                  │  │ (ABR/预加载) │  │  │ (主/备/专线)      │  │
│                  │  └──────────────┘  │  └──────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

// 伪代码：CDN 质量评分模型
type CDNQualityScore struct {
    LatencyP50   float64 `weight:"0.25"` // 首包延迟
    LatencyP99   float64 `weight:"0.15"` // 抖动
    Throughput   float64 `weight:"0.20"` // 吞吐率
    ErrorRate    float64 `weight:"0.20"` // 4xx/5xx 占比
    StuckRate    float64 `weight:"0.20"` // 卡顿率(客户端上报)
}

func (s *Scheduler) SelectOptimalCDN(ctx context.Context, userIP string, streamID string) *CDNNode {
    candidates := s.topology.GetEdgePOPs(userIP)
    scores := make(map[string]float64)
    for _, c := range candidates {
        scores[c.ID] = s.scorer.Calculate(c, streamID)
    }
    // Thompson Sampling 探索-利用平衡
    return s.bandit.Select(candidates, scores)
}

中心旁路流 (SRT/RTMP, 1080p/4K, 单码率)
        │
        ▼
┌────────────────────────────────────────┐
│         边缘媒体节点 (K8s DaemonSet)    │
│  ┌──────────────────────────────────┐  │
│  │  转码工作流编排器 (Argo/自研)      │  │
│  │  - DAG 解析: decode→scale→encode  │  │
│  │  - 资源感知调度: GPU/CPU 亲和性    │  │
│  └──────────────┬───────────────────┘  │
│                 │                      │
│  ┌──────────────▼───────────────────┐  │
│  │  硬件加速转码池                   │  │
│  │  - Intel QSV / NVIDIA NVENC      │  │
│  │  - AMD VCN / Apple VideoToolbox  │  │
│  │  - 显存零拷贝 (dmabuf/VAAPI)     │  │
│  └──────────────┬───────────────────┘  │
│                 │                      │
│  ┌──────────────▼───────────────────┐  │
│  │  封装输出模块                     │  │
│  │  - LL-HLS (200ms chunk)          │  │
│  │  - CMAF DASH (CTE)               │  │
│  │  - WebRTC (WHIP/WHEP)            │  │
│  │  - DRM (Widevine/PlayReady/FPS)  │  │
│  └──────────────────────────────────┘  │
└────────────────────────────────────────┘
        │
        ▼
多 CDN 边缘缓存节点 → 终端用户

# K8s HPA 示例：基于转码队列积压 + GPU 利用率双指标
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: edge-transcoder-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: edge-transcoder
  minReplicas: 3
  maxReplicas: 200
  metrics:
  - type: External
    external:
      metric:
        name: transcoder_queue_backlog
      target:
        type: AverageValue
        averageValue: "50"  # 每 Pod 积压 < 50 任务
  - type: Resource
    resource:
      name: nvidia.com/gpu
      target:
        type: Utilization
        averageUtilization: 70
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 30
      policies:
      - type: Percent
        value: 100
        periodSeconds: 30
    scaleDown:
      stabilizationWindowSeconds: 300  # 5 分钟冷却防抖

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  业务应用层  │────►│  密钥管理服务 │────►│  硬件安全模块 │
│  (申请/撤销) │     │  (KMS/ACL)   │     │  (HSM/SGX)   │
└─────────────┘     └──────┬──────┘     └─────────────┘
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ 推流网关  │ │ 边缘转码  │ │ License  │
        │ (SRT/DTLS)│ │ (内存/DRM)│ │ 服务器   │
        └──────────┘ └──────────┘ └──────────┘

// 核心流程伪代码：WebCodecs 硬解管线
class ModernPlayer {
  private videoDecoder: VideoDecoder;
  private audioDecoder: AudioDecoder;
  private demuxer: WASMDemuxer; // ffmpeg.wasm / gpac.wasm
  private frameBuffer: VideoFrame[] = [];
  
  async init(config: PlayerConfig) {
    // 1. 能力检测与回退策略
    const support = await this.probeHardwareSupport(config.codec);
    this.decoderMode = support.hardware ? 'hardware' : 'wasm-software';
    
    // 2. 初始化解码器 (WebCodecs)
    if (this.decoderMode === 'hardware') {
      this.videoDecoder = new VideoDecoder({
        output: this.handleDecodedFrame.bind(this),
        error: this.fallbackToWASM.bind(this)
      });
      this.videoDecoder.configure({
        codec: config.codec, // 'avc1.640028', 'hev1.1.6.L150.B0', 'vp09.00.10.08'
        codedWidth: config.width,
        codedHeight: config.height,
        hardwareAcceleration: 'prefer-hardware' // 关键：强制硬解
      });
    }
    
    // 3. WASM 解复用器 (无需解码，仅分离 NALU/OBU)
    this.demuxer = await WASMDemuxer.create('ffmpeg.wasm');
  }

  // 4. 网络层：Fetch + ReadableStream + 预取控制器
  async fetchSegments(manifest: M3U8) {
    const controller = new PredictivePrefetcher(manifest, {
      bufferTarget: 3, // 目标缓冲 3 个 chunk (600ms)
      maxConcurrent: 4,
      bandwidthEstimator: this.bwe // BWE 算法实例
    });
    
    for await (const chunk of controller.stream()) {
      const { videoFrames, audioFrames } = await this.demuxer.demux(chunk.data);
      this.videoDecoder.decode(videoFrames); // 零拷贝传入 VideoFrame
      this.audioDecoder.decode(audioFrames);
    }
  }
  
  // 5. 渲染：VideoFrame.requestVideoFrameCallback + Canvas/WebGL
  private handleDecodedFrame(frame: VideoFrame) {
    if (this.renderMode === 'webgl') {
      this.glRenderer.drawVideoFrame(frame); // 零拷贝纹理上传
    } else {
      this.canvasCtx.drawImage(frame, 0, 0); // Canvas 2D 回退
    }
    frame.close(); // 及时释放显存
  }
}

┌─────────────────────────────────────────────────────────────┐
│                  Serverless 媒体处理平面                      │
├─────────────────────────────────────────────────────────────┤
│  触发源          │  网关/路由层      │  函数运行时层           │
│  ┌──────────┐   │  ┌────────────┐  │  ┌──────────────────┐  │
│  │ S3/MinIO │──►│  │ API Gateway │──►│  │ Knative Serving  │  │
│  │ 事件通知  │   │  │ (鉴权/限流)  │  │  │ + KEDA Scaler    │  │
│  └──────────┘   │  └────────────┘  │  └────────┬─────────┘  │
│                 │                  │           │            │
│  ┌──────────┐   │  ┌────────────┐  │  ┌────────▼─────────┐  │
│  │ Kafka/   │──►│  │ 事件总线   │──►│  │ 容器镜像池        │  │
│  │ Pulsar   │   │  │ (CloudEvents)│  │  │ - ffmpeg-scratch │  │
│  └──────────┘   │  └────────────┘  │  │ - gpac-wasm      │  │
│                 │                  │  │ - drm-packager   │  │
│                 │                  │  │ - ai-enhance     │  │
│                 │                  │  └────────┬─────────┘  │
│                 │                  │           │            │
│                 │                  │  ┌────────▼─────────┐  │
│                 │                  │  │ 资源池与计费侧    │  │
│                 │                  │  │ - GPU/NPU 显存池  │  │
│                 │                  │  │ - 秒级计量计费    │  │
│                 │                  │  │ - FinOps 标签注入 │  │
│                 │                  │  └──────────────────┘  │
└─────────────────────────────────────────────────────────────┘

单任务成本 = (GPU_显存_GB × 占用_秒 × 单价_GPU_秒) 
           + (vCPU_核 × 占用_秒 × 单价_CPU_秒) 
           + (输出_GB × 单价_流量_GB) 
           + (License_次数 × 单价_DRM)

# 每个转码 Pod 注入的标签，自动流入账单系统
attributes:
  service.name: "edge-transcoder"
  tenant.id: "tenant_8821"           # 租户维度
  meeting.id: "meet_20240520_001"    # 会议维度
  stream.type: "screen_share"        # 业务类型
  codec.output: "hevc_1080p_30fps"   # 码率规格
  gpu.vendor: "nvidia_t4"            # 硬件型号
  region: "cn-hangzhou-cmcc"         # 边缘 POP 位置

                    ┌────────────────────┐
                    │   全局流量调度 (GTM) │
                    │  (健康检查/权重/就近) │
                    └─────────┬──────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│  杭州可用区 A  │     │  上海可用区 B  │     │  北京可用区 C  │
│  (主站/读写)   │◄───►│  (同城双活/读写)│◄───►│  (异地灾备/只读)│
│  - 信令主集群  │     │  - 信令从集群  │     │  - 信令只读副本 │
│  - 元数据主库  │     │  - 元数据同步库 │     │  - 归档存储    │
│  - 边缘转码池  │     │  - 边缘转码池  │     │  - 应急转码池  │
�───────────────┘     └───────────────┘     └───────────────┘
        │                     │                     │
        └─────────────────────┼─────────────────────┘
                              ▼
                    ┌────────────────────┐
                    │   多 CDN 融合分发   │
                    │ (就近接入/跨区兜底)  │
                    └────────────────────┘

graph TD
    A[故障探测] --> B{故障级别}
    B -->|P0 核心链路不可用| C[秒级熔断: DNS 切流 + 信令强制重连]
    B -->|P1 性能劣化| D[分钟级降级: 关闭 4K/关闭 AI 增强/降低码率上限]
    B -->|P2 非核心功能异常| E[小时级隔离: 录制/回放/字幕服务降级]
    
    C --> F[自动化演练: 每周一 02:00 混沌工程]
    D --> F
    E --> F
    F --> G[注入故障: kill pod / tc netem / disk full / GPU hang]
    G --> H[验证指标: RTO < 30s / RPO = 0 / 业务无感知率 > 99.9%]
    H --> I[复盘报告 -> 更新 Runbook -> 纳入 CI/CD Gate]

// 内部统一接口，屏蔽底层差异
type HardwareCodec interface {
    Encode(ctx context.Context, params EncodeParams) ([]Packet, error)
    Decode(ctx context.Context, packets []Packet) ([]Frame, error)
    Capability() CodecCapability // 查询支持的 Profile/Level/分辨率
    Release() error
}

// 工厂模式 + 插件化注册
var codecRegistry = map[string]func() HardwareCodec{
    "nvidia":  func() HardwareCodec { return &NVENCCodec{} },
    "intel":   func() HardwareCodec { return &QSVCodec{} },
    "moore":   func() HardwareCodec { return &MUSACodec{} }, // 摩尔线程
    "biren":   func() HardwareCodec { return &BRTCodec{} },  // 壁仞
    "software": func() HardwareCodec { return &SWCodec{} },  // 兜底
}

// 运行时自动探测最优后端
func SelectBestCodec(requirement CodecRequirement) HardwareCodec {
    for _, vendor := range detectAvailableVendors() { // 优先级: 专用GPU > 集成GPU > CPU
        if c := codecRegistry[vendor](); c.Capability().Satisfy(requirement) {
            return c
        }
    }
    return codecRegistry["software"]() // 最终兜底
}