┌─────────────────────────────────────────────────────────────┐
│                    业务层 (TypeScript / Rust)                 │
│  会议业务逻辑 │ 设备管理 │ 布局引擎 │ 统计上报                │
├─────────────────────────────────────────────────────────────┤
│                  统一 WASM Runtime 抽象层                     │
│  Instance Pool │ Memory Manager │ Async Proxy │ Fallback     │
├─────────────────────────────────────────────────────────────┤
│                     核心算子 WASM 模块                         │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐             │
│  │ Audio   │ │ Video   │ │ AI      │ │ Codec   │  ...        │
│  │ Pre/Post│ │ Pre/Post│ │ Inference│ │ Filter  │             │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘             │
├─────────────────────────────────────────────────────────────┤
│              宿主能力适配层 (Host Bindings)                    │
│  WebCodecs / WebAudio / MediaStream / GPU Compute / Threads   │
└─────────────────────────────────────────────────────────────┘

# Cargo.toml 关键配置
[profile.release]
lto = "fat"           # 跨模块内联优化
codegen-units = 1     # 单代码单元最大化优化
panic = "abort"       # 减少体积
opt-level = "z"       # 体积优先，配合 SIMD 指令密度高特性

[features]
simd = ["stdsimd"]    # 启用 std::arch::wasm32::*
threads = ["send_wrapper", "wasm-bindgen-rayon"]

// 标量版本（参考实现，用于数值校验）
fn bilinear_scalar(src: &[u8], dst: &mut [u8], sw: u32, sh: u32, dw: u32, dh: u32) {
    for y in 0..dh {
        for x in 0..dw {
            let fx = (x as f32 + 0.5) * (sw as f32 / dw as f32) - 0.5;
            let fy = (y as f32 + 0.5) * (sh as f32 / dh as f32) - 0.5;
            // ... 双线性插值计算
        }
    }
}

// SIMD 版本：按 4 像素并行处理
#[target_feature(enable = "simd128")]
unsafe fn bilinear_simd128(src: &[u8], dst: &mut [u8], sw: u32, sh: u32, dw: u32, dh: u32) {
    use core::arch::wasm32::*;
    let scale_x = v128::f32x4_splat(sw as f32 / dw as f32);
    let scale_y = v128::f32x4_splat(sh as f32 / dh as f32);
    // 利用 v128_load/v128_store、f32x4_mul/add、i32x4_trunc_sat 等指令
    // 关键：边界处理使用 v128_bitselect 避免分支
}

// 宿主侧内存池管理（TypeScript 伪代码）
class WasmMemoryPool {
  private buffers: Map<number, ArrayBuffer> = new Map();
  private freeList: number[] = [];

  acquire(byteLength: number): { ptr: number; buffer: ArrayBuffer } {
    const aligned = (byteLength + 65535) & ~65535; // 64KB 对齐便于大页
    if (this.freeList.length) {
      const ptr = this.freeList.pop()!;
      return { ptr, buffer: this.buffers.get(ptr)! };
    }
    const memory = new WebAssembly.Memory({ initial: aligned / 65536, maximum: 1024, shared: true });
    const ptr = 0; // 简化：单实例单内存
    this.buffers.set(ptr, memory.buffer);
    return { ptr, buffer: memory.buffer };
  }

  release(ptr: number) { this.freeList.push(ptr); }
}

// 视频帧零拷贝流转
async function processVideoFrame(frame: VideoFrame, wasmModule: WasmModule) {
  const { ptr, buffer } = pool.acquire(frame.codedWidth * frame.codedHeight * 4);
  // 1. GPU -> CPU 仅一次读回（或 WebCodecs VideoFrame.copyTo）
  await frame.copyTo(new Uint8ClampedArray(buffer, ptr, frame.codedWidth * frame.codedHeight * 4));
  // 2. WASM 处理（内存不拷贝）
  wasmModule.exports.video_denoise(ptr, frame.codedWidth, frame.codedHeight, 0.8);
  // 3. 结果直接上传纹理/编码器
  const outputFrame = new VideoFrame(buffer.slice(ptr, ptr + ...), { format: 'RGBA', ... });
  pool.release(ptr);
  return outputFrame;
}

// Rust 侧使用 rayon-wasm 实现数据并行
use rayon::prelude::*;

#[wasm_bindgen]
pub fn batch_noise_suppress(ptr: *mut f32, frames: usize, frame_len: usize, level: f32) {
    let slice = unsafe { std::slice::from_raw_parts_mut(ptr, frames * frame_len) };
    slice.par_chunks_mut(frame_len).for_each(|frame| {
        // 每帧内部再用 SIMD 向量化
        noise_suppress_simd(frame, level);
    });
}

// 能力探测与模块加载决策
async function loadOptimalModule(): Promise<WasmModule> {
  const simd = await detectSimdSupport();      // wasmFeatureDetect('simd128')
  const threads = await detectThreadsSupport(); // cross-origin-isolated + SharedArrayBuffer
  const gpu = await detectGpuCompute();         // WebGPU / WebGL compute

  if (simd && threads && gpu) return import('./module_simd_threads_gpu.wasm');
  if (simd && threads) return import('./module_simd_threads.wasm');
  if (simd) return import('./module_simd.wasm');
  return import('./module_scalar.wasm'); // 兜底
}

function detectSimdSupport(): Promise<boolean> {
  return WebAssembly.validate(new Uint8Array([
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version
    0x01, 0x07, 0x01, 0x60, 0x00, 0x01, 0x7b,       // type sec: func -> v128
    0x03, 0x02, 0x01, 0x00,                           // func sec
    0x0a, 0x09, 0x01, 0x07, 0x00, 0xfd, 0x0c, 0x00, 0x0b // code sec: v128.const i32x4.splat
  ]));
}

音频流 → [VAD (WASM SIMD)] → [特征提取 (WASM SIMD)] → [声学模型 (WebGPU / WASM NN)] → [解码器 (WASM SIMD)] → 文本
视频流 → [预处理 (WASM SIMD)] → [人像分割 (WebGPU Compute Shader)] → [后处理融合 (WASM SIMD)] → 编码器

// winograd_conv.wgsl
@group(0) @binding(0) var<storage, read> input: array<f32>;
@group(0) @binding(1) var<storage, read> weight: array<f32>; // 预变换后权重
@group(0) @binding(2) var<storage, read_write> output: array<f32>;
@group(0) @binding(3) var<uniform> params: Params; // OH, OW, IC, OC

@compute @workgroup_size(8, 8, 1)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  let oh = gid.x; let ow = gid.y; let oc = gid.z;
  if (oh >= params.OH || ow >= params.OW || oc >= params.OC) { return; }

  // Winograd 域 4x4 输入瓦片 -> 2x2 输出
  var acc = 0.0;
  for (var ic = 0u; ic < params.IC; ic++) {
    // 加载 4x4 输入瓦片 (协作加载至 shared memory 进一步优化)
    // 此处简化为直接全局内存访问
    let tile = loadInputTile(input, oh * 2, ow * 2, ic);
    let w = loadWeightTile(weight, oc, ic);
    acc += winogradTransform(tile, w); // 16 mul + 12 add
  }
  output[((oc * params.OH + oh) * params.OW + ow)] = acc;
}

class HeterogeneousScheduler {
  private gpuQueue: GPUQueue;
  private wasmPool: WorkerPool;
  private perfDB: Map<string, BackendPerf>; // 算子级性能画像

  async dispatch(op: Operator, inputs: Tensor[]): Promise<Tensor> {
    const backend = this.selectBackend(op.name, inputs[0].shape);
    if (backend === 'webgpu') return this.dispatchGPU(op, inputs);
    return this.dispatchWASM(op, inputs);
  }

  private selectBackend(opName: string, shape: Shape): 'webgpu' | 'wasm' {
    const perf = this.perfDB.get(`${opName}-${shape.join('x')}`);
    if (!perf) return 'wasm'; // 首次默认 WASM，异步探测
    // 考虑当前 GPU 负载、电量模式、热节流状态
    if (perf.gpuLatency * 1.2 < perf.wasmLatency && !this.isThermalThrottling()) return 'webgpu';
    return 'wasm';
  }
}

# 一键生成标准算子工程
cookiecutter gh:your-org/wasm-operator-template 
  operator_name=noise_suppress 
  domain=audio 
  simd_level=simd128 
  test_vectors=./test_vectors/ns_48k.json