graph TD
    A[Web 应用层 JS/TS] -->|调用接口| B(Wasm Module / libaom)
    B --> C[编码核心逻辑]
    B --> D[内存管理模块]
    B --> E[线程池调度]
    C --> F[SIMD 优化内核]
    E --> G[Worker 线程并行]

# 使用 Emscripten 官方镜像
FROM emscripten/emsdk:3.1.50
WORKDIR /src
# 安装 CMake 3.20+ (libaom 新版构建依赖)
RUN apt-get update && apt-get install -y cmake ninja-build

emcmake cmake ../libaom 
  -DCMAKE_BUILD_TYPE=Release 
  -DENABLE_DOCS=OFF 
  -DENABLE_TOOLS=OFF 
  -DENABLE_EXAMPLES=OFF 
  -DCONFIG_MULTITHREAD=1           # 开启多线程支持 (依赖 pthreads)
  -DCONFIG_RUNTIME_CPU_DETECT=0    # 关闭运行时 CPU 检测，减少体积与启动延迟
  -DCONFIG_WEBM_IO=OFF 
  -DCONFIG_AV1_ENCODER=1 
  -DCONFIG_AV1_DECODER=0           # 仅编码场景裁剪解码器，大幅减小体积
  -DCMAKE_C_FLAGS="-O3 -msimd128 -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -mavx2 -mfma" 
  -DCMAKE_CXX_FLAGS="-O3 -msimd128" 
  -DEMSCRIPTEN_LINK_FLAGS="-O3 -msimd128 -pthread -s MODULARIZE=1 -s EXPORT_ES6=1 -s ENVIRONMENT=worker -s INITIAL_MEMORY=128MB -s MAXIMUM_MEMORY=512MB -s ALLOW_MEMORY_GROWTH=1 -s EXPORTED_FUNCTIONS='[_aom_codec_enc_init_ver,_aom_codec_encode,_aom_codec_get_cx_data,_aom_img_alloc,_aom_img_free,_malloc,_free]' -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap","HEAPU8","HEAPU32"]'"

// 推荐实时编码基线配置
cfg->g_usage = AOM_USAGE_REALTIME;      // 关键：启用实时模式内部快速算法
cfg->g_threads = 4;                     // 匹配 Worker 池大小
cfg->rc_target_bitrate = 5000;          // 目标码率 kbps
cfg->rc_min_quantizer = 2;              // 限制最小 QP，防止复杂场景计算爆炸
cfg->rc_max_quantizer = 56;
cfg->kf_min_dist = cfg->kf_max_dist = 3000; // 固定关键帧间隔，减少场景切换检测开销
cfg->g_lag_in_frames = 0;               // 零延迟模式，禁用前向参考帧缓存
cfg->g_error_resilient = 1;             // 抗误码能力，适合弱网推流
// 关键速度档位：0 最慢(高质量) - 8 最快(低质量)
// 实时场景建议起步设为 6 或 7，配合 cpu_used 动态微调
cfg->cpu_used = 7; 

// JS 侧监控编码耗时，反馈调整 cpu_used
let currentCpuUsed = 7;
function onFrameEncoded(durationMs) {
  const targetBudget = 30; // 33ms 预留 3ms 网络抖动
  if (durationMs > targetBudget * 1.2 && currentCpuUsed < 8) {
    currentCpuUsed++;
    encoderModule.setCpuUsed(currentCpuUsed); // 需导出修改 cfg->cpu_used 的接口
  } else if (durationMs < targetBudget * 0.7 && currentCpuUsed > 5) {
    currentCpuUsed--;
    encoderModule.setCpuUsed(currentCpuUsed);
  }
}

// 导出接口：预分配 N 帧缓存池
typedef struct { uint8_t* y; uint8_t* u; uint8_t* v; int stride_y; int stride_uv; int in_use; } FrameBuffer;
FrameBuffer* g_pool = NULL;
int g_pool_size = 0;

EMSCRIPTEN_KEEPALIVE
int init_frame_pool(int count, int w, int h) {
  // 计算对齐步长 (SIMD 要求 16 字节对齐)
  int stride_y = (w + 15) & ~15;
  int stride_uv = (stride_y / 2 + 15) & ~15;
  size_t frame_sz = stride_y * h * 3 / 2; // YUV420
  
  g_pool = (FrameBuffer*)malloc(count * sizeof(FrameBuffer));
  uint8_t* big_buf = (uint8_t*)memalign(64, count * frame_sz); // 64B 对齐优化缓存行
  
  for(int i=0; i<count; i++) {
    g_pool[i].y = big_buf + i * frame_sz;
    g_pool[i].u = g_pool[i].y + stride_y * h;
    g_pool[i].v = g_pool[i].u + stride_uv * (h/2);
    g_pool[i].stride_y = stride_y;
    g_pool[i].stride_uv = stride_uv;
    g_pool[i].in_use = 0;
  }
  g_pool_size = count;
  return (int)g_pool; // 返回指针地址给 JS
}

EMSCRIPTEN_KEEPALIVE
int acquire_frame() {
  for(int i=0; i<g_pool_size; i++) if(!g_pool[i].in_use) { g_pool[i].in_use=1; return i; }
  return -1; // 池耗尽
}

// 假设使用 WebCodecs VideoFrame
async function feedEncoder(videoFrame) {
  const frameIdx = encoderModule.acquireFrame(); // 获取空闲槽位
  if (frameIdx < 0) return dropFrame();
  
  // 直接获取 Wasm Memory 视图，零拷贝写入
  const poolPtr = encoderModule.getPoolPtr();
  const frameInfo = new Int32Array(encoderModule.HEAPU32.buffer, poolPtr + frameIdx * 20, 5); // 结构体偏移计算
  const yPtr = frameInfo[0], uPtr = frameInfo[1], vPtr = frameInfo[2];
  const strideY = frameInfo[3], strideUV = frameInfo[4];
  
  // 使用 VideoFrame.copyTo() 高效拷贝至 ArrayBufferView (映射 Wasm Memory)
  // 注意：需确保 Wasm Memory 为 SharedArrayBuffer 或通过允许的方式映射
  // 此处简化演示，实际需处理 stride 不一致情况
  const yView = new Uint8Array(encoderModule.HEAPU8.buffer, yPtr, strideY * height);
  const uView = new Uint8Array(encoderModule.HEAPU8.buffer, uPtr, strideUV * height / 2);
  const vView = new Uint8Array(encoderModule.HEAPU8.buffer, vPtr, strideUV * height / 2);
  
  await videoFrame.copyTo({ data: yView, stride: strideY }, { data: uView, stride: strideUV }, { data: vView, stride: strideUV });
  
  encoderModule.encodeFrame(frameIdx, videoFrame.timestamp); // 触发编码
  videoFrame.close();
}

#include <wasm_simd128.h>

// 计算 16x16 块 SAD，假设 stride 为 16 对齐
static INLINE int sad_16x16_simd(const uint8_t* src, int src_stride, const uint8_t* ref, int ref_stride) {
  v128_t sum = wasm_i16x8_splat(0); // 使用 16bit 累加防溢出
  
  for (int y = 0; y < 16; y++) {
    // 加载 16 字节 (128 bit)
    v128_t s = wasm_v128_load(src + y * src_stride);
    v128_t r = wasm_v128_load(ref + y * ref_stride);
    
    // 扩展为 16bit 无符号整数进行减法绝对值
    // v128_u8x16_to_u16x8_low/high 拆分高低 8 字节
    v128_t s_lo = wasm_u16x8_extend_low_u8x16(s);
    v128_t s_hi = wasm_u16x8_extend_high_u8x16(s);
    v128_t r_lo = wasm_u16x8_extend_low_u8x16(r);
    v128_t r_hi = wasm_u16x8_extend_high_u8x16(r);
    
    // 计算绝对差 |s - r|
    v128_t diff_lo = wasm_u16x8_sub_sat(s_lo, r_lo); // 饱和减法近似绝对值 (需配合 max/min 修正)
    v128_t diff_hi = wasm_u16x8_sub_sat(s_hi, r_hi);
    // 标准做法: max(s,r) - min(s,r)
    v128_t max_lo = wasm_u16x8_max(s_lo, r_lo);
    v128_t min_lo = wasm_u16x8_min(s_lo, r_lo);
    diff_lo = wasm_u16x8_sub(max_lo, min_lo);
    // ... high 同理
    
    // 横向累加
    sum = wasm_u16x8_add(sum, diff_lo);
    sum = wasm_u16x8_add(sum, diff_hi);
  }
  
  // 最终归约求和
  // 16x8 -> 8x8 -> ... -> scalar
  // 此处简化，实际需多级归约
  return horizontal_sum_u16x8(sum); 
}

// 主线程调度器简化模型
class EncoderScheduler {
  constructor(workerCount) {
    this.workers = [];
    this.taskQueue = new SharedArrayBuffer(/* 环形缓冲区大小 */);
    // ... 初始化队列指针 head/tail
    for(let i=0; i<workerCount; i++) {
      const w = new Worker('encoder_worker.js');
      w.postMessage({ type: 'init', memory: wasmMemory, queue: this.taskQueue });
      this.workers.push(w);
    }
  }
  
  encode(frameData) {
    return new Promise((resolve) => {
      const taskId = generateId();
      // 写入任务到队列 (原子操作)
      pushTask(this.taskQueue, { id: taskId, framePtr: frameData.ptr, timestamp: frameData.ts, resolve });
      Atomics.notify(this.taskQueue, TAIL_OFFSET, 1); // 唤醒一个空闲 Worker
    });
  }
}

// 统一接口定义
interface IEncoder {
  configure(config: EncoderConfig): Promise<void>;
  encode(frame: VideoFrame, options?: EncodeOptions): Promise<void>;
  onEncodedChunk: (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata) => void;
  onError: (error: Error) => void;
  flush(): Promise<void>;
  close(): Promise<void>;
  getStats(): EncoderStats; // 实时性能指标
}

// 策略模式工厂
class EncoderFactory {
  static async create(preferredCodec: 'av1' | 'vp9' | 'h264'): Promise<IEncoder> {
    // 1. 特性检测：硬编支持性
    const hwSupport = await VideoEncoder.isConfigSupported({
      codec: `avc1.42001E`, // 示例 profile
      hardwareAcceleration: 'prefer-hardware'
    });
    
    if (hwSupport.supported && hwSupport.config.hardwareAcceleration === 'hardware') {
      console.log('[EncoderFactory] 硬编可用，实例化 WebCodecsHardEncoder');
      return new WebCodecsHardEncoder(preferredCodec);
    }
    
    // 2. 回退 Wasm 软编
    console.warn('[EncoderFactory] 硬编不可用/降级，回退 WasmSoftEncoder');
    const { WasmSoftEncoder } = await import('./wasm-encoder');
    return new WasmSoftEncoder();
  }
}

class SeamlessSwitcher {
  private currentEncoder: IEncoder;
  private pendingFrames: VideoFrame[] = []; // 切换期间缓冲帧
  private lastTimestamp = 0;

  async switchTo(newEncoder: IEncoder, reason: string) {
    console.log(`[Switcher] 编码器切换: ${reason}`);
    
    // 1. 刷新旧编码器缓冲区，拿到最后一帧 PTS
    await this.currentEncoder.flush();
    
    // 2. 新编码器配置强制输出 IDR
    await newEncoder.configure({ 
      ...this.currentConfig, 
      forceKeyFrame: true // 关键：确保解码器能独立解码新流起点
    });
    
    // 3. 原子切换引用
    this.currentEncoder = newEncoder;
    
    // 4. 重放缓冲帧（带新时间基）
    for (const frame of this.pendingFrames) {
      this.currentEncoder.encode(frame);
    }
    this.pendingFrames = [];
  }
  
  encode(frame: VideoFrame) {
    if (this.isSwitching) this.pendingFrames.push(frame);
    else this.currentEncoder.encode(frame);
  }
}

// 启动期基准测：探测大小核性能比
async function probeCoreTopology() {
  const workers = Array.from({length: navigator.hardwareConcurrency}, () => new Worker('probe.js'));
  const results = await Promise.all(workers.map(w => runBench(w, 100))); // 短时高强度计算
  workers.forEach(w => w.terminate());
  
  // 聚类分析：耗时分为两类 -> 大核组 / 小核组
  const sorted = results.sort((a,b)=>a-b);
  const mid = sorted.length >> 1;
  const perfRatio = sorted[sorted.length-1] / sorted[0]; // 极值比
  
  return {
    totalCores: sorted.length,
    bigCoreCount: sorted.length - mid, // 简化假设
    perfRatio,
    recommendedThreads: perfRatio > 2.5 ? sorted.length - mid : sorted.length // 异构架构仅用大核
  };
}

interface ThermalState {
  level: 'nominal' | 'fair' | 'serious' | 'critical'; // 对应 Device Thermal API
  batteryLevel: number;
  isCharging: boolean;
}

class ThermalController {
  private policyMap = new Map<string, EncoderConfig>([
    ['nominal',    { cpu_used: 6, tiles: 4, fps: 30, bitrate: 5000 }],
    ['fair',       { cpu_used: 7, tiles: 2, fps: 30, bitrate: 4000 }], // 降并行度减发热
    ['serious',    { cpu_used: 8, tiles: 1, fps: 20, bitrate: 3000 }], // 单线程+降帧
    ['critical',   { cpu_used: 8, tiles: 1, fps: 10, bitrate: 1500 }]  // 保底可用
  ]);

  async onThermalChange(state: ThermalState) {
    const config = this.policyMap.get(state.level) || this.policyMap.get('nominal')!;
    
    // 电量低于 20% 且非充电，强制降一档
    if (state.batteryLevel < 0.2 && !state.isCharging) {
      config.cpu_used = Math.min(8, config.cpu_used + 1);
      config.fps = Math.max(10, config.fps - 5);
    }
    
    await this.encoder.reconfigure(config);
    this.reportMetric('thermal_policy_applied', { level: state.level, ...config });
  }
}

// 监听标准 API (Chrome 114+)
if ('thermal' in navigator) {
  (navigator as any).thermal.addEventListener('change', (e) => 
    thermalController.onThermalChange({ level: e.target.thermalState, ...await getBattery() })
  );
}

// 编码上下文中嵌入环形缓冲区管理
typedef struct {
  uint8_t* base;          // 启动期 memalign 分配的大块内存
  size_t capacity;        // 总字节数
  size_t frame_stride;    // 单帧占用字节数 (含 YUV + MV + 滤波临时缓存)
  atomic_int head;        // 生产者索引 (原子操作支持多线程入队)
  atomic_int tail;        // 消费者索引
  int mask;               // capacity / frame_stride - 1 (要求是 2 的幂)
} RingBuffer;

// 入队：原子 CAS 保证线程安全
int ring_push(RingBuffer* rb, const void* frame_data) {
  int head = atomic_load_explicit(&rb->head, memory_order_relaxed);
  int next = (head + 1) & rb->mask;
  if (next == atomic_load_explicit(&rb->tail, memory_order_acquire)) return -1; // 满
  
  memcpy(rb->base + head * rb->frame_stride, frame_data, rb->frame_stride);
  atomic_store_explicit(&rb->head, next, memory_order_release);
  return head; // 返回槽位索引
}

# 添加调试符号且不剥离
emcc ... -g3 -gsource-map -s SEPARATE_DWARF=1 -s DWARF=1 -o encoder.wasm

## 合规声明与组件清单 (SBOM 摘录)

本方案核心依赖组件及许可证合规状态如下：

| 组件 | 版本 | 许可证 | 合规动作 | 专利风险 |
| :--- | :--- | :--- | :--- | :--- |
| **libaom** | 3.6.0+ | BSD-2-Clause | 保留版权声明、许可证文本、变更日志 | **AOMedia Patent License 1.0** (免版税，需遵守互惠条款) |
| **Emscripten** | 3.1.50+ | MIT | 保留许可证 | 无 |
| **zlib** (依赖) | 1.3+ | Zlib | 保留声明 | 无 |
| **WebCodecs API** | W3C Standard | W3C Software License | 标准实现，无额外义务 | 依赖浏览器厂商实现 |

> **风险提示**：
> 1. AV1 专利池虽承诺免版税，但 **Sisvel / Velos Media** 等第三方声称持有必要专利。企业商用建议通过法律顾问确认 **AOMedia 成员身份** 或评估 **专利许可池** 覆盖范围。
> 2. 文章中性能数据均基于 **特定硬件/软件环境测试**，不构成任何性能承诺。实际部署请务必开展全机型兼容性测试。

{
  "encoder_core": {
    "codec": "av1",
    "profile": "main",
    "level": "4.1",
    "tier": "main"
  },
  "rate_control": {
    "mode": "CBR",
    "target_kbps": 4500,
    "max_kbps": 6000,
    "buffer_size_ms": 1000,
    "min_qp": 4,
    "max_qp": 52,
    "undershoot_pct": 50,
    "overshoot_pct": 50
  },
  "realtime_tuning": {
    "cpu_used": 7,
    "tiles_columns": 2,
    "tiles_rows": 1,
    "frame_parallel": 1,
    "aq_mode": 3,
    "deltaq_mode": 1,
    "enable_tpl_model": 1,
    "enable_rect_partitions": 1,
    "enable_ab_partitions": 1,
    "enable_1to1_partitions": 1,
    "disable_trellis_quant": 1,
    "disable_cdef": 0,
    "disable_lr": 0
  },
  "wasm_runtime": {
    "initial_memory_mb": 256,
    "max_memory_mb": 512,
    "thread_count": 4,
    "simd": true,
    "pthreads": true,
    "frame_pool_size": 6
  },
  "fallback_chain": [
    { "type": "webcodecs_hardware", "codec": "av1", "hw_accel": "prefer-hardware" },
    { "type": "webcodecs_hardware", "codec": "vp9", "hw_accel": "prefer-hardware" },
    { "type": "wasm_soft", "config": "realtime_tuning" },
    { "type": "cloud_transcode", "trigger": "all_local_failed" }
  ],
  "thermal_policy": {
    "enabled": true,
    "poll_interval_ms": 5000,
    "throttle_steps": [
      { "state": "nominal", "cpu_used": 7, "fps": 30 },
      { "state": "fair", "cpu_used": 8, "fps": 25 },
      { "state": "serious", "cpu_used": 8, "fps": 15, "bitrate_mul": 0.7 },
      { "state": "critical", "action": "force_cloud_fallback" }
    ]
  }
}