@meframe/core 0.0.15 → 0.0.17

package/dist/workers/MP4Demuxer.js

@@ -7054,9 +7054,11 @@ class MP4Demuxer {
   fileOffset = 0;
   videoTimestampOffset = null;
   audioTimestampOffset = null;
+  skipAudio = false;
   constructor(config = {}) {
     this.mp4boxFile = mp4box_all.createFile();
     this.onReadyCallback = config.onReady;
+    this.skipAudio = config.skipAudio ?? false;
     const DEFAULT_HIGH_WATER_MARK = 10;
     this.demuxHighWaterMark = config.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;
     this.setupHandlers();
@@ -7129,7 +7131,12 @@ class MP4Demuxer {
           data: sample.data
         });
         this.videoController.enqueue(chunk);
-      } else if (track.type === "audio" && this.audioController) {
+      } else if (track.type === "audio") {
+        if (!this.audioController) {
+          const last2 = samples[samples.length - 1].number;
+          this.mp4boxFile.releaseUsedSamples(trackId, last2 + 1);
+          return;
+        }
         if (this.audioTimestampOffset === null) {
           this.audioTimestampOffset = rawTimestamp;
         }
@@ -7175,9 +7182,27 @@ class MP4Demuxer {
     try {
       const fullTrack = this.mp4boxFile.getTrackById(track.id);
       for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {
-        if (entry.esds || entry.dOps) {
-          const stream = new mp4box_all.DataStream();
-          (entry.esds || entry.dOps).write(stream);
+        if (entry.esds) {
+          const decConfigDesc = entry.esds.esd?.descs?.[0];
+          const decSpecInfo = decConfigDesc?.descs?.[0];
+          if (decSpecInfo?.data) {
+            const data = decSpecInfo.data;
+            if (data instanceof Uint8Array) {
+              const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+              return buffer instanceof ArrayBuffer ? buffer : void 0;
+            } else if (Array.isArray(data)) {
+              return new Uint8Array(data).buffer;
+            }
+          }
+          console.warn("[MP4Demuxer] Could not extract AudioSpecificConfig from esds structure");
+          return void 0;
+        } else if (entry.dOps) {
+          const stream = new mp4box_all.DataStream(
+            void 0,
+            0,
+            mp4box_all.DataStream.BIG_ENDIAN
+          );
+          entry.dOps.write(stream);
           return new Uint8Array(stream.buffer.slice(8)).buffer;
         }
       }
@@ -7187,56 +7212,67 @@ class MP4Demuxer {
     return void 0;
   }
   /**
-   * Create transform stream for video track
+   * Create readable stream for video chunks (output only)
    */
   createVideoStream() {
-    return new TransformStream(
+    return new ReadableStream(
       {
-        start: (controller) => {
-          this.videoController = controller;
-        },
-        transform: (chunk, _controller) => {
-          const chunkData = new Uint8Array(chunk);
-          this.appendBuffer(chunkData);
-          this.mp4boxFile.flush();
+        start: (ctrl) => {
+          this.videoController = ctrl;
         },
-        flush: async () => {
-          this.mp4boxFile.flush();
-          await new Promise((resolve) => setTimeout(resolve, 100));
+        cancel: () => {
+          this.videoController = void 0;
         }
       },
-      // Queuing strategy: use configuration
       {
         highWaterMark: this.demuxHighWaterMark,
         size: () => 1
-        // Count-based
       }
     );
   }
   /**
-   * Create transform stream for audio track
+   * Create readable stream for audio chunks (output only)
    */
   createAudioStream() {
-    const hasAudio = Array.from(this.tracks.values()).some((t) => t.type === "audio");
-    if (!hasAudio) return null;
-    return new TransformStream(
+    if (this.skipAudio) {
+      return null;
+    }
+    return new ReadableStream(
       {
-        start: (controller) => {
-          this.audioController = controller;
+        start: (ctrl) => {
+          this.audioController = ctrl;
         },
-        transform: (chunk, _controller) => {
+        cancel: () => {
+          this.audioController = void 0;
+        }
+      },
+      {
+        highWaterMark: this.demuxHighWaterMark,
+        size: () => 1
+      }
+    );
+  }
+  /**
+   * Create writable stream for input data (single source)
+   * This is the only stream that should receive the input data
+   */
+  createInputStream() {
+    return new WritableStream(
+      {
+        write: (chunk) => {
           const chunkData = new Uint8Array(chunk);
           this.appendBuffer(chunkData);
           this.mp4boxFile.flush();
         },
-        flush: () => {
+        close: async () => {
           this.mp4boxFile.flush();
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          this.videoController?.close();
+          this.audioController?.close();
         }
       },
-      // Queuing strategy: use configuration
       {
-        highWaterMark: this.demuxHighWaterMark,
-        size: () => 1
+        highWaterMark: this.demuxHighWaterMark
       }
     );
   }