@give-tech/ec-player 0.0.1-beta.0

package/dist/index.js

@@ -0,0 +1,3869 @@
+class WASMLoader {
+  constructor() {
+    this.module = null;
+  }
+  async load(wasmPath) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = wasmPath;
+      script.type = "text/javascript";
+      script.onload = async () => {
+        try {
+          const createFFmpegDecoder = window.createFFmpegDecoder;
+          if (typeof createFFmpegDecoder !== "function") {
+            reject(new Error("createFFmpegDecoder not found"));
+            return;
+          }
+          this.module = await createFFmpegDecoder();
+          if (typeof this.module?._create_decoder !== "function") {
+            reject(new Error("Module initialization failed"));
+            return;
+          }
+          resolve(this.module);
+        } catch (e) {
+          reject(new Error(`Failed to initialize decoder: ${e.message}`));
+        }
+      };
+      script.onerror = () => {
+        reject(new Error(`Failed to load script: ${wasmPath}`));
+      };
+      document.head.appendChild(script);
+    });
+  }
+  getModule() {
+    return this.module;
+  }
+}
+class H264Decoder {
+  constructor(wasmLoader) {
+    this.wasmModule = null;
+    this.decoderContext = null;
+    this.wasmModule = wasmLoader.getModule();
+  }
+  async init() {
+    if (!this.wasmModule) {
+      throw new Error("WASM module not loaded");
+    }
+    this.decoderContext = this.wasmModule._create_decoder(27);
+    if (this.decoderContext === 0 || this.decoderContext === null) {
+      throw new Error("Failed to create decoder context");
+    }
+  }
+  decode(nalUnit) {
+    if (this.decoderContext === null || !this.wasmModule) {
+      return null;
+    }
+    const dataPtr = this.wasmModule._malloc(nalUnit.size);
+    this.wasmModule.HEAPU8.set(nalUnit.data, dataPtr);
+    const result = this.wasmModule._decode_video(
+      this.decoderContext,
+      dataPtr,
+      nalUnit.size
+    );
+    this.wasmModule._free(dataPtr);
+    if (result === 1) {
+      const width = this.wasmModule._get_frame_width(this.decoderContext);
+      const height = this.wasmModule._get_frame_height(this.decoderContext);
+      if (width <= 0 || height <= 0) {
+        return null;
+      }
+      const yPtr = this.wasmModule._get_frame_data(this.decoderContext, 0);
+      const uPtr = this.wasmModule._get_frame_data(this.decoderContext, 1);
+      const vPtr = this.wasmModule._get_frame_data(this.decoderContext, 2);
+      const yLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 0);
+      const uLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 1);
+      const vLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 2);
+      const frameData = this.yuv420pToRgba(
+        yPtr,
+        uPtr,
+        vPtr,
+        width,
+        height,
+        yLineSize,
+        uLineSize,
+        vLineSize
+      );
+      return { width, height, data: frameData };
+    }
+    return null;
+  }
+  yuv420pToRgba(yPtr, uPtr, vPtr, width, height, yLineSize, uLineSize, vLineSize) {
+    const rgba = new Uint8Array(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const yIndex = y * yLineSize + x;
+        const uIndex = (y >> 1) * uLineSize + (x >> 1);
+        const vIndex = (y >> 1) * vLineSize + (x >> 1);
+        const yValue = this.wasmModule.HEAPU8[yPtr + yIndex];
+        const uValue = this.wasmModule.HEAPU8[uPtr + uIndex];
+        const vValue = this.wasmModule.HEAPU8[vPtr + vIndex];
+        const c = yValue - 16;
+        const d = uValue - 128;
+        const e = vValue - 128;
+        let r = 298 * c + 409 * e + 128 >> 8;
+        let g = 298 * c - 100 * d - 208 * e + 128 >> 8;
+        let b = 298 * c + 516 * d + 128 >> 8;
+        r = r < 0 ? 0 : r > 255 ? 255 : r;
+        g = g < 0 ? 0 : g > 255 ? 255 : g;
+        b = b < 0 ? 0 : b > 255 ? 255 : b;
+        const rgbaIndex = (y * width + x) * 4;
+        rgba[rgbaIndex] = r;
+        rgba[rgbaIndex + 1] = g;
+        rgba[rgbaIndex + 2] = b;
+        rgba[rgbaIndex + 3] = 255;
+      }
+    }
+    return rgba;
+  }
+}
+const DEFAULT_PLAYER_CONFIG = {
+  wasmPath: "/wasm/decoder-simd.js",
+  targetBufferSize: 60,
+  decodeBatchSize: 2,
+  maxQueueSize: 200,
+  isLive: false
+};
+class BasePlayer {
+  constructor(config, callbacks, defaults) {
+    this.wasmLoader = new WASMLoader();
+    this.decoder = null;
+    this.renderer = null;
+    this.decoderInitialized = false;
+    this.isPlaying = false;
+    this.frameTimer = null;
+    this.frameBuffer = [];
+    this.droppedFrames = 0;
+    this.decodeLoopAbort = false;
+    this._currentTime = 0;
+    this._duration = 0;
+    this.state = {
+      isPlaying: false,
+      isLoaded: false,
+      isLoading: false,
+      fps: 0,
+      resolution: "-",
+      decoded: 0,
+      downloaded: 0,
+      droppedFrames: 0,
+      isPrefetching: false,
+      segmentIndex: 0,
+      totalSegments: 0,
+      downloadSpeed: 0,
+      currentTime: 0,
+      duration: 0
+    };
+    this.renderLoop = () => {
+      if (!this.isPlaying) return;
+      this.updateState({
+        decoded: this.frameBuffer.length,
+        droppedFrames: this.droppedFrames
+      });
+      if (this.frameBuffer.length > 0 && this.renderer) {
+        const frame = this.frameBuffer.shift();
+        this.renderer.render(frame);
+        this.updateState({ resolution: `${frame.width}x${frame.height}` });
+        const fps = this.renderer.updateFps();
+        this.updateState({ fps });
+        this.callbacks.onFrameRender?.(frame);
+      }
+      this.frameTimer = requestAnimationFrame(this.renderLoop);
+    };
+    this.config = { ...defaults, ...config };
+    this.callbacks = callbacks;
+  }
+  // ==================== 公共方法 ====================
+  /**
+   * 设置渲染器
+   */
+  setRenderer(renderer) {
+    this.renderer = renderer;
+  }
+  /**
+   * 初始化解码器
+   */
+  async initDecoder() {
+    await this.wasmLoader.load(this.config.wasmPath);
+    this.decoder = new H264Decoder(this.wasmLoader);
+    await this.decoder.init();
+  }
+  /**
+   * 开始播放
+   */
+  async play() {
+    this.isPlaying = true;
+    this.decodeLoopAbort = false;
+    this.updateState({ isPlaying: true });
+    this.decodeLoop();
+    this.frameTimer = requestAnimationFrame(this.renderLoop);
+  }
+  /**
+   * 暂停播放
+   */
+  pause() {
+    this.isPlaying = false;
+    this.decodeLoopAbort = true;
+    this.updateState({ isPlaying: false });
+    if (this.frameTimer !== null) {
+      cancelAnimationFrame(this.frameTimer);
+      this.frameTimer = null;
+    }
+  }
+  /**
+   * 销毁播放器，释放资源
+   */
+  destroy() {
+    console.log("[BasePlayer] Destroying player...");
+    this.pause();
+    this.frameBuffer = [];
+    this.resetState();
+    this.state = {
+      isPlaying: false,
+      isLoaded: false,
+      isLoading: false,
+      fps: 0,
+      resolution: "-",
+      decoded: 0,
+      downloaded: 0,
+      droppedFrames: 0,
+      isPrefetching: false,
+      segmentIndex: 0,
+      totalSegments: 0,
+      downloadSpeed: 0,
+      currentTime: 0,
+      duration: 0
+    };
+    this.decoder = null;
+    this.renderer = null;
+    console.log("[BasePlayer] Player destroyed");
+  }
+  /**
+   * 获取播放状态
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * 获取当前播放时间（毫秒）
+   */
+  getCurrentTime() {
+    return this._currentTime;
+  }
+  /**
+   * 获取总时长（毫秒）
+   */
+  getDuration() {
+    return this._duration;
+  }
+  /**
+   * 设置当前时间（供子类调用）
+   */
+  setCurrentTime(time) {
+    this._currentTime = time;
+    this.updateState({ currentTime: time });
+  }
+  /**
+   * 设置总时长（供子类调用）
+   */
+  setDuration(duration) {
+    this._duration = duration;
+    this.updateState({ duration });
+  }
+  // ==================== 受保护的工具方法 ====================
+  /**
+   * 更新状态
+   */
+  updateState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.callbacks.onStateChange?.(partial);
+  }
+  /**
+   * 快速让出主线程
+   */
+  yieldFast() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  /**
+   * 休眠
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 重置播放器状态
+   */
+  resetState() {
+    this.frameBuffer = [];
+    this.droppedFrames = 0;
+    this.decoderInitialized = false;
+    this.decodeLoopAbort = false;
+    this._currentTime = 0;
+    this._duration = 0;
+  }
+}
+class TSDemuxer {
+  constructor() {
+    this.videoPID = 258;
+    this.audioPID = 257;
+  }
+  parse(data) {
+    let offset = 0;
+    const packets = [];
+    while (offset < data.length - 188) {
+      if (data[offset] !== 71) {
+        offset++;
+        continue;
+      }
+      if (offset + 188 > data.length) break;
+      const adaptationFieldControl = data[offset + 3] >> 4 & 3;
+      const hasPayload = adaptationFieldControl === 1 || adaptationFieldControl === 3;
+      if (!hasPayload) {
+        offset += 188;
+        continue;
+      }
+      const pidValue = (data[offset + 1] & 31) << 8 | data[offset + 2];
+      let streamType = null;
+      if (pidValue === this.videoPID) {
+        streamType = "video";
+      } else if (pidValue === this.audioPID) {
+        streamType = "audio";
+      }
+      packets.push({
+        data: data.subarray(offset, offset + 188),
+        pid: pidValue,
+        stream: streamType
+      });
+      offset += 188;
+    }
+    return {
+      video: packets.filter((p) => p.stream === "video"),
+      audio: packets.filter((p) => p.stream === "audio")
+    };
+  }
+}
+class PESExtractor {
+  /**
+   * 从视频 TS 包中提取 payload 数据
+   */
+  extractVideoPayload(packets) {
+    const payloads = [];
+    let pesHeaderProcessed = false;
+    for (const packet of packets) {
+      const data = packet.data;
+      if (data.length < 5) continue;
+      const payloadUnitStart = (data[1] & 64) !== 0;
+      const adaptationFieldControl = data[3] >> 4 & 3;
+      let payloadStart = 4;
+      if (adaptationFieldControl === 2 || adaptationFieldControl === 3) {
+        const adaptationFieldLength = data[4];
+        payloadStart += 1 + adaptationFieldLength;
+      }
+      if (adaptationFieldControl === 1 || adaptationFieldControl === 3) {
+        if (payloadStart < data.length) {
+          let payload = data.subarray(payloadStart);
+          if (payloadUnitStart && payload.length >= 9) {
+            if (payload[0] === 0 && payload[1] === 0 && payload[2] === 1) {
+              const pesHeaderDataLength = payload[8];
+              const pesHeaderSize = 9 + pesHeaderDataLength;
+              if (payload.length > pesHeaderSize) {
+                payload = payload.subarray(pesHeaderSize);
+                pesHeaderProcessed = true;
+              }
+            }
+          }
+          if (payload.length > 0 && pesHeaderProcessed) {
+            payloads.push(payload);
+          }
+        }
+      }
+    }
+    const totalSize = payloads.reduce((sum, p) => sum + p.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const payload of payloads) {
+      result.set(payload, offset);
+      offset += payload.length;
+    }
+    return result;
+  }
+}
+function readUint32$1(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function readInt32(data, offset) {
+  const value = readUint32$1(data, offset);
+  return value > 2147483647 ? value - 4294967296 : value;
+}
+function readUint64(data, offset) {
+  const view = new DataView(data.buffer, data.byteOffset, data.length);
+  return Number(view.getBigUint64(offset));
+}
+function readFourCC(data, offset) {
+  return String.fromCharCode(
+    data[offset],
+    data[offset + 1],
+    data[offset + 2],
+    data[offset + 3]
+  );
+}
+function readBoxFlags(data, offset) {
+  return (data[offset] << 16 | data[offset + 1] << 8 | data[offset + 2]) >>> 0;
+}
+class fMP4Demuxer {
+  constructor() {
+    this.timescale = 1e3;
+    this.trackId = 1;
+    this.avcC = null;
+  }
+  /**
+   * 解析初始化段 (ftyp + moov)
+   */
+  parseInitSegment(data) {
+    let offset = 0;
+    while (offset < data.length - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "moov") {
+        this.parseMoov(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+    return {
+      trackId: this.trackId,
+      timescale: this.timescale,
+      avcC: this.avcC || void 0
+    };
+  }
+  /**
+   * 解析 moov box
+   */
+  parseMoov(data, moovOffset, moovSize) {
+    let offset = moovOffset + 8;
+    const endOffset = moovOffset + moovSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "trak") {
+        this.parseTrak(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 trak box
+   */
+  parseTrak(data, trakOffset, trakSize) {
+    let offset = trakOffset + 8;
+    const endOffset = trakOffset + trakSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "mdia") {
+        this.parseMdia(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 mdia box
+   */
+  parseMdia(data, mdiaOffset, mdiaSize) {
+    let offset = mdiaOffset + 8;
+    const endOffset = mdiaOffset + mdiaSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "mdhd") {
+        this.parseMdhd(data, offset + 8);
+      } else if (boxType === "minf") {
+        this.parseMinf(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 mdhd box 获取 timescale
+   */
+  parseMdhd(data, boxDataOffset) {
+    const version = data[boxDataOffset];
+    if (version === 1) {
+      this.timescale = readUint32$1(data, boxDataOffset + 20);
+    } else {
+      this.timescale = readUint32$1(data, boxDataOffset + 12);
+    }
+  }
+  /**
+   * 解析 minf box
+   */
+  parseMinf(data, minfOffset, minfSize) {
+    let offset = minfOffset + 8;
+    const endOffset = minfOffset + minfSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "stbl") {
+        this.parseStbl(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 stbl box 获取 avcC
+   */
+  parseStbl(data, stblOffset, stblSize) {
+    let offset = stblOffset + 8;
+    const endOffset = stblOffset + stblSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "stsd") {
+        this.parseStsd(data, offset, boxSize);
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 stsd box 获取 avcC
+   */
+  parseStsd(data, stsdOffset, stsdSize) {
+    const boxDataOffset = stsdOffset + 8;
+    const entryCount = readUint32$1(data, boxDataOffset + 4);
+    let offset = boxDataOffset + 8;
+    const endOffset = stsdOffset + stsdSize;
+    for (let i = 0; i < entryCount && offset < endOffset - 8; i++) {
+      const entrySize = readUint32$1(data, offset);
+      const entryType = readFourCC(data, offset + 4);
+      if (entryType === "avc1" || entryType === "avc3") {
+        this.parseAvcSampleEntry(data, offset, entrySize);
+        return;
+      }
+      offset += entrySize;
+    }
+  }
+  /**
+   * 解析 AVC Sample Entry
+   */
+  parseAvcSampleEntry(data, entryOffset, entrySize) {
+    let offset = entryOffset + 8 + 78;
+    const endOffset = entryOffset + entrySize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "avcC") {
+        this.avcC = data.slice(offset, offset + boxSize);
+        return;
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 moof box
+   */
+  parseMoof(data, moofOffset) {
+    const moofSize = readUint32$1(data, moofOffset);
+    const moof = {
+      mfhd: void 0,
+      trafs: [],
+      dataOffset: moofOffset,
+      size: moofSize
+    };
+    let offset = moofOffset + 8;
+    const endOffset = moofOffset + moofSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "mfhd") {
+        moof.mfhd = {
+          sequenceNumber: readUint32$1(data, offset + 8 + 4)
+        };
+      } else if (boxType === "traf") {
+        const traf = this.parseTraf(data, offset, boxSize);
+        moof.trafs.push(traf);
+      }
+      offset += boxSize;
+    }
+    return moof;
+  }
+  /**
+   * 解析 traf box
+   */
+  parseTraf(data, trafOffset, trafSize) {
+    const traf = {
+      truns: []
+    };
+    let offset = trafOffset + 8;
+    const endOffset = trafOffset + trafSize;
+    while (offset < endOffset - 8) {
+      const boxSize = readUint32$1(data, offset);
+      const boxType = readFourCC(data, offset + 4);
+      if (boxSize < 8) break;
+      if (boxType === "tfhd") {
+        traf.tfhd = this.parseTfhd(data, offset + 8);
+      } else if (boxType === "tfdt") {
+        traf.tfdt = this.parseTfdt(data, offset + 8);
+      } else if (boxType === "trun") {
+        if (traf.tfhd) {
+          traf.truns.push(this.parseTrun(data, offset + 8, traf.tfhd));
+        }
+      }
+      offset += boxSize;
+    }
+    return traf;
+  }
+  /**
+   * 解析 tfhd box
+   */
+  parseTfhd(data, boxDataOffset) {
+    const flags = readBoxFlags(data, boxDataOffset);
+    const tfhd = {
+      trackId: readUint32$1(data, boxDataOffset + 4)
+    };
+    let offset = boxDataOffset + 8;
+    if (flags & 1) {
+      tfhd.baseDataOffset = readUint64(data, offset);
+      offset += 8;
+    }
+    if (flags & 2) {
+      tfhd.sampleDescriptionIndex = readUint32$1(data, offset);
+      offset += 4;
+    }
+    if (flags & 8) {
+      tfhd.defaultSampleDuration = readUint32$1(data, offset);
+      offset += 4;
+    }
+    if (flags & 16) {
+      tfhd.defaultSampleSize = readUint32$1(data, offset);
+      offset += 4;
+    }
+    if (flags & 32) {
+      tfhd.defaultSampleFlags = readUint32$1(data, offset);
+    }
+    return tfhd;
+  }
+  /**
+   * 解析 tfdt box
+   */
+  parseTfdt(data, boxDataOffset) {
+    const version = data[boxDataOffset];
+    return {
+      baseMediaDecodeTime: version === 1 ? readUint64(data, boxDataOffset + 4) : readUint32$1(data, boxDataOffset + 4)
+    };
+  }
+  /**
+   * 解析 trun box
+   */
+  parseTrun(data, boxDataOffset, tfhd) {
+    const version = data[boxDataOffset];
+    const flags = readBoxFlags(data, boxDataOffset + 1);
+    const sampleCount = readUint32$1(data, boxDataOffset + 4);
+    const trun = {
+      sampleCount,
+      samples: []
+    };
+    let offset = boxDataOffset + 8;
+    if (flags & 1) {
+      trun.dataOffset = readInt32(data, offset);
+      offset += 4;
+    }
+    if (flags & 4) {
+      trun.firstSampleFlags = readUint32$1(data, offset);
+      offset += 4;
+    }
+    const hasDuration = (flags & 256) !== 0;
+    const hasSize = (flags & 512) !== 0;
+    const hasFlags = (flags & 1024) !== 0;
+    const hasCto = (flags & 2048) !== 0;
+    for (let i = 0; i < sampleCount; i++) {
+      const sample = {};
+      if (hasDuration) {
+        sample.duration = readUint32$1(data, offset);
+        offset += 4;
+      } else {
+        sample.duration = tfhd.defaultSampleDuration;
+      }
+      if (hasSize) {
+        sample.size = readUint32$1(data, offset);
+        offset += 4;
+      } else {
+        sample.size = tfhd.defaultSampleSize;
+      }
+      if (hasFlags) {
+        sample.flags = readUint32$1(data, offset);
+        offset += 4;
+      } else if (i === 0 && trun.firstSampleFlags !== void 0) {
+        sample.flags = trun.firstSampleFlags;
+      } else {
+        sample.flags = tfhd.defaultSampleFlags;
+      }
+      if (hasCto) {
+        sample.compositionTimeOffset = version === 0 ? readUint32$1(data, offset) : readInt32(data, offset);
+        offset += 4;
+      }
+      trun.samples.push(sample);
+    }
+    return trun;
+  }
+  /**
+   * 从 moof + mdat 提取视频样本
+   */
+  extractSamples(moof, mdatData, mdatOffset) {
+    const samples = [];
+    for (const traf of moof.trafs) {
+      if (!traf.tfhd || !traf.tfdt) continue;
+      let baseDts = traf.tfdt.baseMediaDecodeTime;
+      for (const trun of traf.truns) {
+        let dataOffset = 0;
+        if (trun.dataOffset !== void 0) {
+          dataOffset = trun.dataOffset - mdatOffset - 8;
+        }
+        for (const sample of trun.samples) {
+          if (sample.size === void 0 || sample.size <= 0) continue;
+          const sampleData = mdatData.slice(dataOffset, dataOffset + sample.size);
+          const isSync = (sample.flags ?? 0) & 16777216;
+          const cto = sample.compositionTimeOffset ?? 0;
+          const duration = sample.duration ?? 0;
+          samples.push({
+            data: sampleData,
+            dts: baseDts,
+            pts: baseDts + cto,
+            duration,
+            isSync: isSync !== 0
+          });
+          dataOffset += sample.size;
+          baseDts += duration;
+        }
+      }
+    }
+    return samples;
+  }
+  /**
+   * 获取 timescale
+   */
+  getTimescale() {
+    return this.timescale;
+  }
+  /**
+   * 获取 avcC 配置
+   */
+  getAvcC() {
+    return this.avcC;
+  }
+}
+class NALParser {
+  /**
+   * 解析 H.264 NAL 单元
+   * 支持 3 字节和 4 字节的 start code
+   */
+  parse(data) {
+    const units = [];
+    let i = 0;
+    const len = data.length;
+    while (i < len - 3) {
+      let startCodeSize = 0;
+      let nalStart = 0;
+      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0 && data[i + 3] === 1) {
+        startCodeSize = 4;
+        nalStart = i + 4;
+      } else if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 1) {
+        startCodeSize = 3;
+        nalStart = i + 3;
+      }
+      if (startCodeSize > 0) {
+        let nalEnd = len;
+        for (let j = nalStart; j < len - 3; j++) {
+          if (data[j] === 0 && data[j + 1] === 0) {
+            if (data[j + 2] === 0 && data[j + 3] === 1) {
+              nalEnd = j;
+              break;
+            } else if (data[j + 2] === 1) {
+              nalEnd = j;
+              break;
+            }
+          }
+        }
+        const nalType = data[nalStart] & 31;
+        units.push({
+          type: nalType,
+          data: data.subarray(nalStart, nalEnd),
+          size: nalEnd - nalStart
+        });
+        i = nalEnd;
+      } else {
+        i++;
+      }
+    }
+    return units;
+  }
+}
+class BasePrefetcher {
+  constructor(config, callbacks = {}) {
+    this.isRunning = false;
+    this.abortFlag = false;
+    this.prefetchPromise = null;
+    this.downloadStartTime = 0;
+    this.downloadStartBytes = 0;
+    this.lastSpeedLogTime = 0;
+    this.lastSpeedLogBytes = 0;
+    this.currentSpeed = 0;
+    this.loopCount = 0;
+    this.config = config;
+    this.callbacks = callbacks;
+    this.status = this.createInitialState();
+  }
+  /**
+   * 创建初始状态（子类可覆盖）
+   */
+  createInitialState() {
+    return {
+      isPrefetching: false,
+      queueSize: 0,
+      downloadSpeed: 0,
+      totalBytes: 0
+    };
+  }
+  /**
+   * 启动预取循环
+   */
+  async start() {
+    if (this.isRunning) {
+      console.log("[BasePrefetcher] Already running");
+      return;
+    }
+    this.isRunning = true;
+    this.abortFlag = false;
+    this.loopCount = 0;
+    console.log("[BasePrefetcher] Starting prefetch loop...");
+    this.prefetchPromise = this.prefetchLoop();
+    await this.prefetchPromise;
+  }
+  /**
+   * 停止预取循环
+   */
+  stop() {
+    console.log("[BasePrefetcher] Stopping prefetch loop...");
+    this.abortFlag = true;
+    this.isRunning = false;
+    this.updateStatus({ isPrefetching: false });
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return { ...this.status };
+  }
+  /**
+   * 获取下载速度 (KB/s)
+   */
+  getDownloadSpeed() {
+    return this.currentSpeed;
+  }
+  /**
+   * 预取循环
+   */
+  async prefetchLoop() {
+    try {
+      while (this.isRunning && !this.abortFlag) {
+        this.loopCount++;
+        const queueSize = this.getQueueSize();
+        this.updateStatus({ queueSize });
+        if (this.shouldPrefetch()) {
+          this.updateStatus({ isPrefetching: true });
+          await this.doPrefetch();
+          this.updateStatus({ isPrefetching: false });
+        }
+        const interval = this.calculateInterval(queueSize);
+        await this.sleep(interval);
+      }
+      console.log("[BasePrefetcher] Prefetch loop ended");
+    } catch (error) {
+      console.error("[BasePrefetcher] Prefetch loop error:", error);
+      this.callbacks.onError?.(error);
+      this.updateStatus({
+        isPrefetching: false,
+        lastError: error.message
+      });
+    }
+  }
+  /**
+   * 计算动态等待间隔
+   */
+  calculateInterval(queueSize) {
+    if (!this.config.dynamicInterval) {
+      return this.config.prefetchInterval;
+    }
+    const lowWater = this.config.lowWaterMark;
+    if (queueSize < lowWater / 2) {
+      return 1;
+    } else if (queueSize < lowWater) {
+      return 3;
+    } else if (queueSize < this.config.highWaterMark) {
+      return this.config.prefetchInterval;
+    } else {
+      return this.config.prefetchInterval * 2;
+    }
+  }
+  /**
+   * 更新下载速度
+   */
+  updateDownloadSpeed(totalBytes) {
+    const now = Date.now();
+    if (now - this.lastSpeedLogTime >= 1e3) {
+      const elapsed = (now - this.lastSpeedLogTime) / 1e3;
+      const downloaded = totalBytes - this.lastSpeedLogBytes;
+      const speed = downloaded / elapsed / 1024;
+      this.currentSpeed = Math.round(speed);
+      this.updateStatus({
+        downloadSpeed: this.currentSpeed,
+        totalBytes
+      });
+      this.lastSpeedLogTime = now;
+      this.lastSpeedLogBytes = totalBytes;
+    }
+  }
+  /**
+   * 初始化速度监控
+   */
+  initSpeedMonitor(initialBytes) {
+    this.downloadStartTime = Date.now();
+    this.downloadStartBytes = initialBytes;
+    this.lastSpeedLogTime = this.downloadStartTime;
+    this.lastSpeedLogBytes = initialBytes;
+  }
+  /**
+   * 更新状态（子类可覆盖以支持扩展属性）
+   */
+  updateStatus(partial) {
+    this.status = { ...this.status, ...partial };
+    this.callbacks.onStatusChange?.(this.status);
+  }
+  /**
+   * 辅助方法：休眠
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 辅助方法：快速让出（用于不阻塞事件循环）
+   */
+  async yieldFast() {
+    await this.sleep(0);
+  }
+  /**
+   * 重置预取器状态
+   */
+  reset() {
+    this.stop();
+    this.doReset();
+    this.status = this.createInitialState();
+    this.currentSpeed = 0;
+    this.loopCount = 0;
+    console.log("[BasePrefetcher] Reset complete");
+  }
+}
+class SegmentPrefetcher extends BasePrefetcher {
+  constructor(config, callbacks = {}) {
+    super(config, callbacks);
+    this.prefetchQueue = [];
+    this.segments = [];
+    this.currentSegmentIndex = 0;
+    this.baseUrl = "";
+    this.isPrefetchingSegment = false;
+  }
+  /**
+   * 创建初始状态
+   */
+  createInitialState() {
+    return {
+      ...super.createInitialState(),
+      currentSegmentIndex: 0,
+      totalSegments: 0,
+      prefetchQueueSize: 0
+    };
+  }
+  /**
+   * 设置分片列表
+   */
+  setSegments(segments, baseUrl) {
+    this.segments = segments;
+    this.baseUrl = baseUrl;
+    this.currentSegmentIndex = 0;
+    this.prefetchQueue = [];
+    this.updateStatus({
+      totalSegments: segments.length,
+      currentSegmentIndex: 0,
+      prefetchQueueSize: 0
+    });
+    console.log(`[SegmentPrefetcher] Set ${segments.length} segments, baseUrl: ${baseUrl}`);
+  }
+  /**
+   * 设置当前分片索引（用于 seek）
+   */
+  setCurrentSegmentIndex(index) {
+    this.currentSegmentIndex = index;
+    this.prefetchQueue = [];
+    this.updateStatus({
+      currentSegmentIndex: index,
+      prefetchQueueSize: 0
+    });
+    console.log(`[SegmentPrefetcher] Current segment index set to ${index}`);
+  }
+  /**
+   * 获取当前队列大小（返回预取队列大小）
+   */
+  getQueueSize() {
+    return this.prefetchQueue.length;
+  }
+  /**
+   * 判断是否应该预取
+   */
+  shouldPrefetch() {
+    if (this.isPrefetchingSegment) return false;
+    if (this.segments.length === 0) return false;
+    const prefetchAhead = this.config.prefetchAhead;
+    if (this.prefetchQueue.length >= prefetchAhead) return false;
+    const nextIndex = this.currentSegmentIndex + this.prefetchQueue.length;
+    return nextIndex < this.segments.length;
+  }
+  /**
+   * 执行预取
+   */
+  async doPrefetch() {
+    if (this.isPrefetchingSegment) return;
+    this.isPrefetchingSegment = true;
+    this.updateStatus({ isPrefetching: true });
+    try {
+      const nextIndex = this.currentSegmentIndex + this.prefetchQueue.length;
+      if (nextIndex >= this.segments.length) {
+        return;
+      }
+      const segment = this.segments[nextIndex];
+      const fetchStart = performance.now();
+      const data = await this.fetchSegment(segment, nextIndex);
+      const fetchTime = performance.now() - fetchStart;
+      this.prefetchQueue.push({
+        data,
+        segmentIndex: nextIndex,
+        fetchTime
+      });
+      this.updateStatus({ prefetchQueueSize: this.prefetchQueue.length });
+      const callbacks = this.callbacks;
+      callbacks.onSegmentFetched?.(nextIndex, data);
+      console.log(`[SegmentPrefetcher] Fetched segment #${nextIndex}: ${data.length} bytes, ${fetchTime.toFixed(0)}ms`);
+    } catch (error) {
+      console.error(`[SegmentPrefetcher] Fetch failed:`, error.message);
+      this.callbacks.onError?.(error);
+    } finally {
+      this.isPrefetchingSegment = false;
+      this.updateStatus({ isPrefetching: false });
+    }
+  }
+  /**
+   * 处理预取队列中的数据
+   *
+   * @returns 是否有数据被处理
+   */
+  processQueue() {
+    let processed = false;
+    while (this.prefetchQueue.length > 0) {
+      const item = this.prefetchQueue[0];
+      if (item.segmentIndex !== this.currentSegmentIndex) {
+        break;
+      }
+      this.prefetchQueue.shift();
+      this.updateStatus({ prefetchQueueSize: this.prefetchQueue.length });
+      const parseStart = performance.now();
+      const itemCount = this.parseSegment(item.data, item.segmentIndex);
+      const parseTime = performance.now() - parseStart;
+      this.currentSegmentIndex++;
+      this.updateStatus({ currentSegmentIndex: this.currentSegmentIndex });
+      const callbacks = this.callbacks;
+      callbacks.onSegmentParsed?.(item.segmentIndex, itemCount);
+      console.log(`[SegmentPrefetcher] Parsed segment #${item.segmentIndex}: ${itemCount} items, ${parseTime.toFixed(0)}ms`);
+      processed = true;
+    }
+    return processed;
+  }
+  /**
+   * 重置状态
+   */
+  doReset() {
+    this.prefetchQueue = [];
+    this.segments = [];
+    this.currentSegmentIndex = 0;
+    this.baseUrl = "";
+    this.isPrefetchingSegment = false;
+  }
+  /**
+   * 获取当前分片索引
+   */
+  getCurrentSegmentIndex() {
+    return this.currentSegmentIndex;
+  }
+  /**
+   * 获取总分片数
+   */
+  getTotalSegments() {
+    return this.segments.length;
+  }
+}
+class StreamPrefetcher extends BasePrefetcher {
+  constructor(config, callbacks = {}) {
+    super(config, callbacks);
+    this.downloadBuffer = null;
+    this.bufferLength = 0;
+    this.reader = null;
+    this.downloadComplete = false;
+    this.downloadPromise = null;
+    this.totalDownloadedBytes = 0;
+  }
+  /**
+   * 创建初始状态
+   */
+  createInitialState() {
+    return {
+      ...super.createInitialState(),
+      bufferLength: 0,
+      bufferCapacity: 0,
+      downloadComplete: false
+    };
+  }
+  /**
+   * 设置流读取器
+   */
+  setReader(reader, initialData) {
+    this.reader = reader;
+    this.downloadComplete = false;
+    this.totalDownloadedBytes = 0;
+    const initialSize = this.config.initialBufferSize;
+    this.downloadBuffer = new Uint8Array(initialSize);
+    this.bufferLength = 0;
+    if (initialData && initialData.length > 0) {
+      this.ensureCapacity(initialData.length);
+      this.downloadBuffer.set(initialData, 0);
+      this.bufferLength = initialData.length;
+      this.totalDownloadedBytes = initialData.length;
+    }
+    this.updateStatus({
+      bufferLength: this.bufferLength,
+      bufferCapacity: this.downloadBuffer.length,
+      downloadComplete: false,
+      totalBytes: this.totalDownloadedBytes
+    });
+    this.initSpeedMonitor(this.totalDownloadedBytes);
+    console.log(`[StreamPrefetcher] Reader set, initial buffer: ${this.bufferLength} bytes, capacity: ${this.downloadBuffer.length}`);
+  }
+  /**
+   * 确保缓冲区有足够的容量
+   */
+  ensureCapacity(needed) {
+    if (!this.downloadBuffer) {
+      const size = Math.max(this.config.initialBufferSize, needed * 2);
+      this.downloadBuffer = new Uint8Array(size);
+      this.bufferLength = 0;
+      return;
+    }
+    const remaining = this.downloadBuffer.length - this.bufferLength;
+    if (remaining < needed) {
+      const newSize = Math.max(
+        this.downloadBuffer.length * 2,
+        this.bufferLength + needed
+      );
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.downloadBuffer.slice(0, this.bufferLength), 0);
+      this.downloadBuffer = newBuffer;
+      console.log(`[StreamPrefetcher] Buffer expanded to ${newSize} bytes`);
+      this.updateStatus({ bufferCapacity: newSize });
+    }
+  }
+  /**
+   * 获取当前队列大小（使用缓冲区长度）
+   */
+  getQueueSize() {
+    return this.bufferLength;
+  }
+  /**
+   * 判断是否应该预取
+   */
+  shouldPrefetch() {
+    if (!this.reader) return false;
+    if (this.downloadComplete) return false;
+    return this.bufferLength < this.config.highWaterMark * 1e3;
+  }
+  /**
+   * 执行预取（从流读取数据）
+   */
+  async doPrefetch() {
+    if (!this.reader || this.downloadComplete) return;
+    try {
+      const { done, value } = await this.reader.read();
+      if (value) {
+        this.ensureCapacity(value.length);
+        if (this.downloadBuffer) {
+          this.downloadBuffer.set(value, this.bufferLength);
+          this.bufferLength += value.length;
+          this.totalDownloadedBytes += value.length;
+        }
+        this.updateDownloadSpeed(this.totalDownloadedBytes);
+        this.updateStatus({
+          bufferLength: this.bufferLength,
+          totalBytes: this.totalDownloadedBytes
+        });
+        const callbacks = this.callbacks;
+        callbacks.onDataReceived?.(this.totalDownloadedBytes);
+      }
+      if (done) {
+        this.downloadComplete = true;
+        this.updateStatus({ downloadComplete: true });
+        console.log(`[StreamPrefetcher] Download complete: ${this.totalDownloadedBytes} bytes`);
+      }
+    } catch (error) {
+      console.error(`[StreamPrefetcher] Read error:`, error.message);
+      this.callbacks.onError?.(error);
+    }
+  }
+  /**
+   * 处理缓冲区数据
+   *
+   * @returns 是否有数据被处理
+   */
+  processBuffer() {
+    if (!this.downloadBuffer || this.bufferLength === 0) {
+      return false;
+    }
+    const data = this.downloadBuffer.slice(0, this.bufferLength);
+    const result = this.processBufferData(data);
+    this.updateStatus({ bufferLength: this.bufferLength });
+    const callbacks = this.callbacks;
+    callbacks.onBufferProcessed?.(result.processedBytes);
+    return result.hasNewData;
+  }
+  /**
+   * 获取缓冲区信息
+   */
+  getBufferInfo() {
+    return {
+      buffer: this.downloadBuffer,
+      length: this.bufferLength,
+      capacity: this.downloadBuffer?.length || 0
+    };
+  }
+  /**
+   * 获取缓冲区数据（复制）
+   */
+  getBufferData() {
+    if (!this.downloadBuffer || this.bufferLength === 0) {
+      return null;
+    }
+    return this.downloadBuffer.slice(0, this.bufferLength);
+  }
+  /**
+   * 重置状态
+   */
+  doReset() {
+    this.downloadBuffer = null;
+    this.bufferLength = 0;
+    this.reader = null;
+    this.downloadComplete = false;
+    this.downloadPromise = null;
+    this.totalDownloadedBytes = 0;
+  }
+  /**
+   * 取消下载
+   */
+  cancelDownload() {
+    if (this.reader) {
+      this.reader.cancel();
+      this.reader = null;
+    }
+    this.downloadComplete = true;
+    this.updateStatus({ downloadComplete: true });
+    console.log(`[StreamPrefetcher] Download cancelled`);
+  }
+  /**
+   * 是否下载完成
+   */
+  isDownloadComplete() {
+    return this.downloadComplete;
+  }
+}
+const DEFAULT_PREFETCHER_CONFIG = {
+  lowWaterMark: 30,
+  highWaterMark: 100,
+  prefetchInterval: 10,
+  dynamicInterval: true
+};
+const DEFAULT_SEGMENT_PREFETCHER_CONFIG = {
+  ...DEFAULT_PREFETCHER_CONFIG,
+  prefetchAhead: 2
+};
+const DEFAULT_STREAM_PREFETCHER_CONFIG = {
+  ...DEFAULT_PREFETCHER_CONFIG,
+  lowWaterMark: 100,
+  highWaterMark: 500,
+  initialBufferSize: 2 * 1024 * 1024
+  // 2MB
+};
+const HLS_PREFETCHER_CONFIG = {
+  ...DEFAULT_SEGMENT_PREFETCHER_CONFIG,
+  lowWaterMark: 30,
+  highWaterMark: 100,
+  prefetchAhead: 2,
+  prefetchInterval: 10,
+  dynamicInterval: true
+};
+const DEFAULT_HLS_CONFIG = {
+  ...DEFAULT_PLAYER_CONFIG
+};
+class HLSSegmentPrefetcher extends SegmentPrefetcher {
+  constructor(config, callbacks, player) {
+    super(config, callbacks);
+    this.player = player;
+  }
+  /**
+   * 获取分片数据
+   */
+  async fetchSegment(segment, index) {
+    const baseUrl = this.baseUrl;
+    const url = segment.uri.startsWith("http") ? segment.uri : baseUrl + segment.uri;
+    const headers = {};
+    if (segment.byteRange) {
+      const { start, end } = segment.byteRange;
+      headers["Range"] = `bytes=${start}-${end}`;
+    }
+    const response = await fetch(url, { headers });
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  /**
+   * 解析分片数据
+   */
+  parseSegment(data, index) {
+    if (this.player.isFMP4) {
+      return this.player.parseFMP4Data(data);
+    } else {
+      return this.player.parseTSData(data);
+    }
+  }
+  /**
+   * 获取队列大小（使用 player 的解码队列大小）
+   */
+  getQueueSize() {
+    if (this.player.isFMP4) {
+      return this.player.sampleQueue.length;
+    } else {
+      return this.player.nalQueue.length;
+    }
+  }
+}
+class HLSPlayer extends BasePlayer {
+  constructor(config = {}, callbacks = {}) {
+    super(config, callbacks, DEFAULT_HLS_CONFIG);
+    this.tsDemuxer = new TSDemuxer();
+    this.pesExtractor = new PESExtractor();
+    this.nalParser = new NALParser();
+    this.fmp4Demuxer = new fMP4Demuxer();
+    this.isPrefetching = false;
+    this.currentSegmentIndex = 0;
+    this.segments = [];
+    this.fmp4Segments = [];
+    this.initSegment = null;
+    this._isFMP4 = false;
+    this.currentPlaylistUrl = "";
+    this._nalQueue = [];
+    this._sampleQueue = [];
+    this.prefetcher = null;
+    this.renderLoop = () => {
+      if (!this.isPlaying) return;
+      const downloaded = this.isFMP4 ? this.sampleQueue.length : this.nalQueue.length;
+      const segments = this.isFMP4 ? this.fmp4Segments : this.segments;
+      const totalSegments = segments.length;
+      let currentTime = 0;
+      for (let i = 0; i < this.currentSegmentIndex && i < segments.length; i++) {
+        currentTime += segments[i].duration * 1e3;
+      }
+      this.setCurrentTime(currentTime);
+      this.updateState({
+        decoded: this.frameBuffer.length,
+        downloaded,
+        droppedFrames: this.droppedFrames,
+        segmentIndex: this.currentSegmentIndex,
+        totalSegments
+      });
+      if (this.frameBuffer.length > 0 && this.renderer) {
+        const frame = this.frameBuffer.shift();
+        this.renderer.render(frame);
+        this.updateState({ resolution: `${frame.width}x${frame.height}` });
+        const fps = this.renderer.updateFps();
+        this.updateState({ fps });
+        this.callbacks.onFrameRender?.(frame);
+      }
+      this.frameTimer = requestAnimationFrame(this.renderLoop);
+    };
+  }
+  // 公共访问器（供预取器使用）
+  get isFMP4() {
+    return this._isFMP4;
+  }
+  get nalQueue() {
+    return this._nalQueue;
+  }
+  get sampleQueue() {
+    return this._sampleQueue;
+  }
+  /**
+   * 加载 HLS 播放列表
+   */
+  async load(url) {
+    this.currentPlaylistUrl = url;
+    this.segments = [];
+    this.fmp4Segments = [];
+    this.initSegment = null;
+    this._nalQueue.length = 0;
+    this._sampleQueue.length = 0;
+    this.currentSegmentIndex = 0;
+    this.resetState();
+    if (this.prefetcher) {
+      this.prefetcher.reset();
+      this.prefetcher = null;
+    }
+    const playlist = await this.parsePlaylist(url);
+    this._isFMP4 = playlist.isFMP4;
+    console.log("[load] Detected format:", this.isFMP4 ? "fMP4" : "TS");
+    if (playlist.isFMP4) {
+      if (!playlist.fmp4Segments || playlist.fmp4Segments.length === 0) {
+        throw new Error("No fMP4 segments found");
+      }
+      this.fmp4Segments = playlist.fmp4Segments;
+      if (playlist.initSegment) {
+        this.initSegment = playlist.initSegment;
+      }
+      console.log("[HLSPlayer] fMP4 stream parsed:", playlist.fmp4Segments.length, "segments");
+    } else {
+      if (!playlist.segments || playlist.segments.length === 0) {
+        throw new Error("No TS segments found");
+      }
+      this.segments = playlist.segments;
+      console.log("[HLSPlayer] TS stream parsed:", playlist.segments.length, "segments");
+    }
+    this.currentSegmentIndex = 0;
+    const segments = this.isFMP4 ? this.fmp4Segments : this.segments;
+    const totalDuration = segments.reduce((sum, seg) => sum + seg.duration * 1e3, 0);
+    this.setDuration(totalDuration);
+    this.updateState({
+      isLoaded: true,
+      totalSegments: segments.length
+    });
+  }
+  /**
+   * 初始化解码器（覆盖基类方法，添加 fMP4 支持）
+   */
+  async initDecoder() {
+    await super.initDecoder();
+    if (this.isFMP4 && this.initSegment) {
+      await this.loadInitSegment();
+    }
+  }
+  /**
+   * 开始播放（覆盖基类方法，使用自定义渲染循环）
+   */
+  async play() {
+    this.isPlaying = true;
+    this.decodeLoopAbort = false;
+    this.updateState({ isPlaying: true });
+    this.initPrefetcher();
+    this.prefetcher?.start();
+    this.decodeLoop();
+    this.frameTimer = requestAnimationFrame(this.renderLoop);
+  }
+  /**
+   * 跳转到指定时间
+   */
+  async seek(time) {
+    const segments = this.isFMP4 ? this.fmp4Segments : this.segments;
+    if (segments.length === 0) return;
+    let accumulatedTime = 0;
+    let targetIndex = 0;
+    for (let i = 0; i < segments.length; i++) {
+      const segmentDuration = segments[i].duration * 1e3;
+      if (accumulatedTime + segmentDuration > time) {
+        targetIndex = i;
+        break;
+      }
+      accumulatedTime += segmentDuration;
+      targetIndex = i;
+    }
+    this.frameBuffer = [];
+    this._nalQueue.length = 0;
+    this._sampleQueue.length = 0;
+    this.currentSegmentIndex = targetIndex;
+    if (this.prefetcher) {
+      this.prefetcher.setCurrentSegmentIndex(targetIndex);
+    }
+    this.setCurrentTime(time);
+    console.log("[HLSPlayer] Seek to", time, "ms, segment:", targetIndex);
+  }
+  /**
+   * 解码循环
+   */
+  async decodeLoop() {
+    console.log("[DecodeLoop] START, isFMP4:", this.isFMP4);
+    let batchCount = 0;
+    while (this.isPlaying && !this.decodeLoopAbort) {
+      this.prefetcher?.processQueue();
+      const batchSize = this.config.decodeBatchSize;
+      let decodedInBatch = 0;
+      if (this.isFMP4) {
+        while (this.sampleQueue.length > 0 && decodedInBatch < batchSize) {
+          const queuedSample = this.sampleQueue.shift();
+          const sample = queuedSample.sample;
+          const frame = this.decodeSample(sample);
+          if (frame) {
+            this.frameBuffer.push(frame);
+            decodedInBatch++;
+            while (this.frameBuffer.length > this.config.targetBufferSize) {
+              this.frameBuffer.shift();
+              this.droppedFrames++;
+            }
+          }
+        }
+      } else {
+        while (this.nalQueue.length > 0 && decodedInBatch < batchSize) {
+          const queuedNal = this.nalQueue.shift();
+          const nalUnit = queuedNal.nalUnit;
+          if (!this.decoderInitialized && (nalUnit.type === 7 || nalUnit.type === 8)) {
+            this.initDecoderParamsSync([nalUnit]);
+          }
+          if (nalUnit.type === 5 || nalUnit.type === 1) {
+            const frame = this.decodeNAL(nalUnit);
+            if (frame) {
+              this.frameBuffer.push(frame);
+              decodedInBatch++;
+              while (this.frameBuffer.length > this.config.targetBufferSize) {
+                this.frameBuffer.shift();
+                this.droppedFrames++;
+              }
+            }
+          }
+        }
+      }
+      batchCount++;
+      if (decodedInBatch > 0) {
+        await this.yieldFast();
+      } else {
+        await this.sleep(2);
+      }
+    }
+    console.log("[DecodeLoop] END, batches:", batchCount);
+  }
+  /**
+   * 初始化预取器
+   */
+  initPrefetcher() {
+    this.prefetcher = new HLSSegmentPrefetcher(
+      HLS_PREFETCHER_CONFIG,
+      {
+        onStatusChange: (status) => {
+          this.updateState({
+            isPrefetching: status.isPrefetching,
+            downloadSpeed: status.downloadSpeed
+          });
+        },
+        onSegmentParsed: (segmentIndex, itemCount) => {
+          this.currentSegmentIndex = segmentIndex + 1;
+          this.updateState({ segmentIndex: this.currentSegmentIndex });
+        }
+      },
+      this
+    );
+    const baseUrl = this.currentPlaylistUrl.substring(0, this.currentPlaylistUrl.lastIndexOf("/") + 1);
+    if (this.isFMP4) {
+      const segmentInfos = this.fmp4Segments.map((seg) => ({
+        uri: seg.uri,
+        duration: seg.duration,
+        byteRange: seg.byteRange
+      }));
+      this.prefetcher.setSegments(segmentInfos, baseUrl);
+    } else {
+      const segmentInfos = this.segments.map((seg) => ({
+        uri: seg.uri,
+        duration: seg.duration
+      }));
+      this.prefetcher.setSegments(segmentInfos, baseUrl);
+    }
+  }
+  // ==================== 解析方法 ====================
+  /**
+   * 解析 fMP4 数据
+   */
+  parseFMP4Data(data) {
+    let moofOffset = -1;
+    let mdatOffset = -1;
+    let mdatSize = 0;
+    let offset = 0;
+    while (offset < data.length - 8) {
+      const boxSize = this.readBoxSize(data, offset);
+      const boxType = this.readBoxType(data, offset + 4);
+      if (boxType === "moof") {
+        moofOffset = offset;
+      } else if (boxType === "mdat") {
+        mdatOffset = offset;
+        mdatSize = boxSize;
+        break;
+      }
+      offset += boxSize;
+    }
+    let sampleCount = 0;
+    if (moofOffset >= 0 && mdatOffset >= 0) {
+      const moof = this.fmp4Demuxer.parseMoof(data, moofOffset);
+      const mdatData = data.slice(mdatOffset + 8, mdatOffset + mdatSize);
+      const samples = this.fmp4Demuxer.extractSamples(moof, mdatData, mdatOffset);
+      for (const sample of samples) {
+        this._sampleQueue.push({ sample });
+      }
+      sampleCount = samples.length;
+    }
+    return sampleCount;
+  }
+  /**
+   * 解析 TS 数据
+   */
+  parseTSData(tsData) {
+    const packets = this.tsDemuxer.parse(tsData);
+    let nalCount = 0;
+    if (packets.video.length > 0) {
+      const videoPayload = this.pesExtractor.extractVideoPayload(packets.video);
+      if (videoPayload.length > 0) {
+        const nalUnits = this.nalParser.parse(videoPayload);
+        if (!this.decoderInitialized) {
+          this.initDecoderParamsSync(nalUnits);
+        }
+        for (const nalUnit of nalUnits) {
+          this._nalQueue.push({ nalUnit, pts: 0 });
+        }
+        nalCount = nalUnits.length;
+      }
+    }
+    return nalCount;
+  }
+  // ==================== 私有方法 ====================
+  /**
+   * 加载 fMP4 初始化段
+   */
+  async loadInitSegment() {
+    if (!this.initSegment) {
+      console.error("[fMP4] No init segment defined!");
+      return;
+    }
+    const baseUrl = this.currentPlaylistUrl.substring(0, this.currentPlaylistUrl.lastIndexOf("/") + 1);
+    const url = this.initSegment.uri.startsWith("http") ? this.initSegment.uri : baseUrl + this.initSegment.uri;
+    console.log("[fMP4] Loading init segment:", url, this.initSegment.byteRange);
+    const headers = {};
+    if (this.initSegment.byteRange) {
+      const { start, end } = this.initSegment.byteRange;
+      headers["Range"] = `bytes=${start}-${end}`;
+    }
+    const response = await fetch(url, { headers });
+    const data = new Uint8Array(await response.arrayBuffer());
+    console.log("[fMP4] Init segment data size:", data.length, "bytes");
+    const initInfo = this.fmp4Demuxer.parseInitSegment(data);
+    console.log("[fMP4] Parse result:", initInfo);
+    if (initInfo?.avcC) {
+      console.log("[fMP4] avcC size:", initInfo.avcC.length);
+      this.initDecoderFromAvcC(initInfo.avcC);
+      console.log("[fMP4] Init segment loaded, timescale:", initInfo.timescale);
+    } else {
+      console.error("[fMP4] Failed to parse init segment or no avcC found!");
+      throw new Error("Failed to parse fMP4 init segment");
+    }
+  }
+  /**
+   * 从 avcC 初始化解码器
+   */
+  initDecoderFromAvcC(avcC) {
+    if (this.decoderInitialized || !this.decoder) return;
+    let offset = 8;
+    const configVersion = avcC[offset];
+    const profile = avcC[offset + 1];
+    avcC[offset + 2];
+    const level = avcC[offset + 3];
+    offset += 5;
+    const spsCount = avcC[offset] & 31;
+    offset += 1;
+    console.log(`[fMP4] avcC: version=${configVersion}, profile=${profile}, level=${level}, spsCount=${spsCount}`);
+    if (spsCount > 0) {
+      const spsLength = avcC[offset] << 8 | avcC[offset + 1];
+      offset += 2;
+      const spsData = avcC.slice(offset, offset + spsLength);
+      offset += spsLength;
+      const spsWithStartCode = new Uint8Array(4 + spsLength);
+      spsWithStartCode.set([0, 0, 0, 1], 0);
+      spsWithStartCode.set(spsData, 4);
+      this.decoder.decode({ type: 7, data: spsWithStartCode, size: spsWithStartCode.length });
+      console.log(`[fMP4] SPS decoded, length=${spsLength}`);
+      for (let i = 1; i < spsCount; i++) {
+        const skipLength = avcC[offset] << 8 | avcC[offset + 1];
+        offset += 2 + skipLength;
+      }
+    }
+    const ppsCount = avcC[offset];
+    offset += 1;
+    if (ppsCount > 0) {
+      const ppsLength = avcC[offset] << 8 | avcC[offset + 1];
+      offset += 2;
+      const ppsData = avcC.slice(offset, offset + ppsLength);
+      const ppsWithStartCode = new Uint8Array(4 + ppsLength);
+      ppsWithStartCode.set([0, 0, 0, 1], 0);
+      ppsWithStartCode.set(ppsData, 4);
+      this.decoder.decode({ type: 8, data: ppsWithStartCode, size: ppsWithStartCode.length });
+      console.log(`[fMP4] PPS decoded, length=${ppsLength}`);
+    }
+    this.decoderInitialized = true;
+    console.log("[fMP4] Decoder initialized from avcC");
+  }
+  /**
+   * 解析 HLS 播放列表
+   */
+  async parsePlaylist(url) {
+    const response = await fetch(url);
+    const content = await response.text();
+    const lines = content.split("\n");
+    const segments = [];
+    const fmp4Segments = [];
+    const variants = [];
+    let initSegment;
+    const isMaster = lines.some((line) => line.includes("#EXT-X-STREAM-INF:"));
+    if (isMaster) {
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("#EXT-X-STREAM-INF:")) {
+          const uri = lines[++i]?.trim();
+          if (uri && !uri.startsWith("#")) {
+            variants.push(uri);
+          }
+        }
+      }
+      if (variants.length > 0) {
+        const baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
+        const variantUrl = variants[0].startsWith("http") ? variants[0] : baseUrl + variants[0];
+        this.currentPlaylistUrl = variantUrl;
+        return this.parsePlaylist(variantUrl);
+      }
+      return { isMaster: true, isFMP4: false, segments: [], fmp4Segments: [], variants: variants.length };
+    }
+    const isFMP4 = lines.some((line) => line.includes("#EXT-X-MAP:"));
+    console.log("[parsePlaylist] isFMP4:", isFMP4, "url:", url);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("#EXT-X-MAP:")) {
+        const mapInfo = line.substring("#EXT-X-MAP:".length);
+        const uriMatch = mapInfo.match(/URI="([^"]+)"/);
+        if (uriMatch) {
+          initSegment = { uri: uriMatch[1] };
+          const byteRangeMatch = mapInfo.match(/BYTERANGE="(\d+)@(\d+)"/);
+          if (byteRangeMatch) {
+            initSegment.byteRange = {
+              start: parseInt(byteRangeMatch[2]),
+              end: parseInt(byteRangeMatch[2]) + parseInt(byteRangeMatch[1]) - 1
+            };
+          }
+        }
+      }
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("#EXTINF:")) {
+        const duration = parseFloat(line.split(":")[1].split(",")[0]);
+        let byteRange;
+        let nextLine = lines[++i]?.trim();
+        if (nextLine?.startsWith("#EXT-X-BYTERANGE:")) {
+          const byteRangeMatch = nextLine.match(/#EXT-X-BYTERANGE:(\d+)@(\d+)/);
+          if (byteRangeMatch) {
+            byteRange = {
+              start: parseInt(byteRangeMatch[2]),
+              end: parseInt(byteRangeMatch[2]) + parseInt(byteRangeMatch[1]) - 1
+            };
+          }
+          nextLine = lines[++i]?.trim();
+        }
+        const uri = nextLine;
+        if (uri && !uri.startsWith("#")) {
+          if (isFMP4) {
+            fmp4Segments.push({ uri, duration, byteRange });
+          } else {
+            segments.push({ uri, duration });
+          }
+        }
+      }
+    }
+    return { isMaster: false, isFMP4, segments, fmp4Segments, initSegment, variants: 1 };
+  }
+  /**
+   * 同步初始化解码器参数（SPS/PPS）- TS 流
+   */
+  initDecoderParamsSync(nalUnits) {
+    if (this.decoderInitialized || !this.decoder) return;
+    const spsUnit = nalUnits.find((u) => u.type === 7);
+    const ppsUnit = nalUnits.find((u) => u.type === 8);
+    if (spsUnit) {
+      const nalWithStartCode = new Uint8Array(spsUnit.size + 4);
+      nalWithStartCode.set([0, 0, 0, 1], 0);
+      nalWithStartCode.set(spsUnit.data, 4);
+      this.decoder.decode({ type: 7, data: nalWithStartCode, size: nalWithStartCode.length });
+    }
+    if (ppsUnit) {
+      const nalWithStartCode = new Uint8Array(ppsUnit.size + 4);
+      nalWithStartCode.set([0, 0, 0, 1], 0);
+      nalWithStartCode.set(ppsUnit.data, 4);
+      this.decoder.decode({ type: 8, data: nalWithStartCode, size: nalWithStartCode.length });
+    }
+    if (spsUnit || ppsUnit) {
+      this.decoderInitialized = true;
+      console.log("[Decoder] Initialized with SPS/PPS");
+    }
+  }
+  readBoxSize(data, offset) {
+    return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+  }
+  readBoxType(data, offset) {
+    return String.fromCharCode(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]);
+  }
+  /**
+   * 解码 fMP4 sample
+   */
+  decodeSample(sample) {
+    if (!this.decoder) {
+      console.warn("[fMP4] Decoder not available");
+      return null;
+    }
+    if (!this.decoderInitialized) {
+      console.warn("[fMP4] Decoder not initialized, skipping sample");
+      return null;
+    }
+    const data = sample.data;
+    const hasStartCode = data.length >= 4 && data[0] === 0 && data[1] === 0 && (data[2] === 1 || data[2] === 0 && data[3] === 1);
+    if (hasStartCode) {
+      return this.decoder.decode({
+        type: sample.isSync ? 5 : 1,
+        data,
+        size: data.length
+      });
+    }
+    let nalCount = 0;
+    let totalSize = 0;
+    let offset = 0;
+    while (offset + 4 <= data.length) {
+      const nalLength = data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+      if (nalLength <= 0 || offset + 4 + nalLength > data.length) {
+        console.warn(`[fMP4] Invalid NAL length: ${nalLength} at offset ${offset}`);
+        break;
+      }
+      totalSize += 4 + nalLength;
+      offset += 4 + nalLength;
+      nalCount++;
+    }
+    if (nalCount === 0) {
+      console.warn("[fMP4] No valid NAL units found in sample");
+      return null;
+    }
+    const annexBData = new Uint8Array(totalSize);
+    let writeOffset = 0;
+    offset = 0;
+    while (offset + 4 <= data.length) {
+      const nalLength = data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+      if (nalLength <= 0 || offset + 4 + nalLength > data.length) {
+        break;
+      }
+      annexBData[writeOffset] = 0;
+      annexBData[writeOffset + 1] = 0;
+      annexBData[writeOffset + 2] = 0;
+      annexBData[writeOffset + 3] = 1;
+      writeOffset += 4;
+      annexBData.set(data.slice(offset + 4, offset + 4 + nalLength), writeOffset);
+      writeOffset += nalLength;
+      offset += 4 + nalLength;
+    }
+    const frame = this.decoder.decode({
+      type: sample.isSync ? 5 : 1,
+      data: annexBData,
+      size: annexBData.length
+    });
+    return frame;
+  }
+  /**
+   * 解码单个 NAL 单元
+   */
+  decodeNAL(nalUnit) {
+    if (!this.decoder) return null;
+    const nalWithStartCode = new Uint8Array(nalUnit.size + 4);
+    nalWithStartCode.set([0, 0, 0, 1], 0);
+    nalWithStartCode.set(nalUnit.data, 4);
+    return this.decoder.decode({
+      type: nalUnit.type,
+      data: nalWithStartCode,
+      size: nalWithStartCode.length
+    });
+  }
+}
+const FLV_SIGNATURE = [70, 76, 86];
+const FLV_VERSION = 1;
+const TAG_TYPE_VIDEO = 9;
+const AVC_PACKET_SEQUENCE_HEADER = 0;
+const AVC_PACKET_NALU = 1;
+const CODEC_ID_AVC$1 = 7;
+const CODEC_ID_HEVC$1 = 12;
+const FRAME_TYPE_KEYFRAME = 1;
+function readUint24(data, offset) {
+  return data[offset] << 16 | data[offset + 1] << 8 | data[offset + 2];
+}
+function readUint32(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function readInt24(data, offset) {
+  const value = data[offset] << 16 | data[offset + 1] << 8 | data[offset + 2];
+  return value > 8388607 ? value - 16777216 : value;
+}
+class FLVDemuxer {
+  constructor() {
+    this.avcConfig = null;
+    this.hevcConfig = null;
+    this.codecId = CODEC_ID_AVC$1;
+    this.parseOffset = 0;
+    this.headerParsed = false;
+    this.headerSize = 9;
+  }
+  // FLV header 大小
+  /**
+   * 检测是否为 FLV 格式
+   */
+  static isFLV(data) {
+    if (data.length < 13) return false;
+    if (data[0] !== FLV_SIGNATURE[0] || data[1] !== FLV_SIGNATURE[1] || data[2] !== FLV_SIGNATURE[2]) {
+      return false;
+    }
+    if (data[3] !== FLV_VERSION) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 解析 FLV 数据
+   */
+  parse(data) {
+    const videoTags = [];
+    let duration = 0;
+    if (!FLVDemuxer.isFLV(data)) {
+      console.error("[FLVDemuxer] Invalid FLV format");
+      return { videoTags, avcConfig: null, hevcConfig: null, duration: 0 };
+    }
+    const headerSize = readUint32(data, 5);
+    let offset = headerSize + 4;
+    while (offset < data.length - 15) {
+      const tagType = data[offset];
+      const dataSize = readUint24(data, offset + 1);
+      const timestamp = readUint24(data, offset + 4) | data[offset + 7] << 24;
+      offset += 11;
+      if (offset + dataSize > data.length) {
+        console.warn("[FLVDemuxer] Incomplete tag data, stopping");
+        break;
+      }
+      const tagData = data.slice(offset, offset + dataSize);
+      if (tagType === TAG_TYPE_VIDEO) {
+        const videoTag = this.parseVideoTag(tagData, timestamp);
+        if (videoTag) {
+          videoTags.push(videoTag);
+          if (videoTag.timestamp > duration) {
+            duration = videoTag.timestamp;
+          }
+        }
+      }
+      offset += dataSize;
+      offset += 4;
+    }
+    return {
+      videoTags,
+      avcConfig: this.avcConfig,
+      hevcConfig: this.hevcConfig,
+      duration
+    };
+  }
+  /**
+   * 增量解析 FLV 数据（用于流式下载）
+   * 只解析新收到的数据，避免重复解析
+   * @param data 完整的 FLV 数据（包含已解析和未解析的部分）
+   * @returns 新解析的视频标签
+   */
+  parseIncremental(data) {
+    const videoTags = [];
+    let duration = 0;
+    if (!this.headerParsed) {
+      if (!FLVDemuxer.isFLV(data)) {
+        console.error("[FLVDemuxer] Invalid FLV format");
+        return { videoTags: [], avcConfig: null, hevcConfig: null, duration: 0 };
+      }
+      this.headerSize = readUint32(data, 5);
+      this.parseOffset = this.headerSize + 4;
+      this.headerParsed = true;
+    }
+    let offset = this.parseOffset;
+    while (offset < data.length - 15) {
+      const tagType = data[offset];
+      const dataSize = readUint24(data, offset + 1);
+      const timestamp = readUint24(data, offset + 4) | data[offset + 7] << 24;
+      offset += 11;
+      if (offset + dataSize > data.length) {
+        break;
+      }
+      const tagData = data.slice(offset, offset + dataSize);
+      if (tagType === TAG_TYPE_VIDEO) {
+        const videoTag = this.parseVideoTag(tagData, timestamp);
+        if (videoTag) {
+          videoTags.push(videoTag);
+          if (videoTag.timestamp > duration) {
+            duration = videoTag.timestamp;
+          }
+        }
+      }
+      offset += dataSize;
+      offset += 4;
+      this.parseOffset = offset;
+    }
+    return {
+      videoTags,
+      avcConfig: this.avcConfig,
+      hevcConfig: this.hevcConfig,
+      duration
+    };
+  }
+  /**
+   * 重置增量解析状态（用于重新加载新的 FLV）
+   */
+  resetIncremental() {
+    this.parseOffset = 0;
+    this.headerParsed = false;
+    this.avcConfig = null;
+    this.hevcConfig = null;
+  }
+  /**
+   * 同步增量解析位置（用于从已解析的数据继续）
+   * @param offset 已经解析到的字节位置
+   */
+  syncParseOffset(offset) {
+    this.headerParsed = true;
+    this.parseOffset = offset;
+  }
+  /**
+   * 解析 Video Tag
+   *
+   * Video Tag Data 格式 (AVC/HEVC):
+   * byte 0: Frame Type (4 bits) + Codec ID (4 bits)
+   * byte 1: AVC/HEVC Packet Type
+   * byte 2-4: Composition Time Offset (24 bits signed)
+   * byte 5+: AVC/HEVC Data
+   */
+  parseVideoTag(data, timestamp) {
+    if (data.length < 5) {
+      return null;
+    }
+    const frameType = data[0] >> 4 & 15;
+    const codecId = data[0] & 15;
+    const avcPacketType = data[1];
+    const compositionTimeOffset = readInt24(data, 2);
+    if (codecId !== CODEC_ID_AVC$1 && codecId !== CODEC_ID_HEVC$1) {
+      console.warn("[FLVDemuxer] Unsupported codec ID:", codecId);
+      return null;
+    }
+    this.codecId = codecId;
+    const avcData = data.slice(5);
+    if (avcPacketType === AVC_PACKET_SEQUENCE_HEADER) {
+      if (codecId === CODEC_ID_HEVC$1) {
+        this.hevcConfig = this.parseHEVCSequenceHeader(avcData);
+        console.log("[FLVDemuxer] Parsed HEVC Sequence Header:", {
+          vpsCount: this.hevcConfig?.vpsList.length,
+          spsCount: this.hevcConfig?.spsList.length,
+          ppsCount: this.hevcConfig?.ppsList.length
+        });
+      } else {
+        this.avcConfig = this.parseSequenceHeader(avcData);
+        console.log("[FLVDemuxer] Parsed AVC Sequence Header:", {
+          profile: this.avcConfig?.avcProfileIndication,
+          level: this.avcConfig?.avcLevelIndication,
+          spsCount: this.avcConfig?.spsList.length,
+          ppsCount: this.avcConfig?.ppsList.length
+        });
+      }
+      return null;
+    }
+    if (avcPacketType === AVC_PACKET_NALU) {
+      return {
+        timestamp,
+        frameType,
+        codecId,
+        avcPacketType,
+        compositionTimeOffset,
+        data: avcData
+      };
+    }
+    return null;
+  }
+  /**
+   * 解析 AVC Sequence Header (AVCDecoderConfigurationRecord)
+   *
+   * 结构 (ISO 14496-15):
+   * byte 0: configurationVersion (usually 1)
+   * byte 1: AVCProfileIndication
+   * byte 2: profile_compatibility
+   * byte 3: AVCLevelIndication
+   * byte 4: lengthSizeMinusOne (高6位保留=0x3F, 低2位=NALU长度字节数-1)
+   * byte 5: numOfSequenceParameterSets (高3位保留=0xE0, 低5位=SPS数量)
+   * SPS 列表:
+   *   - 2 bytes: SPS length
+   *   - n bytes: SPS data
+   * byte: numOfPictureParameterSets
+   * PPS 列表:
+   *   - 2 bytes: PPS length
+   *   - n bytes: PPS data
+   */
+  parseSequenceHeader(data) {
+    if (data.length < 7) {
+      console.error("[FLVDemuxer] Sequence Header too short");
+      return null;
+    }
+    let offset = 0;
+    const configurationVersion = data[offset++];
+    const avcProfileIndication = data[offset++];
+    const profileCompatibility = data[offset++];
+    const avcLevelIndication = data[offset++];
+    const lengthSizeMinusOne = data[offset++] & 3;
+    const spsCount = data[offset++] & 31;
+    const spsList = [];
+    for (let i = 0; i < spsCount; i++) {
+      if (offset + 2 > data.length) {
+        console.error("[FLVDemuxer] Incomplete SPS length");
+        return null;
+      }
+      const spsLength = data[offset] << 8 | data[offset + 1];
+      offset += 2;
+      if (offset + spsLength > data.length) {
+        console.error("[FLVDemuxer] Incomplete SPS data");
+        return null;
+      }
+      spsList.push(data.slice(offset, offset + spsLength));
+      offset += spsLength;
+    }
+    if (offset >= data.length) {
+      console.error("[FLVDemuxer] Missing PPS count");
+      return null;
+    }
+    const ppsCount = data[offset++];
+    const ppsList = [];
+    for (let i = 0; i < ppsCount; i++) {
+      if (offset + 2 > data.length) {
+        console.error("[FLVDemuxer] Incomplete PPS length");
+        return null;
+      }
+      const ppsLength = data[offset] << 8 | data[offset + 1];
+      offset += 2;
+      if (offset + ppsLength > data.length) {
+        console.error("[FLVDemuxer] Incomplete PPS data");
+        return null;
+      }
+      ppsList.push(data.slice(offset, offset + ppsLength));
+      offset += ppsLength;
+    }
+    return {
+      configurationVersion,
+      avcProfileIndication,
+      profileCompatibility,
+      avcLevelIndication,
+      lengthSizeMinusOne,
+      spsList,
+      ppsList
+    };
+  }
+  /**
+   * 解析 HEVC Sequence Header (HEVCDecoderConfigurationRecord)
+   *
+   * 结构 (ISO 14496-15):
+   * byte 0: configurationVersion (usually 1)
+   * byte 1: general_profile_space (2 bits) + general_tier_flag (1 bit) + general_profile_idc (5 bits)
+   * byte 2-5: general_profile_compatibility_flags (32 bits)
+   * byte 6-11: general_constraint_indicator_flags (48 bits)
+   * byte 12: general_level_idc
+   * byte 13-14: min_spatial_segmentation_idc (高4位保留)
+   * byte 15: parallelismType (高6位保留)
+   * byte 16: chromaFormat (高6位保留)
+   * byte 17: bitDepthLumaMinus8 (高5位保留)
+   * byte 18: bitDepthChromaMinus8 (高5位保留)
+   * byte 19-20: avgFrameRate
+   * byte 21: constantFrameRate (2 bits) + numTemporalLayers (3 bits) + temporalIdNested (1 bit) + lengthSizeMinusOne (2 bits)
+   * byte 22: numOfArrays (高3位保留)
+   * Arrays:
+   *   byte 0: array_completeness (1 bit) + reserved (1 bit) + NAL_unit_type (6 bits)
+   *   byte 1-2: numNalus
+   *   NALUs:
+   *     byte 0-1: nalUnitLength
+   *     byte n: nalUnit data
+   */
+  parseHEVCSequenceHeader(data) {
+    if (data.length < 23) {
+      console.error("[FLVDemuxer] HEVC Sequence Header too short");
+      return null;
+    }
+    let offset = 0;
+    const configurationVersion = data[offset++];
+    if (configurationVersion !== 1) {
+      console.warn("[FLVDemuxer] Unknown HEVC configuration version:", configurationVersion);
+    }
+    const byte1 = data[offset++];
+    const general_profile_space = byte1 >> 6 & 3;
+    const general_tier_flag = byte1 >> 5 & 1;
+    const general_profile_idc = byte1 & 31;
+    const general_profile_compatibility_flags = data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+    offset += 4;
+    const general_constraint_indicator_flags = BigInt(data[offset]) << 40n | BigInt(data[offset + 1]) << 32n | BigInt(data[offset + 2]) << 24n | BigInt(data[offset + 3]) << 16n | BigInt(data[offset + 4]) << 8n | BigInt(data[offset + 5]);
+    offset += 6;
+    const general_level_idc = data[offset++];
+    offset += 2;
+    offset += 1;
+    offset += 1;
+    offset += 1;
+    offset += 1;
+    offset += 2;
+    const byte21 = data[offset++];
+    const lengthSizeMinusOne = byte21 & 3;
+    const numOfArrays = data[offset++];
+    const vpsList = [];
+    const spsList = [];
+    const ppsList = [];
+    for (let i = 0; i < numOfArrays; i++) {
+      if (offset >= data.length) {
+        console.error("[FLVDemuxer] Incomplete HEVC array header");
+        break;
+      }
+      const nalUnitType = data[offset++] & 63;
+      if (offset + 2 > data.length) {
+        console.error("[FLVDemuxer] Incomplete numNalus");
+        break;
+      }
+      const numNalus = data[offset] << 8 | data[offset + 1];
+      offset += 2;
+      for (let j = 0; j < numNalus; j++) {
+        if (offset + 2 > data.length) {
+          console.error("[FLVDemuxer] Incomplete NAL unit length");
+          break;
+        }
+        const nalUnitLength = data[offset] << 8 | data[offset + 1];
+        offset += 2;
+        if (offset + nalUnitLength > data.length) {
+          console.error("[FLVDemuxer] Incomplete NAL unit data");
+          break;
+        }
+        const nalData = data.slice(offset, offset + nalUnitLength);
+        offset += nalUnitLength;
+        if (nalUnitType === 32) {
+          vpsList.push(nalData);
+        } else if (nalUnitType === 33) {
+          spsList.push(nalData);
+        } else if (nalUnitType === 34) {
+          ppsList.push(nalData);
+        }
+      }
+    }
+    return {
+      configurationVersion,
+      general_profile_space,
+      general_tier_flag,
+      general_profile_idc,
+      general_profile_compatibility_flags,
+      general_constraint_indicator_flags,
+      general_level_idc,
+      lengthSizeMinusOne,
+      vpsList,
+      spsList,
+      ppsList
+    };
+  }
+  /**
+   * 获取 AVC 配置
+   */
+  getAvcConfig() {
+    return this.avcConfig;
+  }
+  /**
+   * 获取 HEVC 配置
+   */
+  getHevcConfig() {
+    return this.hevcConfig;
+  }
+  /**
+   * 获取当前编码类型
+   */
+  getCodecId() {
+    return this.codecId;
+  }
+  /**
+   * 将 Video Tag 转换为 Annex B 格式的数据
+   *
+   * FLV 中的 AVC 数据使用 AVCC 格式 (长度前缀),
+   * 需要转换为 Annex B 格式 (start code) 才能被解码器处理
+   *
+   * @param tag FLV Video Tag
+   * @param lengthSize NALU 长度字节数 (从 Sequence Header 获取, 通常为 4)
+   * @returns Annex B 格式的数据
+   */
+  videoTagToAnnexB(tag, lengthSize = 4) {
+    const data = tag.data;
+    if (data.length === 0) return null;
+    let nalCount = 0;
+    let totalSize = 0;
+    let offset = 0;
+    while (offset + lengthSize <= data.length) {
+      let nalLength = 0;
+      for (let i = 0; i < lengthSize; i++) {
+        nalLength = nalLength << 8 | data[offset + i];
+      }
+      offset += lengthSize;
+      if (nalLength <= 0 || offset + nalLength > data.length) {
+        console.warn(`[FLVDemuxer] Invalid NAL length: ${nalLength} at offset ${offset - lengthSize}`);
+        break;
+      }
+      totalSize += 4 + nalLength;
+      offset += nalLength;
+      nalCount++;
+    }
+    if (nalCount === 0) {
+      console.warn("[FLVDemuxer] No valid NAL units found");
+      return null;
+    }
+    const annexBData = new Uint8Array(totalSize);
+    let writeOffset = 0;
+    offset = 0;
+    while (offset + lengthSize <= data.length) {
+      let nalLength = 0;
+      for (let i = 0; i < lengthSize; i++) {
+        nalLength = nalLength << 8 | data[offset + i];
+      }
+      offset += lengthSize;
+      if (nalLength <= 0 || offset + nalLength > data.length) {
+        break;
+      }
+      annexBData[writeOffset++] = 0;
+      annexBData[writeOffset++] = 0;
+      annexBData[writeOffset++] = 0;
+      annexBData[writeOffset++] = 1;
+      annexBData.set(data.slice(offset, offset + nalLength), writeOffset);
+      writeOffset += nalLength;
+      offset += nalLength;
+    }
+    return annexBData;
+  }
+  /**
+   * 判断 Video Tag 是否为关键帧
+   */
+  isKeyframe(tag) {
+    return tag.frameType === FRAME_TYPE_KEYFRAME;
+  }
+}
+class HEVCDecoder {
+  constructor(wasmLoader) {
+    this.wasmModule = null;
+    this.decoderContext = null;
+    this.wasmModule = wasmLoader.getModule();
+  }
+  async init() {
+    if (!this.wasmModule) {
+      throw new Error("WASM module not loaded");
+    }
+    this.decoderContext = this.wasmModule._create_decoder(173);
+    if (this.decoderContext === 0 || this.decoderContext === null) {
+      throw new Error("Failed to create HEVC decoder context");
+    }
+    console.log("[HEVCDecoder] Initialized with codec_id=173");
+  }
+  decode(nalUnit) {
+    if (this.decoderContext === null || !this.wasmModule) {
+      return null;
+    }
+    const dataPtr = this.wasmModule._malloc(nalUnit.size);
+    this.wasmModule.HEAPU8.set(nalUnit.data, dataPtr);
+    const result = this.wasmModule._decode_video(
+      this.decoderContext,
+      dataPtr,
+      nalUnit.size
+    );
+    this.wasmModule._free(dataPtr);
+    if (result === 1) {
+      const width = this.wasmModule._get_frame_width(this.decoderContext);
+      const height = this.wasmModule._get_frame_height(this.decoderContext);
+      if (width <= 0 || height <= 0) {
+        return null;
+      }
+      const yPtr = this.wasmModule._get_frame_data(this.decoderContext, 0);
+      const uPtr = this.wasmModule._get_frame_data(this.decoderContext, 1);
+      const vPtr = this.wasmModule._get_frame_data(this.decoderContext, 2);
+      const yLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 0);
+      const uLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 1);
+      const vLineSize = this.wasmModule._get_frame_linesize(this.decoderContext, 2);
+      const frameData = this.yuv420pToRgba(
+        yPtr,
+        uPtr,
+        vPtr,
+        width,
+        height,
+        yLineSize,
+        uLineSize,
+        vLineSize
+      );
+      return { width, height, data: frameData };
+    }
+    return null;
+  }
+  yuv420pToRgba(yPtr, uPtr, vPtr, width, height, yLineSize, uLineSize, vLineSize) {
+    const rgba = new Uint8Array(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const yIndex = y * yLineSize + x;
+        const uIndex = (y >> 1) * uLineSize + (x >> 1);
+        const vIndex = (y >> 1) * vLineSize + (x >> 1);
+        const yValue = this.wasmModule.HEAPU8[yPtr + yIndex];
+        const uValue = this.wasmModule.HEAPU8[uPtr + uIndex];
+        const vValue = this.wasmModule.HEAPU8[vPtr + vIndex];
+        const c = yValue - 16;
+        const d = uValue - 128;
+        const e = vValue - 128;
+        let r = 298 * c + 409 * e + 128 >> 8;
+        let g = 298 * c - 100 * d - 208 * e + 128 >> 8;
+        let b = 298 * c + 516 * d + 128 >> 8;
+        r = r < 0 ? 0 : r > 255 ? 255 : r;
+        g = g < 0 ? 0 : g > 255 ? 255 : g;
+        b = b < 0 ? 0 : b > 255 ? 255 : b;
+        const rgbaIndex = (y * width + x) * 4;
+        rgba[rgbaIndex] = r;
+        rgba[rgbaIndex + 1] = g;
+        rgba[rgbaIndex + 2] = b;
+        rgba[rgbaIndex + 3] = 255;
+      }
+    }
+    return rgba;
+  }
+}
+const CODEC_ID_AVC = 7;
+const CODEC_ID_HEVC = 12;
+const FLV_PREFETCHER_CONFIG = {
+  ...DEFAULT_STREAM_PREFETCHER_CONFIG,
+  lowWaterMark: 100,
+  highWaterMark: 500,
+  initialBufferSize: 2 * 1024 * 1024,
+  // 2MB
+  prefetchInterval: 10,
+  dynamicInterval: true
+};
+const DEFAULT_FLV_CONFIG = {
+  ...DEFAULT_PLAYER_CONFIG
+};
+class FLVStreamPrefetcher extends StreamPrefetcher {
+  constructor(config, callbacks, player) {
+    super(config, callbacks);
+    this.player = player;
+  }
+  /**
+   * 判断是否应该预取
+   * 对于直播流：只要有 reader 且未完成，就持续下载
+   */
+  shouldPrefetch() {
+    if (!this.reader) return false;
+    if (this.downloadComplete) return false;
+    return true;
+  }
+  /**
+   * 处理缓冲区数据
+   */
+  processBufferData(data) {
+    return this.player.processPrefetchBuffer(data);
+  }
+  /**
+   * 获取队列大小（使用 player 的 videoTagQueue 大小）
+   */
+  getQueueSize() {
+    return this.player.videoTagQueue.length;
+  }
+}
+class FLVPlayer extends BasePlayer {
+  constructor(config = {}, callbacks = {}) {
+    super(config, callbacks, DEFAULT_FLV_CONFIG);
+    this.flvDemuxer = new FLVDemuxer();
+    this.h264Decoder = null;
+    this.hevcDecoder = null;
+    this.isPrefetching = false;
+    this.currentUrl = "";
+    this._currentCodecId = CODEC_ID_AVC;
+    this._timedFrameBuffer = [];
+    this._videoTagQueue = [];
+    this.playStartTime = 0;
+    this.firstFrameDts = -1;
+    this.lastRenderTime = 0;
+    this.decodeFailCount = 0;
+    this.dynamicMinBufferSize = 10;
+    this.dynamicTargetBufferSize = 60;
+    this.videoWidth = 0;
+    this.videoHeight = 0;
+    this.prefetcher = null;
+    this.liveReader = null;
+    this.liveDownloadAbort = false;
+    this._lastQueuedTimestamp = -1;
+    this._currentDownloadSpeed = 0;
+    this.renderedFrames = 0;
+    this.lastRenderLogTime = 0;
+    this.consecutiveEmptyBuffer = 0;
+    this.lastRenderedDts = -1;
+    this.pausedTime = 0;
+    this.bufferEmptyStartTime = 0;
+    this.playStartTimeOffset = 0;
+    this.resyncCount = 0;
+    this.renderLoop = () => {
+      if (!this.isPlaying) return;
+      this.updateState({
+        decoded: this._timedFrameBuffer.length,
+        downloaded: this._videoTagQueue.length,
+        droppedFrames: this.droppedFrames
+      });
+      const now = performance.now();
+      const isLive = this.config.isLive;
+      if (this._timedFrameBuffer.length > 0 && this.renderer) {
+        this.consecutiveEmptyBuffer = 0;
+        if (this.firstFrameDts < 0) {
+          this.firstFrameDts = this._timedFrameBuffer[0].dts;
+          this.playStartTime = now;
+          this.playStartTimeOffset = 0;
+          console.log("[FLVPlayer] RenderLoop initialized, firstFrameDts:", this.firstFrameDts, "isLive:", isLive);
+        }
+        if (isLive) {
+          const elapsed = now - this.playStartTime - this.pausedTime;
+          const currentTargetDts = this.firstFrameDts + elapsed;
+          this.setCurrentTime(Math.floor(currentTargetDts));
+          let frameToRender = null;
+          while (this._timedFrameBuffer.length > 0 && this._timedFrameBuffer[0].dts <= currentTargetDts) {
+            if (frameToRender) {
+              this.droppedFrames++;
+            }
+            frameToRender = this._timedFrameBuffer.shift();
+          }
+          if (frameToRender) {
+            this.renderFrame(frameToRender, now);
+          }
+        } else {
+          const nextFrame = this._timedFrameBuffer[0];
+          const elapsed = now - this.playStartTime - this.playStartTimeOffset;
+          const currentTargetPts = this.firstFrameDts + elapsed;
+          if (this.lastRenderedDts >= 0) {
+            this.setCurrentTime(Math.floor(this.lastRenderedDts));
+          }
+          if (nextFrame.dts <= currentTargetPts) {
+            const frameToRender = this._timedFrameBuffer.shift();
+            this.renderFrame(frameToRender, now);
+            this.lastRenderedDts = frameToRender.dts;
+            const lag = currentTargetPts - frameToRender.dts;
+            if (lag > 1e3) {
+              this.playStartTime = now;
+              this.playStartTimeOffset = 0;
+              this.firstFrameDts = frameToRender.dts;
+              this.resyncCount++;
+              if (this.resyncCount <= 3) {
+                console.log("[FLVPlayer] Major resync, lag:", Math.floor(lag), "ms");
+              }
+            }
+          }
+        }
+        if (now - this.lastRenderLogTime > 5e3) {
+          console.log("[FLVPlayer] RenderLoop stats:", {
+            renderedFrames: this.renderedFrames,
+            droppedFrames: this.droppedFrames,
+            decoded: this._timedFrameBuffer.length,
+            downloaded: this._videoTagQueue.length,
+            mode: isLive ? "live" : "vod"
+          });
+          this.lastRenderLogTime = now;
+        }
+      } else {
+        if (this.consecutiveEmptyBuffer === 0 && this.lastRenderedDts >= 0) {
+          this.bufferEmptyStartTime = now;
+        }
+        this.consecutiveEmptyBuffer++;
+        if (isLive && this.bufferEmptyStartTime > 0) {
+          this.pausedTime = now - this.bufferEmptyStartTime;
+        } else if (!isLive && this.bufferEmptyStartTime > 0) {
+          this.playStartTimeOffset = now - this.bufferEmptyStartTime;
+        }
+        if (this.consecutiveEmptyBuffer === 1) {
+          console.warn("[FLVPlayer] Buffer empty, waiting for frames... queue:", this._videoTagQueue.length);
+        } else if (this.consecutiveEmptyBuffer % 60 === 0) {
+          console.warn("[FLVPlayer] Buffer still empty after", Math.floor(this.consecutiveEmptyBuffer / 60), "seconds");
+        }
+      }
+      this.frameTimer = requestAnimationFrame(this.renderLoop);
+    };
+  }
+  // 公共访问器（供预取器使用）
+  get videoTagQueue() {
+    return this._videoTagQueue;
+  }
+  get currentCodecId() {
+    return this._currentCodecId;
+  }
+  get lastQueuedTimestamp() {
+    return this._lastQueuedTimestamp;
+  }
+  /**
+   * 加载 FLV 文件
+   */
+  async load(url) {
+    console.log("[FLVPlayer] Loading URL:", url);
+    this.currentUrl = url;
+    this.stopLiveDownload();
+    this._timedFrameBuffer = [];
+    this._videoTagQueue = [];
+    this.liveDownloadAbort = false;
+    this.resetState();
+    this.playStartTime = 0;
+    this.firstFrameDts = -1;
+    this.lastRenderTime = 0;
+    this.decodeFailCount = 0;
+    this.dynamicMinBufferSize = 10;
+    this.dynamicTargetBufferSize = this.config.targetBufferSize;
+    this.videoWidth = 0;
+    this.videoHeight = 0;
+    if (this.prefetcher) {
+      this.prefetcher.reset();
+      this.prefetcher = null;
+    }
+    this._currentDownloadSpeed = 0;
+    this._lastQueuedTimestamp = -1;
+    this.updateState({ downloadSpeed: 0 });
+    this.flvDemuxer = new FLVDemuxer();
+    await this.loadFLV(url);
+    this.updateState({ isLoaded: true });
+    console.log("[FLVPlayer] Loaded, video tags:", this._videoTagQueue.length);
+  }
+  /**
+   * 初始化解码器（覆盖基类方法，支持 AVC 和 HEVC）
+   */
+  async initDecoder() {
+    await this.wasmLoader.load(this.config.wasmPath);
+    const avcConfig = this.flvDemuxer.getAvcConfig();
+    const hevcConfig = this.flvDemuxer.getHevcConfig();
+    this._currentCodecId = this.flvDemuxer.getCodecId();
+    if (hevcConfig) {
+      console.log("[FLVPlayer] Initializing HEVC decoder...");
+      this.hevcDecoder = new HEVCDecoder(this.wasmLoader);
+      await this.hevcDecoder.init();
+      if (hevcConfig.vpsList.length > 0 || hevcConfig.spsList.length > 0) {
+        this.initDecoderFromHEVCConfig(hevcConfig);
+        this.decoderInitialized = true;
+      } else {
+        console.log("[FLVPlayer] HEVC config has no VPS/SPS/PPS, will init from first NALU");
+        if (this._videoTagQueue.length > 0) {
+          const firstTag = this._videoTagQueue[0];
+          this.tryInitFromData(firstTag.annexBData);
+        }
+      }
+    } else if (avcConfig) {
+      console.log("[FLVPlayer] Initializing AVC decoder...");
+      this.h264Decoder = new H264Decoder(this.wasmLoader);
+      await this.h264Decoder.init();
+      if (avcConfig.spsList.length > 0) {
+        this.initDecoderFromAVCConfig(avcConfig);
+        this.decoderInitialized = true;
+      } else {
+        console.log("[FLVPlayer] AVC config has no SPS/PPS, will init from first NALU");
+        if (this._videoTagQueue.length > 0) {
+          const firstTag = this._videoTagQueue[0];
+          this.tryInitFromData(firstTag.annexBData);
+        }
+      }
+    } else {
+      console.warn("[FLVPlayer] No config found, will try to init from first frames");
+    }
+  }
+  /**
+   * 根据视频分辨率动态调整缓冲参数
+   */
+  adjustBufferForResolution(width, height) {
+    this.videoWidth = width;
+    this.videoHeight = height;
+    const pixels = width * height;
+    const basePixels = 1920 * 1080;
+    const ratio = pixels / basePixels;
+    if (ratio > 2) {
+      this.dynamicMinBufferSize = 30;
+      this.dynamicTargetBufferSize = Math.min(150, this.config.targetBufferSize * 2);
+      console.log(`[FLVPlayer] High resolution (${width}x${height}), using larger buffer`);
+    } else if (ratio > 1) {
+      this.dynamicMinBufferSize = 20;
+      this.dynamicTargetBufferSize = Math.min(100, Math.floor(this.config.targetBufferSize * 1.5));
+      console.log(`[FLVPlayer] Medium-high resolution (${width}x${height}), using medium buffer`);
+    } else {
+      this.dynamicMinBufferSize = 10;
+      this.dynamicTargetBufferSize = this.config.targetBufferSize;
+    }
+  }
+  /**
+   * 开始播放（覆盖基类方法）
+   */
+  async play() {
+    const MIN_BUFFER_SIZE = this.dynamicMinBufferSize;
+    const MAX_WAIT_TIME = 1e4;
+    const startTime = Date.now();
+    console.log(`[FLVPlayer] Waiting for buffer (target: ${MIN_BUFFER_SIZE} frames)...`);
+    let aggressiveDecodeCount = 0;
+    const MAX_AGGRESSIVE_DECODE = 100;
+    while (this._timedFrameBuffer.length < MIN_BUFFER_SIZE && this._videoTagQueue.length > 0) {
+      if (Date.now() - startTime > MAX_WAIT_TIME) {
+        console.log("[FLVPlayer] Wait timeout, starting with", this._timedFrameBuffer.length, "frames");
+        break;
+      }
+      const batchSize = Math.min(10, this._videoTagQueue.length);
+      for (let i = 0; i < batchSize && this._videoTagQueue.length > 0; i++) {
+        const queuedTag = this._videoTagQueue.shift();
+        const frame = this.decodeVideoTag(queuedTag);
+        if (frame) {
+          const dts = queuedTag.tag.timestamp;
+          const pts = dts + queuedTag.tag.compositionTimeOffset;
+          this._timedFrameBuffer.push({ frame, dts, pts });
+          if (this.videoWidth === 0 || this.videoHeight === 0) {
+            this.adjustBufferForResolution(frame.width, frame.height);
+          }
+        }
+        aggressiveDecodeCount++;
+      }
+      if (aggressiveDecodeCount > MAX_AGGRESSIVE_DECODE) {
+        await this.sleep(10);
+        aggressiveDecodeCount = 0;
+      }
+    }
+    console.log("[FLVPlayer] Buffer ready, frames:", this._timedFrameBuffer.length, "queue:", this._videoTagQueue.length);
+    if (this._timedFrameBuffer.length > 0) {
+      this.firstFrameDts = this._timedFrameBuffer[0].dts;
+      this.playStartTime = performance.now();
+      console.log("[FLVPlayer] Play time initialized, firstFrameDts:", this.firstFrameDts);
+    }
+    this.isPlaying = true;
+    this.decodeLoopAbort = false;
+    this.updateState({ isPlaying: true });
+    if (this.prefetcher) {
+      this.prefetcher.start();
+    }
+    this.decodeLoop();
+    this.frameTimer = requestAnimationFrame(this.renderLoop);
+  }
+  /**
+   * 暂停播放
+   */
+  pause() {
+    super.pause();
+    if (this.prefetcher) {
+      this.prefetcher.stop();
+    }
+    if (this.config.isLive) {
+      console.log("[FLVPlayer] Pausing live stream, stopping download");
+      this.stopLiveDownload();
+    }
+  }
+  /**
+   * 处理预取缓冲区数据（供预取器调用）
+   */
+  processPrefetchBuffer(data) {
+    if (!data || data.length === 0) {
+      return { hasNewData: false, processedBytes: 0 };
+    }
+    const result = this.flvDemuxer.parseIncremental(data);
+    let lengthSize = 4;
+    if (result.hevcConfig) {
+      lengthSize = result.hevcConfig.lengthSizeMinusOne + 1;
+      this._currentCodecId = CODEC_ID_HEVC;
+    } else if (result.avcConfig) {
+      lengthSize = result.avcConfig.lengthSizeMinusOne + 1;
+      this._currentCodecId = CODEC_ID_AVC;
+    }
+    let newCount = 0;
+    for (const tag of result.videoTags) {
+      if (tag.timestamp > this._lastQueuedTimestamp) {
+        let annexBData = this.flvDemuxer.videoTagToAnnexB(tag, lengthSize);
+        if (!annexBData) {
+          for (const trySize of [4, 2, 1]) {
+            if (trySize !== lengthSize) {
+              annexBData = this.flvDemuxer.videoTagToAnnexB(tag, trySize);
+              if (annexBData) {
+                lengthSize = trySize;
+                break;
+              }
+            }
+          }
+        }
+        if (annexBData) {
+          this._videoTagQueue.push({ tag, annexBData });
+          this._lastQueuedTimestamp = tag.timestamp;
+          newCount++;
+        }
+      }
+    }
+    if (newCount > 0) {
+      console.log(`[FLVPlayer] Prefetch: +${newCount} new tags, queue: ${this._videoTagQueue.length}`);
+    }
+    return { hasNewData: newCount > 0, processedBytes: data.length };
+  }
+  /**
+   * 跳转到指定时间
+   */
+  async seek(time) {
+    this._timedFrameBuffer = [];
+    this.firstFrameDts = -1;
+    this.playStartTime = 0;
+    this.setCurrentTime(time);
+    console.log("[FLVPlayer] Seek to", time, "ms");
+  }
+  /**
+   * 解码循环
+   */
+  async decodeLoop() {
+    console.log("[FLVPlayer] DecodeLoop START, queue size:", this._videoTagQueue.length);
+    let emptyQueueCount = 0;
+    const MAX_EMPTY_QUEUE_WAIT = 100;
+    while (this.isPlaying && !this.decodeLoopAbort) {
+      this.prefetcher?.processBuffer();
+      const targetBuffer = this.dynamicTargetBufferSize;
+      const bufferRatio = this._timedFrameBuffer.length / targetBuffer;
+      let batchSize;
+      if (bufferRatio < 0.3) {
+        batchSize = Math.max(1, this.config.decodeBatchSize);
+      } else if (bufferRatio < 0.6) {
+        batchSize = Math.max(3, this.config.decodeBatchSize);
+      } else {
+        batchSize = Math.max(5, this.config.decodeBatchSize);
+      }
+      let decodedInBatch = 0;
+      while (this._videoTagQueue.length > 0 && decodedInBatch < batchSize) {
+        if (this._timedFrameBuffer.length >= targetBuffer) {
+          break;
+        }
+        const queuedTag = this._videoTagQueue.shift();
+        const frame = this.decodeVideoTag(queuedTag);
+        if (frame) {
+          const dts = queuedTag.tag.timestamp;
+          const pts = dts + queuedTag.tag.compositionTimeOffset;
+          this._timedFrameBuffer.push({ frame, dts, pts });
+          decodedInBatch++;
+          if (this.videoWidth === 0 || this.videoHeight === 0) {
+            this.adjustBufferForResolution(frame.width, frame.height);
+          }
+          if (this._timedFrameBuffer.length <= 5) {
+            console.log("[FLVPlayer] Frame decoded, dts:", dts, "pts:", pts, "buffer size:", this._timedFrameBuffer.length);
+          }
+        } else {
+          this.decodeFailCount++;
+          if (this.decodeFailCount <= 10) {
+            console.log("[FLVPlayer] Decode failed, dts:", queuedTag.tag.timestamp, "total fails:", this.decodeFailCount);
+          }
+        }
+      }
+      if (decodedInBatch > 0) {
+        emptyQueueCount = 0;
+        if (this._timedFrameBuffer.length < targetBuffer * 0.3) {
+          await this.yieldFast();
+        } else if (this._timedFrameBuffer.length < targetBuffer * 0.6) {
+          await this.yieldFast();
+        } else {
+          await this.sleep(2);
+        }
+      } else {
+        if (this._videoTagQueue.length === 0 && this._timedFrameBuffer.length === 0) {
+          emptyQueueCount++;
+          if (emptyQueueCount >= MAX_EMPTY_QUEUE_WAIT) {
+            console.log("[FLVPlayer] No more data after waiting, stopping decode loop");
+            break;
+          }
+          if (emptyQueueCount === 1) {
+            console.log("[FLVPlayer] Queue empty, waiting for more data...");
+          }
+        } else {
+          emptyQueueCount = 0;
+        }
+        await this.sleep(50);
+      }
+    }
+    console.log("[FLVPlayer] DecodeLoop END, decoded:", this._timedFrameBuffer.length + this.droppedFrames, "failed:", this.decodeFailCount, "dropped:", this.droppedFrames);
+  }
+  // ==================== 私有方法 ====================
+  /**
+   * 流式加载 FLV 文件
+   */
+  async loadFLV(url) {
+    console.log("[FLVPlayer] Fetching FLV...");
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch FLV: ${response.status}`);
+    }
+    console.log("[FLVPlayer] Fetch response OK, status:", response.status);
+    this.isPrefetching = true;
+    this.updateState({ isPrefetching: true });
+    const isLive = this.config.isLive || false;
+    console.log("[FLVPlayer] isLive:", isLive);
+    try {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("ReadableStream not supported");
+      }
+      const chunks = [];
+      let totalLength = 0;
+      const MIN_DATA_SIZE = isLive ? 100 * 1024 : 500 * 1024;
+      const TIMEOUT_MS = isLive ? 5e3 : 8e3;
+      const startTime = Date.now();
+      let started = false;
+      let lastLoggedTags = 0;
+      this.liveReader = reader;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (value) {
+          chunks.push(value);
+          totalLength += value.length;
+        }
+        const shouldStart = totalLength >= MIN_DATA_SIZE || Date.now() - startTime > TIMEOUT_MS;
+        if (!started && shouldStart && totalLength > 0) {
+          started = true;
+          console.log("[FLVPlayer] Buffered", totalLength, "bytes, starting...");
+          const data = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            data.set(chunk, offset);
+            offset += chunk.length;
+          }
+          this.parseAndQueueFLV(data);
+          lastLoggedTags = this._videoTagQueue.length;
+          this.updateState({ isLoaded: true });
+          console.log("[FLVPlayer] Stream ready, video tags:", this._videoTagQueue.length);
+          this.initPrefetcher(reader, chunks, totalLength);
+          return;
+        }
+        if (started && totalLength > 0) {
+          const allData = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            allData.set(chunk, offset);
+            offset += chunk.length;
+          }
+          this._videoTagQueue = [];
+          this.parseAndQueueFLV(allData);
+          if (this._videoTagQueue.length - lastLoggedTags >= 50) {
+            console.log("[FLVPlayer] Stream:", this._videoTagQueue.length, "tags,", totalLength, "bytes");
+            lastLoggedTags = this._videoTagQueue.length;
+          }
+        }
+        if (done) {
+          console.log("[FLVPlayer] Download complete:", totalLength, "bytes");
+          if (!started && totalLength > 0) {
+            const data = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of chunks) {
+              data.set(chunk, offset);
+              offset += chunk.length;
+            }
+            this.parseAndQueueFLV(data);
+            this.updateState({ isLoaded: true });
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      console.error("[FLVPlayer] Error loading FLV:", error);
+      throw error;
+    } finally {
+      if (!this.config.isLive) {
+        this.isPrefetching = false;
+        this.updateState({ isPrefetching: false });
+      }
+    }
+  }
+  /**
+   * 初始化预取器
+   */
+  initPrefetcher(reader, chunks, initialLength) {
+    const initialData = new Uint8Array(initialLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      initialData.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.prefetcher = new FLVStreamPrefetcher(
+      FLV_PREFETCHER_CONFIG,
+      {
+        onStatusChange: (status) => {
+          this.updateState({
+            isPrefetching: status.isPrefetching,
+            downloadSpeed: status.downloadSpeed
+          });
+          this._currentDownloadSpeed = status.downloadSpeed;
+        },
+        onDataReceived: (totalBytes) => {
+          console.log(`[FLVPlayer] Data received: ${totalBytes} bytes`);
+        }
+      },
+      this
+    );
+    this.prefetcher.setReader(reader, initialData);
+    this.flvDemuxer.parseIncremental(initialData);
+    console.log(`[FLVPlayer] Prefetcher initialized with ${initialLength} bytes`);
+  }
+  /**
+   * 停止直播流下载
+   */
+  stopLiveDownload() {
+    this.liveDownloadAbort = true;
+    if (this.liveReader) {
+      this.liveReader.cancel();
+      this.liveReader = null;
+    }
+    if (this.prefetcher) {
+      this.prefetcher.cancelDownload();
+    }
+  }
+  /**
+   * 解析 FLV 数据并入队
+   */
+  parseAndQueueFLV(data) {
+    if (data.length < 13) {
+      throw new Error("Invalid FLV: data too short");
+    }
+    const flvHeader = String.fromCharCode(data[0], data[1], data[2]);
+    if (flvHeader !== "FLV") {
+      throw new Error("Invalid FLV: header not found, got: " + flvHeader);
+    }
+    console.log("[FLVPlayer] FLV header valid");
+    const result = this.flvDemuxer.parse(data);
+    console.log("[FLVPlayer] Parsed FLV:", {
+      videoTags: result.videoTags.length,
+      duration: result.duration,
+      hasAvcConfig: !!result.avcConfig,
+      hasHevcConfig: !!result.hevcConfig
+    });
+    this.setDuration(result.duration);
+    let lengthSize = 4;
+    if (result.hevcConfig) {
+      lengthSize = result.hevcConfig.lengthSizeMinusOne + 1;
+      this._currentCodecId = CODEC_ID_HEVC;
+    } else if (result.avcConfig) {
+      lengthSize = result.avcConfig.lengthSizeMinusOne + 1;
+      this._currentCodecId = CODEC_ID_AVC;
+    }
+    let detectedLengthSize = lengthSize;
+    for (const tag of result.videoTags) {
+      let annexBData = this.flvDemuxer.videoTagToAnnexB(tag, detectedLengthSize);
+      if (!annexBData && detectedLengthSize !== 4) {
+        annexBData = this.flvDemuxer.videoTagToAnnexB(tag, 4);
+        if (annexBData) {
+          detectedLengthSize = 4;
+          console.log("[FLVPlayer] Auto-detected length size: 4 bytes");
+        }
+      }
+      if (annexBData) {
+        this._videoTagQueue.push({ tag, annexBData });
+        if (tag.timestamp > this._lastQueuedTimestamp) {
+          this._lastQueuedTimestamp = tag.timestamp;
+        }
+      }
+    }
+    console.log("[FLVPlayer] Queued", this._videoTagQueue.length, "video tags, lengthSize:", detectedLengthSize);
+  }
+  /**
+   * 从 AVC 配置初始化解码器
+   */
+  initDecoderFromAVCConfig(config) {
+    if (!this.h264Decoder) return;
+    if (config.spsList.length > 0) {
+      const sps = config.spsList[0];
+      const spsWithStartCode = new Uint8Array(4 + sps.length);
+      spsWithStartCode.set([0, 0, 0, 1], 0);
+      spsWithStartCode.set(sps, 4);
+      this.h264Decoder.decode({ type: 7, data: spsWithStartCode, size: spsWithStartCode.length });
+      console.log("[FLVPlayer] AVC SPS decoded, length:", sps.length);
+    }
+    if (config.ppsList.length > 0) {
+      const pps = config.ppsList[0];
+      const ppsWithStartCode = new Uint8Array(4 + pps.length);
+      ppsWithStartCode.set([0, 0, 0, 1], 0);
+      ppsWithStartCode.set(pps, 4);
+      this.h264Decoder.decode({ type: 8, data: ppsWithStartCode, size: ppsWithStartCode.length });
+      console.log("[FLVPlayer] AVC PPS decoded, length:", pps.length);
+    }
+    console.log("[FLVPlayer] Decoder initialized from AVC config");
+  }
+  /**
+   * 从 HEVC 配置初始化解码器
+   */
+  initDecoderFromHEVCConfig(config) {
+    if (!this.hevcDecoder) return;
+    if (config.vpsList.length > 0) {
+      const vps = config.vpsList[0];
+      const vpsWithStartCode = new Uint8Array(4 + vps.length);
+      vpsWithStartCode.set([0, 0, 0, 1], 0);
+      vpsWithStartCode.set(vps, 4);
+      this.hevcDecoder.decode({ type: 32, data: vpsWithStartCode, size: vpsWithStartCode.length });
+      console.log("[FLVPlayer] HEVC VPS decoded, length:", vps.length);
+    }
+    if (config.spsList.length > 0) {
+      const sps = config.spsList[0];
+      const spsWithStartCode = new Uint8Array(4 + sps.length);
+      spsWithStartCode.set([0, 0, 0, 1], 0);
+      spsWithStartCode.set(sps, 4);
+      this.hevcDecoder.decode({ type: 33, data: spsWithStartCode, size: spsWithStartCode.length });
+      console.log("[FLVPlayer] HEVC SPS decoded, length:", sps.length);
+    }
+    if (config.ppsList.length > 0) {
+      const pps = config.ppsList[0];
+      const ppsWithStartCode = new Uint8Array(4 + pps.length);
+      ppsWithStartCode.set([0, 0, 0, 1], 0);
+      ppsWithStartCode.set(pps, 4);
+      this.hevcDecoder.decode({ type: 34, data: ppsWithStartCode, size: ppsWithStartCode.length });
+      console.log("[FLVPlayer] HEVC PPS decoded, length:", pps.length);
+    }
+    console.log("[FLVPlayer] Decoder initialized from HEVC config");
+  }
+  /**
+   * 解码 Video Tag
+   */
+  decodeVideoTag(queuedTag) {
+    const decoder = this._currentCodecId === CODEC_ID_HEVC ? this.hevcDecoder : this.h264Decoder;
+    if (!decoder) {
+      console.warn("[FLVPlayer] Decoder not available");
+      return null;
+    }
+    if (!this.decoderInitialized) {
+      if (this.flvDemuxer.isKeyframe(queuedTag.tag)) {
+        this.tryInitFromData(queuedTag.annexBData);
+      }
+      if (!this.decoderInitialized) {
+        return null;
+      }
+    }
+    const isKeyframe = this.flvDemuxer.isKeyframe(queuedTag.tag);
+    const frame = decoder.decode({
+      type: isKeyframe ? 5 : 1,
+      data: queuedTag.annexBData,
+      size: queuedTag.annexBData.length
+    });
+    return frame;
+  }
+  /**
+   * 尝试从 Annex B 数据中初始化解码器
+   */
+  tryInitFromData(data) {
+    if (this.decoderInitialized) return;
+    const decoder = this._currentCodecId === CODEC_ID_HEVC ? this.hevcDecoder : this.h264Decoder;
+    if (!decoder) return;
+    if (this._currentCodecId === CODEC_ID_HEVC) {
+      this.tryInitHEVCFromData(data, decoder);
+    } else {
+      this.tryInitAVCFromData(data, decoder);
+    }
+  }
+  /**
+   * 从数据中初始化 AVC 解码器
+   */
+  tryInitAVCFromData(data, decoder) {
+    let offset = 0;
+    let sps = null;
+    let pps = null;
+    while (offset + 4 < data.length) {
+      if (data[offset] === 0 && data[offset + 1] === 0 && (data[offset + 2] === 1 || data[offset + 2] === 0 && data[offset + 3] === 1)) {
+        const startCodeSize = data[offset + 2] === 1 ? 3 : 4;
+        const nalStart = offset + startCodeSize;
+        if (nalStart >= data.length) break;
+        const nalType = data[nalStart] & 31;
+        let nalEnd = data.length;
+        for (let i = nalStart + 1; i < data.length - 3; i++) {
+          if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 1) {
+            nalEnd = i;
+            break;
+          }
+        }
+        if (nalType === 7 && !sps) {
+          sps = data.slice(offset, nalEnd);
+        } else if (nalType === 8 && !pps) {
+          pps = data.slice(offset, nalEnd);
+        }
+        offset = nalEnd;
+      } else {
+        offset++;
+      }
+    }
+    if (sps) {
+      decoder.decode({ type: 7, data: sps, size: sps.length });
+      console.log("[FLVPlayer] AVC SPS decoded from data");
+    }
+    if (pps) {
+      decoder.decode({ type: 8, data: pps, size: pps.length });
+      console.log("[FLVPlayer] AVC PPS decoded from data");
+    }
+    if (sps || pps) {
+      this.decoderInitialized = true;
+    }
+  }
+  /**
+   * 从数据中初始化 HEVC 解码器
+   */
+  tryInitHEVCFromData(data, decoder) {
+    if (!data) return;
+    let offset = 0;
+    let vps = null;
+    let sps = null;
+    let pps = null;
+    while (offset + 5 < data.length) {
+      if (data[offset] === 0 && data[offset + 1] === 0 && (data[offset + 2] === 1 || data[offset + 2] === 0 && data[offset + 3] === 1)) {
+        const startCodeSize = data[offset + 2] === 1 ? 3 : 4;
+        const nalStart = offset + startCodeSize;
+        if (nalStart >= data.length) break;
+        const nalType = data[nalStart] >> 1 & 63;
+        let nalEnd = data.length;
+        for (let i = nalStart + 1; i < data.length - 3; i++) {
+          if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 1) {
+            nalEnd = i;
+            break;
+          }
+        }
+        if (nalType === 32 && !vps) {
+          vps = data.slice(offset, nalEnd);
+        } else if (nalType === 33 && !sps) {
+          sps = data.slice(offset, nalEnd);
+        } else if (nalType === 34 && !pps) {
+          pps = data.slice(offset, nalEnd);
+        }
+        offset = nalEnd;
+      } else {
+        offset++;
+      }
+    }
+    if (vps) {
+      decoder.decode({ type: 32, data: vps, size: vps.length });
+      console.log("[FLVPlayer] HEVC VPS decoded from data");
+    }
+    if (sps) {
+      decoder.decode({ type: 33, data: sps, size: sps.length });
+      console.log("[FLVPlayer] HEVC SPS decoded from data");
+    }
+    if (pps) {
+      decoder.decode({ type: 34, data: pps, size: pps.length });
+      console.log("[FLVPlayer] HEVC PPS decoded from data");
+    }
+    if (vps || sps || pps) {
+      this.decoderInitialized = true;
+    }
+  }
+  /**
+   * 渲染一帧
+   */
+  renderFrame(frame, now) {
+    if (!this.renderer) return;
+    this.renderer.render(frame.frame);
+    this.renderedFrames++;
+    this.lastRenderedDts = frame.dts;
+    this.updateState({ resolution: `${frame.frame.width}x${frame.frame.height}` });
+    const fps = this.renderer.updateFps();
+    this.updateState({ fps });
+    this.callbacks.onFrameRender?.(frame.frame);
+    this.lastRenderTime = now;
+  }
+}
+class FormatDetector {
+  /**
+   * 通过 URL 检测格式
+   */
+  static detectFromUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      const pathname = urlObj.pathname.toLowerCase();
+      if (pathname.endsWith(".m3u8") || pathname.endsWith(".m3u")) {
+        return "hls-ts";
+      }
+      if (pathname.endsWith(".flv")) {
+        return "flv";
+      }
+      if (pathname.endsWith(".mp4")) {
+        return "mp4";
+      }
+    } catch {
+      const lower = url.toLowerCase();
+      if (lower.includes(".m3u8") || lower.includes(".m3u")) return "hls-ts";
+      if (lower.includes(".flv")) return "flv";
+      if (lower.includes(".mp4")) return "mp4";
+    }
+    return "unknown";
+  }
+  /**
+   * 通过数据头检测格式
+   */
+  static detectFromData(data) {
+    if (data.length < 4) return "unknown";
+    if (data[0] === 70 && data[1] === 76 && data[2] === 86) {
+      return "flv";
+    }
+    if (data.length >= 8 && data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112) {
+      return "hls-fmp4";
+    }
+    if (data[0] === 71) {
+      return "hls-ts";
+    }
+    return "unknown";
+  }
+  /**
+   * 通过 Content-Type 检测格式
+   */
+  static detectFromContentType(contentType) {
+    const type = contentType.toLowerCase();
+    if (type.includes("mpegurl") || type.includes("x-mpegurl")) {
+      return "hls-ts";
+    }
+    if (type.includes("x-flv") || type.includes("flv")) {
+      return "flv";
+    }
+    if (type.includes("mp4")) {
+      return "mp4";
+    }
+    return "unknown";
+  }
+}
+class Canvas2DRenderer {
+  constructor(canvas) {
+    this.ctx = null;
+    this.frameCount = 0;
+    this.lastFpsUpdate = performance.now();
+    this.lastFps = 0;
+    this.canvas = canvas;
+    this.ctx = canvas.getContext("2d");
+    if (!this.ctx) {
+      throw new Error("Invalid canvas element");
+    }
+  }
+  render(frame) {
+    const { width, height, data } = frame;
+    if (this.canvas.width !== width || this.canvas.height !== height) {
+      this.canvas.width = width;
+      this.canvas.height = height;
+    }
+    const imageData = new ImageData(new Uint8ClampedArray(data), width, height);
+    this.ctx.putImageData(imageData, 0, 0);
+  }
+  updateFps() {
+    this.frameCount++;
+    const now = performance.now();
+    if (now - this.lastFpsUpdate >= 1e3) {
+      this.lastFps = this.frameCount;
+      this.frameCount = 0;
+      this.lastFpsUpdate = now;
+    }
+    return this.lastFps;
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+}
+const DEFAULT_EC_CONFIG = {
+  ...DEFAULT_PLAYER_CONFIG
+};
+class EcPlayerCore {
+  constructor(config = {}, callbacks = {}) {
+    this.player = null;
+    this.detectedFormat = "unknown";
+    this.pendingRenderer = null;
+    this.renderer = null;
+    this.config = { ...DEFAULT_EC_CONFIG, ...config };
+    this.callbacks = callbacks;
+    if (this.config.canvas) {
+      this.renderer = new Canvas2DRenderer(this.config.canvas);
+      this.pendingRenderer = this.renderer;
+    }
+  }
+  /**
+   * 加载视频（自动检测格式、初始化解码器）
+   * @param url 视频 URL
+   * @param isLive 是否为直播流（直播流会持续下载数据）
+   */
+  async load(url, isLive) {
+    this.callbacks.onStateChange?.({ isLoading: true, isLoaded: false });
+    try {
+      this.detectedFormat = FormatDetector.detectFromUrl(url);
+      console.log("[EcPlayerCore] Detected format:", this.detectedFormat, "from URL:", url, "isLive:", isLive);
+      if (isLive !== void 0) {
+        this.config.isLive = isLive;
+      }
+      this.player = this.createPlayer(this.detectedFormat);
+      if (this.pendingRenderer) {
+        this.player.setRenderer(this.pendingRenderer);
+        this.pendingRenderer = null;
+      }
+      await this.player.load(url);
+      await this.player.initDecoder();
+      this.callbacks.onStateChange?.({ isLoaded: true });
+    } finally {
+      this.callbacks.onStateChange?.({ isLoading: false });
+    }
+  }
+  /**
+   * 根据格式创建播放器
+   */
+  createPlayer(format) {
+    switch (format) {
+      case "flv":
+        return new FLVPlayer(this.config, this.callbacks);
+      case "hls-ts":
+      case "hls-fmp4":
+      case "unknown":
+      default:
+        return new HLSPlayer(this.config, this.callbacks);
+    }
+  }
+  // ==================== 公共 API ====================
+  /**
+   * 播放视频
+   * @param options 播放参数
+   */
+  async play(options) {
+    if (options?.url) {
+      await this.load(options.url, options.isLive);
+    }
+    return this.player?.play();
+  }
+  /**
+   * 暂停播放
+   */
+  pause() {
+    this.player?.pause();
+  }
+  /**
+   * 跳转到指定时间
+   */
+  async seek(time) {
+    return this.player?.seek(time);
+  }
+  /**
+   * 获取当前播放时间（毫秒）
+   */
+  getCurrentTime() {
+    return this.player?.getCurrentTime() ?? 0;
+  }
+  /**
+   * 获取总时长（毫秒）
+   */
+  getDuration() {
+    return this.player?.getDuration() ?? 0;
+  }
+  /**
+   * 获取播放状态
+   */
+  getState() {
+    if (!this.player) {
+      return {
+        isPlaying: false,
+        isLoaded: false,
+        isLoading: false,
+        fps: 0,
+        resolution: "-",
+        decoded: 0,
+        downloaded: 0,
+        droppedFrames: 0,
+        isPrefetching: false,
+        segmentIndex: 0,
+        totalSegments: 0,
+        downloadSpeed: 0,
+        currentTime: 0,
+        duration: 0
+      };
+    }
+    return this.player.getState();
+  }
+  /**
+   * 获取检测到的格式
+   */
+  getDetectedFormat() {
+    return this.detectedFormat;
+  }
+  /**
+   * 销毁播放器，释放资源
+   */
+  destroy() {
+    console.log("[EcPlayerCore] Destroying player...");
+    if (this.player) {
+      this.player.destroy();
+      this.player = null;
+    }
+    this.pendingRenderer = null;
+    this.renderer = null;
+    this.detectedFormat = "unknown";
+    console.log("[EcPlayerCore] Player destroyed");
+  }
+  /**
+   * 获取内部播放器实例
+   * 用于需要访问特定播放器功能的场景
+   */
+  getPlayer() {
+    return this.player;
+  }
+}
+const _EnvDetector = class _EnvDetector {
+  /**
+   * 检测当前环境（带缓存）
+   */
+  static detect() {
+    if (this.cache) {
+      return this.cache;
+    }
+    const ua = this.getUserAgent();
+    const platform = this.detectPlatform(ua);
+    const isMiniProgram = this.isMiniProgramEnv(ua, platform);
+    const isWeChat = platform === "wechat-miniprogram";
+    const isMobile = this.isMobileDevice(ua);
+    const capabilities = this.detectCapabilities(isMiniProgram);
+    this.cache = {
+      platform,
+      envType: isMiniProgram ? "miniprogram" : "browser",
+      isMiniProgram,
+      isWeChat,
+      isMobile,
+      userAgent: ua,
+      capabilities
+    };
+    return this.cache;
+  }
+  /**
+   * 获取 User Agent
+   */
+  static getUserAgent() {
+    if (typeof navigator !== "undefined" && navigator.userAgent) {
+      return navigator.userAgent;
+    }
+    return "";
+  }
+  /**
+   * 检测平台类型
+   */
+  static detectPlatform(ua) {
+    const uaLower = ua.toLowerCase();
+    if (this.checkIsWeChatMiniProgram(uaLower)) {
+      return "wechat-miniprogram";
+    }
+    if (uaLower.includes("alipay") && uaLower.includes("miniprogram")) {
+      return "alipay-miniprogram";
+    }
+    if (uaLower.includes("swan-baiduboxapp")) {
+      return "other-miniprogram";
+    }
+    if (uaLower.includes("toutiaomicroapp")) {
+      return "other-miniprogram";
+    }
+    if (uaLower.includes("qqminiapp")) {
+      return "other-miniprogram";
+    }
+    if (this.isMobileDevice(ua)) {
+      return "mobile-browser";
+    }
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      return "pc-browser";
+    }
+    return "unknown";
+  }
+  /**
+   * 检测微信小程序环境（内部方法）
+   */
+  static checkIsWeChatMiniProgram(uaLower) {
+    if (typeof globalThis !== "undefined") {
+      const g = globalThis;
+      if (g.__wxjs_environment === "miniprogram") {
+        return true;
+      }
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      if (win.__wxjs_environment === "miniprogram") {
+        return true;
+      }
+    }
+    if (uaLower.includes("miniprogram")) {
+      if (uaLower.includes("micromessenger") || uaLower.includes("wechat")) {
+        return true;
+      }
+      if (!uaLower.includes("alipay") && !uaLower.includes("baidu") && !uaLower.includes("toutiao")) {
+        return true;
+      }
+    }
+    if (uaLower.includes("miniprogramwebview")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 判断是否为小程序环境
+   */
+  static isMiniProgramEnv(ua, platform) {
+    if (platform === "wechat-miniprogram" || platform === "alipay-miniprogram" || platform === "other-miniprogram") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 检测是否为移动设备
+   */
+  static isMobileDevice(ua) {
+    const uaLower = ua.toLowerCase();
+    const mobileKeywords = [
+      "android",
+      "webos",
+      "iphone",
+      "ipad",
+      "ipod",
+      "blackberry",
+      "windows phone",
+      "mobile"
+    ];
+    return mobileKeywords.some((keyword) => uaLower.includes(keyword));
+  }
+  /**
+   * 检测环境能力
+   */
+  static detectCapabilities(isMiniProgram) {
+    const capabilities = {
+      sharedArrayBuffer: false,
+      wasmThreads: false,
+      wasmSimd: false,
+      webGL: false,
+      webGL2: false,
+      videoFrame: false,
+      offscreenCanvas: false,
+      webAudio: false,
+      webWorker: false,
+      fetch: false,
+      webSocket: false,
+      readableStream: false
+    };
+    capabilities.sharedArrayBuffer = this.checkSharedArrayBuffer();
+    if (isMiniProgram) {
+      capabilities.wasmThreads = false;
+    } else {
+      capabilities.wasmThreads = capabilities.sharedArrayBuffer;
+    }
+    capabilities.wasmSimd = this.checkWasmSimd();
+    capabilities.webGL = this.checkWebGL();
+    capabilities.webGL2 = this.checkWebGL2();
+    capabilities.videoFrame = typeof VideoFrame !== "undefined";
+    capabilities.offscreenCanvas = typeof OffscreenCanvas !== "undefined";
+    capabilities.webAudio = typeof AudioContext !== "undefined" || typeof window !== "undefined" && "webkitAudioContext" in window;
+    capabilities.webWorker = typeof Worker !== "undefined";
+    capabilities.fetch = typeof fetch !== "undefined";
+    capabilities.webSocket = typeof WebSocket !== "undefined";
+    capabilities.readableStream = typeof ReadableStream !== "undefined";
+    return capabilities;
+  }
+  /**
+   * 检测 SharedArrayBuffer
+   */
+  static checkSharedArrayBuffer() {
+    if (typeof window !== "undefined" && window.crossOriginIsolated === false) {
+      return false;
+    }
+    if (typeof SharedArrayBuffer === "undefined") {
+      return false;
+    }
+    try {
+      new SharedArrayBuffer(1);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 检测 WASM SIMD 支持
+   */
+  static checkWasmSimd() {
+    const simdTestBytes = new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      // magic: \0asm
+      1,
+      0,
+      0,
+      0,
+      // version: 1
+      // Type section (1)
+      1,
+      5,
+      1,
+      // section id=1, size=5, 1 type
+      96,
+      0,
+      1,
+      123,
+      // func () -> v128
+      // Function section (3)
+      3,
+      2,
+      1,
+      // section id=3, size=2, 1 func
+      0,
+      // function 0 uses type 0
+      // Export section (7)
+      7,
+      8,
+      1,
+      // section id=7, size=8, 1 export
+      4,
+      116,
+      101,
+      115,
+      116,
+      // name: "test"
+      0,
+      // export kind: function
+      0,
+      // function index: 0
+      // Code section (10)
+      10,
+      19,
+      1,
+      // section id=10, size=19, 1 func
+      17,
+      0,
+      // func body size=17, 0 locals
+      // v128.const i32x4 0 0 0 0
+      253,
+      12,
+      // v128.const
+      0,
+      // i32x4 lane format
+      0,
+      0,
+      0,
+      0,
+      // lane 0
+      0,
+      0,
+      0,
+      0,
+      // lane 1
+      0,
+      0,
+      0,
+      0,
+      // lane 2
+      0,
+      0,
+      0,
+      0,
+      // lane 3
+      11
+      // end
+    ]);
+    try {
+      return WebAssembly.validate(simdTestBytes);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 检测 WebGL 支持
+   */
+  static checkWebGL() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+      return !!gl;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 检测 WebGL 2 支持
+   */
+  static checkWebGL2() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl2");
+      return !!gl;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 清除缓存（用于测试）
+   */
+  static resetCache() {
+    this.cache = null;
+  }
+  /**
+   * 快速判断是否为小程序环境
+   */
+  static isMiniProgram() {
+    return this.detect().isMiniProgram;
+  }
+  /**
+   * 快速判断是否为微信小程序
+   */
+  static isWeChatMiniProgram() {
+    return this.detect().isWeChat;
+  }
+  /**
+   * 快速获取平台类型
+   */
+  static getPlatform() {
+    return this.detect().platform;
+  }
+  /**
+   * 快速获取环境能力
+   */
+  static getCapabilities() {
+    return this.detect().capabilities;
+  }
+  /**
+   * 打印环境信息（调试用）
+   */
+  static printEnvInfo() {
+    const env = this.detect();
+    console.log("=== 环境检测结果 ===");
+    console.log("平台:", env.platform);
+    console.log("环境类型:", env.envType);
+    console.log("是否小程序:", env.isMiniProgram);
+    console.log("是否微信:", env.isWeChat);
+    console.log("是否移动端:", env.isMobile);
+    console.log("能力检测:", env.capabilities);
+    console.log("UA:", env.userAgent);
+    console.log("==================");
+  }
+};
+_EnvDetector.cache = null;
+let EnvDetector = _EnvDetector;
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
+  LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+function setLogLevel(level) {
+}
+export {
+  EcPlayerCore,
+  EnvDetector,
+  LogLevel,
+  setLogLevel
+};
+//# sourceMappingURL=index.js.map