@bendyline/squisq-video-react 2.4.11 → 2.4.12

package/dist/chunk-IFQJAW4V.js

@@ -0,0 +1,321 @@
+import {
+  ADTS,
+  AudioSample,
+  AudioSampleSink,
+  AudioSampleSource,
+  BlobSource,
+  BufferTarget,
+  FLAC,
+  Input,
+  MATROSKA,
+  MP3,
+  MP4,
+  OGG,
+  Output,
+  QTFF,
+  WAVE,
+  WEBM,
+  WavOutputFormat,
+  WebMOutputFormat,
+  canEncodeAudio
+} from "./chunk-4GFZ3GUE.js";
+
+// src/mediaEdit/mediaEditEngine.ts
+import {
+  MEDIA_FX_ENGINE,
+  analyzeMediaFx,
+  correctedLoudnessAnalysis,
+  createBreathAnalyzer,
+  detectPauseCuts,
+  parseMediaFx,
+  renderMediaFx
+} from "@bendyline/squisq/mediaEdit";
+
+// src/mediaEdit/audioRenderSink.ts
+var OPUS_BITRATE_PER_CHANNEL = 96e3;
+async function createAudioRenderSink(channels, sampleRate) {
+  const bitrate = OPUS_BITRATE_PER_CHANNEL * channels;
+  const opus = await canEncodeAudio("opus", { numberOfChannels: channels, sampleRate, bitrate });
+  const target = new BufferTarget();
+  const output = new Output({
+    format: opus ? new WebMOutputFormat() : new WavOutputFormat(),
+    target
+  });
+  const source = new AudioSampleSource(opus ? { codec: "opus", bitrate } : { codec: "pcm-s16" });
+  output.addAudioTrack(source);
+  await output.start();
+  let written = 0;
+  return {
+    async write(block) {
+      const frames = block[0]?.length ?? 0;
+      if (frames === 0) return;
+      const data = new Float32Array(frames * channels);
+      for (let c = 0; c < channels; c++) data.set(block[c], c * frames);
+      const sample = new AudioSample({
+        data,
+        format: "f32-planar",
+        numberOfChannels: channels,
+        sampleRate,
+        timestamp: written / sampleRate
+      });
+      try {
+        await source.add(sample);
+      } finally {
+        sample.close();
+      }
+      written += frames;
+    },
+    async finish() {
+      source.close();
+      await output.finalize();
+      if (!target.buffer) throw new Error("The audio render produced no output.");
+      return opus ? { bytes: target.buffer, mimeType: "audio/webm", extension: "webm" } : { bytes: target.buffer, mimeType: "audio/wav", extension: "wav" };
+    },
+    cancel: () => output.cancel()
+  };
+}
+
+// src/mediaEdit/mediaAudioSource.ts
+import {
+  MEDIA_FX_SAMPLE_RATE,
+  createResampler
+} from "@bendyline/squisq/mediaEdit";
+var INPUT_FORMATS = [MP4, QTFF, WEBM, MATROSKA, WAVE, MP3, OGG, FLAC, ADTS];
+async function openMediaAudio(blob, options = {}) {
+  const input = new Input({ source: new BlobSource(blob), formats: INPUT_FORMATS });
+  const track = await input.getPrimaryAudioTrack();
+  if (!track) {
+    input.dispose();
+    return null;
+  }
+  const trackDurationSec = await track.computeDuration();
+  const sourceRate = track.sampleRate;
+  const channels = Math.min(2, Math.max(1, track.numberOfChannels));
+  const startSec = Math.max(0, options.startSec ?? 0);
+  const endSec = Math.max(startSec, Math.min(options.endSec ?? trackDurationSec, trackDurationSec));
+  const durationSec = endSec - startSec;
+  const frames = Math.round(durationSec * MEDIA_FX_SAMPLE_RATE);
+  const sourceFrames = Math.round(durationSec * sourceRate);
+  async function* open() {
+    const sink = new AudioSampleSink(track);
+    const resamplers = Array.from(
+      { length: channels },
+      () => createResampler(sourceRate, MEDIA_FX_SAMPLE_RATE)
+    );
+    let placed = 0;
+    let emitted = 0;
+    const feed = (planes) => {
+      const out = resamplers.map((r, c) => r.process(planes[c]));
+      const room2 = frames - emitted;
+      const take = Math.min(out[0].length, room2);
+      if (take <= 0) return null;
+      emitted += take;
+      return out.map((ch) => ch.length === take ? ch : ch.subarray(0, take));
+    };
+    for await (const sample of sink.samples(startSec, endSec)) {
+      try {
+        const at = Math.round((sample.timestamp - startSec) * sourceRate);
+        let planes = Array.from({ length: channels }, (_, c) => {
+          const plane = new Float32Array(sample.numberOfFrames);
+          sample.copyTo(plane, {
+            planeIndex: Math.min(c, sample.numberOfChannels - 1),
+            format: "f32-planar"
+          });
+          return plane;
+        });
+        if (at > placed) {
+          const gap = Math.min(at - placed, sourceFrames - placed);
+          if (gap > 0) {
+            const out2 = feed(Array.from({ length: channels }, () => new Float32Array(gap)));
+            placed += gap;
+            if (out2) yield out2;
+          }
+        }
+        const overlap = placed - at;
+        if (overlap > 0) planes = planes.map((p) => p.subarray(Math.min(overlap, p.length)));
+        const room2 = sourceFrames - placed;
+        if (room2 <= 0) break;
+        if (planes[0].length > room2) planes = planes.map((p) => p.subarray(0, room2));
+        if (planes[0].length === 0) continue;
+        placed += planes[0].length;
+        const out = feed(planes);
+        if (out) yield out;
+      } finally {
+        sample.close();
+      }
+    }
+    if (placed < sourceFrames) {
+      const out = feed(
+        Array.from({ length: channels }, () => new Float32Array(sourceFrames - placed))
+      );
+      if (out) yield out;
+    }
+    const tail = resamplers.map((r) => r.flush());
+    const room = frames - emitted;
+    if (room > 0) {
+      const padded = tail.map((ch) => {
+        const full = new Float32Array(room);
+        full.set(ch.subarray(0, room));
+        return full;
+      });
+      emitted += room;
+      yield padded;
+    }
+  }
+  return {
+    sampleRate: MEDIA_FX_SAMPLE_RATE,
+    channels,
+    frames,
+    durationSec,
+    trackDurationSec,
+    sourceSampleRate: sourceRate,
+    open,
+    dispose: () => input.dispose()
+  };
+}
+
+// src/mediaEdit/mediaEditEngine.ts
+var PREVIEW_PREROLL_SEC = 1;
+var FIRST_PASS_SHARE = 0.67;
+function chainOf(fx) {
+  const chain = parseMediaFx(fx);
+  if (!chain || chain.ops.length === 0) throw new Error(`Nothing to render in fx "${fx}".`);
+  return chain;
+}
+function concatBlocks(blocks, channels) {
+  return Array.from({ length: channels }, (_, c) => {
+    const total = blocks.reduce((n, b) => n + b[c].length, 0);
+    const out = new Float32Array(total);
+    let at = 0;
+    for (const b of blocks) {
+      out.set(b[c], at);
+      at += b[c].length;
+    }
+    return out;
+  });
+}
+async function renderMediaEditAudio(request, options = {}) {
+  const fx = chainOf(request.fx);
+  const source = await openMediaAudio(request.source);
+  if (!source) throw new Error("This media has no audio track to process.");
+  try {
+    let analysis;
+    for (let attempt = 0; ; attempt++) {
+      const from = attempt === 0 ? 0 : FIRST_PASS_SHARE;
+      const span = attempt === 0 ? FIRST_PASS_SHARE : 1 - FIRST_PASS_SHARE;
+      const sink = await createAudioRenderSink(source.channels, source.sampleRate);
+      try {
+        const result = await renderMediaFx({
+          fx,
+          source,
+          denoiser: options.denoiser,
+          write: (block) => sink.write(block),
+          onProgress: (f) => options.onProgress?.(from + f * span),
+          signal: options.signal,
+          ...analysis ? { analysis } : {}
+        });
+        const corrected = attempt === 0 ? correctedLoudnessAnalysis(fx, result) : null;
+        if (corrected) {
+          await sink.cancel();
+          analysis = corrected;
+          continue;
+        }
+        const encoded = await sink.finish();
+        options.onProgress?.(1);
+        return {
+          ...encoded,
+          analysis: result.analysis,
+          ignoredOps: result.ignoredOps,
+          sourceDuration: source.trackDurationSec,
+          engine: MEDIA_FX_ENGINE
+        };
+      } catch (err) {
+        await sink.cancel().catch(() => {
+        });
+        throw err;
+      }
+    }
+  } finally {
+    source.dispose();
+  }
+}
+async function analyzeMediaEditAudio(request, options = {}) {
+  const fx = chainOf(request.fx);
+  const source = await openMediaAudio(request.source);
+  if (!source) return null;
+  try {
+    return await analyzeMediaFx({
+      fx,
+      source,
+      denoiser: options.denoiser,
+      onProgress: options.onProgress,
+      signal: options.signal
+    });
+  } finally {
+    source.dispose();
+  }
+}
+async function previewMediaEditAudio(request, options = {}) {
+  const fx = chainOf(request.fx);
+  const decodeFrom = Math.max(0, request.startSec - PREVIEW_PREROLL_SEC);
+  const source = await openMediaAudio(request.source, {
+    startSec: decodeFrom,
+    endSec: request.endSec
+  });
+  if (!source) throw new Error("This media has no audio track to process.");
+  try {
+    const originalBlocks = [];
+    for await (const block of source.open()) originalBlocks.push(block.map((ch) => ch.slice()));
+    const processedBlocks = [];
+    await renderMediaFx({
+      fx,
+      source,
+      startSec: decodeFrom,
+      denoiser: options.denoiser,
+      write: (block) => {
+        processedBlocks.push(block.map((ch) => ch.slice()));
+      },
+      onProgress: options.onProgress,
+      signal: options.signal,
+      ...request.analysis ? { analysis: request.analysis } : {}
+    });
+    const skip = Math.round((request.startSec - decodeFrom) * source.sampleRate);
+    const trim = (channels) => channels.map((ch) => ch.slice(skip));
+    return {
+      sampleRate: source.sampleRate,
+      startSec: request.startSec,
+      original: trim(concatBlocks(originalBlocks, source.channels)),
+      processed: trim(concatBlocks(processedBlocks, source.channels))
+    };
+  } finally {
+    source.dispose();
+  }
+}
+async function analyzeMediaEditPauses(request, options = {}) {
+  const source = await openMediaAudio(request.source);
+  if (!source) throw new Error("This media has no audio track to analyze.");
+  try {
+    const analyzer = createBreathAnalyzer(source.sampleRate);
+    let seen = 0;
+    for await (const block of source.open()) {
+      options.signal?.throwIfAborted();
+      const mono = block.length === 1 ? block[0] : block[0].map((_, i) => block.reduce((sum, ch) => sum + ch[i], 0) / block.length);
+      analyzer.push(mono);
+      seen += block[0].length;
+      options.onProgress?.(Math.min(1, seen / Math.max(1, source.frames)));
+    }
+    return {
+      cuts: detectPauseCuts(analyzer.frames(), request.options),
+      durationSec: source.trackDurationSec
+    };
+  } finally {
+    source.dispose();
+  }
+}
+
+export {
+  renderMediaEditAudio,
+  analyzeMediaEditAudio,
+  previewMediaEditAudio,
+  analyzeMediaEditPauses
+};