@bendyline/squisq-video-react 2.4.19 → 2.4.21

package/README.md

@@ -220,6 +220,36 @@ available, and otherwise skipped with `audioIncluded: false` plus an
 completes. GIF skips audio preparation entirely. `supportsWebCodecsH264(config)` probes a specific encoder
 configuration; `EncoderConfig` and `FfmpegWasmLoadConfig` are also exported.
 
+## Audio export
+
+`@bendyline/squisq-video-react/encoder` also exports a streaming audio-file
+encoder and a whole-document audio mix for hosts that export audio on its own
+(or save generated narration):
+
+```ts
+import {
+  createAudioFileEncoder,
+  renderDocumentAudio,
+  supportedAudioFileFormats,
+} from '@bendyline/squisq-video-react/encoder';
+
+const formats = await supportedAudioFileFormats(); // 'm4a' (AAC), 'opus-webm', 'wav' (always)
+const mixed = await renderDocumentAudio(doc, { readMedia: (src) => container.readFile(src) });
+if (mixed) {
+  const encoder = await createAudioFileEncoder({
+    format: formats[0],
+    sampleRate: mixed.sampleRate,
+    channels: 2,
+  });
+  await encoder.append([mixed.getChannelData(0), mixed.getChannelData(1)]);
+  const file = await encoder.finish(); // encoder.mimeType / encoder.extension
+}
+```
+
+M4A is an audio-only MP4; input at rates the codec rejects (24 kHz TTS for
+AAC) is resampled in-stream. See the
+[host guide](https://github.com/bendyline/squisq/blob/main/docs/narration-and-audio-export.md).
+
 ## Full API Reference
 
 See [docs/API.md](https://github.com/bendyline/squisq/blob/main/docs/API.md)

package/dist/chunk-2W6JQSIY.js

@@ -0,0 +1,51 @@
+// src/audioFile/shared.ts
+var LOSSY_FORMATS = {
+  m4a: {
+    format: "m4a",
+    codec: "aac",
+    label: "AAC (M4A)",
+    mimeType: "audio/mp4",
+    extension: "m4a",
+    bitrate: { 1: 96e3, 2: 128e3 }
+  },
+  "opus-webm": {
+    format: "opus-webm",
+    codec: "opus",
+    label: "Opus (WebM)",
+    mimeType: "audio/webm",
+    extension: "webm",
+    bitrate: { 1: 64e3, 2: 96e3 }
+  }
+};
+function blockFrames(block, channels) {
+  if (block.length !== channels) {
+    throw new RangeError(`Expected ${channels} channel(s) of PCM, got ${block.length}.`);
+  }
+  const frames = block[0].length;
+  for (const channel of block) {
+    if (!(channel instanceof Float32Array)) {
+      throw new TypeError("PCM channels must be Float32Arrays.");
+    }
+    if (channel.length !== frames) throw new RangeError("Every channel must have the same length.");
+  }
+  return frames;
+}
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  return (task) => {
+    const run = tail.then(task);
+    tail = run.catch(() => void 0);
+    return run;
+  };
+}
+function assertOpen(state) {
+  if (state === "finished") throw new Error("The audio file encoder is already finished.");
+  if (state === "cancelled") throw new Error("The audio file encoder was cancelled.");
+}
+
+export {
+  LOSSY_FORMATS,
+  blockFrames,
+  createSerialQueue,
+  assertOpen
+};

package/dist/{chunk-MI4EJXTD.js → chunk-47ODXCBA.js}

@@ -1,19 +1,21 @@
 import {
   useFrameCapture
-} from "./chunk-QJWEZRZS.js";
+} from "./chunk-A52VG7RA.js";
 import {
   EXPORT_AUDIO_CHANNELS,
   EXPORT_AUDIO_SAMPLE_RATE,
   audioBufferToWav,
   createEncoder,
+  documentAudioTimeline,
   encodeAacTrack,
+  loadAudioTimelineSources,
+  mixAudioTimeline,
   muxAudioWithFfmpegWasm,
-  renderAudioTimeline,
   selectAudioTier,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "./chunk-GBIYYDMY.js";
+} from "./chunk-ISYJJJXN.js";
 
 // src/hooks/useVideoExport.ts
 import { useState, useRef, useCallback, useEffect } from "react";
@@ -26,12 +28,7 @@ import {
   MAX_COVER_SLIDE_DURATION_SECONDS,
   resolveCoverSlideSettings
 } from "@bendyline/squisq/doc";
-import {
-  resolveDimensions,
-  computeAudioTimeline,
-  resolveFfmpegWasmLoad as resolveFfmpegWasmLoad2,
-  QUALITY_PRESETS
-} from "@bendyline/squisq-video";
+import { resolveDimensions, resolveFfmpegWasmLoad as resolveFfmpegWasmLoad2, QUALITY_PRESETS } from "@bendyline/squisq-video";
 
 // src/workerEncoder.ts
 import { validateVideoExportOptions } from "@bendyline/squisq-video";
@@ -420,24 +417,19 @@ function collectDocumentMediaReferences(doc) {
   visit(doc);
   return references;
 }
-async function resolveAudioBuffers(clips, sources) {
-  const srcs = new Set(clips.map((c) => c.src));
-  const out = /* @__PURE__ */ new Map();
-  for (const src of srcs) {
-    let data = sources.audio?.get(src) ?? sources.images?.get(src);
-    if (!data && sources.mediaProvider) {
-      try {
-        const url = await sources.mediaProvider.resolveUrl(src);
-        const resource = await fetchResourceBytes(url, {
-          policy: sources.resourcePolicy
-        });
-        data = toArrayBuffer(resource.bytes);
-      } catch {
-      }
+function exportMediaReader(sources) {
+  return async (src) => {
+    const data = sources.audio?.get(src) ?? sources.images?.get(src);
+    if (data) return data;
+    if (!sources.mediaProvider) return null;
+    try {
+      const url = await sources.mediaProvider.resolveUrl(src);
+      const resource = await fetchResourceBytes(url, { policy: sources.resourcePolicy });
+      return toArrayBuffer(resource.bytes);
+    } catch {
+      return null;
     }
-    if (data) out.set(src, data);
-  }
-  return out;
+  };
 }
 function resolveVideoExportCover(doc, config = {}) {
   const legacyPreRollOverride = config.coverPreRoll;
@@ -689,9 +681,10 @@ function useVideoExport(options = {}) {
         ).catch(() => false);
         if (cancelled()) return;
         const audioBitrate = (QUALITY_PRESETS[quality] ?? QUALITY_PRESETS.normal).audioBitrate;
-        const timeline = effectiveOutputFormat === "mp4" && audioPolicy !== "omit" ? config.processedAudio ? computeAudioTimeline(doc, coverPlan.audioOffset, {
-          processedAudio: config.processedAudio
-        }) : computeAudioTimeline(doc, coverPlan.audioOffset) : [];
+        const timeline = effectiveOutputFormat === "mp4" && audioPolicy !== "omit" ? documentAudioTimeline(doc, {
+          offsetSec: coverPlan.audioOffset,
+          ...config.processedAudio ? { processedAudio: config.processedAudio } : {}
+        }) : [];
         const aacSupported = timeline.length > 0 ? await supportsWebCodecsAac(EXPORT_AUDIO_SAMPLE_RATE, EXPORT_AUDIO_CHANNELS) : false;
         if (cancelled()) return;
         const tierDecision = selectAudioTier({
@@ -709,17 +702,17 @@ function useVideoExport(options = {}) {
         if (tierDecision.tier === 1 || tierDecision.tier === 2) {
           setPhase("Preparing audio\u2026");
           try {
-            const buffers = await resolveAudioBuffers(timeline, {
-              audio: config.audio,
-              images,
-              mediaProvider: config.mediaProvider,
-              resourcePolicy: config.resourcePolicy
-            });
+            const { buffers, missing: missingSources } = await loadAudioTimelineSources(
+              timeline,
+              exportMediaReader({
+                audio: config.audio,
+                images,
+                mediaProvider: config.mediaProvider,
+                resourcePolicy: config.resourcePolicy
+              })
+            );
             try {
               if (cancelled()) return;
-              const missingSources = [...new Set(timeline.map((clip) => clip.src))].filter(
-                (src) => !buffers.has(src)
-              );
               if (missingSources.length > 0) {
                 audioReasonLocal = `Audio files could not be loaded: ${missingSources.join(", ")}`;
                 if (audioPolicy === "require") throw new Error(audioReasonLocal);
@@ -727,14 +720,10 @@ function useVideoExport(options = {}) {
               if (buffers.size === 0) {
                 audioReasonLocal ?? (audioReasonLocal = "Audio files for this document could not be loaded.");
               } else {
-                const totalAudioDur = timeline.reduce(
-                  (max, c) => Math.max(max, c.startSec + c.durationSec),
-                  exportDuration
-                );
-                renderedAudio = await renderAudioTimeline(
+                renderedAudio = await mixAudioTimeline(
                   timeline,
                   buffers,
-                  totalAudioDur,
+                  exportDuration,
                   EXPORT_AUDIO_SAMPLE_RATE
                 );
                 if (cancelled()) return;

package/dist/{chunk-QJWEZRZS.js → chunk-A52VG7RA.js}

@@ -6,7 +6,7 @@ import {
   QTFF,
   VideoSampleSink,
   WEBM
-} from "./chunk-4GFZ3GUE.js";
+} from "./chunk-C7NEHV5X.js";
 
 // src/hooks/useFrameCapture.ts
 import { createElement } from "react";

package/dist/{chunk-IFQJAW4V.js → chunk-BNNLPKT2.js}

@@ -18,7 +18,7 @@ import {
   WavOutputFormat,
   WebMOutputFormat,
   canEncodeAudio
-} from "./chunk-4GFZ3GUE.js";
+} from "./chunk-C7NEHV5X.js";
 
 // src/mediaEdit/mediaEditEngine.ts
 import {