@give-tech/ec-player 0.0.1-beta.4 → 0.0.1-beta.41

package/dist/index.js

@@ -1,8 +1,43 @@
+const moduleCache = /* @__PURE__ */ new Map();
+const loadingPromises = /* @__PURE__ */ new Map();
 class WASMLoader {
   constructor() {
-    this.module = null;
+    this.localModule = null;
+    this.localPath = null;
   }
+  /**
+   * 加载 WASM 模块
+   */
   async load(wasmPath) {
+    if (this.localModule && this.localPath === wasmPath) {
+      return this.localModule;
+    }
+    const cachedModule = moduleCache.get(wasmPath);
+    if (cachedModule) {
+      this.localModule = cachedModule;
+      this.localPath = wasmPath;
+      return cachedModule;
+    }
+    const loadingPromise = loadingPromises.get(wasmPath);
+    if (loadingPromise) {
+      const module = await loadingPromise;
+      this.localModule = module;
+      this.localPath = wasmPath;
+      return module;
+    }
+    const loadPromise = this.doLoad(wasmPath);
+    loadingPromises.set(wasmPath, loadPromise);
+    try {
+      const module = await loadPromise;
+      this.localModule = module;
+      this.localPath = wasmPath;
+      return module;
+    } catch (error) {
+      loadingPromises.delete(wasmPath);
+      throw error;
+    }
+  }
+  async doLoad(wasmPath) {
     return new Promise((resolve, reject) => {
       const script = document.createElement("script");
       script.src = wasmPath;
@@ -14,30 +49,75 @@ class WASMLoader {
             reject(new Error("createFFmpegDecoder not found"));
             return;
           }
-          this.module = await createFFmpegDecoder();
-          if (typeof this.module?._create_decoder !== "function") {
+          const module = await createFFmpegDecoder();
+          if (typeof module?._create_decoder !== "function") {
             reject(new Error("Module initialization failed"));
             return;
           }
-          resolve(this.module);
+          moduleCache.set(wasmPath, module);
+          loadingPromises.delete(wasmPath);
+          resolve(module);
         } catch (e) {
+          loadingPromises.delete(wasmPath);
           reject(new Error(`Failed to initialize decoder: ${e.message}`));
         }
       };
       script.onerror = () => {
+        loadingPromises.delete(wasmPath);
         reject(new Error(`Failed to load script: ${wasmPath}`));
       };
       document.head.appendChild(script);
     });
   }
   getModule() {
-    return this.module;
+    return this.localModule;
+  }
+  /**
+   * 预加载 WASM 模块（后台加载，不阻塞）
+   */
+  static preload(wasmPath) {
+    if (moduleCache.has(wasmPath) || loadingPromises.has(wasmPath)) {
+      return;
+    }
+    const loader = new WASMLoader();
+    loader.load(wasmPath).catch((err) => {
+      console.warn(`[WASMLoader] Preload failed for ${wasmPath}:`, err.message);
+    });
+  }
+  /**
+   * 批量预加载
+   */
+  static preloadAll(wasmPaths) {
+    wasmPaths.forEach((path) => this.preload(path));
+  }
+  /**
+   * 检查是否已加载
+   */
+  static isLoaded(wasmPath) {
+    if (wasmPath) {
+      return moduleCache.has(wasmPath);
+    }
+    return moduleCache.size > 0;
+  }
+  /**
+   * 获取已缓存的路径
+   */
+  static getLoadedPaths() {
+    return Array.from(moduleCache.keys());
+  }
+  /**
+   * 重置（仅用于测试）
+   */
+  static reset() {
+    moduleCache.clear();
+    loadingPromises.clear();
   }
 }
 class H264Decoder {
   constructor(wasmLoader) {
     this.wasmModule = null;
     this.decoderContext = null;
+    this.destroyed = false;
     this.wasmModule = wasmLoader.getModule();
   }
   async init() {
@@ -50,7 +130,7 @@ class H264Decoder {
     }
   }
   decode(nalUnit) {
-    if (this.decoderContext === null || !this.wasmModule) {
+    if (this.destroyed || this.decoderContext === null || !this.wasmModule) {
       return null;
     }
     const dataPtr = this.wasmModule._malloc(nalUnit.size);
@@ -87,6 +167,18 @@ class H264Decoder {
     }
     return null;
   }
+  /**
+   * 销毁解码器，释放 WASM 资源
+   */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.decoderContext !== null && this.wasmModule?._destroy_decoder) {
+      this.wasmModule._destroy_decoder(this.decoderContext);
+    }
+    this.decoderContext = null;
+    this.wasmModule = null;
+  }
   yuv420pToRgba(yPtr, uPtr, vPtr, width, height, yLineSize, uLineSize, vLineSize) {
     const rgba = new Uint8Array(width * height * 4);
     for (let y = 0; y < height; y++) {
@@ -118,9 +210,11 @@ class H264Decoder {
 }
 const DEFAULT_PLAYER_CONFIG = {
   wasmPath: "/wasm/decoder-simd.js",
-  targetBufferSize: 60,
+  targetBufferSize: 90,
+  // 90 帧（约 3.6 秒 @25fps），适应高分辨率视频
   decodeBatchSize: 2,
-  maxQueueSize: 200,
+  maxQueueSize: 300,
+  // 增加 sample 队列上限
   isLive: false
 };
 class BasePlayer {
@@ -415,6 +509,10 @@ class fMP4Demuxer {
     this.timescale = 1e3;
     this.trackId = 1;
     this.avcC = null;
+    this.hvcC = null;
+    this.isHevc = false;
+    this.lengthSizeMinusOne = 3;
+    this.trackHandlers = /* @__PURE__ */ new Map();
   }
   /**
    * 解析初始化段 (ftyp + moov)
@@ -433,7 +531,10 @@ class fMP4Demuxer {
     return {
       trackId: this.trackId,
       timescale: this.timescale,
-      avcC: this.avcC || void 0
+      avcC: this.avcC || void 0,
+      hvcC: this.hvcC || void 0,
+      isHevc: this.isHevc,
+      lengthSizeMinusOne: this.lengthSizeMinusOne
     };
   }
   /**
@@ -458,33 +559,56 @@ class fMP4Demuxer {
   parseTrak(data, trakOffset, trakSize) {
     let offset = trakOffset + 8;
     const endOffset = trakOffset + trakSize;
+    let currentTrackId = null;
+    let handlerType = null;
+    console.log("[fMP4Demuxer] parseTrak called, size:", 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);
+      if (boxType === "tkhd") {
+        const boxDataStart = offset + 8;
+        const version = data[boxDataStart];
+        if (version === 1) {
+          currentTrackId = readUint32$1(data, boxDataStart + 1 + 3 + 8 + 8);
+        } else {
+          currentTrackId = readUint32$1(data, boxDataStart + 1 + 3 + 4 + 4);
+        }
+        console.log("[fMP4Demuxer] tkhd: version=", version, "trackId=", currentTrackId);
+      } else if (boxType === "mdia") {
+        handlerType = this.parseMdiaAndGetHandlerType(data, offset, boxSize);
+        if (handlerType && currentTrackId !== null) {
+          this.trackHandlers.set(currentTrackId, handlerType);
+          console.log("[fMP4Demuxer] Track", currentTrackId, "handler:", handlerType);
+          if (handlerType === "vide") {
+            this.trackId = currentTrackId;
+          }
+        }
       }
       offset += boxSize;
     }
   }
   /**
-   * 解析 mdia box
+   * 解析 mdia box 并返回 handler type
    */
-  parseMdia(data, mdiaOffset, mdiaSize) {
+  parseMdiaAndGetHandlerType(data, mdiaOffset, mdiaSize) {
     let offset = mdiaOffset + 8;
     const endOffset = mdiaOffset + mdiaSize;
+    let handlerType = null;
     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") {
+      } else if (boxType === "hdlr") {
+        handlerType = readFourCC(data, offset + 8 + 8);
+      } else if (boxType === "minf" && handlerType === "vide") {
         this.parseMinf(data, offset, boxSize);
       }
       offset += boxSize;
     }
+    return handlerType;
   }
   /**
    * 解析 mdhd box 获取 timescale
@@ -530,7 +654,7 @@ class fMP4Demuxer {
     }
   }
   /**
-   * 解析 stsd box 获取 avcC
+   * 解析 stsd box 获取 avcC 或 hvcC
    */
   parseStsd(data, stsdOffset, stsdSize) {
     const boxDataOffset = stsdOffset + 8;
@@ -544,6 +668,10 @@ class fMP4Demuxer {
         this.parseAvcSampleEntry(data, offset, entrySize);
         return;
       }
+      if (entryType === "hvc1" || entryType === "hev1") {
+        this.parseHevcSampleEntry(data, offset, entrySize);
+        return;
+      }
       offset += entrySize;
     }
   }
@@ -559,6 +687,33 @@ class fMP4Demuxer {
       if (boxSize < 8) break;
       if (boxType === "avcC") {
         this.avcC = data.slice(offset, offset + boxSize);
+        if (boxSize > 12) {
+          this.lengthSizeMinusOne = data[offset + 8 + 4] & 3;
+          console.log("[fMP4Demuxer] avcC lengthSizeMinusOne:", this.lengthSizeMinusOne, "(NAL length size:", this.lengthSizeMinusOne + 1, "bytes)");
+        }
+        return;
+      }
+      offset += boxSize;
+    }
+  }
+  /**
+   * 解析 HEVC Sample Entry
+   */
+  parseHevcSampleEntry(data, entryOffset, entrySize) {
+    this.isHevc = true;
+    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 === "hvcC") {
+        this.hvcC = data.slice(offset, offset + boxSize);
+        if (boxSize > 12) {
+          this.lengthSizeMinusOne = data[offset + 8 + 21] & 3;
+          console.log("[fMP4Demuxer] hvcC lengthSizeMinusOne:", this.lengthSizeMinusOne, "(NAL length size:", this.lengthSizeMinusOne + 1, "bytes)");
+        }
+        console.log("[fMP4Demuxer] Found hvcC, size:", boxSize);
         return;
       }
       offset += boxSize;
@@ -714,21 +869,51 @@ class fMP4Demuxer {
   }
   /**
    * 从 moof + mdat 提取视频样本
+   * 只提取视频轨道（trackId 匹配）的数据
    */
-  extractSamples(moof, mdatData, mdatOffset) {
+  extractSamples(moof, mdatData, moofOffset, mdatOffset) {
     const samples = [];
+    console.log(`[fMP4Demuxer] extractSamples: moof.trafs=${moof.trafs.length}, trackHandlers=${JSON.stringify(Object.fromEntries(this.trackHandlers))}`);
     for (const traf of moof.trafs) {
-      if (!traf.tfhd || !traf.tfdt) continue;
+      if (!traf.tfhd || !traf.tfdt) {
+        console.log(`[fMP4Demuxer] traf missing tfhd or tfdt`);
+        continue;
+      }
+      const trackId = traf.tfhd.trackId;
+      const handlerType = this.trackHandlers.get(trackId);
+      if (handlerType && handlerType !== "vide") {
+        console.log(`[fMP4Demuxer] Skipping non-video track: trackId=${trackId}, handler=${handlerType}`);
+        continue;
+      }
+      if (!handlerType) {
+        console.log(`[fMP4Demuxer] Unknown trackId=${trackId}, will filter by sample size`);
+      } else {
+        console.log(`[fMP4Demuxer] Processing video track: trackId=${trackId}, truns=${traf.truns.length}`);
+      }
       let baseDts = traf.tfdt.baseMediaDecodeTime;
+      const baseDataOffset = traf.tfhd.baseDataOffset ?? moofOffset;
       for (const trun of traf.truns) {
         let dataOffset = 0;
         if (trun.dataOffset !== void 0) {
-          dataOffset = trun.dataOffset - mdatOffset - 8;
+          const absoluteOffset = baseDataOffset + trun.dataOffset;
+          dataOffset = absoluteOffset - 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;
+          let sampleSize = sample.size;
+          if (sampleSize === void 0 || sampleSize <= 0) {
+            sampleSize = mdatData.length - dataOffset;
+          }
+          if (sampleSize <= 0) {
+            console.log(`[fMP4Demuxer] Skipping sample: no data available`);
+            continue;
+          }
+          if (!handlerType && sampleSize < 1e3) {
+            dataOffset += sampleSize;
+            baseDts += sample.duration ?? 0;
+            continue;
+          }
+          const sampleData = mdatData.slice(dataOffset, dataOffset + sampleSize);
+          const isSync = !((sample.flags ?? 0) & 16777216);
           const cto = sample.compositionTimeOffset ?? 0;
           const duration = sample.duration ?? 0;
           samples.push({
@@ -736,9 +921,9 @@ class fMP4Demuxer {
             dts: baseDts,
             pts: baseDts + cto,
             duration,
-            isSync: isSync !== 0
+            isSync
           });
-          dataOffset += sample.size;
+          dataOffset += sampleSize;
           baseDts += duration;
         }
       }
@@ -757,6 +942,24 @@ class fMP4Demuxer {
   getAvcC() {
     return this.avcC;
   }
+  /**
+   * 获取 hvcC 配置
+   */
+  getHvcC() {
+    return this.hvcC;
+  }
+  /**
+   * 是否为 HEVC 编码
+   */
+  isHevcStream() {
+    return this.isHevc;
+  }
+  /**
+   * 获取 NAL 长度字段大小 - 1
+   */
+  getLengthSizeMinusOne() {
+    return this.lengthSizeMinusOne;
+  }
 }
 class NALParser {
   /**
@@ -804,6 +1007,106 @@ class NALParser {
     return units;
   }
 }
+const HEVC_NAL_TYPE = {
+  // Picture Parameter Set
+  IDR_W_RADL: 19
+};
+class HEVCDecoder {
+  constructor(wasmLoader) {
+    this.wasmModule = null;
+    this.decoderContext = null;
+    this.destroyed = false;
+    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.destroyed || 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;
+  }
+  /**
+   * 销毁解码器，释放 WASM 资源
+   */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.decoderContext !== null && this.wasmModule?._destroy_decoder) {
+      this.wasmModule._destroy_decoder(this.decoderContext);
+    }
+    this.decoderContext = null;
+    this.wasmModule = 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;
+  }
+}
 class BasePrefetcher {
   constructor(config, callbacks = {}) {
     this.isRunning = false;
@@ -1056,7 +1359,8 @@ class SegmentPrefetcher extends BasePrefetcher {
       this.prefetchQueue.push({
         data,
         segmentIndex: nextIndex,
-        fetchTime
+        fetchTime,
+        segmentDuration: segment.duration
       });
       this.fetchedSegmentCount++;
       this.updateStatus({
@@ -1067,6 +1371,10 @@ class SegmentPrefetcher extends BasePrefetcher {
       callbacks.onSegmentFetched?.(nextIndex, data);
       console.log(`[SegmentPrefetcher] Fetched segment #${nextIndex}: ${data.length} bytes, ${fetchTime.toFixed(0)}ms`);
     } catch (error) {
+      if (error.name === "AbortError") {
+        console.log(`[SegmentPrefetcher] Fetch aborted`);
+        return;
+      }
       console.error(`[SegmentPrefetcher] Fetch failed:`, error.message);
       this.callbacks.onError?.(error);
     } finally {
@@ -1077,11 +1385,16 @@ class SegmentPrefetcher extends BasePrefetcher {
   /**
    * 处理预取队列中的数据
    *
+   * @param maxSegments 最多处理的分片数量（默认处理所有）
    * @returns 是否有数据被处理
    */
-  processQueue() {
+  processQueue(maxSegments) {
     let processed = false;
+    let processedCount = 0;
     while (this.prefetchQueue.length > 0) {
+      if (maxSegments !== void 0 && processedCount >= maxSegments) {
+        break;
+      }
       const item = this.prefetchQueue[0];
       if (item.segmentIndex !== this.currentSegmentIndex) {
         break;
@@ -1089,7 +1402,7 @@ class SegmentPrefetcher extends BasePrefetcher {
       this.prefetchQueue.shift();
       this.updateStatus({ prefetchQueueSize: this.prefetchQueue.length });
       const parseStart = performance.now();
-      const itemCount = this.parseSegment(item.data, item.segmentIndex);
+      const itemCount = this.parseSegment(item.data, item.segmentIndex, item.segmentDuration);
       const parseTime = performance.now() - parseStart;
       this.currentSegmentIndex++;
       this.updateStatus({ currentSegmentIndex: this.currentSegmentIndex });
@@ -1097,6 +1410,7 @@ class SegmentPrefetcher extends BasePrefetcher {
       callbacks.onSegmentParsed?.(item.segmentIndex, itemCount);
       console.log(`[SegmentPrefetcher] Parsed segment #${item.segmentIndex}: ${itemCount} items, ${parseTime.toFixed(0)}ms`);
       processed = true;
+      processedCount++;
     }
     return processed;
   }
@@ -1234,6 +1548,10 @@ class StreamPrefetcher extends BasePrefetcher {
         console.log(`[StreamPrefetcher] Download complete: ${this.totalDownloadedBytes} bytes`);
       }
     } catch (error) {
+      if (error.name === "AbortError") {
+        console.log(`[StreamPrefetcher] Read aborted`);
+        return;
+      }
       console.error(`[StreamPrefetcher] Read error:`, error.message);
       this.callbacks.onError?.(error);
     }
@@ -1324,7 +1642,8 @@ const HLS_PREFETCHER_CONFIG = {
   ...DEFAULT_SEGMENT_PREFETCHER_CONFIG,
   lowWaterMark: 30,
   highWaterMark: 100,
-  prefetchAhead: 2,
+  prefetchAhead: 6,
+  // 预载 6 个分片（约 30 秒），适应高分辨率视频
   prefetchInterval: 10,
   dynamicInterval: true
 };
@@ -1334,12 +1653,18 @@ const DEFAULT_HLS_CONFIG = {
 class HLSSegmentPrefetcher extends SegmentPrefetcher {
   constructor(config, callbacks, player) {
     super(config, callbacks);
+    this.currentInitSegmentUri = null;
     this.player = player;
   }
   /**
    * 获取分片数据
    */
   async fetchSegment(segment, index) {
+    if (segment.initSegmentUri && segment.initSegmentUri !== this.currentInitSegmentUri) {
+      console.log("[HLSSegmentPrefetcher] Init segment changed:", segment.initSegmentUri);
+      await this.player.loadNewInitSegment(segment.initSegmentUri);
+      this.currentInitSegmentUri = segment.initSegmentUri;
+    }
     const baseUrl = this.baseUrl;
     const url = segment.uri.startsWith("http") ? segment.uri : baseUrl + segment.uri;
     const headers = {};
@@ -1347,17 +1672,18 @@ class HLSSegmentPrefetcher extends SegmentPrefetcher {
       const { start, end } = segment.byteRange;
       headers["Range"] = `bytes=${start}-${end}`;
     }
-    const response = await fetch(url, { headers });
+    const signal = this.player.getAbortSignal();
+    const response = await fetch(url, { headers, signal });
     return new Uint8Array(await response.arrayBuffer());
   }
   /**
    * 解析分片数据
    */
-  parseSegment(data, index) {
+  parseSegment(data, index, segmentDuration) {
     if (this.player.isFMP4) {
       return this.player.parseFMP4Data(data);
     } else {
-      return this.player.parseTSData(data);
+      return this.player.parseTSData(data, segmentDuration);
     }
   }
   /**
@@ -1378,19 +1704,53 @@ class HLSPlayer extends BasePlayer {
     this.pesExtractor = new PESExtractor();
     this.nalParser = new NALParser();
     this.fmp4Demuxer = new fMP4Demuxer();
+    this.hevcDecoder = null;
     this.isPrefetching = false;
     this.currentSegmentIndex = 0;
     this.segments = [];
     this.fmp4Segments = [];
     this.initSegment = null;
     this._isFMP4 = false;
+    this._isHevc = false;
     this.currentPlaylistUrl = "";
     this._nalQueue = [];
     this._sampleQueue = [];
+    this._currentSegmentDuration = 0;
     this.prefetcher = null;
+    this.abortController = null;
+    this.readyFired = false;
+    this._nalCountInCurrentSegment = 0;
     this.lastRenderTime = 0;
+    this.playStartTime = 0;
+    this.accumulatedMediaTime = 0;
+    this._lastLogTime = 0;
+    this._lastRafTime = 0;
     this.renderLoop = (timestamp = 0) => {
       if (!this.isPlaying) return;
+      const now = performance.now();
+      const BACKGROUND_PAUSE_THRESHOLD = 500;
+      if (this._lastRafTime > 0 && now - this._lastRafTime > BACKGROUND_PAUSE_THRESHOLD) {
+        const pauseDuration = now - this._lastRafTime;
+        console.log("[renderLoop] Background pause detected, duration:", pauseDuration.toFixed(0), "ms");
+        if (this.config.isLive) {
+          const KEEP_FRAMES = 5;
+          if (this.frameBuffer.length > KEEP_FRAMES) {
+            const droppedCount = this.frameBuffer.length - KEEP_FRAMES;
+            this.frameBuffer = this.frameBuffer.slice(-KEEP_FRAMES);
+            this.droppedFrames += droppedCount;
+            console.log("[renderLoop] Live resume: dropped", droppedCount, "old frames, keeping latest", KEEP_FRAMES);
+          }
+          this.playStartTime = now;
+          this.accumulatedMediaTime = 0;
+        } else {
+          this.playStartTime = now - this.accumulatedMediaTime;
+        }
+      }
+      this._lastRafTime = now;
+      if (!this._lastLogTime || now - this._lastLogTime > 1e3) {
+        this._lastLogTime = now;
+        console.log("[renderLoop] frameBuffer=", this.frameBuffer.length, "renderer=", !!this.renderer);
+      }
       const downloaded = this.isFMP4 ? this.sampleQueue.length : this.nalQueue.length;
       const segments = this.isFMP4 ? this.fmp4Segments : this.segments;
       const totalSegments = segments.length;
@@ -1402,19 +1762,35 @@ class HLSPlayer extends BasePlayer {
         totalSegments
       });
       if (this.frameBuffer.length > 0 && this.renderer) {
-        const frame = this.frameBuffer.shift();
-        this.renderer.render(frame);
-        if (this.lastRenderTime > 0) {
-          const elapsed = timestamp - this.lastRenderTime;
-          this.setCurrentTime(this._currentTime + elapsed);
+        const frame = this.frameBuffer[0];
+        const timescale = this.fmp4Demuxer.getTimescale();
+        if (this.playStartTime === 0) {
+          this.playStartTime = now;
+          this.accumulatedMediaTime = 0;
+          console.log("[renderLoop] Init: timescale=", timescale);
+        }
+        const elapsedWallTime = now - this.playStartTime;
+        const frameDurationMs = frame.duration ? frame.duration * 1e3 / timescale : 33.33;
+        if (Math.floor(elapsedWallTime / 1e3) !== Math.floor((elapsedWallTime - 20) / 1e3)) {
+          console.log("[renderLoop] elapsed=", Math.floor(elapsedWallTime), "accumulated=", Math.floor(this.accumulatedMediaTime), "frameDuration=", frame.duration, "frameDurationMs=", frameDurationMs.toFixed(2), "frameBuffer=", this.frameBuffer.length);
+        }
+        const bufferMs = 50;
+        if (elapsedWallTime >= this.accumulatedMediaTime - bufferMs) {
+          this.frameBuffer.shift();
+          this.renderer.render(frame);
+          this.accumulatedMediaTime += frameDurationMs;
+          this.setCurrentTime(this.accumulatedMediaTime);
+          this.updateState({ resolution: `${frame.width}x${frame.height}` });
+          const fps = this.renderer.updateFps();
+          this.updateState({ fps });
+          this.callbacks.onFrameRender?.(frame);
         }
-        this.lastRenderTime = timestamp;
-        this.updateState({ resolution: `${frame.width}x${frame.height}` });
-        const fps = this.renderer.updateFps();
-        this.updateState({ fps });
-        this.callbacks.onFrameRender?.(frame);
       } else {
-        this.lastRenderTime = 0;
+        if (this.playStartTime !== 0) {
+          const oldPlayStartTime = this.playStartTime;
+          this.playStartTime = now - this.accumulatedMediaTime;
+          console.log("[renderLoop] No frames, adjusting playStartTime from", oldPlayStartTime, "to", this.playStartTime, "accumulated=", this.accumulatedMediaTime);
+        }
       }
       this.frameTimer = requestAnimationFrame(this.renderLoop);
     };
@@ -1423,23 +1799,40 @@ class HLSPlayer extends BasePlayer {
   get isFMP4() {
     return this._isFMP4;
   }
+  get isHevc() {
+    return this._isHevc;
+  }
   get nalQueue() {
     return this._nalQueue;
   }
   get sampleQueue() {
     return this._sampleQueue;
   }
+  /** 获取 AbortSignal（供预取器使用） */
+  getAbortSignal() {
+    if (!this.abortController) {
+      const controller = new AbortController();
+      controller.abort();
+      return controller.signal;
+    }
+    return this.abortController.signal;
+  }
   /**
    * 加载 HLS 播放列表
    */
   async load(url) {
     this.currentPlaylistUrl = url;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.abortController = new AbortController();
     this.segments = [];
     this.fmp4Segments = [];
     this.initSegment = null;
     this._nalQueue.length = 0;
     this._sampleQueue.length = 0;
     this.currentSegmentIndex = 0;
+    this.readyFired = false;
     this.resetState();
     if (this.prefetcher) {
       this.prefetcher.reset();
@@ -1472,6 +1865,8 @@ class HLSPlayer extends BasePlayer {
       isLoaded: true,
       totalSegments: segments.length
     });
+    this.initPrefetcher();
+    this.prefetcher.start();
   }
   /**
    * 初始化解码器（覆盖基类方法，添加 fMP4 支持）
@@ -1489,6 +1884,8 @@ class HLSPlayer extends BasePlayer {
     this.isPlaying = true;
     this.decodeLoopAbort = false;
     this.lastRenderTime = 0;
+    this.playStartTime = 0;
+    this.accumulatedMediaTime = 0;
     this.updateState({ isPlaying: true });
     if (!this.prefetcher) {
       this.initPrefetcher();
@@ -1497,6 +1894,24 @@ class HLSPlayer extends BasePlayer {
     this.decodeLoop();
     this.frameTimer = requestAnimationFrame(this.renderLoop);
   }
+  /**
+   * 销毁播放器，释放所有资源
+   */
+  destroy() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.prefetcher) {
+      this.prefetcher.reset();
+      this.prefetcher = null;
+    }
+    if (this.hevcDecoder) {
+      this.hevcDecoder.destroy();
+      this.hevcDecoder = null;
+    }
+    super.destroy();
+  }
   /**
    * 跳转到指定时间
    */
@@ -1531,10 +1946,22 @@ class HLSPlayer extends BasePlayer {
     console.log("[DecodeLoop] START, isFMP4:", this.isFMP4);
     let batchCount = 0;
     while (this.isPlaying && !this.decodeLoopAbort) {
-      this.prefetcher?.processQueue();
+      const sampleQueueSize = this.sampleQueue.length;
+      const maxSamplesBeforePause = this.config.maxQueueSize * 3;
+      if (sampleQueueSize < maxSamplesBeforePause && this.prefetcher) {
+        this.prefetcher.processQueue(1);
+      }
+      if (!this.config.isLive && this.frameBuffer.length >= this.config.targetBufferSize) {
+        await this.sleep(10);
+        continue;
+      }
       const batchSize = this.config.decodeBatchSize;
       let decodedInBatch = 0;
       if (this.isFMP4) {
+        const queueSize = this.sampleQueue.length;
+        if (queueSize > 0 || batchCount % 50 === 0) {
+          console.log("[DecodeLoop] fMP4: sampleQueue=", queueSize, "frameBuffer=", this.frameBuffer.length, "batch=", batchCount, "decoderInit=", this.decoderInitialized);
+        }
         while (this.sampleQueue.length > 0 && decodedInBatch < batchSize) {
           const queuedSample = this.sampleQueue.shift();
           const sample = queuedSample.sample;
@@ -1542,27 +1969,42 @@ class HLSPlayer extends BasePlayer {
           if (frame) {
             this.frameBuffer.push(frame);
             decodedInBatch++;
-            while (this.frameBuffer.length > this.config.targetBufferSize) {
-              this.frameBuffer.shift();
-              this.droppedFrames++;
+            if (!this.readyFired) {
+              this.readyFired = true;
+              this.callbacks.onReady?.();
+            }
+            if (this.config.isLive) {
+              while (this.frameBuffer.length > this.config.targetBufferSize) {
+                this.frameBuffer.shift();
+                this.droppedFrames++;
+              }
             }
+          } else {
+            console.warn("[DecodeLoop] decodeSample returned null, remaining samples=", this.sampleQueue.length);
           }
         }
       } else {
         while (this.nalQueue.length > 0 && decodedInBatch < batchSize) {
           const queuedNal = this.nalQueue.shift();
           const nalUnit = queuedNal.nalUnit;
+          const segmentDuration = queuedNal.segmentDuration;
           if (!this.decoderInitialized && (nalUnit.type === 7 || nalUnit.type === 8)) {
             this.initDecoderParamsSync([nalUnit]);
           }
           if (nalUnit.type === 5 || nalUnit.type === 1) {
-            const frame = this.decodeNAL(nalUnit);
+            const frame = this.decodeNAL(nalUnit, segmentDuration);
             if (frame) {
               this.frameBuffer.push(frame);
               decodedInBatch++;
-              while (this.frameBuffer.length > this.config.targetBufferSize) {
-                this.frameBuffer.shift();
-                this.droppedFrames++;
+              if (!this.readyFired) {
+                this.readyFired = true;
+                this.callbacks.onReady?.();
+              }
+              if (this.config.isLive) {
+                while (this.frameBuffer.length > this.config.targetBufferSize) {
+                  this.frameBuffer.shift();
+                  this.droppedFrames++;
+                }
               }
             }
           }
@@ -1604,7 +2046,9 @@ class HLSPlayer extends BasePlayer {
       const segmentInfos = this.fmp4Segments.map((seg) => ({
         uri: seg.uri,
         duration: seg.duration,
-        byteRange: seg.byteRange
+        byteRange: seg.byteRange,
+        initSegmentUri: seg.initSegmentUri
+        // 传递初始化段 URI
       }));
       this.prefetcher.setSegments(segmentInfos, baseUrl);
     } else {
@@ -1620,38 +2064,53 @@ class HLSPlayer extends BasePlayer {
    * 解析 fMP4 数据
    */
   parseFMP4Data(data) {
-    let moofOffset = -1;
-    let mdatOffset = -1;
-    let mdatSize = 0;
+    let totalSampleCount = 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;
+      let moofOffset = -1;
+      let mdatOffset = -1;
+      let mdatSize = 0;
+      while (offset < data.length - 8) {
+        const boxSize = this.readBoxSize(data, offset);
+        const boxType = this.readBoxType(data, offset + 4);
+        if (boxSize < 8) break;
+        if (boxType === "moof") {
+          moofOffset = offset;
+          offset += boxSize;
+          break;
+        }
+        offset += boxSize;
       }
-      offset += boxSize;
-    }
-    let sampleCount = 0;
-    if (moofOffset >= 0 && mdatOffset >= 0) {
+      if (moofOffset < 0) break;
+      while (offset < data.length - 8) {
+        const boxSize = this.readBoxSize(data, offset);
+        const boxType = this.readBoxType(data, offset + 4);
+        if (boxSize < 8) break;
+        if (boxType === "mdat") {
+          mdatOffset = offset;
+          mdatSize = boxSize;
+          offset += boxSize;
+          break;
+        }
+        offset += boxSize;
+      }
+      if (mdatOffset < 0) break;
       const moof = this.fmp4Demuxer.parseMoof(data, moofOffset);
       const mdatData = data.slice(mdatOffset + 8, mdatOffset + mdatSize);
-      const samples = this.fmp4Demuxer.extractSamples(moof, mdatData, mdatOffset);
+      const samples = this.fmp4Demuxer.extractSamples(moof, mdatData, moofOffset, mdatOffset);
       for (const sample of samples) {
         this._sampleQueue.push({ sample });
       }
-      sampleCount = samples.length;
+      totalSampleCount += samples.length;
+      console.log("[parseFMP4Data] Pushed", samples.length, "samples, totalQueue=", this._sampleQueue.length);
     }
-    return sampleCount;
+    console.log("[parseFMP4Data] Total samples parsed:", totalSampleCount);
+    return totalSampleCount;
   }
   /**
    * 解析 TS 数据
    */
-  parseTSData(tsData) {
+  parseTSData(tsData, segmentDuration) {
     const packets = this.tsDemuxer.parse(tsData);
     let nalCount = 0;
     if (packets.video.length > 0) {
@@ -1661,8 +2120,15 @@ class HLSPlayer extends BasePlayer {
         if (!this.decoderInitialized) {
           this.initDecoderParamsSync(nalUnits);
         }
+        if (segmentDuration !== void 0) {
+          this._currentSegmentDuration = segmentDuration;
+        }
         for (const nalUnit of nalUnits) {
-          this._nalQueue.push({ nalUnit, pts: 0 });
+          this._nalQueue.push({
+            nalUnit,
+            pts: 0,
+            segmentDuration: this._currentSegmentDuration
+          });
         }
         nalCount = nalUnits.length;
       }
@@ -1686,20 +2152,103 @@ class HLSPlayer extends BasePlayer {
       const { start, end } = this.initSegment.byteRange;
       headers["Range"] = `bytes=${start}-${end}`;
     }
-    const response = await fetch(url, { headers });
+    let response;
+    try {
+      response = await fetch(url, { headers, signal: this.abortController?.signal });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("[fMP4] Load init segment aborted");
+        return;
+      }
+      throw error;
+    }
     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] Parse result:", {
+      isHevc: initInfo?.isHevc,
+      hasAvcC: !!initInfo?.avcC,
+      hasHvcC: !!initInfo?.hvcC,
+      timescale: initInfo?.timescale,
+      lengthSizeMinusOne: initInfo?.lengthSizeMinusOne
+    });
+    this._isHevc = initInfo?.isHevc ?? false;
+    if (initInfo?.hvcC && this._isHevc) {
+      console.log("[fMP4] hvcC size:", initInfo.hvcC.length);
+      await this.initHevcDecoder();
+      this.initDecoderFromHvcC(initInfo.hvcC);
+      console.log("[fMP4] HEVC decoder initialized, timescale:", initInfo.timescale);
+    } else if (initInfo?.avcC) {
       console.log("[fMP4] avcC size:", initInfo.avcC.length);
       this.initDecoderFromAvcC(initInfo.avcC);
-      console.log("[fMP4] Init segment loaded, timescale:", initInfo.timescale);
+      console.log("[fMP4] AVC decoder initialized, 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");
+      console.error("[fMP4] Failed to parse init segment or no avcC/hvcC found!");
+      throw new Error("Failed to parse fMP4 init segment: no valid codec config found");
     }
   }
+  /**
+   * 加载新的初始化段（用于不连续性流）
+   */
+  async loadNewInitSegment(uri) {
+    console.log("[fMP4] Loading new init segment for discontinuity:", uri);
+    this._sampleQueue.length = 0;
+    this._nalQueue.length = 0;
+    const url = uri.startsWith("http") ? uri : this.currentPlaylistUrl.substring(0, this.currentPlaylistUrl.lastIndexOf("/") + 1) + uri;
+    const headers = {};
+    if (this.initSegment?.uri === uri && this.initSegment.byteRange) {
+      const { start, end } = this.initSegment.byteRange;
+      headers["Range"] = `bytes=${start}-${end}`;
+      console.log("[fMP4] Using byte range for init segment:", { start, end });
+    }
+    let response;
+    try {
+      response = await fetch(url, { headers, signal: this.abortController?.signal });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("[fMP4] Load new init segment aborted");
+        return;
+      }
+      throw error;
+    }
+    const data = new Uint8Array(await response.arrayBuffer());
+    console.log("[fMP4] New init segment data size:", data.length, "bytes");
+    const initInfo = this.fmp4Demuxer.parseInitSegment(data);
+    console.log("[fMP4] New init segment parse result:", {
+      isHevc: initInfo?.isHevc,
+      hasAvcC: !!initInfo?.avcC,
+      hasHvcC: !!initInfo?.hvcC
+    });
+    const newIsHevc = initInfo?.isHevc ?? false;
+    if (newIsHevc !== this._isHevc) {
+      console.log("[fMP4] Codec type changed from", this._isHevc ? "HEVC" : "AVC", "to", newIsHevc ? "HEVC" : "AVC");
+      this._isHevc = newIsHevc;
+      this.decoderInitialized = false;
+      if (newIsHevc) {
+        await this.initHevcDecoder();
+      }
+    } else {
+      this.decoderInitialized = false;
+    }
+    if (initInfo?.hvcC && this._isHevc) {
+      this.initDecoderFromHvcC(initInfo.hvcC);
+      console.log("[fMP4] HEVC decoder re-initialized for discontinuity");
+    } else if (initInfo?.avcC) {
+      this.initDecoderFromAvcC(initInfo.avcC);
+      console.log("[fMP4] AVC decoder re-initialized for discontinuity");
+    } else {
+      console.error("[fMP4] Failed to parse new init segment!");
+    }
+  }
+  /**
+   * 初始化 HEVC 解码器
+   */
+  async initHevcDecoder() {
+    if (this.hevcDecoder) return;
+    this.hevcDecoder = new HEVCDecoder(this.wasmLoader);
+    await this.hevcDecoder.init();
+    console.log("[fMP4] HEVC decoder created");
+  }
   /**
    * 从 avcC 初始化解码器
    */
@@ -1744,11 +2293,57 @@ class HLSPlayer extends BasePlayer {
     this.decoderInitialized = true;
     console.log("[fMP4] Decoder initialized from avcC");
   }
+  /**
+   * 从 hvcC 初始化 HEVC 解码器
+   */
+  initDecoderFromHvcC(hvcC) {
+    if (this.decoderInitialized || !this.hevcDecoder) return;
+    console.log("[fMP4] hvcC length:", hvcC.length);
+    console.log("[fMP4] hvcC first 8 bytes:", Array.from(hvcC.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join(" "));
+    console.log("[fMP4] hvcC bytes 8-24:", Array.from(hvcC.slice(8, 24)).map((b) => b.toString(16).padStart(2, "0")).join(" "));
+    let offset = 8 + 22;
+    const numOfArrays = hvcC[offset];
+    console.log("[fMP4] hvcC[30] (numOfArrays):", numOfArrays, "0x" + numOfArrays.toString(16));
+    offset += 1;
+    for (let i = 0; i < numOfArrays && offset < hvcC.length - 3; i++) {
+      const typeCompressed = hvcC[offset];
+      const arrayType = typeCompressed & 63;
+      const numNalus = hvcC[offset + 1] << 8 | hvcC[offset + 2];
+      offset += 3;
+      console.log(`[fMP4] HEVC array: type=${arrayType}, count=${numNalus}`);
+      for (let j = 0; j < numNalus && offset < hvcC.length - 2; j++) {
+        const nalUnitLength = hvcC[offset] << 8 | hvcC[offset + 1];
+        offset += 2;
+        if (offset + nalUnitLength > hvcC.length) break;
+        const nalUnitData = hvcC.slice(offset, offset + nalUnitLength);
+        offset += nalUnitLength;
+        const nalWithStartCode = new Uint8Array(4 + nalUnitLength);
+        nalWithStartCode.set([0, 0, 0, 1], 0);
+        nalWithStartCode.set(nalUnitData, 4);
+        if (arrayType === 32 || arrayType === 33 || arrayType === 34) {
+          this.hevcDecoder.decode({ type: arrayType, data: nalWithStartCode, size: nalWithStartCode.length });
+          const typeName = arrayType === 32 ? "VPS" : arrayType === 33 ? "SPS" : "PPS";
+          console.log(`[fMP4] HEVC ${typeName} decoded, length=${nalUnitLength}`);
+        }
+      }
+    }
+    this.decoderInitialized = true;
+    console.log("[fMP4] HEVC decoder initialized from hvcC");
+  }
   /**
    * 解析 HLS 播放列表
    */
   async parsePlaylist(url) {
-    const response = await fetch(url);
+    let response;
+    try {
+      response = await fetch(url, { signal: this.abortController?.signal });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("[HLSPlayer] Parse playlist aborted");
+        return { isMaster: true, isFMP4: false, segments: [], fmp4Segments: [], variants: 0 };
+      }
+      throw error;
+    }
     const content = await response.text();
     const lines = content.split("\n");
     const segments = [];
@@ -1776,25 +2371,31 @@ class HLSPlayer extends BasePlayer {
     }
     const isFMP4 = lines.some((line) => line.includes("#EXT-X-MAP:"));
     console.log("[parsePlaylist] isFMP4:", isFMP4, "url:", url);
+    let currentInitSegment;
     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] };
+          currentInitSegment = { uri: uriMatch[1] };
           const byteRangeMatch = mapInfo.match(/BYTERANGE="(\d+)@(\d+)"/);
           if (byteRangeMatch) {
-            initSegment.byteRange = {
+            currentInitSegment.byteRange = {
               start: parseInt(byteRangeMatch[2]),
               end: parseInt(byteRangeMatch[2]) + parseInt(byteRangeMatch[1]) - 1
             };
           }
+          if (!initSegment) {
+            initSegment = currentInitSegment;
+          }
         }
+        continue;
+      }
+      if (line === "#EXT-X-DISCONTINUITY") {
+        console.log("[parsePlaylist] Found EXT-X-DISCONTINUITY");
+        continue;
       }
-    }
-    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;
@@ -1812,7 +2413,13 @@ class HLSPlayer extends BasePlayer {
         const uri = nextLine;
         if (uri && !uri.startsWith("#")) {
           if (isFMP4) {
-            fmp4Segments.push({ uri, duration, byteRange });
+            fmp4Segments.push({
+              uri,
+              duration,
+              byteRange,
+              initSegmentUri: currentInitSegment?.uri
+              // 关联当前初始化段
+            });
           } else {
             segments.push({ uri, duration });
           }
@@ -1855,46 +2462,63 @@ class HLSPlayer extends BasePlayer {
    * 解码 fMP4 sample
    */
   decodeSample(sample) {
-    if (!this.decoder) {
-      console.warn("[fMP4] Decoder not available");
+    const decoder = this._isHevc ? this.hevcDecoder : this.decoder;
+    if (!decoder) {
+      console.warn("[fMP4] Decoder not available, isHevc=", this._isHevc);
       return null;
     }
     if (!this.decoderInitialized) {
-      console.warn("[fMP4] Decoder not initialized, skipping sample");
+      console.warn("[fMP4] Decoder not initialized, isHevc=", this._isHevc, ", sample size=", sample.data.length);
       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
-      });
-    }
+    const lengthSize = this.fmp4Demuxer.getLengthSizeMinusOne() + 1;
+    const readNalLength = (data2, offset2, size) => {
+      switch (size) {
+        case 1:
+          return data2[offset2];
+        case 2:
+          return data2[offset2] << 8 | data2[offset2 + 1];
+        case 4:
+        default:
+          return data2[offset2] << 24 | data2[offset2 + 1] << 16 | data2[offset2 + 2] << 8 | data2[offset2 + 3];
+      }
+    };
+    const hasAnnexBStartCode = data.length >= 4 && data[0] === 0 && data[1] === 0 && (data[2] === 0 && data[3] === 1 || data[2] === 1);
     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}`);
+    let avccParseError = false;
+    while (offset + lengthSize <= data.length) {
+      const nalLength = readNalLength(data, offset, lengthSize);
+      if (nalLength <= 0 || nalLength > 1e7 || offset + lengthSize + nalLength > data.length) {
+        avccParseError = true;
         break;
       }
       totalSize += 4 + nalLength;
-      offset += 4 + nalLength;
+      offset += lengthSize + nalLength;
       nalCount++;
     }
+    if (avccParseError && hasAnnexBStartCode) {
+      const nalType2 = this._isHevc ? sample.isSync ? HEVC_NAL_TYPE.IDR_W_RADL : 1 : sample.isSync ? 5 : 1;
+      console.log("[fMP4] Sample appears to be Annex B format, isSync=", sample.isSync, "size=", data.length);
+      return decoder.decode({
+        type: nalType2,
+        data,
+        size: data.length
+      });
+    }
     if (nalCount === 0) {
-      console.warn("[fMP4] No valid NAL units found in sample");
+      console.warn("[fMP4] No valid NAL units found in sample, data.length=", data.length, "lengthSize=", lengthSize, "firstBytes=", Array.from(data.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join(" "));
       return null;
     }
+    console.log("[fMP4] AVCC sample: nalCount=", nalCount, "annexBSize=", totalSize, "isSync=", sample.isSync, "lengthSize=", lengthSize);
     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) {
+    while (offset + lengthSize <= data.length) {
+      const nalLength = readNalLength(data, offset, lengthSize);
+      if (nalLength <= 0 || offset + lengthSize + nalLength > data.length) {
         break;
       }
       annexBData[writeOffset] = 0;
@@ -1902,30 +2526,42 @@ class HLSPlayer extends BasePlayer {
       annexBData[writeOffset + 2] = 0;
       annexBData[writeOffset + 3] = 1;
       writeOffset += 4;
-      annexBData.set(data.slice(offset + 4, offset + 4 + nalLength), writeOffset);
+      annexBData.set(data.slice(offset + lengthSize, offset + lengthSize + nalLength), writeOffset);
       writeOffset += nalLength;
-      offset += 4 + nalLength;
+      offset += lengthSize + nalLength;
     }
-    const frame = this.decoder.decode({
-      type: sample.isSync ? 5 : 1,
+    const nalType = this._isHevc ? sample.isSync ? HEVC_NAL_TYPE.IDR_W_RADL : 1 : sample.isSync ? 5 : 1;
+    const frame = decoder.decode({
+      type: nalType,
       data: annexBData,
       size: annexBData.length
     });
+    if (frame) {
+      frame.pts = sample.pts;
+      frame.dts = sample.dts;
+      frame.duration = sample.duration;
+    }
     return frame;
   }
   /**
    * 解码单个 NAL 单元
    */
-  decodeNAL(nalUnit) {
+  decodeNAL(nalUnit, segmentDuration) {
     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({
+    const frame = this.decoder.decode({
       type: nalUnit.type,
       data: nalWithStartCode,
       size: nalWithStartCode.length
     });
+    if (frame && segmentDuration && segmentDuration > 0) {
+      const timescale = 1e3;
+      const frameDuration = timescale / 60;
+      frame.duration = frameDuration;
+    }
+    return frame;
   }
 }
 const FLV_SIGNATURE = [70, 76, 86];
@@ -2388,89 +3024,6 @@ class FLVDemuxer {
     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 = {
@@ -2535,6 +3088,8 @@ class FLVPlayer extends BasePlayer {
     this.liveReader = null;
     this.liveDownloadAbort = false;
     this._lastQueuedTimestamp = -1;
+    this.abortController = null;
+    this.readyFired = false;
     this._currentDownloadSpeed = 0;
     this.renderedFrames = 0;
     this.lastRenderLogTime = 0;
@@ -2544,6 +3099,7 @@ class FLVPlayer extends BasePlayer {
     this.bufferEmptyStartTime = 0;
     this.playStartTimeOffset = 0;
     this.resyncCount = 0;
+    this._lastRafTime = 0;
     this.renderLoop = () => {
       if (!this.isPlaying) return;
       this.updateState({
@@ -2553,27 +3109,56 @@ class FLVPlayer extends BasePlayer {
       });
       const now = performance.now();
       const isLive = this.config.isLive;
+      const BACKGROUND_PAUSE_THRESHOLD = 500;
+      if (this._lastRafTime > 0 && now - this._lastRafTime > BACKGROUND_PAUSE_THRESHOLD) {
+        const pauseDuration = now - this._lastRafTime;
+        console.log("[FLVPlayer] Background pause detected, duration:", pauseDuration.toFixed(0), "ms, isLive:", isLive, "queue:", this._videoTagQueue.length, "buffer:", this._timedFrameBuffer.length);
+        if (isLive) {
+          const droppedDecoded = this._timedFrameBuffer.length;
+          const droppedQueue = this._videoTagQueue.length;
+          this._timedFrameBuffer = [];
+          this._videoTagQueue = [];
+          this.droppedFrames += droppedDecoded;
+          this.playStartTime = 0;
+          this.firstFrameDts = -1;
+          this.pausedTime = 0;
+          console.log("[FLVPlayer] Live resume: cleared all buffers (decoded:", droppedDecoded, ", queue:", droppedQueue, "), waiting for new data");
+        } else {
+          this.playStartTimeOffset += pauseDuration;
+        }
+      }
+      this._lastRafTime = now;
       if (this._timedFrameBuffer.length > 0 && this.renderer) {
         this.consecutiveEmptyBuffer = 0;
         if (this.playStartTime <= 0) {
           this.firstFrameDts = this._timedFrameBuffer[0].dts;
           this.playStartTime = now;
           this.playStartTimeOffset = 0;
+          this.pausedTime = 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 (this.lastRenderedDts < 0 && this._timedFrameBuffer.length > 0) {
+            const firstFrame = this._timedFrameBuffer.shift();
+            this.renderFrame(firstFrame, now);
+            this.firstFrameDts = firstFrame.dts;
+            this.playStartTime = now;
+            this.pausedTime = 0;
+            console.log("[FLVPlayer] Live first frame rendered immediately, dts:", firstFrame.dts);
+          } else {
+            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.droppedFrames++;
+              this.renderFrame(frameToRender, now);
             }
-            frameToRender = this._timedFrameBuffer.shift();
-          }
-          if (frameToRender) {
-            this.renderFrame(frameToRender, now);
           }
         } else {
           const nextFrame = this._timedFrameBuffer[0];
@@ -2644,9 +3229,11 @@ class FLVPlayer extends BasePlayer {
     console.log("[FLVPlayer] Loading URL:", url);
     this.currentUrl = url;
     this.stopLiveDownload();
+    this.abortController = new AbortController();
     this._timedFrameBuffer = [];
     this._videoTagQueue = [];
     this.liveDownloadAbort = false;
+    this.readyFired = false;
     this.resetState();
     this.playStartTime = 0;
     this.firstFrameDts = -1;
@@ -2734,8 +3321,8 @@ class FLVPlayer extends BasePlayer {
    * 开始播放（覆盖基类方法）
    */
   async play() {
-    const MIN_BUFFER_SIZE = this.dynamicMinBufferSize;
-    const MAX_WAIT_TIME = 1e4;
+    const MIN_BUFFER_SIZE = this.config.isLive ? 3 : this.dynamicMinBufferSize;
+    const MAX_WAIT_TIME = this.config.isLive ? 3e3 : 1e4;
     const startTime = Date.now();
     console.log(`[FLVPlayer] Waiting for buffer (target: ${MIN_BUFFER_SIZE} frames)...`);
     let aggressiveDecodeCount = 0;
@@ -2753,6 +3340,10 @@ class FLVPlayer extends BasePlayer {
           const dts = queuedTag.tag.timestamp;
           const pts = dts + queuedTag.tag.compositionTimeOffset;
           this._timedFrameBuffer.push({ frame, dts, pts });
+          if (!this.readyFired) {
+            this.readyFired = true;
+            this.callbacks.onReady?.();
+          }
           if (this.videoWidth === 0 || this.videoHeight === 0) {
             this.adjustBufferForResolution(frame.width, frame.height);
           }
@@ -2797,6 +3388,25 @@ class FLVPlayer extends BasePlayer {
       console.log("[FLVPlayer] Pausing live stream, keeping download running");
     }
   }
+  /**
+   * 销毁播放器，释放所有资源
+   */
+  destroy() {
+    this.stopLiveDownload();
+    if (this.h264Decoder) {
+      this.h264Decoder.destroy();
+      this.h264Decoder = null;
+    }
+    if (this.hevcDecoder) {
+      this.hevcDecoder.destroy();
+      this.hevcDecoder = null;
+    }
+    if (this.prefetcher) {
+      this.prefetcher.reset();
+      this.prefetcher = null;
+    }
+    super.destroy();
+  }
   /**
    * 处理预取缓冲区数据（供预取器调用）
    */
@@ -2879,6 +3489,10 @@ class FLVPlayer extends BasePlayer {
           const pts = dts + queuedTag.tag.compositionTimeOffset;
           this._timedFrameBuffer.push({ frame, dts, pts });
           decodedInBatch++;
+          if (!this.readyFired) {
+            this.readyFired = true;
+            this.callbacks.onReady?.();
+          }
           if (this.videoWidth === 0 || this.videoHeight === 0) {
             this.adjustBufferForResolution(frame.width, frame.height);
           }
@@ -2925,7 +3539,17 @@ class FLVPlayer extends BasePlayer {
    */
   async loadFLV(url) {
     console.log("[FLVPlayer] Fetching FLV...");
-    const response = await fetch(url);
+    const signal = this.abortController?.signal;
+    let response;
+    try {
+      response = await fetch(url, { signal });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("[FLVPlayer] Fetch aborted");
+        return;
+      }
+      throw error;
+    }
     if (!response.ok) {
       throw new Error(`Failed to fetch FLV: ${response.status}`);
     }
@@ -3000,6 +3624,10 @@ class FLVPlayer extends BasePlayer {
         }
       }
     } catch (error) {
+      if (error.name === "AbortError" || this.liveDownloadAbort) {
+        console.log("[FLVPlayer] Loading aborted");
+        return;
+      }
       console.error("[FLVPlayer] Error loading FLV:", error);
       throw error;
     } finally {
@@ -3044,6 +3672,10 @@ class FLVPlayer extends BasePlayer {
    */
   stopLiveDownload() {
     this.liveDownloadAbort = true;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
     if (this.liveReader) {
       this.liveReader.cancel();
       this.liveReader = null;
@@ -3367,6 +3999,13 @@ class Canvas2DRenderer {
     if (!this.ctx) {
       throw new Error("Invalid canvas element");
     }
+    this.clear();
+  }
+  /**
+   * 清除 canvas 内容
+   */
+  clear() {
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
   }
   render(frame) {
     const { width, height, data } = frame;
@@ -3426,6 +4065,10 @@ class EcPlayerCore {
         this.pendingRenderer = null;
       }
       await this.player.load(url);
+      if (this.player instanceof HLSPlayer) {
+        this.detectedFormat = this.player.isFMP4 ? "hls-fmp4" : "hls-ts";
+        console.log("[EcPlayerCore] Updated format after playlist parse:", this.detectedFormat);
+      }
       await this.player.initDecoder();
       this.callbacks.onStateChange?.({ isLoaded: true });
     } finally {
@@ -3886,6 +4529,7 @@ export {
   EcPlayerCore,
   EnvDetector,
   LogLevel,
+  WASMLoader,
   setLogLevel
 };
 //# sourceMappingURL=index.js.map