┌─────────────────────────────────────────────────────────────────┐
│                      发送端 (Encoder Side)                       │
│  Video Encoder → RTCRtpScriptTransform (Sender) → Network       │
│       │                    │                                     │
│       │         ┌──────────▼──────────┐                          │
│       │         │  FlexFEC Encoder    │                          │
│       │         │  (WASM / JS)        │                          │
│       │         │  - 分组策略          │                          │
│       │         │  - 系统码生成        │                          │
│       │         │  - RTP 封包          │                          │
│       │         └──────────┬──────────┘                          │
│       │                    │                                     │
└───────│────────────────────│────────────────────────────────────┘
        │                    │
        ▼                    ▼
   ┌─────────────────────────────────────────────────────────────┐
   │                      接收端 (Decoder Side)                   │
   │  Network → RTCRtpScriptTransform (Receiver) → Video Decoder │
   │                    │                    │                    │
   │         ┌──────────▼──────────┐        │                    │
   │         │  FlexFEC Decoder    │        │                    │
   │         │  (WASM / JS)        │        │                    │
   │         │  - 缓冲与去抖动      │        │                    │
   │         │  - 丢包检测与恢复    │        │                    │
   │         │  - 重组原始帧        │        │                    │
   │         └──────────┬──────────┘        │                    │
   │                    │                    │                    │
   └────────────────────┴────────────────────┴────────────────────┘

// 伪代码：语义感知分组算法
interface FrameMeta {
  frameId: number;
  frameType: 'I' | 'P' | 'B';
  spatialLayer: number;
  temporalLayer: number;
  dependencies: number[]; // 依赖的 frameId
  size: number;
  timestamp: number;
}

class FlexFECGroupingStrategy {
  private readonly maxGroupSize = 16;      // 最大源包数
  private readonly maxLatencyMs = 20;      // 最大分组等待延迟
  private readonly targetOverhead = 0.15;  // 目标冗余开销 15%

  // 核心：根据帧重要性计算保护权重
  private computeProtectionWeight(meta: FrameMeta): number {
    let weight = 1.0;
    if (meta.frameType === 'I') weight *= 3.0;      // 关键帧权重 3x
    else if (meta.frameType === 'P') weight *= 1.5; // 参考帧权重 1.5x
    weight *= (1 + meta.spatialLayer * 0.2);        // 高空间层略微加权
    weight *= (1 + meta.temporalLayer * 0.1);       // 高时间层略微加权
    return weight;
  }

  // 滑动窗口分组：在延迟预算内尽量塞入高权重帧
  createGroups(frames: FrameMeta[]): FECGroup[] {
    const groups: FECGroup[] = [];
    let currentGroup: FrameMeta[] = [];
    let currentWeight = 0;
    let groupStartTime = frames[0]?.timestamp ?? 0;

    for (const frame of frames) {
      const weight = this.computeProtectionWeight(frame);
      const projectedOverhead = (currentWeight + weight) / currentWeight * this.targetOverhead;

      // 约束检查：组大小、延迟、开销
      if (currentGroup.length >= this.maxGroupSize ||
          frame.timestamp - groupStartTime > this.maxLatencyMs ||
          projectedOverhead > this.targetOverhead * 1.5) {
        if (currentGroup.length > 0) groups.push(this.finalizeGroup(currentGroup));
        currentGroup = [];
        currentWeight = 0;
        groupStartTime = frame.timestamp;
      }

      currentGroup.push(frame);
      currentWeight += weight;
    }
    if (currentGroup.length > 0) groups.push(this.finalizeGroup(currentGroup));
    return groups;
  }
}

m=video 9000 RTP/SAVPF 96 97 98
a=rtpmap:96 VP8/90000
a=rtpmap:97 rtx/90000
a=fmtp:97 apt=96
a=rtpmap:98 flexfec/90000
a=fmtp:98 repair-window=10000000; L=27; D=10
a=ssrc-group:FEC-FR 111111 222222
a=ssrc:111111 cname:local
a=ssrc:222222 cname:local

class FlexFECReassemblyPipeline {
  private mediaBuffer: Map<number, RTCEncodedVideoFrame> = new Map(); // key: seqNum
  private fecBuffer: Map<number, RTCEncodedVideoFrame> = new Map();   // key: fecSeqNum
  private readonly recoveryWindowMs = 100; // 与 SDP repair-window 对齐
  private pendingRecovery: Set<number> = new Set(); // 待恢复的媒体 seqNum

  // 媒体包到达
  onMediaFrame(frame: RTCEncodedVideoFrame): void {
    this.mediaBuffer.set(frame.sequenceNumber, frame);
    this.checkAndTriggerRecovery(frame.sequenceNumber);
  }

  // FEC 包到达
  onFECFrame(frame: RTCEncodedVideoFrame): void {
    this.fecBuffer.set(frame.sequenceNumber, frame);
    this.parseFECHeader(frame); // 解析 mask、k、n、snBase
    this.checkAndTriggerRecovery();
  }

  // 核心：丢包检测与恢复触发
  private checkAndTriggerRecovery(triggerSeq?: number): void {
    const now = performance.now();
    const deadline = now - this.recoveryWindowMs;

    // 1. 扫描媒体缓冲，找出“已过期且未收到”的序列号
    for (const [seq, frame] of this.mediaBuffer) {
      if (frame.timestamp < deadline && !this.pendingRecovery.has(seq)) {
        this.pendingRecovery.add(seq);
      }
    }

    // 2. 尝试恢复
    for (const lostSeq of this.pendingRecovery) {
      if (this.attemptRecovery(lostSeq)) {
        this.pendingRecovery.delete(lostSeq);
        this.mediaBuffer.delete(lostSeq); // 恢复成功，移除占位
      }
    }

    // 3. 清理过期缓冲（防止内存泄漏）
    this.evictExpiredFrames(deadline);
  }

  // 单包恢复尝试：高斯消元法（稀疏矩阵优化）
  private attemptRecovery(targetSeq: number): boolean {
    // 收集所有包含 targetSeq 的 FEC 包
    const relevantFEC = this.collectRelevantFEC(targetSeq);
    if (relevantFEC.length === 0) return false;

    // 构造线性方程组：Ax = b
    // A: 系数矩阵 (来自 FEC mask)
    // b: 已知媒体包载荷 + FEC 包载荷
    // x: 未知载荷（含 targetSeq）
    const { solvable, payload } = this.gaussianElimination(relevantFEC, targetSeq);
    if (solvable && payload) {
      // 重构 RTCEncodedVideoFrame 注入解码管线
      const recoveredFrame = this.reconstructFrame(targetSeq, payload);
      this.controller.enqueue(recoveredFrame); // 交给下游解码器
      return true;
    }
    return false;
  }
}

a=extmap:1 urn:ietf:params:rtp-hdr-ext:fec-flexfec-group
a=extmap:2 urn:ietf:params:rtp-hdr-ext:fec-flexfec-fragment
a=extmap:3 urn:ietf:params:rtp-hdr-ext:dependency

// 简化版：根据丢包率动态调整 FEC 开销比
class FECOverheadController {
  private currentOverhead = 0.1;
  private readonly minOverhead = 0.05;
  private readonly maxOverhead = 0.3;

  update(stats: RTCReceivedRtpStreamStats): void {
    const lossRate = stats.packetsLost / (stats.packetsReceived + stats.packetsLost);
    const rtt = stats.roundTripTime * 1000; // ms

    // 启发式公式：丢包率高、RTT 大 → 增加 FEC
    const target = Math.min(
      this.maxOverhead,
      Math.max(this.minOverhead, lossRate * 2 + rtt / 500 * 0.05)
    );

    // 平滑调整，避免震荡
    this.currentOverhead = this.currentOverhead * 0.8 + target * 0.2;
    this.groupingStrategy.setTargetOverhead(this.currentOverhead);
  }
}

// 编码器内部决策逻辑
selectCodeMode(stats: NetworkStats): 'systematic' | 'non-systematic' {
  if (stats.lossRate < 0.15 && stats.rtt < 150) return 'systematic'; // 优先低延迟、低CPU
  return 'non-systematic'; // 高丢包、高抖动场景追求极致恢复率
}

// WASM 核心伪代码 (Rust -> wasm32)
pub fn sparse_gaussian_elimination(
    mut rows: Vec<SparseRow>, // 每行: { mask: u128, payload: &mut [u8] }
    target_col: usize
) -> Option<Vec<u8>> {
    // 1. 列主元选择：找 mask 最稀疏(1最少)的行作为主元，减少填充
    rows.sort_by_key(|r| r.mask.count_ones()); 
    
    // 2. 前向消元：仅对 mask 含 target_col 的行操作
    for i in 0..rows.len() {
        if (rows[i].mask >> target_col) & 1 == 0 { continue; }
        // 找到主元行 pivot
        let pivot = find_pivot(&rows[i..], target_col)?;
        swap(&mut rows[i], &mut rows[pivot]);
        
        // 向量化 XOR 消元 (SIMD 128-bit)
        for j in (i+1)..rows.len() {
            if (rows[j].mask >> target_col) & 1 == 1 {
                rows[j].mask ^= rows[i].mask;
                xor_payload_simd(&mut rows[j].payload, &rows[i].payload); // 关键加速点
            }
        }
    }
    // 3. 回代求解...
}

class SenderTransformStream extends TransformStream<RTCEncodedVideoFrame, RTCEncodedVideoFrame> {
  private fecEncoder: FlexFECEncoder;
  private highWaterMark = 30; // 缓冲上限：约 1 帧 @ 30fps
  private writer: WritableStreamDefaultWriter<RTCEncodedVideoFrame>;

  constructor() {
    super({
      transform: this.handleFrame.bind(this),
      highWaterMark: this.highWaterMark,
      size: () => 1 // 按帧计数
    });
    this.writer = this.writable.getWriter();
  }

  async handleFrame(frame: RTCEncodedVideoFrame, controller: TransformStreamDefaultController<RTCEncodedVideoFrame>) {
    // 1. 背压检查：等待底层网络缓冲区排空
    if (this.writable.desiredSize === null || this.writable.desiredSize <= 0) {
      await this.writer.ready; // 关键：异步等待背压释放
      // 若此时 frame 已过期 (timestamp < now - maxLatency)，直接丢弃并标记关键帧请求
      if (frame.timestamp < performance.now() - this.maxLatencyMs) {
        this.requestKeyFrame();
        frame.close(); // 释放底层 ArrayBuffer
        return;
      }
    }

    // 2. 编码生成 FEC 包 (WASM 调用)
    const fecFrames = this.fecEncoder.encode(frame); 
    
    // 3. 顺序入队：媒体包优先，FEC 包紧随其后 (保证接收端时序局部性)
    controller.enqueue(frame); 
    for (const f of fecFrames) controller.enqueue(f);
  }
}

class ReceiverPipeline {
  private deadlineTimer: number = 0;
  private readonly tickInterval = 5; // ms, 粒度小于帧间隔

  start() {
    this.scheduleNextTick();
  }

  private scheduleNextTick() {
    this.deadlineTimer = setTimeout(() => {
      const now = performance.now();
      const deadline = now - this.recoveryWindowMs;
      
      // 1. 推进时间窗口，强制触发过期帧恢复/丢弃
      this.advanceWindow(deadline);
      
      // 2. 动态调整下次 tick 间隔：若缓冲区堆积严重，加快 tick
      const backlog = this.mediaBuffer.size + this.fecBuffer.size;
      const nextInterval = backlog > 100 ? 2 : this.tickInterval;
      
      this.scheduleNextTick();
    }, this.tickInterval);
  }
}

Main Thread (UI / Signaling)
    │
    ├── Worker Pool (N = navigator.hardwareConcurrency - 1)
    │     ├── Worker 1: FlexFEC Encoder/Decoder Instance
    │     ├── Worker 2: FlexFEC Encoder/Decoder Instance
    │     └── ...
    │
    └── SharedArrayBuffer Pool (Ring Buffer for Frame Data)
          ├── Media Frame Payloads
          └── FEC Frame Payloads

// Main Thread: 发送帧给 Worker
function postFrameToWorker(frame: RTCEncodedVideoFrame, worker: Worker) {
  // 1. 将 ArrayBuffer 转移给 SharedArrayBuffer 池管理器，获取 offset + length
  const { buffer, byteOffset, byteLength } = frame.data;
  const slot = sabPool.allocate(byteLength);
  new Uint8Array(sabPool.buffer, slot.offset, byteLength).set(new Uint8Array(buffer, byteOffset, byteLength));
  
  // 2. 仅传递元数据 + offset/length (极小对象，结构化克隆极快)
  worker.postMessage({
    type: 'ENCODE',
    frameId: frame.frameId,
    timestamp: frame.timestamp,
    payload: { offset: slot.offset, length: byteLength },
    metadata: { ... } // 依赖关系、层级等
  }, [frame.data]); // Transfer ownership of original buffer to avoid copy (if not using SAB)
  
  // 3. 监听结果
  return new Promise(resolve => {
    const handler = (e: MessageEvent) => {
      if (e.data.frameId === frameId) {
        worker.removeEventListener('message', handler);
        resolve(e.data.fecFrames); // 含 SAB offset/length
      }
    };
    worker.addEventListener('message', handler);
  });
}

# docker-compose.test.yml
services:
  sut: # System Under Test (Chrome Headless + Puppeteer)
    image: webrtc-test:latest
    cap_add: [NET_ADMIN] # 允许修改网络
    depends_on: [signaling, turn]
  
  network-impairer:
    image: gaiadocker/iproute2
    cap_add: [NET_ADMIN]
    command: >
      sh -c "tc qdisc add dev eth0 root handle 1: netem loss 10% delay 100ms 20ms duplicate 1% corrupt 0.1% &&
             tc qdisc add dev eth0 parent 1:1 handle 10: tbf rate 1.5mbit burst 1540 latency 50ms"
    network_mode: "service:sut" # 共享网络命名空间，零侵入施加弱网

async function detectCapabilities(): Promise<CapabilityLevel> {
  // 1. API 存在性
  if (!('RTCRtpScriptTransform' in window)) return 'RTX_ONLY';
  
  // 2. 编解码器支持 (通过 createOffer 协商)
  const pc = new RTCPeerConnection();
  const transceiver = pc.addTransceiver('video', { direction: 'sendrecv' });
  transceiver.setCodecPreferences([
    { mimeType: 'video/VP8', clockRate: 90000 },
    { mimeType: 'video/flexfec', clockRate: 90000 } // 关键探测
  ]);
  const offer = await pc.createOffer();
  const hasFlexFEC = offer.sdp.includes('flexfec');
  pc.close();
  
  // 3. WASM SIMD 支持
  const hasSIMD = await checkWASMSIMDSupport();
  
  return hasFlexFEC ? (hasSIMD ? 'FULL_FLEXFEC_SIMD' : 'FULL_FLEXFEC_SCALAR') : 'ULPFEC_FALLBACK';
}

Sender: Encoder -> [FlexFEC Transform] -> [SFrame Encrypt Transform] -> Network
Receiver: Network -> [SFrame Decrypt Transform] -> [FlexFEC Transform] -> Decoder