// decoder-pipeline.js
class VideoDecodePipeline {
  constructor({ onFrameDecoded, onError }) {
    this.onFrameDecoded = onFrameDecoded;
    this.decoder = new VideoDecoder({
      output: this.handleFrame.bind(this),
      error: onError
    });
    this.pendingFrames = new Map(); // 用于乱序重排
    this.decodeQueue = []; // 缓冲队列，背压控制
  }

  // 1. 配置解码器：关键在于 hardwareAcceleration 与 optimizeForLatency
  init(config) {
    this.decoder.configure({
      codec: config.codec, // 如 'avc1.42001f', 'vp09.00.10.08', 'hev1.1.6.L93.B0'
      codedWidth: config.width,
      codedHeight: config.height,
      // 显式声明硬件加速偏好，生产环境建议 'prefer-hardware' 并做降级兜底
      hardwareAcceleration: 'prefer-hardware', 
      optimizeForLatency: true // 低延迟模式，减少内部缓冲
    });
  }

  // 2. 推送压缩数据
  pushChunk(chunk, metadata) {
    // 背压控制：解码器内部队列满时暂停拉流
    if (this.decoder.decodeQueueSize > 30) { // 经验阈值，根据设备调整
      return Promise.resolve({ status: 'backpressure' });
    }
    
    try {
      this.decoder.decode(chunk);
      return Promise.resolve({ status: 'ok' });
    } catch (e) {
      // 处理配置变更导致的解码错误
      if (e.name === 'EncodingError') {
        this.handleConfigChange(metadata);
      }
      return Promise.reject(e);
    }
  }

  // 3. 处理解码输出：VideoFrame 必须 close() 释放显存
  async handleFrame(frame) {
    try {
      // 业务逻辑：渲染、传给处理层、或入编码队列
      // 注意：frame 所有权转移，使用完必须 close()
      await this.onFrameDecoded(frame);
    } finally {
      frame.close(); // 关键：释放 GPU 纹理/内存，防止 OOM
    }
  }

  // 4. 动态配置变更处理 (如分辨率切换)
  handleConfigChange(newConfig) {
    this.decoder.flush().then(() => {
      this.decoder.reconfigure(newConfig);
    });
  }

  destroy() {
    this.decoder.close();
  }
}

// processor-webgpu.js
class FrameProcessor {
  constructor(device, canvas) {
    this.device = device;
    this.context = canvas.getContext('webgpu');
    this.context.configure({
      device,
      format: navigator.gpu.getPreferredCanvasFormat(),
      alphaMode: 'premultiplied'
    });
    // 预编译着色器管线
    this.pipeline = this.createRenderPipeline();
  }

  async process(inputFrame, outputFrame) {
    // 1. 将 VideoFrame 导入为 GPUExternalTexture (零拷贝)
    const externalTexture = this.device.importExternalTexture({
      source: inputFrame,
      colorSpace: 'srgb', // 或 'display-p3' 根据源元数据
      premultipliedAlpha: true
    });

    // 2. 录制渲染命令
    const encoder = this.device.createCommandEncoder();
    const renderPass = encoder.beginRenderPass({
      colorAttachments: [{
        view: this.context.getCurrentTexture().createView(),
        loadOp: 'clear',
        storeOp: 'store'
      }]
    });
    
    renderPass.setPipeline(this.pipeline);
    renderPass.setBindGroup(0, this.bindGroupLayout.bindGroup(externalTexture));
    renderPass.draw(3); // 全屏三角形
    renderPass.end();

    // 3. 提交命令
    this.device.queue.submit([encoder.finish()]);
    
    // 4. 关键：将渲染结果拷贝回目标 VideoFrame (如果后续需编码)
    // 此处需使用 copyExternalImageToTexture 或配合 VideoFrame.fromCanvas()
    // 注意：VideoFrame.fromCanvas() 在主流浏览器已支持 GPU 纹理零拷贝导入
    const processedFrame = await VideoFrame.fromCanvas(canvas, {
      timestamp: inputFrame.timestamp
    });
    
    inputFrame.close(); // 释放输入帧
    return processedFrame; // 返回新帧送编码器
  }
}

// encoder-pipeline.js
class VideoEncodePipeline {
  constructor({ onChunk, onError, mimeType = 'video/mp4; codecs="avc1.42001f"' }) {
    this.chunks = [];
    this.encoder = new VideoEncoder({
      output: (chunk, metadata) => {
        this.chunks.push({ chunk, metadata });
        onChunk(chunk, metadata); // 实时回调：用于 WebRTC 发送或 Muxer 写入
      },
      error: onError
    });
    this.mimeType = mimeType;
  }

  async init(config) {
    const support = await VideoEncoder.isConfigSupported({
      codec: config.codec,
      width: config.width,
      height: config.height,
      bitrate: config.bitrate,
      framerate: config.framerate,
      hardwareAcceleration: 'prefer-hardware'
    });
    
    if (!support.supported) {
      throw new Error(`编码配置不支持: ${JSON.stringify(config)}`);
    }

    this.encoder.configure({
      codec: config.codec,
      width: config.width,
      height: config.height,
      bitrate: config.bitrate, // 目标码率
      framerate: config.framerate,
      latencyMode: 'realtime', // 实时模式：强制低延迟，可能牺牲压缩率
      hardwareAcceleration: 'prefer-hardware',
      // 关键帧间隔：实时通信建议 1-2s，存储建议 5-10s
      keyFrameInterval: config.isRealtime ? 1.0 : 5.0 
    });
  }

  encode(frame, forceKeyFrame = false) {
    // 时间戳单调性校验：编码器要求 timestamp 严格单调递增
    if (this.lastTimestamp !== undefined && frame.timestamp <= this.lastTimestamp) {
      console.warn('时间戳非单调递增，丢弃帧', frame.timestamp);
      frame.close();
      return;
    }
    this.lastTimestamp = frame.timestamp;

    const insertKeyframe = forceKeyFrame || this.needsKeyFrame();
    try {
      this.encoder.encode(frame, { keyFrame: insertKeyframe });
    } catch (e) {
      // 编码器内部错误，尝试重置
      frame.close();
      throw e;
    }
  }

  // 网络抖动/丢包恢复：请求下一帧为关键帧
  requestKeyFrame() {
    this.forceNextKeyFrame = true;
  }
  
  needsKeyFrame() { return this.forceNextKeyFrame = false; }

  async flush() {
    await this.encoder.flush();
    return this.chunks;
  }

  close() { this.encoder.close(); }
}

// 简易 VideoFrame 对象池示例
class FramePool {
  constructor(width, height, format = 'NV12', size = 10) {
    this.pool = [];
    this.inUse = new Set();
    for(let i=0; i<size; i++) {
      // 预分配可能较慢，建议懒加载或首帧解码时初始化
    }
  }
  acquire(timestamp) {
    let frame = this.pool.pop();
    if (!frame) {
      // 动态扩容
      frame = new VideoFrame(new Uint8Array(...), { timestamp, format, codedWidth: w, codedHeight: h });
    }
    this.inUse.add(frame);
    frame.timestamp = timestamp;
    return frame;
  }
  release(frame) {
    if (this.inUse.delete(frame)) this.pool.push(frame);
  }
}

graph LR
    Main[主线程 UI/网络] -->|postMessage EncodedVideoChunk| Worker[媒体处理 Worker]
    Worker -->|VideoDecoder| Decode[解码]
    Decode -->|VideoFrame| Process[处理 WebGPU/WASM]
    Process -->|VideoFrame| Encode[编码]
    Encode -->|postMessage EncodedVideoChunk| Main
    Main -->|WebRTC / Muxer / 下载| Output[输出]

// 伪代码：编码器码率动态调整
function onBandwidthEstimateChanged(estimatedBps) {
  // 留 20% 余量给音频和网络抖动
  const targetBitrate = Math.floor(estimatedBps * 0.8); 
  
  // 避免频繁变更震荡，设置阈值 (如 10%)
  if (Math.abs(targetBitrate - currentBitrate) / currentBitrate > 0.1) {
    encoder.encodeConfig.bitrate = targetBitrate;
    // reconfigure 是异步的，不阻塞编码流
    encoder.reconfigure({ bitrate: targetBitrate }).catch(console.error);
    currentBitrate = targetBitrate;
  }
}

// timeline-sync.js
class MediaTimeline {
  constructor() {
    this.baseTime = 0; // 管线启动时的 performance.now()
    this.audioOffset = 0; // 音频首帧 PTS 相对基准的偏移
    this.videoOffset = 0; // 视频首帧 PTS 相对基准的偏移
    this.started = false;
  }

  // 将轨道原始 PTS (微秒/时钟周期) 统一转换为内部微秒时间戳
  toInternalTimestamp(trackType, rawTimestamp, timescale) {
    const tsUs = (rawTimestamp / timescale) * 1_000_000; // 统一转微秒
    if (!this.started) {
      // 首帧校准：以最先到达的有效帧为基准
      this.baseTime = performance.now();
      this.started = true;
    }
    return tsUs;
  }

  // 获取当前播放/录制进度 (微秒)
  getCurrentTime() {
    return (performance.now() - this.baseTime) * 1000;
  }
}

// av-synchronizer.js
class AVSynchronizer {
  constructor(timeline, { onVideoFrame, onAudioFrame, maxBufferAhead = 500_000 }) { // 500ms 预缓冲
    this.timeline = timeline;
    this.videoQueue = []; // { frame, ptsUs }
    this.audioQueue = []; // { data, ptsUs, durationUs }
    this.onVideoFrame = onVideoFrame;
    this.onAudioFrame = onAudioFrame;
    this.maxBufferAhead = maxBufferAhead;
  }

  pushVideo(frame) {
    const ptsUs = this.timeline.toInternalTimestamp('video', frame.timestamp, 1_000_000);
    this.videoQueue.push({ frame, ptsUs });
    this.videoQueue.sort((a, b) => a.ptsUs - b.ptsUs);
    this.drain();
  }

  pushAudio(audioData, pts, timescale) {
    const ptsUs = this.timeline.toInternalTimestamp('audio', pts, timescale);
    const durationUs = (audioData.numberOfFrames / audioData.sampleRate) * 1_000_000;
    this.audioQueue.push({ data: audioData, ptsUs, durationUs });
    this.audioQueue.sort((a, b) => a.ptsUs - b.ptsUs);
    this.drain();
  }

  drain() {
    const now = this.timeline.getCurrentTime();
    const deadline = now + this.maxBufferAhead;

    // 视频：取 PTS <= now 的最新帧（丢弃过旧帧），若队列首帧 > now + 阈值，等待
    while (this.videoQueue.length > 0) {
      const head = this.videoQueue[0];
      if (head.ptsUs <= now) {
        this.videoQueue.shift();
        // 丢弃过旧帧：如果下一帧也已过期，继续丢弃
        if (this.videoQueue.length > 0 && this.videoQueue[0].ptsUs <= now) {
          head.frame.close(); // 释放资源
          continue;
        }
        this.onVideoFrame(head.frame); // 送编码/渲染
      } else if (head.ptsUs > deadline) {
        break; // 未来帧，等待
      } else {
        // 在 [now, deadline] 窗口内，提前送编码器（编码器内部有队列）
        this.videoQueue.shift();
        this.onVideoFrame(head.frame);
      }
    }

    // 音频：必须连续无间隙，缺帧需静音填充（或 PLC）
    while (this.audioQueue.length > 0) {
      const head = this.audioQueue[0];
      if (head.ptsUs + head.durationUs <= now) {
        // 已过期，丢弃
        this.audioQueue.shift();
        head.data.close();
      } else if (head.ptsUs <= now) {
        this.audioQueue.shift();
        this.onAudioFrame(head.data);
      } else {
        break;
      }
    }
  }
}

// fmp4-muxer-wrapper.js
import { Transmuxer } from 'mux.js'; // 或使用更轻量的 mp4-muxer

class StreamingMP4Muxer {
  constructor({ onSegment, onInitSegment, videoConfig, audioConfig }) {
    this.transmuxer = new Transmuxer({
      // 关键配置：生成 fMP4
      segmentType: 'fmp4',
      // 关键：传入编码器配置，避免解析裸流获取 SPS/PPS
      videoConfig, // { codec, width, height, sps, pps ... }
      audioConfig  // { codec, sampleRate, channelCount, config ... }
    });

    this.transmuxer.on('data', (segment) => {
      // segment: { initSegment, data, type: 'video'/'audio', ... }
      // fMP4 模式下，initSegment 仅首次触发，后续为 media segments
      if (segment.initSegment) {
        onInitSegment(segment.initSegment, segment.type);
      }
      onSegment(segment.data, segment.type); // ArrayBuffer 分片
    });
  }

  pushVideoChunk(chunk, metadata) {
    this.transmuxer.pushVideo(chunk, metadata); // metadata 包含 timestamp, duration, keyFrame
  }

  pushAudioChunk(chunk, metadata) {
    this.transmuxer.pushAudio(chunk, metadata);
  }

  flush() {
    this.transmuxer.flush();
  }
}

// resilient-codec-wrapper.js
class ResilientVideoEncoder {
  constructor(config, { onChunk, onError, onReconfigure }) {
    this.config = config;
    this.onChunk = onChunk;
    this.onError = onError;
    this.onReconfigure = onReconfigure; // 通知上层重新请求关键帧
    this.encoder = null;
    this.pendingFrames = []; // 重建期间缓存帧
    this.init();
  }

  async init() {
    this.encoder = new VideoEncoder({
      output: (chunk, meta) => this.onChunk(chunk, meta),
      error: (err) => this.handleError(err)
    });
    await this.configure(this.config);
    this.drainPending();
  }

  async configure(cfg) {
    // isConfigSupported 预检
    const support = await VideoEncoder.isConfigSupported(cfg);
    if (!support.supported) throw new Error('Config unsupported');
    
    this.encoder.configure(cfg);
    this.config = cfg;
  }

  encode(frame, options) {
    if (this.encoder.state === 'configured' || this.encoder.state === 'encoding') {
      try {
        this.encoder.encode(frame, options);
      } catch (e) {
        this.handleError(e);
        frame.close();
      }
    } else {
      // 编码器未就绪，入队等待
      if (this.pendingFrames.length < 60) { // 限制缓存大小
        this.pendingFrames.push({ frame, options });
      } else {
        frame.close(); // 丢弃最旧帧
      }
    }
  }

  async handleError(err) {
    console.error('[Encoder] Error:', err.message, 'State:', this.encoder?.state);
    this.onError(err);
    
    // 策略：非致命错误尝试 flush -> reset -> reconfigure
    if (this.encoder.state !== 'closed') {
      try { await this.encoder.flush(); } catch {}
      this.encoder.close();
    }
    
    // 指数退避重建
    await this.sleep(500); 
    await this.init(); // 复用原 config 重建
    this.onReconfigure(); // 触发上层请求 IDR
  }

  drainPending() {
    while (this.pendingFrames.length) {
      const { frame, options } = this.pendingFrames.shift();
      this.encode(frame, options);
    }
  }
  
  sleep(ms) => new Promise(r => setTimeout(r, ms));
}

// resource-governor.js
class ResourceGovernor {
  constructor({ onPressure }) {
    this.onPressure = onPressure; // 回调：要求管线降级
    this.checkInterval = null;
    this.pressureLevel = 'normal'; // normal, moderate, critical
  }

  start() {
    // 1. 监听浏览器原生 Memory Pressure API (Chrome 100+)
    if (navigator.deviceMemory && navigator.memory) {
      // 非标准但可用: performance.memory (Chrome only)
      this.checkInterval = setInterval(() => this.checkMemory(), 2000);
    }
    
    // 2. 监听 WebGL/WebGPU 上下文丢失事件 (显存耗尽前兆)
    // 需在持有 context 的模块中转发事件
  }

  checkMemory() {
    // 启发式：JS Heap > 1.5GB 或 接近 deviceMemory 限制
    const mem = performance.memory;
    if (mem) {
      const ratio = mem.usedJSHeapSize / mem.jsHeapSizeLimit;
      if (ratio > 0.85) this.trigger('critical');
      else if (ratio > 0.6) this.trigger('moderate');
      else this.trigger('normal');
    }
  }

  trigger(level) {
    if (level !== this.pressureLevel) {
      this.pressureLevel = level;
      this.onPressure(level);
    }
  }

  // 降级动作示例：
  // moderate: 降低编码分辨率/帧率/码率；关闭非核心滤镜
  // critical: 暂停编码，仅保留音频；释放所有 Frame Pool；提示用户
}

# .github/workflows/perf-ci.yml (伪代码)
jobs:
  benchmark:
    runs-on: [self-hosted, gpu-enabled] # 需自建 GPU Runner
    steps:
      - uses: actions/checkout@v4
      - name: Run Headless Benchmark
        run: |
          # 使用 Playwright/Puppeteer 驱动无头浏览器 (需开启 --enable-webgpu --use-angle=swiftshader 等)
          node bench/run.js --scenario=encode-1080p30 --duration=60s
      - name: Check Budget
        run: |
          # 解析 JSON 报告，对比基线
          node scripts/check-budget.js 
            --metric=avg_encode_latency_ms --max=12 --baseline=10 
            --metric=p99_frame_drop_rate --max=0.005 
            --metric=gpu_mem_peak_mb --max=300