// Rust + wasm-bindgen 片段
#[target_feature(enable = "simd128")]
pub unsafe fn nv12_to_rgba_simd(y_plane: &[u8], uv_plane: &[u8], rgba: &mut [u8], w: usize, h: usize) {
    let v128_load = |ptr: *const u8| v128::load(ptr as *const v128);
    let v128_store = |ptr: *mut u8, val: v128| v128::store(ptr as *mut v128, val);
    
    for row in 0..h {
        let y_row = y_plane.get_unchecked(row * w..).as_ptr();
        let uv_row = uv_plane.get_unchecked((row / 2) * w..).as_ptr();
        let dst_row = rgba.get_unchecked_mut(row * w * 4..).as_mut_ptr();
        
        // 每次处理 16 像素（128bit = 16×u8）
        for col in (0..w).step_by(16) {
            let y_vec = v128_load(y_row.add(col));
            let uv_vec = v128_load(uv_row.add(col));
            // ... 向量化 YUV→RGB 矩阵乘法 + 饱和截断
            v128_store(dst_row.add(col * 4), rgba_vec);
        }
    }
}

┌─────────────┐   SAB Ring Buffer   ┌─────────────┐   SAB Ring Buffer   ┌─────────────┐
│ Capture     │ ──────────────────▶ │ Preprocess  │ ──────────────────▶ │ Encode      │
│ (Main/Worker)│  (YUV420P, 60fps)  │ (Wasm Thread)│  (Denoise, BG)     │ (Wasm Thread)│
└─────────────┘                     └─────────────┘                     └─────────────┘
       │                                    │                                    │
       ▼                                    ▼                                    ▼
  getUserMedia                      SIMD Denoise +                    WebCodecs /
  VideoFrame                        Virtual BG                        VideoEncoder

// 无锁环形缓冲区：生产者-消费者单写单读，仅需原子序列号
struct RingBuffer<T> {
    slots: Box<[AtomicPtr<T>]>,
    head: AtomicUsize,  // 生产者位置
    tail: AtomicUsize,  // 消费者位置
}

// JS 胶水层：VideoFrame → Wasm 线性内存视图
async function feedFrameToWasm(frame, wasmMemory) {
  const { width, height, format } = frame;
  const planes = new Array(3);
  
  // 1. 申请 Wasm 内存视图（无拷贝）
  const ySize = width * height;
  const uvSize = ySize / 4;
  const yPtr = wasmModule.malloc(ySize);
  const uPtr = wasmModule.malloc(uvSize);
  const vPtr = wasmModule.malloc(uvSize);
  
  // 2. 浏览器原生拷贝至 Wasm 内存（单次 DMA 级拷贝）
  await frame.copyTo([
    { layout: [{ offset: 0, stride: width }], data: new Uint8Array(wasmMemory.buffer, yPtr, ySize) },
    { layout: [{ offset: 0, stride: width/2 }], data: new Uint8Array(wasmMemory.buffer, uPtr, uvSize) },
    { layout: [{ offset: 0, stride: width/2 }], data: new Uint8Array(wasmMemory.buffer, vPtr, uvSize) },
  ], { format: 'I420' });
  
  // 3. 通知 Wasm 线程处理（原子标志位）
  wasmModule.onNewFrame(yPtr, uPtr, vPtr, width, height, frame.timestamp);
}

graph LR
    A[AudioWorkletNode<br/>48kHz Float32] --> B[Wasm Thread: RNNoise<br/>降噪 + VAD]
    B --> C{VAD 判断}
    C -- 语音段 --> D[Wasm Thread: Whisper.cpp<br/>流式转写]
    C -- 静音 --> E[丢弃/舒适噪音]
    D --> F[WebSocket 推流<br/>字幕渲染]

// wasm-memory-pool crate 核心逻辑
pub struct FramePool {
    // 预分配 30 帧 1080p I420 缓冲区（约 30 * 3.75MB = 112MB）
    buffers: ArrayVec<[FrameBuffer; 30]>, 
    free_list: AtomicUsize, // 位图或无锁栈
}

impl FramePool {
    pub fn acquire(&self) -> Option<FrameBuffer> {
        // CAS 抢占空闲槽位，零系统调用
        let idx = self.free_list.fetch_or(1 << slot, Ordering::AcqRel);
        if idx & (1 << slot) == 0 { Some(self.buffers[slot]) } else { None }
    }
    
    pub fn release(&self, buf: FrameBuffer) {
        // 归还池，不执行 drop/dealloc
        self.free_list.fetch_and(!(1 << buf.slot), Ordering::Release);
    }
}

主线程 (UI/JS/网络/WebCodecs 回调)          → 大核 0 (高优先级)
└─ Wasm Thread 1: Capture + Preprocess      → 大核 1 (实时优先级)
└─ Wasm Thread 2: AI Inference (ORT)        → 大核 2 (实时优先级)
└─ Wasm Thread 3: Encoder (rav1e/dav1d)     → 大核 3 (实时优先级)
└─ Wasm Thread 4: Mixer / Audio Process     → 小核 0 (后台优先级)
└─ Wasm Thread 5: File I/O / Network Sender → 小核 1 (后台优先级)

// core/capability.ts
export interface MediaCaps {
  simd: boolean;
  threads: boolean;
  sab: boolean;
  webcodecs: boolean;
  webgpu: boolean;
  maxThreads: number;
}

export async function detectCaps(): Promise<MediaCaps> {
  const simd = await WasmFeatureDetect.simd128();
  const threads = await WasmFeatureDetect.threads();
  const sab = crossOriginIsolated; // 同步检测
  const webcodecs = 'VideoEncoder' in window;
  const webgpu = !!navigator.gpu;
  
  return {
    simd, threads, sab, webcodecs, webgpu,
    maxThreads: navigator.hardwareConcurrency || 4
  };
}

// 动态加载对应 Wasm 模块
async function loadPipeline(caps: MediaCaps) {
  const modules = [];
  if (caps.threads && caps.sab) {
    modules.push(import('./pipeline.mt.simd.wasm')); // 多线程 SIMD 版
  } else if (caps.simd) {
    modules.push(import('./pipeline.st.simd.wasm')); // 单线程 SIMD 版
  } else {
    modules.push(import('./pipeline.st.scalar.wasm')); // 纯标量兜底
  }
  
  if (caps.webcodecs) modules.push(import('./encoder.webcodecs.js'));
  else modules.push(import('./encoder.ffmpeg.wasm.js')); // FFmpeg.wasm 兜底编码
  
  return Promise.all(modules);
}

┌─────────────────────────────────────────────────────────────┐
│                    浏览器进程沙箱                            │
│  ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │  主进程       │  │  GPU 进程     │  │  Utility 进程       │  │
│  │  (UI/JS)     │  │  (WebGPU/GL)  │  │  (Audio/Video 编解码)│  │
│  └──────┬───────┘  └──────┬───────┘  └─────────┬──────────┘  │
│         │                 │                    │             │
│         ▼                 ▼                    ▼             │
│  ┌────────────────────────────────────────────────────────┐  │
│  │              Wasm 线性内存 (进程内共享)                 │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────────┐  │  │
│  │  │ 采集帧   │ │ 预处理   │ │  AI 推理  │ │  编码输出    │  │  │
│  │  │ (明文)  │ │ (明文)  │ │ (明文)   │ │ (加密载荷)  │  │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────────┘  │  │
│  └────────────────────────────────────────────────────────┘  │
│                          │                                    │
│                          ▼ (E2EE 加密后离开沙箱)               │
│  ┌────────────────────────────────────────────────────────┐  │
│  │              网络进程 → TLS/DTLS → 服务器                │  │
│  └────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

// wit/media.wit
package media:pipeline;

interface frame-processor {
  // 输入输出均为线性内存指针+元数据，零拷贝
  record frame { ptr: u32, len: u32, width: u32, height: u32, fmt: pixel-format, ts: u64 }
  enum pixel-format { i420, nv12, rgba, bgra }
  
  // 处理函数：返回处理后帧指针，0 表示失败/丢帧
  process: func(input: frame) -> u32
  
  // 配置下发：JSON 字符串指针
  configure: func(config_json: u32) -> bool
}

world media-plugin {
  export frame-processor;
  import memory; // 共享线性内存
  import log: func(level: u32, msg_ptr: u32, msg_len: u32); // 回调 JS 日志
}

# 1. 生成 Rust 接口
wit-bindgen rust --world media-plugin --out-dir src/bindings wit/media.wit

# 2. 生成 TypeScript 绑定 (wasm-component-model)
wit-bindgen ts --world media-plugin --out-dir src/bindings wit/media.wit

# 3. Rust 实现 trait
impl frame_processor::FrameProcessor for MyProcessor { ... }

# 4. 编译为 Component Model (.wasm)
cargo component build --release

# .github/workflows/wasm-perf.yml
jobs:
  perf-regression:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Wasm (SIMD/Threads)
        run: cargo component build --release --target wasm32-wasip1
      - name: Run Benchmarks (Node.js + WASI Preview 2)
        run: |
          wasmtime run --wasi=preview2 target/wasm32-wasip1/release/media.wasm 
            --bench=encode_1080p30 --bench=denoise_720p --bench=bg_segmentation
      - name: Compare with Baseline
        run: |
          python scripts/compare_perf.py 
            --current target/criterion 
            --baseline artifacts/perf-baseline.json 
            --threshold 1.05  # 允许 5% 回归
      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: wasm-perf-report
          path: target/criterion/**/report/*

// 运行时根据设备画像动态开关
const profile = await DeviceProfiler.getProfile(); // 基准跑分 + 电池电量 + 热节流状态
const policy = PolicyEngine.decide(profile, userPrefs);
// 例：低电量模式下自动关闭虚拟背景、降级字幕模型为更小版本

// panic hook 捕获 Trap 上下文
#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    let mut ctx = TrapContext::default();
    ctx.message = format!("{}", info);
    ctx.backtrace = get_backtrace(); // 需编译时 panic=unwind
    ctx.memory_usage = get_memory_stats();
    ctx.timestamp = js_sys::Date::now();
    
    // 通过预留的 JS 回调上报（避免控制台丢失）
    unsafe { crate::bindings::report_trap(&ctx as *const _ as u32, size_of::<TrapContext>() as u32) };
    
    core::arch::wasm32::unreachable()
}