webcodecs-utils 0.2.5 → 0.2.6

package/dist/mux/simple-muxer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Simple wrapper around MediaBunny's Output for easier muxing
+ * Provides WritableStream interface for use in pipelines
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use MediaBunny directly.
+ *
+ * @example
+ * ```typescript
+ * const muxer = new SimpleMuxer({ video: 'avc', audio: 'aac' });
+ *
+ * await videoStream
+ *   .pipeThrough(new VideoDecodeStream(config))
+ *   .pipeThrough(new VideoEncodeStream(config))
+ *   .pipeTo(muxer.videoSink());
+ *
+ * const blob = await muxer.finalize();
+ * ```
+ */
+export declare class SimpleMuxer {
+    private output;
+    private videoSource?;
+    private audioSource?;
+    private started;
+    constructor(config: {
+        video?: 'avc' | 'hevc' | 'vp8' | 'vp9' | 'av1';
+        audio?: 'aac' | 'opus' | 'mp3' | 'vorbis' | 'flac';
+    });
+    /**
+     * Get a WritableStream for video chunks with metadata
+     * Use with .pipeTo() in a pipeline
+     */
+    videoSink(): WritableStream<{
+        chunk: EncodedVideoChunk;
+        meta?: EncodedVideoChunkMetadata;
+    }>;
+    /**
+     * Get a WritableStream for audio chunks
+     * Use with .pipeTo() in a pipeline
+     */
+    audioSink(): WritableStream<EncodedAudioChunk>;
+    /**
+     * Finalize the muxer and return the output as a Blob
+     * Call this after all streams have finished writing
+     */
+    finalize(): Promise<Blob>;
+}
+//# sourceMappingURL=simple-muxer.d.ts.map

package/dist/mux/simple-muxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-muxer.d.ts","sourceRoot":"","sources":["../../src/mux/simple-muxer.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAC,CAA2B;IAC/C,OAAO,CAAC,WAAW,CAAC,CAA2B;IAC/C,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE;QAClB,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;QAC/C,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;KACpD;IAmBD;;;OAGG;IACH,SAAS,IAAI,cAAc,CAAC;QAAE,KAAK,EAAE,iBAAiB,CAAC;QAAC,IAAI,CAAC,EAAE,yBAAyB,CAAA;KAAE,CAAC;IA8B3F;;;OAGG;IACH,SAAS,IAAI,cAAc,CAAC,iBAAiB,CAAC;IA8B9C;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAQhC"}

package/dist/mux/simple-muxer.js

@@ -0,0 +1,83 @@
+import { BufferTarget as u, Output as n, Mp4OutputFormat as s, EncodedVideoPacketSource as d, EncodedAudioPacketSource as c, EncodedPacket as i } from "mediabunny";
+let a = !1;
+function h() {
+  a || (console.warn(
+    "⚠️  Demo/Learning Function: SimpleMuxer is intended for demos and learning purposes only. For production use, please use MediaBunny directly (https://mediabunny.dev/) for more features and better control."
+  ), a = !0);
+}
+class w {
+  constructor(t) {
+    this.started = !1, h();
+    const o = new u();
+    this.output = new n({
+      format: new s(),
+      target: o
+    }), t.video && (this.videoSource = new d(t.video), this.output.addVideoTrack(this.videoSource)), t.audio && (this.audioSource = new c(t.audio), this.output.addAudioTrack(this.audioSource));
+  }
+  /**
+   * Get a WritableStream for video chunks with metadata
+   * Use with .pipeTo() in a pipeline
+   */
+  videoSink() {
+    if (!this.videoSource)
+      throw new Error("SimpleMuxer: No video track configured");
+    const t = this.videoSource, o = async () => {
+      this.started || (await this.output.start(), this.started = !0);
+    };
+    return new WritableStream({
+      start: async () => {
+        await o();
+      },
+      write: (e) => {
+        const r = i.fromEncodedChunk(e.chunk);
+        t.add(r, e.meta);
+      },
+      close: () => {
+        console.log("Video sink closed");
+      },
+      abort: (e) => {
+        console.error("Video sink aborted:", e);
+      }
+    });
+  }
+  /**
+   * Get a WritableStream for audio chunks
+   * Use with .pipeTo() in a pipeline
+   */
+  audioSink() {
+    if (!this.audioSource)
+      throw new Error("SimpleMuxer: No audio track configured");
+    const t = this.audioSource, o = async () => {
+      this.started || (await this.output.start(), this.started = !0);
+    };
+    return new WritableStream({
+      start: async () => {
+        await o();
+      },
+      write: (e) => {
+        const r = i.fromEncodedChunk(e);
+        t.add(r);
+      },
+      close: () => {
+        console.log("Audio sink closed");
+      },
+      abort: (e) => {
+        console.error("Audio sink aborted:", e);
+      }
+    });
+  }
+  /**
+   * Finalize the muxer and return the output as a Blob
+   * Call this after all streams have finished writing
+   */
+  async finalize() {
+    await this.output.finalize();
+    const t = this.output.target.buffer;
+    if (!t)
+      throw new Error("SimpleMuxer: No data was written to the muxer");
+    return new Blob([t], { type: "video/mp4" });
+  }
+}
+export {
+  w as SimpleMuxer
+};

package/dist/polyfills/media-stream-track-processor.d.ts

@@ -0,0 +1,5 @@
+export declare const MediaStreamTrackProcessor: {
+    new (init: MediaStreamTrackProcessorInit): MediaStreamTrackProcessor;
+    prototype: MediaStreamTrackProcessor;
+};
+//# sourceMappingURL=media-stream-track-processor.d.ts.map

package/dist/polyfills/media-stream-track-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-stream-track-processor.d.ts","sourceRoot":"","sources":["../../src/polyfills/media-stream-track-processor.ts"],"names":[],"mappings":"AAoLA,eAAO,MAAM,yBAAyB;;;CAAsE,CAAC"}

package/dist/polyfills/media-stream-track-processor.js

@@ -0,0 +1,109 @@
+const b = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  sampleCount = 0;
+
+  process(inputs) {
+    if (inputs.length === 0 || inputs[0].length === 0) {
+      return true;
+    }
+
+    const channels = inputs[0];
+    const timestamp = (this.sampleCount / sampleRate) * 1_000_000; // Convert to microseconds
+
+    this.port.postMessage({
+      timestamp,
+      channels: channels.map(channel => channel.slice()),
+    });
+
+    this.sampleCount += channels[0].length;
+    return true;
+  }
+}
+
+registerProcessor('audio-capture-processor', AudioCaptureProcessor);
+`;
+class f {
+  constructor({ track: a }) {
+    const o = a.getSettings();
+    if (!o)
+      throw new Error("track has no settings");
+    if (a.kind === "video")
+      this.readable = this.createVideoStream(a, o);
+    else if (a.kind === "audio")
+      this.readable = this.createAudioStream(a, o);
+    else
+      throw new Error(`Unsupported track kind: ${a.kind}`);
+  }
+  createVideoStream(a, o) {
+    let e, t, n;
+    const l = o.frameRate ?? 30;
+    return new ReadableStream({
+      async start() {
+        e = document.createElement("video"), e.srcObject = new MediaStream([a]), await Promise.all([
+          e.play(),
+          new Promise((s) => {
+            e.onloadedmetadata = s;
+          })
+        ]), t = performance.now();
+      },
+      async pull(s) {
+        for (; ; ) {
+          const i = performance.now();
+          if (i - t < 1e3 / l) {
+            await new Promise((u) => requestAnimationFrame(u));
+            continue;
+          }
+          const c = n ?? Math.round((i - t) * 1e3);
+          n = c, t = i, s.enqueue(new VideoFrame(e, {
+            timestamp: t * 1e3,
+            duration: c
+          }));
+          break;
+        }
+      }
+    });
+  }
+  createAudioStream(a, o) {
+    let e, t, n;
+    return new ReadableStream({
+      async start(l) {
+        e = new AudioContext({
+          sampleRate: o.sampleRate || 48e3
+        });
+        const s = new MediaStreamAudioSourceNode(e, {
+          mediaStream: new MediaStream([a])
+        }), i = new Blob([b], { type: "application/javascript" });
+        n = URL.createObjectURL(i), await e.audioWorklet.addModule(n), t = new AudioWorkletNode(e, "audio-capture-processor", {
+          numberOfInputs: 1,
+          numberOfOutputs: 0,
+          channelCount: o.channelCount || 2
+        }), s.connect(t), t.port.onmessage = (c) => {
+          const { timestamp: u, channels: w } = c.data, d = w, m = d[0].length, p = d.length, S = m * p, h = new Float32Array(S);
+          for (let r = 0; r < p; r++)
+            h.set(d[r], r * m);
+          try {
+            const r = new AudioData({
+              format: "f32-planar",
+              sampleRate: e.sampleRate,
+              numberOfFrames: m,
+              numberOfChannels: p,
+              timestamp: u,
+              data: h
+            });
+            l.enqueue(r);
+          } catch (r) {
+            console.error("Failed to create AudioData:", r);
+          }
+        };
+      },
+      cancel() {
+        t && (t.disconnect(), t.port.onmessage = null), e && e.close(), n && URL.revokeObjectURL(n);
+      }
+    });
+  }
+}
+self.MediaStreamTrackProcessor || (self.MediaStreamTrackProcessor = f);
+const g = self.MediaStreamTrackProcessor || f;
+export {
+  g as MediaStreamTrackProcessor
+};

package/dist/streams/video-decode-stream.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TransformStream that decodes EncodedVideoChunks into VideoFrames
+ * Handles backpressure from both the decoder's internal queue and downstream
+ */
+export declare class VideoDecodeStream extends TransformStream<EncodedVideoChunk, VideoFrame> {
+    constructor(config: VideoDecoderConfig, options?: {
+        highWaterMark?: number;
+        maxDecodeQueueSize?: number;
+    });
+}
+//# sourceMappingURL=video-decode-stream.d.ts.map

package/dist/streams/video-decode-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-decode-stream.d.ts","sourceRoot":"","sources":["../../src/streams/video-decode-stream.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,eAAe,CAAC,iBAAiB,EAAE,UAAU,CAAC;gBAEjF,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC7B;CAkDJ"}

package/dist/streams/video-decode-stream.js

@@ -0,0 +1,39 @@
+class t extends TransformStream {
+  constructor(u, r) {
+    let a;
+    const o = (r == null ? void 0 : r.highWaterMark) ?? 10, s = (r == null ? void 0 : r.maxDecodeQueueSize) ?? 20;
+    super(
+      {
+        start(c) {
+          a = new VideoDecoder({
+            output: (e) => {
+              c.enqueue(e);
+            },
+            error: (e) => {
+              console.error("VideoDecoder error:", e), c.error(e);
+            }
+          }), a.configure(u);
+        },
+        async transform(c, e) {
+          for (; a.decodeQueueSize >= s; )
+            await new Promise((d) => setTimeout(d, 10));
+          for (; e.desiredSize !== null && e.desiredSize < 0; )
+            await new Promise((d) => setTimeout(d, 10));
+          a.decode(c);
+        },
+        async flush() {
+          await a.flush();
+          try {
+            a.close();
+          } catch (c) {
+            console.error("Error closing decoder:", c);
+          }
+        }
+      },
+      { highWaterMark: o }
+    );
+  }
+}
+export {
+  t as VideoDecodeStream
+};

package/dist/streams/video-encode-stream.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TransformStream that encodes VideoFrames into EncodedVideoChunks with metadata
+ * Handles backpressure from both the encoder's internal queue and downstream
+ */
+export declare class VideoEncodeStream extends TransformStream<VideoFrame, {
+    chunk: EncodedVideoChunk;
+    meta?: EncodedVideoChunkMetadata;
+}> {
+    constructor(config: VideoEncoderConfig, options?: {
+        highWaterMark?: number;
+        maxEncodeQueueSize?: number;
+        keyFrameInterval?: number;
+    });
+}
+//# sourceMappingURL=video-encode-stream.d.ts.map

package/dist/streams/video-encode-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-encode-stream.d.ts","sourceRoot":"","sources":["../../src/streams/video-encode-stream.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,eAAe,CACpD,UAAU,EACV;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,IAAI,CAAC,EAAE,yBAAyB,CAAA;CAAE,CAC/D;gBAEG,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B;CA0DJ"}

package/dist/streams/video-encode-stream.js

@@ -0,0 +1,40 @@
+class h extends TransformStream {
+  constructor(t, e) {
+    let c, n = 0;
+    const m = (e == null ? void 0 : e.highWaterMark) ?? 10, s = (e == null ? void 0 : e.maxEncodeQueueSize) ?? 20, l = (e == null ? void 0 : e.keyFrameInterval) ?? 60;
+    super(
+      {
+        start(r) {
+          c = new VideoEncoder({
+            output: (a, u) => {
+              r.enqueue({ chunk: a, meta: u });
+            },
+            error: (a) => {
+              console.error("VideoEncoder error:", a), r.error(a);
+            }
+          }), c.configure(t);
+        },
+        async transform(r, a) {
+          for (; c.encodeQueueSize >= s; )
+            await new Promise((d) => setTimeout(d, 10));
+          for (; a.desiredSize !== null && a.desiredSize < 0; )
+            await new Promise((d) => setTimeout(d, 10));
+          const u = n % l === 0;
+          c.encode(r, { keyFrame: u }), n++, r.close();
+        },
+        async flush() {
+          await c.flush();
+          try {
+            c.close();
+          } catch (r) {
+            console.error("Error closing encoder:", r);
+          }
+        }
+      },
+      { highWaterMark: m }
+    );
+  }
+}
+export {
+  h as VideoEncodeStream
+};

package/dist/streams/video-process-stream.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TransformStream that applies a custom processing function to each VideoFrame
+ * The transform function receives a frame and should return a new processed frame
+ *
+ * @example
+ * ```typescript
+ * const upscaler = new VideoProcessStream(async (frame) => {
+ *   await websr.render(frame);
+ *   const upscaledFrame = new VideoFrame(canvas, {
+ *     timestamp: frame.timestamp,
+ *     duration: frame.duration
+ *   });
+ *   return upscaledFrame;
+ * });
+ * ```
+ */
+export declare class VideoProcessStream extends TransformStream<VideoFrame, VideoFrame> {
+    constructor(transformFn: (frame: VideoFrame) => Promise<VideoFrame> | VideoFrame, options?: {
+        highWaterMark?: number;
+    });
+}
+//# sourceMappingURL=video-process-stream.d.ts.map

package/dist/streams/video-process-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-process-stream.d.ts","sourceRoot":"","sources":["../../src/streams/video-process-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,kBAAmB,SAAQ,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC;gBAE3E,WAAW,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,EACpE,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB;CA4BJ"}

package/dist/streams/video-process-stream.js

@@ -0,0 +1,21 @@
+class h extends TransformStream {
+  constructor(a, s) {
+    const o = (s == null ? void 0 : s.highWaterMark) ?? 5;
+    super(
+      {
+        async transform(e, c) {
+          try {
+            const r = await a(e);
+            c.enqueue(r), r !== e && e.close();
+          } catch (r) {
+            console.error("VideoProcessStream error:", r), e.close(), c.error(r);
+          }
+        }
+      },
+      { highWaterMark: o }
+    );
+  }
+}
+export {
+  h as VideoProcessStream
+};

package/dist/video/get-bitrate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Calculate optimal bitrate for video encoding based on resolution, framerate, and quality.
+ *
+ * This function uses a simple heuristic formula: `pixels * fps * quality_factor`
+ *
+ * @param width - Video width in pixels
+ * @param height - Video height in pixels
+ * @param fps - Target framerate (default: 30)
+ * @param quality - Quality preset: 'low' (0.05), 'good' (0.08), 'high' (0.10), 'very-high' (0.15)
+ * @returns Bitrate in bits per second (bps)
+ *
+ * @example
+ * ```typescript
+ * // 1080p at 30fps, good quality
+ * const bitrate = getBitrate(1920, 1080, 30, 'good');
+ * // Returns: ~4.9 Mbps
+ *
+ * encoder.configure({
+ *   codec: 'avc1.42003e',
+ *   width: 1920,
+ *   height: 1080,
+ *   bitrate,
+ *   framerate: 30
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // 4K at 60fps, high quality
+ * const bitrate = getBitrate(3840, 2160, 60, 'high');
+ * // Returns: ~49.7 Mbps
+ * ```
+ */
+export declare function getBitrate(width: number, height: number, fps?: number, quality?: 'low' | 'good' | 'high' | 'very-high'): number;
+//# sourceMappingURL=get-bitrate.d.ts.map

package/dist/video/get-bitrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-bitrate.d.ts","sourceRoot":"","sources":["../../src/video/get-bitrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAW,EAAE,OAAO,GAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,WAAoB,UAUlI"}

package/dist/video/get-bitrate.js

@@ -0,0 +1,12 @@
+function n(t, r, c = 30, e = "good") {
+  const g = t * r, o = {
+    low: 0.05,
+    good: 0.08,
+    high: 0.1,
+    "very-high": 0.15
+  }, i = o[e] || o.good;
+  return g * c * i;
+}
+export {
+  n as getBitrate
+};

package/dist/video/get-codec-string.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generate proper codec strings with profiles and levels for video encoding.
+ *
+ * This function automatically determines the appropriate profile and level based on
+ * video resolution and bitrate. The codec strings follow the format required by
+ * VideoEncoder.configure() and are essential for proper encoding.
+ *
+ * Supported codecs:
+ * - **AVC (H.264)**: High Profile, levels 1-6.2
+ * - **HEVC (H.265)**: Main Profile, levels 1-6.2 (Low/High Tier)
+ * - **VP8**: Simple codec string 'vp8'
+ * - **VP9**: Profile 0, 8-bit, levels 1-6.2
+ * - **AV1**: Main Profile, levels 2.0-6.3 (Main/High Tier)
+ *
+ * @param codec - Codec type: 'avc', 'hevc', 'vp8', 'vp9', or 'av1'
+ * @param width - Video width in pixels
+ * @param height - Video height in pixels
+ * @param bitrate - Target bitrate in bits per second
+ * @returns Properly formatted codec string (e.g., 'avc1.640028' for H.264)
+ *
+ * @example
+ * ```typescript
+ * // H.264 for 1080p
+ * const codecString = getCodecString('avc', 1920, 1080, 5000000);
+ * // Returns: 'avc1.640028' (High Profile, Level 4.0)
+ *
+ * encoder.configure({
+ *   codec: codecString,
+ *   width: 1920,
+ *   height: 1080,
+ *   bitrate: 5000000
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // VP9 for 4K
+ * const codecString = getCodecString('vp9', 3840, 2160, 20000000);
+ * // Returns: 'vp09.00.50.08' (Profile 0, Level 5.0, 8-bit)
+ * ```
+ *
+ * @remarks
+ * Adapted from MediaBunny's codec.ts: https://github.com/Vanilagy/mediabunny/blob/main/src/codec.ts
+ */
+export declare function getCodecString(codec: 'avc' | 'hevc' | 'vp8' | 'vp9' | 'av1', width: number, height: number, bitrate: number): string;
+//# sourceMappingURL=get-codec-string.d.ts.map

package/dist/video/get-codec-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-codec-string.d.ts","sourceRoot":"","sources":["../../src/video/get-codec-string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,cAAc,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAmK5H"}