┌─────────────────────────────────────────────────────────────┐
│                      应用层 (JS/TS)                          │
│  MediaSource / Fetch Stream → Demux (MP4Box.js / mux.js)    │
└──────────────────────────┬──────────────────────────────────┘
                           │ AnnexB / OBU 帧流
┌──────────────────────────▼──────────────────────────────────┐
│                   WebAssembly Module (Rust/C++)              │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │ 解复用适配层  │→ │ 硬解器抽象层  │→ │ 内存管理/零拷贝适配器 │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
└──────────────────────────┬──────────────────────────────────┘
                           │ VideoDecoder.configure({hardwareAcceleration:'prefer-hardware'})
┌──────────────────────────▼──────────────────────────────────┐
│                    WebCodecs API (浏览器内核)                 │
│  VideoDecoder → GPU Process → Platform Decoder (VA-API/D3D11/VideoToolbox) │
└──────────────────────────┬──────────────────────────────────┘
                           │ VideoFrame (GPU 内存 / CPU 内存)
┌──────────────────────────▼──────────────────────────────────┐
│                      渲染/后处理层                            │
│  VideoFrame → WebGL texImage2D / WebGPU importExternalTexture │
└─────────────────────────────────────────────────────────────┘

// 1. 特性检测与回落决策
async function createAV1HardwareDecoder(): Promise<VideoDecoder | null> {
  if (!('VideoDecoder' in window)) return null;
  const support = await VideoDecoder.isConfigSupported({
    codec: 'av01.0.05M.08', // AV1 Main Profile Level 5.1
    hardwareAcceleration: 'prefer-hardware'
  });
  if (!support.supported) return null; // 回落 Wasm 软解

  // 2. 实例化解码器
  const decoder = new VideoDecoder({
    output: handleFrame,
    error: e => console.error('Decoder error:', e)
  });

  decoder.configure({
    codec: 'av01.0.05M.08',
    hardwareAcceleration: 'prefer-hardware', // 关键：请求硬解
    optimizeForLatency: true // 低延迟模式
  });
  return decoder;
}

// Rust 侧伪代码：将 AnnexB NALU 转为 EncodedVideoChunk
#[wasm_bindgen]
pub fn feed_frame(decoder: &web_sys::VideoDecoder, nalu: &[u8], pts_us: u64, is_key: bool) {
    let chunk_type = if is_key { web_sys::EncodedVideoChunkType::Key } else { web_sys::EncodedVideoChunkType::Delta };
    let init = web_sys::EncodedVideoChunkInit::new(chunk_type, pts_us, nalu);
    let chunk = web_sys::EncodedVideoChunk::new(&init).unwrap();
    decoder.decode(&chunk);
}

// WebGL 路径（通用性最好）
function handleFrame(frame) {
  const gl = canvas.getContext('webgl2');
  const tex = gl.createTexture();
  gl.bindTexture(gl.TEXTURE_2D, tex);
  // 直接上传 GPU 内存，无 CPU 拷贝
  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, frame);
  // 渲染三角形...
  frame.close(); // 释放引用，归还显存
}

// WebGPU 路径（更高性能，Chrome 113+）
async function handleFrameGPU(frame) {
  const gpuTexture = device.importExternalTexture({ source: frame, colorSpace: 'srgb' });
  // 绑定到 BindGroup 直接采样
  frame.close();
}

async function getDecoderChain() {
  const hw = await createAV1HardwareDecoder();
  if (hw) return { decoder: hw, type: 'hardware' };
  const { default: Dav1dDecoder } = await import('./dav1d.wasm.js');
  return { decoder: new Dav1dDecoder(), type: 'software' };
}

// Rust 示例：8x8 逆 DCT SIMD 实现片段 (对应 dav1d 的 inv_txfm_8x8)
#[target_feature(enable = "simd128")]
unsafe fn idct8x8_simd(input: &[i32; 64], output: &mut [i16; 64], stride: usize) {
    // 1. 加载系数矩阵到 v128 (常量池预存)
    let cos_pi_4_16 = v128_const_i16x8([...]); // cos(pi/16) * 8192
    // ... 省略常量加载
    
    // 2. 行变换：利用 i16x8.splat / i16x8.mul / i16x8.add 横向蝶形运算
    let mut rows = [v128::default(); 8];
    for r in 0..8 {
        let src = v128_load(input.as_ptr().add(r * 8) as *const v128);
        rows[r] = butterfly_8x8_stage1(src, &COEFFS_STAGE1);
    }
    
    // 3. 列变换：转置 + 同行逻辑 (利用 v128.swizzle / v128.shuffle 实现高效转置)
    let cols = transpose_8x8_v128(rows);
    for c in 0..8 {
        let res = butterfly_8x8_stage2(cols[c], &COEFFS_STAGE2);
        v128_store(output.as_mut_ptr().add(c) as *mut v128, res); // stride 处理需额外 scatter
    }
}

graph LR
    Main[主线程 UI/渲染] -->|OffscreenCanvas / VideoFrame| WorkerPool[Worker Pool n=navigator.hardwareConcurrency]
    WorkerPool -->|postMessage(ArrayBuffer)| DecoderWasm[Wasm Decoder Instance]
    DecoderWasm -->|VideoFrame| Main
    WorkerPool -.->|SharedArrayBuffer| FrameRingBuffer[帧环形缓冲区]

// WGSL 片段：BT.2020 PQ (ST.2084) → 线性 Rec.2020 → sRGB 输出
fn pq_eotf(n: f32) -> f32 {
    let m1 = 0.1593017578125;  // 2610/16384
    let m2 = 78.84375;         // 2523/32
    let c1 = 0.8359375;        // 3424/4096
    let c2 = 18.8515625;       // 2413/128
    let c3 = 18.6875;          // 2392/128
    let pow = pow(n, m1);
    return pow((max(pow - c1, 0.0) / (c2 - c3 * pow)), m2);
}

@fragment
fn fs_main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
    let yuv = textureSample(externalTex, samp, uv); // externalTex 来自 importExternalTexture
    // 1. YUV → 线性 Rec.2020 (矩阵来自 ITU-R BT.2408)
    let rgb_linear = mat3x3<f32>(... ) * (yuv.rgb - vec3(0.0625, 0.5, 0.5));
    // 2. PQ EOTF
    let rgb_pq = vec3(pq_eotf(rgb_linear.r), pq_eotf(rgb_linear.g), pq_eotf(rgb_linear.b));
    // 3. 色调映射 (简单 Reinhard) → sRGB OETF
    let rgb_srgb = srgb_oetf(rgb_pq / (1.0 + rgb_pq));
    return vec4(rgb_srgb, 1.0);
}

// 架构：VideoFrame → WebGPU Texture → WebNN Model (ESRAN/RealBasicVSR) → Output Texture
async function enhanceFrame(frame: VideoFrame, model: MLModel) {
  const gpuTex = device.importExternalTexture({ source: frame, colorSpace: 'bt2020' });
  // 1. 预处理 Compute Shader: NHWC → NCHW, FP16 量化
  const inputTensor = await preprocessCompute(gpuTex); 
  // 2. WebNN 推理 (后端自动选 NPU/GPU/CPU)
  const outputTensor = await model.compute({ input: inputTensor });
  // 3. 后处理 Compute Shader: NCHW → 纹理
  return postprocessCompute(outputTensor);
}

// Wasm 侧解析 CMAF Chunk (ISOBMFF 片段)
#[wasm_bindgen]
pub fn parse_cmaf_chunk(data: &[u8]) -> Vec<Av1Obu> {
    let moof = parse_box(data, b"moof")?;
    let mdat = parse_box(data, b"mdat")?;
    let trun = find_trun(&moof)?;
    let sample_offsets = compute_sample_offsets(&trun, &moof);
    
    sample_offsets.iter().map(|offset| {
        let nalu = &mdat[*offset..][..trun.sample_size];
        // 关键：将 AnnexB start code (00 00 00 01) 转为 AV1 OBU (若封装为 OBU)
        // 或直接喂给 VideoDecoder (Chrome 支持 AnnexB AV1)
        annexb_to_obu(nalu) 
    }).collect()
}

// 主线程
const transformer = new TransformStream({
  async transform(controller, frame) {
    // frame 是 RTCEncodedVideoFrame (加密)
    const decrypted = await wasmDecrypt(frame.data, keySchedule); // Wasm AES-GCM
    controller.enqueue(new RTCEncodedVideoFrame({
      type: frame.type,
      timestamp: frame.timestamp,
      data: decrypted // 明文 AV1 OBU
    }));
  }
});
peerConnection.receiver.receiver.transform = transformer;

# .github/workflows/wasm-perf.yml
jobs:
  wasm-budget:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Release Wasm
        run: cargo build --target wasm32-unknown-unknown --release -Z build-std=panic_abort,std
      - name: Check Size Budget
        run: |
          SIZE=$(stat -c%s target/wasm32-unknown-unknown/release/av1_decoder.wasm)
          MAX=2_500_000 # 2.5MB gzip 前
          if [ $SIZE -gt $MAX ]; then exit 1; fi
      - name: Wasm-opt Strip & O4
        run: wasm-opt -O4 --strip-debug -o decoder.opt.wasm target/.../av1_decoder.wasm
      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with: { name: wasm-module, path: decoder.opt.wasm }

# bench/ci_benchmark.py (伪代码)
DEVICES = [
    ("Pixel 7 Pro", "Chrome 124", "android"),
    ("iPhone 15 Pro", "Safari 17.4", "ios"),
    ("Win11 RTX 4070", "Chrome 124", "windows"),
    ("M2 MacBook", "Safari 17.4", "macos"),
]

def run_benchmark(device, browser, os):
    # 1. 启动浏览器加载测试页 (包含 4K/1080p AV1 测试流)
    # 2. 注入 PerformanceObserver 采集 decoder.decodeQueueSize, frameDecodeTime
    # 3. 运行 60s, 导出 p50/p95/p99 延迟、CPU/GPU 占用、内存峰值
    # 4. 对比基线 (存储在 S3/DB), 超过阈值 (p95 > 1.2x baseline) 标红阻断合并
    pass