webcodecs-utils 0.2.4 → 0.2.6

package/README.md

@@ -10,6 +10,8 @@ npm install webcodecs-utils
 
 ## Quick Start
 
+### Individual Utilities
+
 ```typescript
 import { getBitrate, GPUFrameRenderer, extractChannels, MP4Demuxer } from 'webcodecs-utils';
 
@@ -37,6 +39,35 @@ await demuxer.load();
 const videoChunks = await demuxer.extractSegment('video', 0, 10);
 ```
 
+### Streaming Pipeline
+
+```typescript
+import {
+  SimpleDemuxer,
+  VideoDecodeStream,
+  VideoProcessStream,
+  VideoEncodeStream,
+  SimpleMuxer
+} from 'webcodecs-utils';
+
+// Build a composable streaming pipeline with automatic backpressure
+const demuxer = new SimpleDemuxer(file);
+await demuxer.load();
+
+const muxer = new SimpleMuxer({ video: 'avc' });
+
+await demuxer.videoStream()
+  .pipeThrough(new VideoDecodeStream(await demuxer.getVideoDecoderConfig()))
+  .pipeThrough(new VideoProcessStream(async (frame) => {
+    // Custom processing: upscaling, filters, etc.
+    return frame;
+  }))
+  .pipeThrough(new VideoEncodeStream(encoderConfig))
+  .pipeTo(muxer.videoSink());
+
+const blob = await muxer.finalize();
+```
+
 ## Utilities
 
 ### Video
@@ -197,6 +228,117 @@ console.log(`Video: ${videoTrack.codec}, ${videoTrack.codedWidth}x${videoTrack.c
 const videoChunks = await demuxer.extractSegment('video', 0, 10);
 ```
 
+### Streaming Pipelines
+
+Build production-ready video processing pipelines using the Streams API with automatic backpressure management.
+
+- 📄 [Documentation](./src/streams/README.md)
+- 🎮 [Transcode Demo](./demos/transcode-pipeline.html)
+- 🎮 [AI Upscaling Demo](./demos/upscale-pipeline.html)
+
+#### **VideoDecodeStream**
+TransformStream that decodes EncodedVideoChunks into VideoFrames with automatic backpressure.
+
+```typescript
+class VideoDecodeStream extends TransformStream<EncodedVideoChunk, VideoFrame> {
+  constructor(
+    config: VideoDecoderConfig,
+    options?: {
+      highWaterMark?: number;        // default: 10
+      maxDecodeQueueSize?: number;   // default: 20
+    }
+  )
+}
+```
+
+#### **VideoEncodeStream**
+TransformStream that encodes VideoFrames into EncodedVideoChunks with automatic backpressure.
+
+```typescript
+class VideoEncodeStream extends TransformStream<
+  VideoFrame,
+  { chunk: EncodedVideoChunk; meta?: EncodedVideoChunkMetadata }
+> {
+  constructor(
+    config: VideoEncoderConfig,
+    options?: {
+      highWaterMark?: number;        // default: 10
+      maxEncodeQueueSize?: number;   // default: 20
+      keyFrameInterval?: number;     // default: 60
+    }
+  )
+}
+```
+
+#### **VideoProcessStream**
+TransformStream that applies a custom processing function to each VideoFrame.
+
+```typescript
+class VideoProcessStream extends TransformStream<VideoFrame, VideoFrame> {
+  constructor(
+    transformFn: (frame: VideoFrame) => Promise<VideoFrame> | VideoFrame,
+    options?: {
+      highWaterMark?: number;  // default: 5
+    }
+  )
+}
+```
+
+**Example - AI Upscaling:**
+```typescript
+import WebSR from '@websr/websr';
+
+const websr = new WebSR({ resolution, network, weights, gpu, canvas });
+
+const upscaleStream = new VideoProcessStream(async (frame) => {
+  await websr.render(frame);  // AI upscaling with WebGPU
+  return new VideoFrame(canvas, {
+    timestamp: frame.timestamp,
+    duration: frame.duration
+  });
+});
+
+// Use in pipeline
+await videoStream
+  .pipeThrough(new VideoDecodeStream(config))
+  .pipeThrough(upscaleStream)
+  .pipeThrough(new VideoEncodeStream(config))
+  .pipeTo(muxer.videoSink());
+```
+
+#### **SimpleDemuxer** ⚠️ Demo/Learning Only
+Simple wrapper around web-demuxer for easier usage in demos. For production, use [web-demuxer](https://github.com/bilibili/web-demuxer) or [MediaBunny](https://mediabunny.dev/) directly.
+
+```typescript
+class SimpleDemuxer {
+  constructor(file: File, options?: { wasmFilePath?: string })
+
+  async load(): Promise<void>
+  videoStream(startTime?: number): ReadableStream<EncodedVideoChunk>
+  audioStream(startTime?: number): ReadableStream<EncodedAudioChunk>
+  async getVideoDecoderConfig(): Promise<VideoDecoderConfig>
+  async getAudioDecoderConfig(): Promise<AudioDecoderConfig>
+  async getSegment(type: 'video' | 'audio', start: number, end: number): Promise<EncodedVideoChunk[] | EncodedAudioChunk[]>
+  async getMediaInfo(): Promise<MediaInfo>
+}
+```
+
+#### **SimpleMuxer** ⚠️ Demo/Learning Only
+Simple wrapper around MediaBunny's Output for easier muxing in demos. For production, use [MediaBunny](https://mediabunny.dev/) directly.
+
+```typescript
+class SimpleMuxer {
+  constructor(config: {
+    video?: 'avc' | 'hevc' | 'vp8' | 'vp9' | 'av1';
+    audio?: 'aac' | 'opus' | 'mp3' | 'vorbis' | 'flac';
+  })
+
+  videoSink(): WritableStream<{ chunk: EncodedVideoChunk; meta?: EncodedVideoChunkMetadata }>
+  audioSink(): WritableStream<EncodedAudioChunk>
+  async finalize(): Promise<Blob>
+}
+```
+
 ## Browser Support
 
 These utilities require:

package/dist/audio/extract-channels.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Extract audio channels from AudioData as separate Float32Array buffers.
+ *
+ * AudioData can store samples in two formats:
+ * - **Planar (f32-planar)**: Each channel is stored separately (most common)
+ * - **Interleaved (f32)**: All channels are mixed together (L, R, L, R, L, R...)
+ *
+ * This function handles both formats automatically and returns an array of Float32Array,
+ * where each array represents one channel (typically [left, right] for stereo).
+ *
+ * @param audioData - The AudioData object to extract channels from
+ * @returns Array of Float32Array, one per channel (e.g., [leftChannel, rightChannel])
+ *
+ * @example
+ * ```typescript
+ * // Extract channels from decoded audio
+ * const decoder = new AudioDecoder({
+ *   output: (audioData) => {
+ *     const channels = extractChannels(audioData);
+ *     const leftChannel = channels[0];
+ *     const rightChannel = channels[1]; // if stereo
+ *
+ *     // Process audio samples...
+ *     for (let i = 0; i < leftChannel.length; i++) {
+ *       leftChannel[i] *= 0.5; // Reduce volume by 50%
+ *     }
+ *   },
+ *   error: (e) => console.error(e)
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Mix two audio sources
+ * const source1Channels = extractChannels(audioData1);
+ * const source2Channels = extractChannels(audioData2);
+ *
+ * const mixedLeft = new Float32Array(source1Channels[0].length);
+ * for (let i = 0; i < mixedLeft.length; i++) {
+ *   mixedLeft[i] = source1Channels[0][i] + source2Channels[0][i];
+ * }
+ * ```
+ */
+export declare function extractChannels(audioData: AudioData): Float32Array[];
+//# sourceMappingURL=extract-channels.d.ts.map

package/dist/audio/extract-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-channels.d.ts","sourceRoot":"","sources":["../../src/audio/extract-channels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,YAAY,EAAE,CA8BpE"}

package/dist/audio/extract-channels.js

@@ -0,0 +1,25 @@
+function c(e) {
+  var s;
+  const l = [];
+  if ((s = e.format) != null && s.includes("planar"))
+    for (let n = 0; n < e.numberOfChannels; n++) {
+      const r = new Float32Array(e.numberOfFrames);
+      e.copyTo(r, { frameOffset: 0, planeIndex: n }), l.push(r);
+    }
+  else {
+    const n = new Float32Array(
+      e.numberOfFrames * e.numberOfChannels
+    );
+    e.copyTo(n, { frameOffset: 0, planeIndex: 0 });
+    for (let r = 0; r < e.numberOfChannels; r++) {
+      const m = new Float32Array(e.numberOfFrames);
+      for (let f = 0; f < e.numberOfFrames; f++)
+        m[f] = n[f * e.numberOfChannels + r];
+      l.push(m);
+    }
+  }
+  return l;
+}
+export {
+  c as extractChannels
+};

package/dist/audio/get-sample-rate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Get the actual sample rate from an audio MediaStreamTrack.
+ *
+ * Firefox doesn't always expose sampleRate in track.getSettings(), so this
+ * function creates a temporary AudioContext to determine the actual sample rate.
+ *
+ * @param track - The audio MediaStreamTrack to get the sample rate from
+ * @returns The actual sample rate in Hz
+ *
+ * @example
+ * ```typescript
+ * const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+ * const audioTrack = stream.getAudioTracks()[0];
+ * const sampleRate = await getSampleRate(audioTrack);
+ * console.log(`Sample rate: ${sampleRate} Hz`);
+ * ```
+ */
+export declare function getSampleRate(track: MediaStreamTrack): Promise<number>;
+//# sourceMappingURL=get-sample-rate.d.ts.map

package/dist/audio/get-sample-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-sample-rate.d.ts","sourceRoot":"","sources":["../../src/audio/get-sample-rate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwB5E"}

package/dist/audio/get-sample-rate.js

@@ -0,0 +1,14 @@
+async function i(e) {
+  if (e.kind !== "audio")
+    throw new Error("Track must be an audio track");
+  const a = e.getSettings();
+  if (a.sampleRate)
+    return a.sampleRate;
+  const t = new AudioContext(), n = new MediaStreamAudioSourceNode(t, {
+    mediaStream: new MediaStream([e])
+  }), o = t.sampleRate;
+  return n.disconnect(), await t.close(), o;
+}
+export {
+  i as getSampleRate
+};

package/dist/audio/mp3.d.ts

@@ -0,0 +1,162 @@
+interface MP3EncoderConfig {
+    sampleRate: number;
+    bitRate: number;
+    channels: number;
+}
+/**
+ * Encode audio to MP3 format using LameJS.
+ *
+ * This encoder converts AudioData objects to MP3 format. It handles both
+ * planar (f32-planar) and interleaved (f32) audio formats automatically.
+ *
+ * @example
+ * ```typescript
+ * // Create encoder
+ * const encoder = new MP3Encoder({
+ *   sampleRate: 48000,
+ *   bitRate: 192,  // 192 kbps
+ *   channels: 2    // Stereo
+ * });
+ *
+ * // Encode AudioData objects
+ * for (const audioData of audioDataArray) {
+ *   const mp3Chunk = encoder.processBatch(audioData);
+ *   encoder.encodedData.push(mp3Chunk);
+ * }
+ *
+ * // Get final MP3 file
+ * const mp3Blob = encoder.finish();
+ * ```
+ *
+ * @remarks
+ * This encoder uses LameJS for encoding. For production use, consider using
+ * the native AudioEncoder API with opus codec, or a server-side encoder.
+ */
+declare class MP3Encoder {
+    private mp3encoder;
+    private config;
+    encodedData: Uint8Array[];
+    /**
+     * Create a new MP3Encoder.
+     *
+     * @param config - Encoder configuration
+     * @param config.sampleRate - Audio sample rate in Hz (e.g., 48000)
+     * @param config.bitRate - MP3 bitrate in kbps (e.g., 192)
+     * @param config.channels - Number of audio channels (1 = mono, 2 = stereo)
+     */
+    constructor(config: MP3EncoderConfig);
+    private convertAudioDataToInt16;
+    /**
+     * Encode a single AudioData object to MP3.
+     *
+     * @param audioData - The AudioData object to encode
+     * @returns Encoded MP3 data as Uint8Array (add this to encodedData array)
+     */
+    processBatch(audioData: AudioData): Uint8Array;
+    /**
+     * Finalize encoding and get the complete MP3 file as a Blob.
+     *
+     * This method flushes any remaining data and combines all encoded chunks
+     * into a single MP3 file blob.
+     *
+     * @returns Complete MP3 file as a Blob
+     */
+    finish(): Blob;
+    getEncodedSize(): number;
+}
+export interface MP3DecoderOutput {
+    channels: Float32Array[];
+    sampleRate: number;
+    numberOfChannels: number;
+}
+/**
+ * Decode MP3 files to raw PCM samples or AudioData objects.
+ *
+ * This decoder uses mpg123-decoder (WebAssembly) to decode MP3 files.
+ * It can output either raw Float32Array samples or AudioData objects
+ * ready for use with WebCodecs APIs.
+ *
+ * @example
+ * ```typescript
+ * // Decode to raw samples
+ * const decoder = new MP3Decoder();
+ * await decoder.initialize();
+ *
+ * const mp3Buffer = await file.arrayBuffer();
+ * const { channels, sampleRate, numberOfChannels } = await decoder.toSamples(mp3Buffer);
+ *
+ * // channels[0] = left channel (Float32Array)
+ * // channels[1] = right channel (Float32Array) if stereo
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Decode to AudioData objects
+ * const decoder = new MP3Decoder();
+ * await decoder.initialize();
+ *
+ * const mp3Buffer = await file.arrayBuffer();
+ * const audioDataArray = await decoder.toAudioData(mp3Buffer);
+ *
+ * // Use with AudioEncoder or other WebCodecs APIs
+ * for (const audioData of audioDataArray) {
+ *   encoder.encode(audioData);
+ *   audioData.close();
+ * }
+ *
+ * await decoder.destroy();
+ * ```
+ */
+declare class MP3Decoder {
+    private decoder;
+    private isReady;
+    /**
+     * Create a new MP3Decoder.
+     *
+     * The decoder auto-detects sample rate and channel configuration from the MP3 file.
+     * Call initialize() before using.
+     */
+    constructor();
+    /**
+     * Initialize the decoder (async)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Decode MP3 buffer to raw PCM samples
+     * @param mp3Buffer - The MP3 data as ArrayBuffer
+     * @returns Promise<{channels: Float32Array[], sampleRate: number, numberOfChannels: number}>
+     */
+    toSamples(mp3Buffer: ArrayBuffer): Promise<{
+        channels: Float32Array[];
+        sampleRate: number;
+        numberOfChannels: number;
+    }>;
+    /**
+     * Decode MP3 to AudioData objects.
+     * Internally calls decodeMP3ToSamples and converts the Float32Array channels to AudioData.
+     *
+     * @param mp3Buffer - The MP3 data as ArrayBuffer
+     * @returns Promise<AudioData[]> - Array of AudioData objects
+     *
+     * @example
+     * ```typescript
+     * const decoder = new MP3Decoder();
+     * await decoder.initialize();
+     * const mp3Buffer = await file.arrayBuffer();
+     * const audioDataArray = await decoder.decode(mp3Buffer);
+     *
+     * // Use with AudioEncoder or other WebCodecs APIs
+     * for (const audioData of audioDataArray) {
+     *   encoder.encode(audioData);
+     *   audioData.close();
+     * }
+     * ```
+     */
+    toAudioData(mp3Buffer: ArrayBuffer): Promise<AudioData[]>;
+    /**
+     * Clean up decoder resources
+     */
+    destroy(): Promise<void>;
+}
+export { MP3Encoder, MP3Decoder };
+//# sourceMappingURL=mp3.d.ts.map

package/dist/audio/mp3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mp3.d.ts","sourceRoot":"","sources":["../../src/audio/mp3.ts"],"names":[],"mappings":"AAmBA,UAAU,gBAAgB;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,cAAM,UAAU;IACZ,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,MAAM,CAAmB;IACjC,WAAW,EAAE,UAAU,EAAE,CAAC;IAE1B;;;;;;;OAOG;gBACS,MAAM,EAAE,gBAAgB;IAapC,OAAO,CAAC,uBAAuB;IAmB/B;;;;;OAKG;IACH,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU;IAwB9C;;;;;;;OAOG;IACH,MAAM,IAAI,IAAI;IAuBd,cAAc,IAAI,MAAM;CAG3B;AAED,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,cAAM,UAAU;IACZ,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAkB;IAEjC;;;;;OAKG;;IAKH;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;;;OAIG;IACG,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,OAAO,CAAC;QAC7C,QAAQ,EAAE,YAAY,EAAE,CAAC;QACzB,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAA;KAC3B,CAAC;IAmCF;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,WAAW,CAAC,SAAS,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAiD/D;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAOjC;AAED,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC"}

package/dist/audio/mp3.js

@@ -0,0 +1,173 @@
+import g from "lamejs";
+import w from "lamejs/src/js/MPEGMode";
+import D from "lamejs/src/js/Lame";
+import M from "lamejs/src/js/BitStream";
+import { MPEGDecoderWebWorker as b } from "mpg123-decoder";
+import { extractChannels as A } from "./extract-channels.js";
+globalThis.MPEGMode = w;
+globalThis.Lame = D;
+globalThis.BitStream = M;
+class E {
+  /**
+   * Create a new MP3Encoder.
+   *
+   * @param config - Encoder configuration
+   * @param config.sampleRate - Audio sample rate in Hz (e.g., 48000)
+   * @param config.bitRate - MP3 bitrate in kbps (e.g., 192)
+   * @param config.channels - Number of audio channels (1 = mono, 2 = stereo)
+   */
+  constructor(e) {
+    this.config = e, this.mp3encoder = new g.Mp3Encoder(
+      e.channels,
+      e.sampleRate,
+      e.bitRate
+    ), this.encodedData = [];
+  }
+  // Convert AudioData to interleaved Int16 samples
+  convertAudioDataToInt16(e) {
+    const t = e.numberOfChannels, a = e.numberOfFrames, r = A(e), o = new Int16Array(a * t);
+    for (let n = 0; n < a; n++)
+      for (let s = 0; s < t; s++) {
+        const i = Math.max(-1, Math.min(1, r[s][n]));
+        o[n * t + s] = i * 32767;
+      }
+    return o;
+  }
+  /**
+   * Encode a single AudioData object to MP3.
+   *
+   * @param audioData - The AudioData object to encode
+   * @returns Encoded MP3 data as Uint8Array (add this to encodedData array)
+   */
+  processBatch(e) {
+    const t = this.convertAudioDataToInt16(e);
+    let a;
+    if (this.config.channels === 2) {
+      const r = new Int16Array(t.length / 2), o = new Int16Array(t.length / 2);
+      for (let n = 0; n < t.length / 2; n++)
+        r[n] = t[n * 2], o[n] = t[n * 2 + 1];
+      a = this.mp3encoder.encodeBuffer(r, o);
+    } else
+      a = this.mp3encoder.encodeBuffer(t);
+    return a;
+  }
+  /**
+   * Finalize encoding and get the complete MP3 file as a Blob.
+   *
+   * This method flushes any remaining data and combines all encoded chunks
+   * into a single MP3 file blob.
+   *
+   * @returns Complete MP3 file as a Blob
+   */
+  finish() {
+    const e = this.mp3encoder.flush();
+    e.length > 0 && this.encodedData.push(e);
+    const t = this.encodedData.reduce((o, n) => o + n.length, 0), a = new Uint8Array(t);
+    let r = 0;
+    for (const o of this.encodedData)
+      a.set(o, r), r += o.length;
+    return this.encodedData = [], new Blob([a], { type: "audio/mp3" });
+  }
+  // Optional: Get current size of encoded data
+  getEncodedSize() {
+    return this.encodedData.reduce((e, t) => e + t.length, 0);
+  }
+}
+class I {
+  /**
+   * Create a new MP3Decoder.
+   *
+   * The decoder auto-detects sample rate and channel configuration from the MP3 file.
+   * Call initialize() before using.
+   */
+  constructor() {
+    this.isReady = !1;
+  }
+  /**
+   * Initialize the decoder (async)
+   */
+  async initialize() {
+    if (!this.isReady)
+      try {
+        this.decoder = new b(), await this.decoder.ready, this.isReady = !0;
+      } catch (e) {
+        throw console.error("Failed to initialize MP3 decoder:", e), e;
+      }
+  }
+  /**
+   * Decode MP3 buffer to raw PCM samples
+   * @param mp3Buffer - The MP3 data as ArrayBuffer
+   * @returns Promise<{channels: Float32Array[], sampleRate: number, numberOfChannels: number}>
+   */
+  async toSamples(e) {
+    this.isReady || await this.initialize();
+    try {
+      const t = await this.decoder.decode(new Uint8Array(e)), { channelData: a, sampleRate: r } = t, o = a.length;
+      return {
+        channels: a.map((s) => {
+          const i = new Float32Array(s.length);
+          for (let c = 0; c < s.length; c++)
+            i[c] = s[c];
+          return i;
+        }),
+        sampleRate: r,
+        numberOfChannels: o
+      };
+    } catch (t) {
+      throw console.error("Failed to decode MP3:", t), t;
+    }
+  }
+  /**
+   * Decode MP3 to AudioData objects.
+   * Internally calls decodeMP3ToSamples and converts the Float32Array channels to AudioData.
+   *
+   * @param mp3Buffer - The MP3 data as ArrayBuffer
+   * @returns Promise<AudioData[]> - Array of AudioData objects
+   *
+   * @example
+   * ```typescript
+   * const decoder = new MP3Decoder();
+   * await decoder.initialize();
+   * const mp3Buffer = await file.arrayBuffer();
+   * const audioDataArray = await decoder.decode(mp3Buffer);
+   *
+   * // Use with AudioEncoder or other WebCodecs APIs
+   * for (const audioData of audioDataArray) {
+   *   encoder.encode(audioData);
+   *   audioData.close();
+   * }
+   * ```
+   */
+  async toAudioData(e) {
+    const { channels: t, sampleRate: a, numberOfChannels: r } = await this.toSamples(e), o = 1024, n = t[0].length, s = [];
+    console.log("Samples", n);
+    for (let i = 0; i < n; i += o) {
+      const c = n - i, h = Math.min(o, c), u = t.map(
+        (l) => l.slice(i, i + h)
+      ), m = new Float32Array(h * r);
+      for (let l = 0; l < h; l++)
+        for (let d = 0; d < r; d++)
+          m[l * r + d] = u[d][l];
+      const p = i / a * 1e6, y = new AudioData({
+        format: "f32",
+        sampleRate: a,
+        numberOfFrames: h,
+        numberOfChannels: r,
+        timestamp: Math.round(p),
+        data: m
+      });
+      s.push(y);
+    }
+    return s;
+  }
+  /**
+   * Clean up decoder resources
+   */
+  async destroy() {
+    this.decoder && (await this.decoder.free(), this.decoder = null, this.isReady = !1);
+  }
+}
+export {
+  I as MP3Decoder,
+  E as MP3Encoder
+};

package/dist/demux/example-muxer.d.ts

@@ -0,0 +1,74 @@
+import { EncodedVideoPacketSource, EncodedAudioPacketSource, BufferTarget, Output } from 'mediabunny';
+/**
+ * Simple muxer for creating MP4 files from encoded video or audio chunks.
+ *
+ * This class wraps MediaBunny's muxing functionality to provide a simplified
+ * API for demos and learning purposes. It handles a single video or audio track.
+ *
+ * **⚠️ Demo/Learning Only**: This utility is intended for demos and learning.
+ * For production use, please use MediaBunny directly: https://mediabunny.dev/
+ *
+ * @example
+ * ```typescript
+ * // Create muxer for video
+ * const muxer = new ExampleMuxer('video');
+ *
+ * // In VideoEncoder output callback:
+ * encoder.configure({
+ *   output: (chunk, metadata) => {
+ *     muxer.addChunk(chunk, metadata);
+ *   },
+ *   error: (e) => console.error(e)
+ * });
+ *
+ * // ... encode frames ...
+ * await encoder.flush();
+ *
+ * // Get final MP4
+ * const mp4Buffer = await muxer.finish();
+ * const blob = new Blob([mp4Buffer], { type: 'video/mp4' });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create muxer for audio
+ * const muxer = new ExampleMuxer('audio');
+ *
+ * // In AudioEncoder output callback:
+ * encoder.configure({
+ *   output: (chunk) => {
+ *     muxer.addChunk(chunk);
+ *   },
+ *   error: (e) => console.error(e)
+ * });
+ * ```
+ */
+export declare class ExampleMuxer {
+    type: 'audio' | 'video';
+    output: Output;
+    source: EncodedVideoPacketSource | EncodedAudioPacketSource;
+    started: boolean;
+    target: BufferTarget;
+    /**
+     * Create a new ExampleMuxer.
+     *
+     * @param type - Track type: 'video' (default) or 'audio'
+     */
+    constructor(type?: 'audio' | 'video');
+    /**
+     * Add an encoded chunk to the MP4 file.
+     *
+     * @param chunk - EncodedVideoChunk or EncodedAudioChunk from encoder output
+     * @param meta - Optional metadata from encoder (for video, contains decoderConfig)
+     */
+    addChunk(chunk: EncodedAudioChunk | EncodedVideoChunk, meta?: any): void;
+    /**
+     * Finalize the MP4 file and return the complete buffer.
+     *
+     * Call this after all chunks have been added.
+     *
+     * @returns Complete MP4 file as ArrayBuffer
+     */
+    finish(): Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=example-muxer.d.ts.map

package/dist/demux/example-muxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-muxer.d.ts","sourceRoot":"","sources":["../../src/demux/example-muxer.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EACxB,wBAAwB,EACxB,YAAY,EAEZ,MAAM,EACP,MAAM,YAAY,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,YAAY;IAErB,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,wBAAwB,GAAG,wBAAwB,CAAA;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAA;IAEpB;;;;OAIG;gBACS,IAAI,CAAC,EAAE,OAAO,GAAC,OAAO;IAyBlC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,IAAI,CAAC,EAAE,GAAG;IASjE;;;;;;OAMG;IACG,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC;CAYvC"}