@meframe/core 0.0.1

package/dist/stages/demux/MP3FrameParser.js

@@ -0,0 +1,186 @@
+const BITRATE_TABLE = {
+  "1-3": [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],
+  "1-2": [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
+  "1-1": [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
+  "2-3": [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+  "2-2": [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+  "2-1": [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0]
+};
+const SAMPLE_RATE_TABLE = {
+  1: [44100, 48e3, 32e3],
+  2: [22050, 24e3, 16e3],
+  2.5: [11025, 12e3, 8e3]
+};
+class MP3FrameParser {
+  buffer = new Uint8Array(0);
+  config = null;
+  timestampUs = 0;
+  push(chunk) {
+    this.appendToBuffer(chunk);
+    this.skipId3Headers();
+    const frames = [];
+    let configEmitted;
+    let offset = 0;
+    while (offset <= this.buffer.length - 4) {
+      const header = this.parseHeader(this.buffer, offset);
+      if (!header) {
+        offset += 1;
+        continue;
+      }
+      if (offset + header.frameSize > this.buffer.length) {
+        break;
+      }
+      const frameBytes = this.buffer.slice(offset, offset + header.frameSize);
+      const durationUs = Math.round(header.samplesPerFrame * 1e6 / header.sampleRate);
+      if (!this.config) {
+        this.config = {
+          codec: "mp3",
+          sampleRate: header.sampleRate,
+          channels: header.channels,
+          bitrateKbps: header.bitrateKbps,
+          samplesPerFrame: header.samplesPerFrame
+        };
+        configEmitted = this.config;
+      }
+      frames.push({
+        data: frameBytes,
+        timestampUs: this.timestampUs,
+        durationUs
+      });
+      this.timestampUs += durationUs;
+      offset += header.frameSize;
+    }
+    if (offset > 0) {
+      this.buffer = this.buffer.slice(offset);
+    }
+    return { frames, config: configEmitted };
+  }
+  flush() {
+    const { frames } = this.push(new Uint8Array(0));
+    const remainder = this.buffer;
+    this.buffer = new Uint8Array(0);
+    if (remainder.length) {
+      console.warn("[MP3FrameParser] Remaining unparsed bytes:", remainder.length);
+    }
+    return frames;
+  }
+  appendToBuffer(chunk) {
+    if (chunk.length === 0) {
+      return;
+    }
+    const combined = new Uint8Array(this.buffer.length + chunk.length);
+    combined.set(this.buffer, 0);
+    combined.set(chunk, this.buffer.length);
+    this.buffer = combined;
+  }
+  skipId3Headers() {
+    let offset = 0;
+    while (this.buffer.length - offset >= 10) {
+      if (this.buffer[offset] === 73 && this.buffer[offset + 1] === 68 && this.buffer[offset + 2] === 51) {
+        const size = this.readSynchsafeInteger(this.buffer.subarray(offset + 6, offset + 10));
+        const total = size + 10;
+        if (offset + total <= this.buffer.length) {
+          offset += total;
+          continue;
+        }
+      }
+      break;
+    }
+    if (offset > 0) {
+      this.buffer = this.buffer.slice(offset);
+    }
+  }
+  parseHeader(buffer, offset) {
+    if (offset + 3 >= buffer.length) {
+      return null;
+    }
+    if (buffer[offset] !== 255 || ((buffer[offset + 1] ?? 0) & 224) !== 224) {
+      return null;
+    }
+    const versionBits = (buffer[offset + 1] ?? 0) >> 3 & 3;
+    const layerBits = (buffer[offset + 1] ?? 0) >> 1 & 3;
+    const bitrateIndex = (buffer[offset + 2] ?? 0) >> 4 & 15;
+    const sampleRateIndex = (buffer[offset + 2] ?? 0) >> 2 & 3;
+    const paddingBit = (buffer[offset + 2] ?? 0) >> 1 & 1;
+    const channelMode = (buffer[offset + 3] ?? 0) >> 6 & 3;
+    const version = this.getVersion(versionBits);
+    const layer = this.getLayer(layerBits);
+    if (!version || !layer) {
+      return null;
+    }
+    const sampleRate = SAMPLE_RATE_TABLE[version]?.[sampleRateIndex] ?? null;
+    if (!sampleRate) {
+      return null;
+    }
+    const bitrateKey = `${version === 1 ? 1 : 2}-${layer}`;
+    const bitrateKbps = BITRATE_TABLE[bitrateKey]?.[bitrateIndex] ?? null;
+    if (bitrateKbps === null) {
+      return null;
+    }
+    const samplesPerFrame = this.getSamplesPerFrame(version, layer);
+    const frameSize = this.calculateFrameSize(layer, bitrateKbps, sampleRate, paddingBit);
+    if (!frameSize || frameSize < 24) {
+      return null;
+    }
+    const channels = channelMode === 3 ? 1 : 2;
+    return {
+      frameSize,
+      sampleRate,
+      channels,
+      bitrateKbps: bitrateKbps || null,
+      samplesPerFrame
+    };
+  }
+  getVersion(bits) {
+    switch (bits) {
+      case 3:
+        return 1;
+      case 2:
+        return 2;
+      case 0:
+        return 2.5;
+      default:
+        return null;
+    }
+  }
+  getLayer(bits) {
+    switch (bits) {
+      case 3:
+        return 1;
+      case 2:
+        return 2;
+      case 1:
+        return 3;
+      default:
+        return null;
+    }
+  }
+  getSamplesPerFrame(version, layer) {
+    if (layer === 1) {
+      return 384;
+    }
+    if (layer === 2) {
+      return 1152;
+    }
+    return version === 1 ? 1152 : 576;
+  }
+  calculateFrameSize(layer, bitrateKbps, sampleRate, padding) {
+    if (bitrateKbps <= 0) {
+      return 0;
+    }
+    if (layer === 1) {
+      return (12 * bitrateKbps * 1e3 / sampleRate + padding) * 4;
+    }
+    return Math.floor(144 * bitrateKbps * 1e3 / sampleRate + padding);
+  }
+  readSynchsafeInteger(bytes) {
+    if (bytes.length !== 4) {
+      return 0;
+    }
+    return ((bytes[0] ?? 0) & 127) << 21 | ((bytes[1] ?? 0) & 127) << 14 | ((bytes[2] ?? 0) & 127) << 7 | (bytes[3] ?? 0) & 127;
+  }
+}
+export {
+  MP3FrameParser
+};
+//# sourceMappingURL=MP3FrameParser.js.map

package/dist/stages/demux/MP3FrameParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MP3FrameParser.js","sources":["../../../src/stages/demux/MP3FrameParser.ts"],"sourcesContent":["const BITRATE_TABLE: Record<string, number[]> = {\n  '1-3': [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],\n  '1-2': [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],\n  '1-1': [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],\n  '2-3': [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],\n  '2-2': [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],\n  '2-1': [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],\n};\n\nconst SAMPLE_RATE_TABLE: Record<number, number[]> = {\n  1: [44100, 48000, 32000],\n  2: [22050, 24000, 16000],\n  2.5: [11025, 12000, 8000],\n};\n\nexport interface MP3Config {\n  codec: 'mp3';\n  sampleRate: number;\n  channels: number;\n  bitrateKbps: number | null;\n  samplesPerFrame: number;\n}\n\nexport interface MP3Frame {\n  data: Uint8Array;\n  timestampUs: number;\n  durationUs: number;\n}\n\ninterface ParseResult {\n  frames: MP3Frame[];\n  config?: MP3Config;\n}\n\nexport class MP3FrameParser {\n  private buffer = new Uint8Array(0);\n  private config: MP3Config | null = null;\n  private timestampUs = 0;\n\n  push(chunk: Uint8Array): ParseResult {\n    this.appendToBuffer(chunk);\n    this.skipId3Headers();\n\n    const frames: MP3Frame[] = [];\n    let configEmitted: MP3Config | undefined;\n\n    let offset = 0;\n    while (offset <= this.buffer.length - 4) {\n      const header = this.parseHeader(this.buffer, offset);\n      if (!header) {\n        offset += 1;\n        continue;\n      }\n\n      if (offset + header.frameSize > this.buffer.length) {\n        break;\n      }\n\n      const frameBytes = this.buffer.slice(offset, offset + header.frameSize);\n      const durationUs = Math.round((header.samplesPerFrame * 1_000_000) / header.sampleRate);\n\n      if (!this.config) {\n        this.config = {\n          codec: 'mp3',\n          sampleRate: header.sampleRate,\n          channels: header.channels,\n          bitrateKbps: header.bitrateKbps,\n          samplesPerFrame: header.samplesPerFrame,\n        };\n        configEmitted = this.config;\n      }\n\n      frames.push({\n        data: frameBytes,\n        timestampUs: this.timestampUs,\n        durationUs,\n      });\n\n      this.timestampUs += durationUs;\n      offset += header.frameSize;\n    }\n\n    if (offset > 0) {\n      this.buffer = this.buffer.slice(offset);\n    }\n\n    return { frames, config: configEmitted };\n  }\n\n  flush(): MP3Frame[] {\n    const { frames } = this.push(new Uint8Array(0));\n    const remainder = this.buffer;\n    this.buffer = new Uint8Array(0);\n    if (remainder.length) {\n      console.warn('[MP3FrameParser] Remaining unparsed bytes:', remainder.length);\n    }\n    return frames;\n  }\n\n  private appendToBuffer(chunk: Uint8Array): void {\n    if (chunk.length === 0) {\n      return;\n    }\n    const combined = new Uint8Array(this.buffer.length + chunk.length);\n    combined.set(this.buffer, 0);\n    combined.set(chunk, this.buffer.length);\n    this.buffer = combined;\n  }\n\n  private skipId3Headers(): void {\n    let offset = 0;\n    while (this.buffer.length - offset >= 10) {\n      if (\n        this.buffer[offset] === 0x49 &&\n        this.buffer[offset + 1] === 0x44 &&\n        this.buffer[offset + 2] === 0x33\n      ) {\n        const size = this.readSynchsafeInteger(this.buffer.subarray(offset + 6, offset + 10));\n        const total = size + 10;\n        if (offset + total <= this.buffer.length) {\n          offset += total;\n          continue;\n        }\n      }\n      break;\n    }\n    if (offset > 0) {\n      this.buffer = this.buffer.slice(offset);\n    }\n  }\n\n  private parseHeader(\n    buffer: Uint8Array,\n    offset: number\n  ): {\n    frameSize: number;\n    sampleRate: number;\n    channels: number;\n    bitrateKbps: number | null;\n    samplesPerFrame: number;\n  } | null {\n    if (offset + 3 >= buffer.length) {\n      return null;\n    }\n    if (buffer[offset] !== 0xff || ((buffer[offset + 1] ?? 0) & 0xe0) !== 0xe0) {\n      return null;\n    }\n\n    const versionBits = ((buffer[offset + 1] ?? 0) >> 3) & 0x03;\n    const layerBits = ((buffer[offset + 1] ?? 0) >> 1) & 0x03;\n    const bitrateIndex = ((buffer[offset + 2] ?? 0) >> 4) & 0x0f;\n    const sampleRateIndex = ((buffer[offset + 2] ?? 0) >> 2) & 0x03;\n    const paddingBit = ((buffer[offset + 2] ?? 0) >> 1) & 0x01;\n    const channelMode = ((buffer[offset + 3] ?? 0) >> 6) & 0x03;\n\n    const version = this.getVersion(versionBits);\n    const layer = this.getLayer(layerBits);\n    if (!version || !layer) {\n      return null;\n    }\n\n    const sampleRate = SAMPLE_RATE_TABLE[version]?.[sampleRateIndex] ?? null;\n    if (!sampleRate) {\n      return null;\n    }\n\n    const bitrateKey = `${version === 1 ? 1 : 2}-${layer}`;\n    const bitrateKbps = BITRATE_TABLE[bitrateKey]?.[bitrateIndex] ?? null;\n    if (bitrateKbps === null) {\n      return null;\n    }\n\n    const samplesPerFrame = this.getSamplesPerFrame(version, layer);\n    const frameSize = this.calculateFrameSize(layer, bitrateKbps, sampleRate, paddingBit);\n    if (!frameSize || frameSize < 24) {\n      return null;\n    }\n\n    const channels = channelMode === 3 ? 1 : 2;\n\n    return {\n      frameSize,\n      sampleRate,\n      channels,\n      bitrateKbps: bitrateKbps || null,\n      samplesPerFrame,\n    };\n  }\n\n  private getVersion(bits: number): 1 | 2 | 2.5 | null {\n    switch (bits) {\n      case 0b11:\n        return 1;\n      case 0b10:\n        return 2;\n      case 0b00:\n        return 2.5;\n      default:\n        return null;\n    }\n  }\n\n  private getLayer(bits: number): 1 | 2 | 3 | null {\n    switch (bits) {\n      case 0b11:\n        return 1;\n      case 0b10:\n        return 2;\n      case 0b01:\n        return 3;\n      default:\n        return null;\n    }\n  }\n\n  private getSamplesPerFrame(version: 1 | 2 | 2.5, layer: 1 | 2 | 3): number {\n    if (layer === 1) {\n      return 384;\n    }\n    if (layer === 2) {\n      return 1152;\n    }\n    return version === 1 ? 1152 : 576;\n  }\n\n  private calculateFrameSize(\n    layer: 1 | 2 | 3,\n    bitrateKbps: number,\n    sampleRate: number,\n    padding: number\n  ): number {\n    if (bitrateKbps <= 0) {\n      return 0;\n    }\n\n    if (layer === 1) {\n      return ((12 * bitrateKbps * 1000) / sampleRate + padding) * 4;\n    }\n\n    return Math.floor((144 * bitrateKbps * 1000) / sampleRate + padding);\n  }\n\n  private readSynchsafeInteger(bytes: Uint8Array): number {\n    if (bytes.length !== 4) {\n      return 0;\n    }\n    return (\n      (((bytes[0] ?? 0) & 0x7f) << 21) |\n      (((bytes[1] ?? 0) & 0x7f) << 14) |\n      (((bytes[2] ?? 0) & 0x7f) << 7) |\n      ((bytes[3] ?? 0) & 0x7f)\n    );\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/stages/demux/MP4Demuxer.d.ts

@@ -0,0 +1,45 @@
+import { DemuxConfig, TrackInfo } from './types';
+
+/**
+ * MP4 Demuxer - Extract encoded chunks from MP4 container
+ * Simplified implementation following Stream API pattern
+ */
+export declare class MP4Demuxer {
+    private mp4boxFile;
+    tracks: Map<number, TrackInfo>;
+    isReady: boolean;
+    private videoController?;
+    private audioController?;
+    private backpressureMonitor;
+    private demuxHighWaterMark;
+    private onReadyCallback?;
+    private fileOffset;
+    constructor(config?: DemuxConfig & {
+        onReady?: () => void;
+    });
+    updateConfig(config: DemuxConfig): void;
+    private setupHandlers;
+    private processTracks;
+    private processSamples;
+    private getVideoDescription;
+    private getAudioDescription;
+    /**
+     * Create transform stream for video track
+     */
+    createVideoStream(): TransformStream<Uint8Array, EncodedVideoChunk>;
+    /**
+     * Create transform stream for audio track
+     */
+    createAudioStream(): TransformStream<Uint8Array, EncodedAudioChunk> | null;
+    appendBuffer(chunk: Uint8Array): void;
+    /**
+     * Get video track info if available
+     */
+    get videoTrackInfo(): TrackInfo | undefined;
+    /**
+     * Get audio track info if available
+     */
+    get audioTrackInfo(): TrackInfo | undefined;
+    destroy(): void;
+}
+//# sourceMappingURL=MP4Demuxer.d.ts.map

package/dist/stages/demux/MP4Demuxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MP4Demuxer.d.ts","sourceRoot":"","sources":["../../../src/stages/demux/MP4Demuxer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGtD;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAM;IACxB,MAAM,yBAAgC;IACtC,OAAO,UAAS;IAChB,OAAO,CAAC,eAAe,CAAC,CAAsD;IAC9E,OAAO,CAAC,eAAe,CAAC,CAAsD;IAC9E,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,UAAU,CAAK;gBAEX,MAAM,GAAE,WAAW,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;KAAO;IAY/D,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAIvC,OAAO,CAAC,aAAa;IA2BrB,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,mBAAmB;IA0B3B,OAAO,CAAC,mBAAmB;IAgB3B;;OAEG;IACH,iBAAiB,IAAI,eAAe,CAAC,UAAU,EAAE,iBAAiB,CAAC;IAuCnE;;OAEG;IACH,iBAAiB,IAAI,eAAe,CAAC,UAAU,EAAE,iBAAiB,CAAC,GAAG,IAAI;IAkC1E,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAOrC;;OAEG;IACH,IAAI,cAAc,IAAI,SAAS,GAAG,SAAS,CAE1C;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,SAAS,GAAG,SAAS,CAE1C;IAED,OAAO,IAAI,IAAI;CAOhB"}

package/dist/stages/demux/MP4Demuxer.js

@@ -0,0 +1,227 @@
+import "../../node_modules/.pnpm/mp4box@0.5.4/node_modules/mp4box/dist/mp4box.all.js";
+import { BackpressureMonitor } from "../../plugins/BackpressureMonitor.js";
+import { __exports as mp4box_all } from "../../_virtual/mp4box.all.js";
+class MP4Demuxer {
+  mp4boxFile;
+  tracks = /* @__PURE__ */ new Map();
+  isReady = false;
+  videoController;
+  audioController;
+  backpressureMonitor;
+  demuxHighWaterMark;
+  onReadyCallback;
+  fileOffset = 0;
+  constructor(config = {}) {
+    this.mp4boxFile = mp4box_all.createFile();
+    this.backpressureMonitor = new BackpressureMonitor();
+    this.onReadyCallback = config.onReady;
+    const DEFAULT_HIGH_WATER_MARK = 10;
+    this.demuxHighWaterMark = config.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;
+    this.setupHandlers();
+  }
+  updateConfig(config) {
+    this.demuxHighWaterMark = config.highWaterMark ?? this.demuxHighWaterMark;
+  }
+  setupHandlers() {
+    this.mp4boxFile.onError = (error) => {
+      console.error("MP4Box error:", error);
+      this.videoController?.error(new Error(error));
+      this.audioController?.error(new Error(error));
+    };
+    this.mp4boxFile.onReady = (info) => {
+      this.processTracks(info.tracks);
+      this.isReady = true;
+      if (this.onReadyCallback) {
+        this.onReadyCallback();
+      }
+      this.mp4boxFile.start();
+    };
+    this.mp4boxFile.onSamples = (trackId, _user, samples) => {
+      this.processSamples(trackId, samples);
+    };
+  }
+  processTracks(tracks) {
+    for (const track of tracks) {
+      const trackInfo = {
+        id: track.id,
+        type: track.type === "video" ? "video" : "audio",
+        codec: track.codec,
+        timescale: track.timescale
+      };
+      if (track.type === "video") {
+        trackInfo.width = track.video?.width;
+        trackInfo.height = track.video?.height;
+        trackInfo.description = this.getVideoDescription(track);
+      } else if (track.type === "audio") {
+        trackInfo.sampleRate = track.audio?.sample_rate;
+        trackInfo.numberOfChannels = track.audio?.channel_count;
+        trackInfo.description = this.getAudioDescription(track);
+      }
+      this.tracks.set(track.id, trackInfo);
+      this.mp4boxFile.setExtractionOptions(track.id, track, {
+        nbSamples: 30
+        // Batch size per callback (balance between latency and overhead)
+      });
+    }
+  }
+  processSamples(trackId, samples) {
+    const track = this.tracks.get(trackId);
+    if (!track) return;
+    const timescale = track.timescale || 9e4;
+    for (const sample of samples) {
+      const timestamp = sample.cts * 1e6 / timescale;
+      const duration = sample.duration * 1e6 / timescale;
+      if (track.type === "video") {
+        if (!this.videoController) {
+          console.error("[MP4Demuxer] videoController is null when trying to output chunk!");
+          return;
+        }
+        const chunk = new EncodedVideoChunk({
+          type: sample.is_sync ? "key" : "delta",
+          timestamp,
+          duration,
+          data: sample.data
+        });
+        this.videoController.enqueue(chunk);
+      } else if (track.type === "audio" && this.audioController) {
+        const chunk = new EncodedAudioChunk({
+          type: "key",
+          timestamp,
+          duration,
+          data: sample.data
+        });
+        this.audioController.enqueue(chunk);
+      }
+    }
+    const last = samples[samples.length - 1].number;
+    this.mp4boxFile.releaseUsedSamples(trackId, last + 1);
+  }
+  getVideoDescription(track) {
+    try {
+      const fullTrack = this.mp4boxFile.getTrackById(track.id);
+      for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {
+        const box = entry.avcC ?? entry.hvcC ?? entry.av1C ?? entry.vpcC;
+        if (box) {
+          const stream = new mp4box_all.DataStream(
+            void 0,
+            0,
+            mp4box_all.DataStream.BIG_ENDIAN
+            // IMPORTANT: must be BIG_ENDIAN
+          );
+          box.write(stream);
+          return new Uint8Array(stream.buffer.slice(8)).buffer;
+        }
+      }
+    } catch (error) {
+      console.error("Failed to get video description:", error);
+    }
+    return void 0;
+  }
+  // private getVideoDescription(track: any): ArrayBuffer | undefined {
+  //   if (!this.mp4boxFile) return undefined;
+  //   return getVideoDescription(this.mp4boxFile, track);
+  // }
+  getAudioDescription(track) {
+    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);
+          return new Uint8Array(stream.buffer.slice(8)).buffer;
+        }
+      }
+    } catch (error) {
+      console.error("Failed to get audio description:", error);
+    }
+    return void 0;
+  }
+  /**
+   * Create transform stream for video track
+   */
+  createVideoStream() {
+    return new TransformStream(
+      {
+        start: (controller) => {
+          this.videoController = controller;
+        },
+        transform: (chunk, controller) => {
+          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;
+          this.backpressureMonitor.updateMetrics("demux-video", desiredSize);
+          const chunkData = new Uint8Array(chunk);
+          this.appendBuffer(chunkData);
+          this.mp4boxFile.flush();
+        },
+        flush: async () => {
+          this.mp4boxFile.flush();
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          console.log("[MP4Demuxer] Video stream flush complete");
+        }
+      },
+      // Queuing strategy: use configuration
+      {
+        highWaterMark: this.demuxHighWaterMark,
+        size: () => 1
+        // Count-based
+      }
+    );
+  }
+  /**
+   * Create transform stream for audio track
+   */
+  createAudioStream() {
+    const hasAudio = Array.from(this.tracks.values()).some((t) => t.type === "audio");
+    if (!hasAudio) return null;
+    return new TransformStream(
+      {
+        start: (controller) => {
+          this.audioController = controller;
+        },
+        transform: (chunk, controller) => {
+          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;
+          this.backpressureMonitor.updateMetrics("demux-audio", desiredSize);
+          const chunkData = new Uint8Array(chunk);
+          this.appendBuffer(chunkData);
+          this.mp4boxFile.flush();
+        },
+        flush: () => {
+          this.mp4boxFile.flush();
+        }
+      },
+      // Queuing strategy: use configuration
+      {
+        highWaterMark: this.demuxHighWaterMark,
+        size: () => 1
+      }
+    );
+  }
+  appendBuffer(chunk) {
+    const buffer = chunk.buffer;
+    buffer.fileStart = this.fileOffset;
+    this.mp4boxFile.appendBuffer(buffer);
+    this.fileOffset += chunk.byteLength;
+  }
+  /**
+   * Get video track info if available
+   */
+  get videoTrackInfo() {
+    return Array.from(this.tracks.values()).find((track) => track.type === "video");
+  }
+  /**
+   * Get audio track info if available
+   */
+  get audioTrackInfo() {
+    return Array.from(this.tracks.values()).find((track) => track.type === "audio");
+  }
+  destroy() {
+    this.mp4boxFile?.stop();
+    this.mp4boxFile = null;
+    this.tracks.clear();
+    this.backpressureMonitor.clear();
+    this.isReady = false;
+  }
+}
+export {
+  MP4Demuxer
+};
+//# sourceMappingURL=MP4Demuxer.js.map

package/dist/stages/demux/MP4Demuxer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MP4Demuxer.js","sources":["../../../src/stages/demux/MP4Demuxer.ts"],"sourcesContent":["import * as MP4Box from 'mp4box';\nimport type { DemuxConfig, TrackInfo } from './types';\nimport { BackpressureMonitor } from '../../plugins/BackpressureMonitor';\n\n/**\n * MP4 Demuxer - Extract encoded chunks from MP4 container\n * Simplified implementation following Stream API pattern\n */\nexport class MP4Demuxer {\n  private mp4boxFile: any;\n  tracks = new Map<number, TrackInfo>();\n  isReady = false;\n  private videoController?: TransformStreamDefaultController<EncodedVideoChunk>;\n  private audioController?: TransformStreamDefaultController<EncodedAudioChunk>;\n  private backpressureMonitor: BackpressureMonitor;\n  private demuxHighWaterMark: number;\n  private onReadyCallback?: () => void;\n  private fileOffset = 0;\n\n  constructor(config: DemuxConfig & { onReady?: () => void } = {}) {\n    this.mp4boxFile = MP4Box.createFile();\n    this.backpressureMonitor = new BackpressureMonitor();\n    this.onReadyCallback = config.onReady;\n\n    // Use provided config with local default as fallback\n    const DEFAULT_HIGH_WATER_MARK = 10; // Default for video chunks\n    this.demuxHighWaterMark = config.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;\n\n    this.setupHandlers();\n  }\n\n  updateConfig(config: DemuxConfig): void {\n    this.demuxHighWaterMark = config.highWaterMark ?? this.demuxHighWaterMark;\n  }\n\n  private setupHandlers(): void {\n    this.mp4boxFile.onError = (error: string) => {\n      console.error('MP4Box error:', error);\n      this.videoController?.error(new Error(error));\n      this.audioController?.error(new Error(error));\n    };\n\n    this.mp4boxFile.onReady = (info: any) => {\n      this.processTracks(info.tracks);\n      this.isReady = true;\n\n      // Call the ready callback before starting\n      if (this.onReadyCallback) {\n        this.onReadyCallback();\n      }\n\n      // Start processing samples after callback\n      // Note: start() enables extraction, actual samples will be output\n      // when flush() is called (by TransformStream's flush callback)\n      this.mp4boxFile.start();\n    };\n\n    this.mp4boxFile.onSamples = (trackId: number, _user: any, samples: any[]) => {\n      this.processSamples(trackId, samples);\n    };\n  }\n\n  private processTracks(tracks: any[]): void {\n    for (const track of tracks) {\n      const trackInfo: TrackInfo = {\n        id: track.id,\n        type: track.type === 'video' ? 'video' : 'audio',\n        codec: track.codec,\n        timescale: track.timescale,\n      };\n\n      if (track.type === 'video') {\n        trackInfo.width = track.video?.width;\n        trackInfo.height = track.video?.height;\n        trackInfo.description = this.getVideoDescription(track);\n      } else if (track.type === 'audio') {\n        trackInfo.sampleRate = track.audio?.sample_rate;\n        trackInfo.numberOfChannels = track.audio?.channel_count;\n        trackInfo.description = this.getAudioDescription(track);\n      }\n\n      this.tracks.set(track.id, trackInfo);\n\n      // Configure extraction\n      this.mp4boxFile.setExtractionOptions(track.id, track, {\n        nbSamples: 30, // Batch size per callback (balance between latency and overhead)\n      });\n    }\n  }\n\n  private processSamples(trackId: number, samples: any[]): void {\n    const track = this.tracks.get(trackId);\n    if (!track) return;\n\n    const timescale = track.timescale || 90000;\n    for (const sample of samples) {\n      const timestamp = (sample.cts * 1000000) / timescale;\n      const duration = (sample.duration * 1000000) / timescale;\n\n      if (track.type === 'video') {\n        if (!this.videoController) {\n          console.error('[MP4Demuxer] videoController is null when trying to output chunk!');\n          // Should not happen - stream should be created before appendBuffer\n          return;\n        }\n\n        const chunk = new EncodedVideoChunk({\n          type: sample.is_sync ? 'key' : 'delta',\n          timestamp,\n          duration,\n          data: sample.data,\n        });\n        this.videoController.enqueue(chunk);\n      } else if (track.type === 'audio' && this.audioController) {\n        const chunk = new EncodedAudioChunk({\n          type: 'key',\n          timestamp,\n          duration,\n          data: sample.data,\n        });\n        this.audioController.enqueue(chunk);\n      }\n    }\n\n    const last = samples[samples.length - 1].number;\n    // Release memory immediately\n    this.mp4boxFile.releaseUsedSamples(trackId, last + 1);\n  }\n\n  private getVideoDescription(track: any): ArrayBuffer | undefined {\n    try {\n      const fullTrack = this.mp4boxFile.getTrackById(track.id);\n      for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {\n        const box = entry.avcC ?? entry.hvcC ?? entry.av1C ?? entry.vpcC;\n        if (box) {\n          const stream = new (MP4Box as any).DataStream(\n            undefined,\n            0,\n            (MP4Box as any).DataStream.BIG_ENDIAN // IMPORTANT: must be BIG_ENDIAN\n          );\n          box.write(stream);\n          return new Uint8Array(stream.buffer.slice(8)).buffer;\n        }\n      }\n    } catch (error) {\n      console.error('Failed to get video description:', error);\n    }\n    return undefined;\n  }\n\n  // private getVideoDescription(track: any): ArrayBuffer | undefined {\n  //   if (!this.mp4boxFile) return undefined;\n  //   return getVideoDescription(this.mp4boxFile, track);\n  // }\n\n  private getAudioDescription(track: any): ArrayBuffer | undefined {\n    try {\n      const fullTrack = this.mp4boxFile.getTrackById(track.id);\n      for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {\n        if (entry.esds || entry.dOps) {\n          const stream = new (MP4Box as any).DataStream();\n          (entry.esds || entry.dOps).write(stream);\n          return new Uint8Array(stream.buffer.slice(8)).buffer;\n        }\n      }\n    } catch (error) {\n      console.error('Failed to get audio description:', error);\n    }\n    return undefined;\n  }\n\n  /**\n   * Create transform stream for video track\n   */\n  createVideoStream(): TransformStream<Uint8Array, EncodedVideoChunk> {\n    // const hasVideo = Array.from(this.tracks.values()).some((t) => t.type === 'video');\n    return new TransformStream<Uint8Array, EncodedVideoChunk>(\n      {\n        start: (controller) => {\n          this.videoController = controller;\n        },\n        transform: (chunk, controller) => {\n          // Update backpressure metrics\n          // desiredSize can be null, negative (backpressure), or positive\n          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;\n          this.backpressureMonitor.updateMetrics('demux-video', desiredSize);\n\n          // Create a copy to avoid buffer reuse issues (required for mp4box 0.5.x)\n          const chunkData = new Uint8Array(chunk);\n          this.appendBuffer(chunkData);\n\n          // Flush after each append to trigger sample extraction immediately\n          this.mp4boxFile.flush();\n        },\n        flush: async () => {\n          // Trigger MP4Box flush\n          this.mp4boxFile.flush();\n\n          // Wait for MP4Box to complete sample extraction (onSamples callbacks)\n          // Give MP4Box time to process asynchronously\n          await new Promise((resolve) => setTimeout(resolve, 100));\n\n          console.log('[MP4Demuxer] Video stream flush complete');\n        },\n      },\n      // Queuing strategy: use configuration\n      {\n        highWaterMark: this.demuxHighWaterMark,\n        size: () => 1, // Count-based\n      }\n    );\n  }\n\n  /**\n   * Create transform stream for audio track\n   */\n  createAudioStream(): TransformStream<Uint8Array, EncodedAudioChunk> | null {\n    const hasAudio = Array.from(this.tracks.values()).some((t) => t.type === 'audio');\n    if (!hasAudio) return null;\n\n    return new TransformStream<Uint8Array, EncodedAudioChunk>(\n      {\n        start: (controller) => {\n          this.audioController = controller;\n        },\n        transform: (chunk, controller) => {\n          // Update backpressure metrics\n          // desiredSize can be null, negative (backpressure), or positive\n          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;\n          this.backpressureMonitor.updateMetrics('demux-audio', desiredSize);\n\n          // Create a copy to avoid buffer reuse issues (required for mp4box 0.5.x)\n          const chunkData = new Uint8Array(chunk);\n          this.appendBuffer(chunkData);\n\n          // Flush after each append to trigger sample extraction immediately\n          this.mp4boxFile.flush();\n        },\n        flush: () => {\n          this.mp4boxFile.flush();\n        },\n      },\n      // Queuing strategy: use configuration\n      {\n        highWaterMark: this.demuxHighWaterMark,\n        size: () => 1,\n      }\n    );\n  }\n\n  appendBuffer(chunk: Uint8Array): void {\n    const buffer = chunk.buffer as ArrayBuffer & { fileStart: number };\n    buffer.fileStart = this.fileOffset;\n    this.mp4boxFile.appendBuffer(buffer);\n    this.fileOffset += chunk.byteLength;\n  }\n\n  /**\n   * Get video track info if available\n   */\n  get videoTrackInfo(): TrackInfo | undefined {\n    return Array.from(this.tracks.values()).find((track) => track.type === 'video');\n  }\n\n  /**\n   * Get audio track info if available\n   */\n  get audioTrackInfo(): TrackInfo | undefined {\n    return Array.from(this.tracks.values()).find((track) => track.type === 'audio');\n  }\n\n  destroy(): void {\n    this.mp4boxFile?.stop();\n    this.mp4boxFile = null;\n    this.tracks.clear();\n    this.backpressureMonitor.clear();\n    this.isReady = false;\n  }\n}\n"],"names":["MP4Box.createFile","MP4Box.DataStream"],"mappings":"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"}

package/dist/stages/demux/aac-esds-extractor.d.ts

@@ -0,0 +1,7 @@
+interface AacEsdsExtractionResult {
+    codecId?: string;
+    description: ArrayBuffer;
+}
+export declare const extractAacEsdsFromFmp4: (initSegment?: ArrayBuffer) => AacEsdsExtractionResult | undefined;
+export {};
+//# sourceMappingURL=aac-esds-extractor.d.ts.map

package/dist/stages/demux/aac-esds-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aac-esds-extractor.d.ts","sourceRoot":"","sources":["../../../src/stages/demux/aac-esds-extractor.ts"],"names":[],"mappings":"AAEA,UAAU,uBAAuB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,eAAO,MAAM,sBAAsB,GACjC,cAAc,WAAW,KACxB,uBAAuB,GAAG,SAqD5B,CAAC"}

package/dist/stages/demux/audio-demux.worker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * AudioDemuxWorker - First stage for audio processing
+ * Extracts audio tracks from various container formats (MP3, MP4/M4A, etc.)
+ *
+ * Pipeline: ResourceLoader (Main Thread) → AudioDemuxWorker → DecodeWorker
+ *
+ * Features:
+ * - Multi-format support (MP3, AAC in MP4/M4A)
+ * - Stream-based processing with backpressure
+ * - Direct streaming to DecodeWorker
+ */
+export declare class AudioDemuxWorker {
+    private channel;
+    private demuxer;
+    private audioStream;
+    private mp3Parser;
+    private currentFormat;
+    private decoderPort;
+    constructor();
+    private setupHandlers;
+    /**
+     * Unified connect handler used by stream pipeline
+     */
+    private handleConnect;
+    /**
+     * Configure demuxer with format settings
+     * @param payload.config - Demuxer configuration
+     * @param payload.initial - If true, initialize worker state; otherwise just update config
+     */
+    private handleConfigure;
+    /**
+     * Detect audio format from configuration
+     */
+    private detectFormat;
+    /**
+     * Handle input stream from ResourceLoader (main thread)
+     */
+    private handleInputStream;
+    private pipeMp3Stream;
+    /**
+     * Get demuxer statistics
+     */
+    private handleGetStats;
+    /**
+     * Dispose worker and cleanup resources
+     */
+    private handleDispose;
+}
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=audio-demux.worker.d.ts.map

package/dist/stages/demux/audio-demux.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-demux.worker.d.ts","sourceRoot":"","sources":["../../../src/stages/demux/audio-demux.worker.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,WAAW,CAA+D;IAClF,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,aAAa,CAA8B;IAGnD,OAAO,CAAC,WAAW,CAA4B;;IAY/C,OAAO,CAAC,aAAa;IAarB;;OAEG;YACW,aAAa;IAU3B;;;;OAIG;YACW,eAAe;IAuF7B;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;YACW,iBAAiB;YAkDjB,aAAa;IAiI3B;;OAEG;YACW,cAAc;IAyB5B;;OAEG;YACW,aAAa;CAgB5B;;AAUD,wBAAoB"}