@give-tech/ec-player 0.0.1-beta.48 → 0.0.1-beta.50

package/dist/index.d.ts

@@ -7,6 +7,6 @@
 export { EcPlayerCore, type EcPlayerCoreConfig } from './player';
 export { EnvDetector, type EnvInfo, type EnvCapabilities } from './env';
 export { WASMLoader } from './decoder/WASMLoader';
-export type { PlayerState as EcPlayerState, PlayerCallbacks as EcPlayerCallbacks } from './types';
+export type { PlayerState as EcPlayerState, PlayerCallbacks as EcPlayerCallbacks, LoadingStageInfo as EcLoadingStageInfo } from './types';
 export { LogLevel, setLogLevel } from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAGhE,OAAO,EACL,WAAW,EACX,KAAK,OAAO,EACZ,KAAK,eAAe,EACrB,MAAM,OAAO,CAAA;AAGd,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGjD,YAAY,EACV,WAAW,IAAI,aAAa,EAC5B,eAAe,IAAI,iBAAiB,EACrC,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAGhE,OAAO,EACL,WAAW,EACX,KAAK,OAAO,EACZ,KAAK,eAAe,EACrB,MAAM,OAAO,CAAA;AAGd,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGjD,YAAY,EACV,WAAW,IAAI,aAAa,EAC5B,eAAe,IAAI,iBAAiB,EACpC,gBAAgB,IAAI,kBAAkB,EACvC,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -235,6 +235,8 @@ class BasePlayer {
       isPlaying: false,
       isLoaded: false,
       isLoading: false,
+      isBuffering: false,
+      bufferingProgress: void 0,
       fps: 0,
       resolution: "-",
       decoded: 0,
@@ -283,6 +285,23 @@ class BasePlayer {
     this.decoder = new H264Decoder(this.wasmLoader);
     await this.decoder.init();
   }
+  /**
+   * 预初始化解码器（并行加载优化）
+   * 在数据下载的同时加载 WASM 模块
+   * 返回初始化结果，供 finishInitDecoder 使用
+   */
+  async preInitDecoder() {
+    await this.wasmLoader.load(this.config.wasmPath);
+    return null;
+  }
+  /**
+   * 完成解码器初始化
+   * 使用 preInitDecoder 的结果完成初始化
+   */
+  async finishInitDecoder(_initResult) {
+    this.decoder = new H264Decoder(this.wasmLoader);
+    await this.decoder.init();
+  }
   /**
    * 开始播放
    */
@@ -317,6 +336,8 @@ class BasePlayer {
       isPlaying: false,
       isLoaded: false,
       isLoading: false,
+      isBuffering: false,
+      bufferingProgress: void 0,
       fps: 0,
       resolution: "-",
       decoded: 0,
@@ -1202,9 +1223,9 @@ class BasePrefetcher {
         const queueSize = this.getQueueSize();
         this.updateStatus({ queueSize });
         if (this.shouldPrefetch()) {
-          this.updateStatus({ isPrefetching: true });
-          await this.doPrefetch();
-          this.updateStatus({ isPrefetching: false });
+          this.doPrefetch().catch((err) => {
+            console.error("[BasePrefetcher] Prefetch error:", err);
+          });
         }
         const interval = this.calculateInterval(queueSize);
         await this.sleep(interval);
@@ -1303,7 +1324,8 @@ class SegmentPrefetcher extends BasePrefetcher {
     this.currentSegmentIndex = 0;
     this.fetchedSegmentCount = 0;
     this.baseUrl = "";
-    this.isPrefetchingSegment = false;
+    this.activePrefetchCount = 0;
+    this.prefetchingIndexes = /* @__PURE__ */ new Set();
   }
   /**
    * 创建初始状态
@@ -1356,35 +1378,46 @@ class SegmentPrefetcher extends BasePrefetcher {
    * 判断是否应该预取
    */
   shouldPrefetch() {
-    if (this.isPrefetchingSegment) return false;
+    const maxConcurrent = this.config.maxConcurrentPrefetch ?? 1;
+    if (this.activePrefetchCount >= maxConcurrent) 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;
+    const totalPending = this.prefetchQueue.length + this.activePrefetchCount;
+    if (totalPending >= prefetchAhead) return false;
+    const nextIndex = this.currentSegmentIndex + this.prefetchQueue.length + this.activePrefetchCount;
     return nextIndex < this.segments.length;
   }
   /**
-   * 执行预取
+   * 执行预取（支持并行下载）
    */
   async doPrefetch() {
-    if (this.isPrefetchingSegment) return;
-    this.isPrefetchingSegment = true;
+    const maxConcurrent = this.config.maxConcurrentPrefetch ?? 1;
+    if (this.activePrefetchCount >= maxConcurrent) return;
+    this.activePrefetchCount++;
     this.updateStatus({ isPrefetching: true });
     try {
-      const nextIndex = this.currentSegmentIndex + this.prefetchQueue.length;
+      const nextIndex = this.currentSegmentIndex + this.prefetchQueue.length + this.prefetchingIndexes.size;
       if (nextIndex >= this.segments.length) {
+        this.activePrefetchCount--;
+        return;
+      }
+      if (this.prefetchingIndexes.has(nextIndex)) {
+        this.activePrefetchCount--;
         return;
       }
+      this.prefetchingIndexes.add(nextIndex);
       const segment = this.segments[nextIndex];
       const fetchStart = performance.now();
       const data = await this.fetchSegment(segment, nextIndex);
       const fetchTime = performance.now() - fetchStart;
+      this.prefetchingIndexes.delete(nextIndex);
       this.prefetchQueue.push({
         data,
         segmentIndex: nextIndex,
         fetchTime,
         segmentDuration: segment.duration
       });
+      this.prefetchQueue.sort((a, b) => a.segmentIndex - b.segmentIndex);
       this.fetchedSegmentCount++;
       this.updateStatus({
         prefetchQueueSize: this.prefetchQueue.length,
@@ -1396,13 +1429,15 @@ class SegmentPrefetcher extends BasePrefetcher {
     } catch (error) {
       if (error.name === "AbortError") {
         console.log(`[SegmentPrefetcher] Fetch aborted`);
+        this.prefetchingIndexes.clear();
+        this.activePrefetchCount = 0;
         return;
       }
       console.error(`[SegmentPrefetcher] Fetch failed:`, error.message);
       this.callbacks.onError?.(error);
     } finally {
-      this.isPrefetchingSegment = false;
-      this.updateStatus({ isPrefetching: false });
+      this.activePrefetchCount--;
+      this.updateStatus({ isPrefetching: this.activePrefetchCount > 0 });
     }
   }
   /**
@@ -1445,7 +1480,8 @@ class SegmentPrefetcher extends BasePrefetcher {
     this.segments = [];
     this.currentSegmentIndex = 0;
     this.baseUrl = "";
-    this.isPrefetchingSegment = false;
+    this.activePrefetchCount = 0;
+    this.prefetchingIndexes.clear();
   }
   /**
    * 获取当前分片索引
@@ -1652,7 +1688,8 @@ const DEFAULT_PREFETCHER_CONFIG = {
 };
 const DEFAULT_SEGMENT_PREFETCHER_CONFIG = {
   ...DEFAULT_PREFETCHER_CONFIG,
-  prefetchAhead: 2
+  prefetchAhead: 2,
+  maxConcurrentPrefetch: 2
 };
 const DEFAULT_STREAM_PREFETCHER_CONFIG = {
   ...DEFAULT_PREFETCHER_CONFIG,
@@ -1668,7 +1705,9 @@ const HLS_PREFETCHER_CONFIG = {
   prefetchAhead: 6,
   // 预载 6 个分片（约 30 秒），适应高分辨率视频
   prefetchInterval: 10,
-  dynamicInterval: true
+  dynamicInterval: true,
+  maxConcurrentPrefetch: 2
+  // 并行下载 2 个分片
 };
 const DEFAULT_HLS_CONFIG = {
   ...DEFAULT_PLAYER_CONFIG
@@ -1677,10 +1716,12 @@ class HLSSegmentPrefetcher extends SegmentPrefetcher {
   constructor(config, callbacks, player) {
     super(config, callbacks);
     this.currentInitSegmentUri = null;
+    this.progressDisplayIndex = -1;
+    this.lastReportedPercent = -1;
     this.player = player;
   }
   /**
-   * 获取分片数据
+   * 获取分片数据（支持流式下载和进度报告）
    */
   async fetchSegment(segment, index) {
     if (segment.initSegmentUri && segment.initSegmentUri !== this.currentInitSegmentUri) {
@@ -1697,7 +1738,61 @@ class HLSSegmentPrefetcher extends SegmentPrefetcher {
     }
     const signal = this.player.getAbortSignal();
     const response = await fetch(url, { headers, signal });
-    return new Uint8Array(await response.arrayBuffer());
+    const contentLength = response.headers.get("Content-Length");
+    const totalSize = contentLength ? parseInt(contentLength, 10) : 0;
+    const reader = response.body?.getReader();
+    if (!reader) {
+      return new Uint8Array(await response.arrayBuffer());
+    }
+    const chunks = [];
+    let loadedBytes = 0;
+    let lastProgressTime = 0;
+    let lastProgressBytes = 0;
+    let downloadSpeed = 0;
+    const PROGRESS_INTERVAL = 200;
+    if (index > this.progressDisplayIndex) {
+      this.progressDisplayIndex = index;
+    }
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      loadedBytes += value.length;
+      const now = Date.now();
+      if (now - lastProgressTime >= PROGRESS_INTERVAL) {
+        if (lastProgressTime > 0) {
+          const timeDiff = (now - lastProgressTime) / 1e3;
+          const bytesDiff = loadedBytes - lastProgressBytes;
+          downloadSpeed = bytesDiff / timeDiff;
+        }
+        lastProgressTime = now;
+        lastProgressBytes = loadedBytes;
+        if (index === this.progressDisplayIndex && totalSize > 0) {
+          const percent = Math.min(100, Math.round(loadedBytes / totalSize * 100));
+          if (percent !== this.lastReportedPercent) {
+            this.lastReportedPercent = percent;
+            const callbacks = this.callbacks;
+            callbacks.onDownloadProgress?.({
+              segmentIndex: index,
+              loaded: loadedBytes,
+              total: totalSize,
+              speed: downloadSpeed > 0 ? downloadSpeed : void 0
+            });
+          }
+        }
+      }
+    }
+    if (index === this.progressDisplayIndex) {
+      this.progressDisplayIndex = -1;
+      this.lastReportedPercent = -1;
+    }
+    const result = new Uint8Array(loadedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
   }
   /**
    * 解析分片数据
@@ -1785,12 +1880,20 @@ class HLSPlayer extends BasePlayer {
         totalSegments
       });
       if (this.frameBuffer.length > 0 && this.renderer) {
+        const wasBuffering = this.state.isBuffering;
+        if (this.state.isBuffering) {
+          this.updateState({ isBuffering: false, bufferingProgress: void 0 });
+        }
         const timescale = this.fmp4Demuxer.getTimescale();
         if (this.playStartTime === 0) {
           this.playStartTime = now;
           this.accumulatedMediaTime = 0;
           console.log("[renderLoop] Init: timescale=", timescale);
         }
+        if (wasBuffering && this.accumulatedMediaTime > 0) {
+          this.playStartTime = now - this.accumulatedMediaTime / this._playbackRate;
+          console.log("[renderLoop] Buffer recovered, reset playStartTime to continue from", Math.floor(this.accumulatedMediaTime), "ms");
+        }
         const elapsedWallTime = (now - this.playStartTime) * this._playbackRate;
         if (Math.floor(elapsedWallTime / 1e3) !== Math.floor((elapsedWallTime - 20 * this._playbackRate) / 1e3)) {
           console.log("[renderLoop] elapsed=", Math.floor(elapsedWallTime), "accumulated=", Math.floor(this.accumulatedMediaTime), "rate=", this._playbackRate, "frameBuffer=", this.frameBuffer.length);
@@ -1831,6 +1934,9 @@ class HLSPlayer extends BasePlayer {
           this.callbacks.onFrameRender?.(frame);
         }
       } else {
+        if (this.isPlaying && !this.state.isBuffering) {
+          this.updateState({ isBuffering: true });
+        }
         if (this.playStartTime === 0) {
           console.log("[renderLoop] Waiting for frames...");
         }
@@ -1909,7 +2015,6 @@ class HLSPlayer extends BasePlayer {
       totalSegments: segments.length
     });
     this.initPrefetcher();
-    this.prefetcher.start();
   }
   /**
    * 初始化解码器（覆盖基类方法，添加 fMP4 支持）
@@ -1920,6 +2025,22 @@ class HLSPlayer extends BasePlayer {
       await this.loadInitSegment();
     }
   }
+  /**
+   * 预初始化解码器（并行加载优化）
+   * 在数据下载的同时加载 WASM 模块
+   */
+  async preInitDecoder() {
+    return super.preInitDecoder();
+  }
+  /**
+   * 完成解码器初始化（使用预加载的 WASM）
+   */
+  async finishInitDecoder(initResult) {
+    await super.finishInitDecoder(initResult);
+    if (this.isFMP4 && this.initSegment) {
+      await this.loadInitSegment();
+    }
+  }
   /**
    * 开始播放（覆盖基类方法，使用自定义渲染循环）
    */
@@ -2017,14 +2138,26 @@ class HLSPlayer extends BasePlayer {
   async decodeLoop() {
     console.log("[DecodeLoop] START, isFMP4:", this.isFMP4);
     let batchCount = 0;
-    const READY_TIMEOUT_MS = 5e3;
-    const readyTimeoutId = setTimeout(() => {
-      if (!this.readyFired) {
-        console.warn("[HLSPlayer] Ready timeout, triggering onReady anyway");
+    const CHECK_INTERVAL_MS = 5e3;
+    let checkCount = 0;
+    const MAX_CHECK_COUNT = 24;
+    const checkReadyTimeout = () => {
+      if (this.readyFired || this.decodeLoopAbort) return;
+      checkCount++;
+      if (checkCount > MAX_CHECK_COUNT) {
+        console.warn("[HLSPlayer] Max ready timeout reached, triggering onReady");
         this.readyFired = true;
         this.callbacks.onReady?.();
+        return;
       }
-    }, READY_TIMEOUT_MS);
+      if (this.frameBuffer.length > 0) {
+        this.readyFired = true;
+        this.callbacks.onReady?.();
+        return;
+      }
+      setTimeout(checkReadyTimeout, CHECK_INTERVAL_MS);
+    };
+    setTimeout(checkReadyTimeout, CHECK_INTERVAL_MS);
     while (this.isPlaying && !this.decodeLoopAbort) {
       const sampleQueueSize = this.sampleQueue.length;
       const maxSamplesBeforePause = this.config.maxQueueSize * 3;
@@ -2131,7 +2264,6 @@ class HLSPlayer extends BasePlayer {
         await this.sleep(2);
       }
     }
-    clearTimeout(readyTimeoutId);
     console.log("[DecodeLoop] END, batches:", batchCount);
   }
   /**
@@ -2152,6 +2284,18 @@ class HLSPlayer extends BasePlayer {
         onSegmentParsed: (segmentIndex, itemCount) => {
           this.currentSegmentIndex = segmentIndex + 1;
           this.updateState({ segmentIndex: this.currentSegmentIndex });
+        },
+        onDownloadProgress: (progress) => {
+          if (progress.total && progress.total > 0) {
+            const percent = Math.round(progress.loaded / progress.total * 100);
+            this.callbacks.onLoadingStageChange?.({
+              stage: "loading",
+              detail: `下载中 ${percent}%`
+            });
+            if (this.state.isBuffering) {
+              this.updateState({ bufferingProgress: percent });
+            }
+          }
         }
       },
       this
@@ -2354,6 +2498,9 @@ class HLSPlayer extends BasePlayer {
     } else {
       console.error("[fMP4] Failed to parse new init segment!");
     }
+    if (initInfo?.avcC || initInfo?.hvcC) {
+      this.decoderInitialized = true;
+    }
   }
   /**
    * 初始化 HEVC 解码器
@@ -3206,6 +3353,9 @@ class FLVPlayer extends BasePlayer {
     this.abortController = null;
     this.readyFired = false;
     this._currentDownloadSpeed = 0;
+    this._decoderInitContext = null;
+    this._totalFileSize = 0;
+    this._downloadedBytes = 0;
     this.renderedFrames = 0;
     this.lastRenderLogTime = 0;
     this.consecutiveEmptyBuffer = 0;
@@ -3244,6 +3394,9 @@ class FLVPlayer extends BasePlayer {
       }
       this._lastRafTime = now;
       if (this._timedFrameBuffer.length > 0 && this.renderer) {
+        if (this.state.isBuffering) {
+          this.updateState({ isBuffering: false, bufferingProgress: void 0 });
+        }
         this.consecutiveEmptyBuffer = 0;
         if (this.playStartTime <= 0) {
           this.firstFrameDts = this._timedFrameBuffer[0].dts;
@@ -3309,6 +3462,9 @@ class FLVPlayer extends BasePlayer {
           this.lastRenderLogTime = now;
         }
       } else {
+        if (this.isPlaying && !this.state.isBuffering) {
+          this.updateState({ isBuffering: true });
+        }
         if (this.consecutiveEmptyBuffer === 0 && this.lastRenderedDts >= 0) {
           this.bufferEmptyStartTime = now;
         }
@@ -3410,6 +3566,62 @@ class FLVPlayer extends BasePlayer {
       console.warn("[FLVPlayer] No config found, will try to init from first frames");
     }
   }
+  /**
+   * 预初始化解码器（并行加载优化）
+   * 在数据下载的同时加载 WASM 模块
+   */
+  async preInitDecoder() {
+    await this.wasmLoader.load(this.config.wasmPath);
+    this._decoderInitContext = {
+      wasmLoaded: true,
+      codecId: this._currentCodecId
+    };
+    console.log("[FLVPlayer] WASM pre-loaded for parallel init");
+    return this._decoderInitContext;
+  }
+  /**
+   * 完成解码器初始化（使用预加载的 WASM）
+   */
+  async finishInitDecoder(_initResult) {
+    if (!this._decoderInitContext?.wasmLoaded) {
+      return this.initDecoder();
+    }
+    const avcConfig = this.flvDemuxer.getAvcConfig();
+    const hevcConfig = this.flvDemuxer.getHevcConfig();
+    this._currentCodecId = this.flvDemuxer.getCodecId();
+    if (hevcConfig) {
+      console.log("[FLVPlayer] Finishing HEVC decoder init...");
+      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] Finishing AVC decoder init...");
+      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");
+    }
+    this._decoderInitContext = null;
+  }
   /**
    * 根据视频分辨率动态调整缓冲参数
    */
@@ -3687,10 +3899,6 @@ class FLVPlayer extends BasePlayer {
     }
     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 signal = this.abortController?.signal;
@@ -3708,6 +3916,10 @@ class FLVPlayer extends BasePlayer {
       throw new Error(`Failed to fetch FLV: ${response.status}`);
     }
     console.log("[FLVPlayer] Fetch response OK, status:", response.status);
+    const contentLength = response.headers.get("Content-Length");
+    this._totalFileSize = contentLength ? parseInt(contentLength, 10) : 0;
+    this._downloadedBytes = 0;
+    console.log("[FLVPlayer] Content-Length:", this._totalFileSize, "bytes");
     this.isPrefetching = true;
     this.updateState({ isPrefetching: true });
     const isLive = this.config.isLive || false;
@@ -3724,12 +3936,25 @@ class FLVPlayer extends BasePlayer {
       const startTime = Date.now();
       let started = false;
       let lastLoggedTags = 0;
+      let lastProgressUpdate = 0;
       this.liveReader = reader;
       while (true) {
         const { done, value } = await reader.read();
         if (value) {
           chunks.push(value);
           totalLength += value.length;
+          this._downloadedBytes = totalLength;
+          const now = Date.now();
+          if (this._totalFileSize > 0 && now - lastProgressUpdate > 200) {
+            lastProgressUpdate = now;
+            const percent = Math.round(totalLength / this._totalFileSize * 100);
+            const downloadedMB = (totalLength / 1024 / 1024).toFixed(1);
+            const totalMB = (this._totalFileSize / 1024 / 1024).toFixed(1);
+            this.callbacks.onLoadingStageChange?.({
+              stage: "loading",
+              detail: `${percent}% (${downloadedMB}/${totalMB} MB)`
+            });
+          }
         }
         const shouldStart = totalLength >= MIN_DATA_SIZE || Date.now() - startTime > TIMEOUT_MS;
         if (!started && shouldStart && totalLength > 0) {
@@ -4207,9 +4432,11 @@ class EcPlayerCore {
    */
   async load(url, isLive) {
     this.callbacks.onStateChange?.({ isLoading: true, isLoaded: false });
+    this.callbacks.onLoadingStageChange?.({ stage: "connecting" });
     try {
       this.detectedFormat = FormatDetector.detectFromUrl(url);
       console.log("[EcPlayerCore] Detected format:", this.detectedFormat, "from URL:", url, "isLive:", isLive);
+      this.callbacks.onLoadingStageChange?.({ stage: "detected", detail: this.detectedFormat });
       if (isLive !== void 0) {
         this.config.isLive = isLive;
       }
@@ -4218,13 +4445,22 @@ class EcPlayerCore {
         this.player.setRenderer(this.pendingRenderer);
         this.pendingRenderer = null;
       }
-      await this.player.load(url);
+      this.callbacks.onLoadingStageChange?.({ stage: "loading" });
+      const [_, initResult] = await Promise.all([
+        this.player.load(url),
+        this.player.preInitDecoder()
+      ]);
       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.onLoadingStageChange?.({ stage: "initializing" });
+      await this.player.finishInitDecoder(initResult);
       this.callbacks.onStateChange?.({ isLoaded: true });
+    } catch (error) {
+      console.error("[EcPlayerCore] Load failed:", error);
+      this.callbacks.onError?.(error);
+      throw error;
     } finally {
       this.callbacks.onStateChange?.({ isLoading: false });
     }
@@ -4300,6 +4536,7 @@ class EcPlayerCore {
         isPlaying: false,
         isLoaded: false,
         isLoading: false,
+        isBuffering: false,
         fps: 0,
         resolution: "-",
         decoded: 0,