@bendyline/squisq-video-react 2.5.28 → 2.5.30

package/dist/{chunk-3IMR25SX.js → chunk-MVEZDB4G.js}

@@ -1,6 +1,6 @@
 import {
   useFrameCapture
-} from "./chunk-ZEA6XJL7.js";
+} from "./chunk-YO7JVV3K.js";
 import {
   EXPORT_AUDIO_CHANNELS,
   EXPORT_AUDIO_SAMPLE_RATE,

package/dist/{chunk-XPWYKETM.js → chunk-QKTQL3NK.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-3NJDHK62.js";
 import {
   useFrameCapture
-} from "./chunk-ZEA6XJL7.js";
+} from "./chunk-YO7JVV3K.js";
 
 // src/CoverImageExportModal.tsx
 import { useCallback, useId, useRef, useState } from "react";

package/dist/{chunk-JKRF65OD.js → chunk-QZSP5DGO.js}

@@ -1,6 +1,6 @@
 import {
   useVideoExport
-} from "./chunk-3IMR25SX.js";
+} from "./chunk-MVEZDB4G.js";
 
 // src/VideoExportModal.tsx
 import { useState, useCallback, useEffect, useId, useRef } from "react";

package/dist/{chunk-J6MJYH2I.js → chunk-SGLTT5CL.js}

@@ -1,24 +1,16 @@
 import {
-  ADTS,
+  openMediaAudio,
+  probeMediaDuration
+} from "./chunk-AARDBHRJ.js";
+import {
   AudioSample,
-  AudioSampleSink,
   AudioSampleSource,
-  BlobSource,
   BufferTarget,
-  FLAC,
-  Input,
-  MATROSKA,
-  MP3,
-  MP4,
-  OGG,
   Output,
-  QTFF,
-  WAVE,
-  WEBM,
   WavOutputFormat,
   WebMOutputFormat,
   canEncodeAudio
-} from "./chunk-EJ3DVPFF.js";
+} from "./chunk-MOIVICAD.js";
 
 // src/mediaEdit/mediaEditEngine.ts
 import {
@@ -75,102 +67,34 @@ async function createAudioRenderSink(channels, sampleRate) {
   };
 }
 
-// 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;
-          }
+// src/mediaEdit/waveformPeaks.ts
+var WAVEFORM_PEAKS_PER_SEC = 100;
+function createPeakAccumulator(sampleRate, peaksPerSec = WAVEFORM_PEAKS_PER_SEC, expectedFrames = 0) {
+  const framesPerPeak = sampleRate / peaksPerSec;
+  let peaks = new Float32Array(Math.max(16, Math.ceil(expectedFrames / framesPerPeak)));
+  let seen = 0;
+  return {
+    push(block) {
+      const length = block[0]?.length ?? 0;
+      if (length === 0) return;
+      const last = Math.floor((seen + length - 1) / framesPerPeak);
+      if (last >= peaks.length) {
+        const grown = new Float32Array(Math.max(last + 1, peaks.length * 2));
+        grown.set(peaks);
+        peaks = grown;
+      }
+      for (const channel of block) {
+        for (let i = 0; i < length; i++) {
+          const magnitude = Math.abs(channel[i]);
+          const slot = Math.floor((seen + i) / framesPerPeak);
+          if (magnitude > peaks[slot]) peaks[slot] = magnitude;
         }
-        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();
       }
+      seen += length;
+    },
+    finish() {
+      return peaks.slice(0, Math.ceil(seen / framesPerPeak));
     }
-    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()
   };
 }
 
@@ -291,6 +215,37 @@ async function previewMediaEditAudio(request, options = {}) {
     source.dispose();
   }
 }
+async function analyzeMediaEditWaveform(request, options = {}) {
+  const source = await openMediaAudio(request.source);
+  if (!source) {
+    return {
+      peaks: new Float32Array(0),
+      peaksPerSec: WAVEFORM_PEAKS_PER_SEC,
+      durationSec: await probeMediaDuration(request.source)
+    };
+  }
+  try {
+    const accumulator = createPeakAccumulator(
+      source.sampleRate,
+      WAVEFORM_PEAKS_PER_SEC,
+      source.frames
+    );
+    let seen = 0;
+    for await (const block of source.open()) {
+      options.signal?.throwIfAborted();
+      accumulator.push(block);
+      seen += block[0].length;
+      options.onProgress?.(Math.min(1, seen / Math.max(1, source.frames)));
+    }
+    return {
+      peaks: accumulator.finish(),
+      peaksPerSec: WAVEFORM_PEAKS_PER_SEC,
+      durationSec: await source.mediaDuration()
+    };
+  } 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.");
@@ -317,5 +272,6 @@ export {
   renderMediaEditAudio,
   analyzeMediaEditAudio,
   previewMediaEditAudio,
+  analyzeMediaEditWaveform,
   analyzeMediaEditPauses
 };

package/dist/chunk-VKGKDTWK.js

@@ -0,0 +1,292 @@
+import {
+  MEDIA_INPUT_FORMATS,
+  openMediaAudio
+} from "./chunk-AARDBHRJ.js";
+import {
+  AudioSample,
+  AudioSampleSource,
+  BlobSource,
+  BufferTarget,
+  Input,
+  Mp4OutputFormat,
+  Output,
+  QUALITY_HIGH,
+  VideoSampleSink,
+  VideoSampleSource,
+  WavOutputFormat,
+  WebMOutputFormat,
+  canEncodeAudio,
+  canEncodeVideo,
+  getFirstEncodableVideoCodec
+} from "./chunk-MOIVICAD.js";
+
+// src/mediaEdit/mediaBakeEngine.ts
+import {
+  MEDIA_BAKE_ENGINE,
+  createMediaBakeAudioStage,
+  createMediaTimeMap,
+  mediaBakeFrameRanges
+} from "@bendyline/squisq/mediaEdit";
+var SEEK_PAST_CUT_SEC = 6;
+var FALLBACK_FRAME_SEC = 1 / 30;
+var AUDIO_BITRATE_PER_CHANNEL = 96e3;
+function audioBitrate(channels) {
+  return Math.min(192e3, AUDIO_BITRATE_PER_CHANNEL * channels);
+}
+function timeMapFor(request, sourceDuration) {
+  const map = createMediaTimeMap({
+    clipStart: request.clipStart,
+    clipEnd: request.clipEnd,
+    cuts: request.cuts,
+    sourceDuration
+  });
+  if (!(map.playedDuration > 0) || !Number.isFinite(map.playedDuration)) {
+    throw new Error("Nothing is left of this clip after its trim and cuts.");
+  }
+  return map;
+}
+function audioStageFor(request, map, sampleRate) {
+  return createMediaBakeAudioStage({
+    ranges: mediaBakeFrameRanges(map.keptRanges(), map.windowStart, sampleRate),
+    sampleRate,
+    gainDb: request.gain,
+    fadeInSec: request.fadeIn,
+    fadeOutSec: request.fadeOut
+  });
+}
+async function pumpAudio(audio, stage, source, options, onFrames) {
+  let written = 0;
+  for await (const block of audio.open()) {
+    options.signal?.throwIfAborted();
+    const kept = stage.process(block);
+    if (!kept) continue;
+    const frames = kept[0].length;
+    const data = new Float32Array(frames * kept.length);
+    kept.forEach((channel, c) => data.set(channel, c * frames));
+    const sample = new AudioSample({
+      data,
+      format: "f32-planar",
+      numberOfChannels: kept.length,
+      sampleRate: audio.sampleRate,
+      timestamp: written / audio.sampleRate
+    });
+    try {
+      await source.add(sample);
+    } finally {
+      sample.close();
+    }
+    written += frames;
+    onFrames?.(written);
+  }
+  return written;
+}
+async function pickAudioTarget(channels, sampleRate) {
+  const probe = { numberOfChannels: channels, sampleRate, bitrate: audioBitrate(channels) };
+  if (await canEncodeAudio("aac", probe)) {
+    return {
+      format: new Mp4OutputFormat(),
+      codec: "aac",
+      mimeType: "audio/mp4",
+      extension: "m4a"
+    };
+  }
+  if (await canEncodeAudio("opus", probe)) {
+    return {
+      format: new WebMOutputFormat(),
+      codec: "opus",
+      mimeType: "audio/webm",
+      extension: "webm"
+    };
+  }
+  return {
+    format: new WavOutputFormat(),
+    codec: "pcm-s16",
+    mimeType: "audio/wav",
+    extension: "wav"
+  };
+}
+async function bakeAudioClip(request, options) {
+  const audio = await openMediaAudio(request.audio ?? request.source, {
+    startSec: request.clipStart ?? 0,
+    endSec: request.clipEnd
+  });
+  if (!audio) throw new Error("This clip has no audio track to bake.");
+  try {
+    const map = timeMapFor(request, audio.trackDurationSec);
+    const stage = audioStageFor(request, map, audio.sampleRate);
+    const target = await pickAudioTarget(audio.channels, audio.sampleRate);
+    const buffer = new BufferTarget();
+    const output = new Output({ format: target.format, target: buffer });
+    const source = new AudioSampleSource(
+      target.codec === "pcm-s16" ? { codec: "pcm-s16" } : { codec: target.codec, bitrate: audioBitrate(audio.channels) }
+    );
+    output.addAudioTrack(source);
+    await output.start();
+    try {
+      const written = await pumpAudio(
+        audio,
+        stage,
+        source,
+        options,
+        (frames) => options.onProgress?.(Math.min(1, frames / Math.max(1, stage.totalFrames)))
+      );
+      source.close();
+      await output.finalize();
+      if (!buffer.buffer) throw new Error("The bake produced no output.");
+      options.onProgress?.(1);
+      return {
+        bytes: buffer.buffer,
+        mimeType: target.mimeType,
+        extension: target.extension,
+        durationSec: written / audio.sampleRate,
+        engine: MEDIA_BAKE_ENGINE
+      };
+    } catch (err) {
+      await output.cancel().catch(() => {
+      });
+      throw err;
+    }
+  } finally {
+    audio.dispose();
+  }
+}
+async function pickVideoTarget(width, height, audio) {
+  const audioProbe = audio && {
+    numberOfChannels: audio.channels,
+    sampleRate: audio.sampleRate,
+    bitrate: audioBitrate(audio.channels)
+  };
+  const size = { width, height };
+  if (await canEncodeVideo("avc", size) && (!audioProbe || await canEncodeAudio("aac", audioProbe))) {
+    return {
+      format: new Mp4OutputFormat(),
+      video: "avc",
+      audio: "aac",
+      mimeType: "video/mp4",
+      extension: "mp4"
+    };
+  }
+  const webm = await getFirstEncodableVideoCodec(["vp9", "vp8"], size);
+  if (webm && (!audioProbe || await canEncodeAudio("opus", audioProbe))) {
+    return {
+      format: new WebMOutputFormat(),
+      video: webm,
+      audio: "opus",
+      mimeType: "video/webm",
+      extension: "webm"
+    };
+  }
+  throw new Error("This browser cannot encode video, so the clip cannot be baked.");
+}
+function bakeCropRectangle(crop, displayWidth, displayHeight) {
+  const even = (value) => Math.max(2, Math.floor(value / 2) * 2);
+  const left = crop ? Math.round(crop.x * displayWidth) : 0;
+  const top = crop ? Math.round(crop.y * displayHeight) : 0;
+  const width = even(
+    Math.min(displayWidth - left, crop ? Math.round(crop.w * displayWidth) : displayWidth)
+  );
+  const height = even(
+    Math.min(displayHeight - top, crop ? Math.round(crop.h * displayHeight) : displayHeight)
+  );
+  if (left === 0 && top === 0 && width === displayWidth && height === displayHeight) return null;
+  return { left, top, width, height };
+}
+function bakeDecodeRuns(kept) {
+  const runs = [];
+  for (const range of kept) {
+    const last = runs[runs.length - 1];
+    if (last && range.start - last.end < SEEK_PAST_CUT_SEC) last.end = range.end;
+    else runs.push({ ...range });
+  }
+  return runs;
+}
+async function bakeVideoClip(request, options) {
+  const input = new Input({ source: new BlobSource(request.source), formats: MEDIA_INPUT_FORMATS });
+  let audio = null;
+  try {
+    const track = await input.getPrimaryVideoTrack();
+    if (!track) throw new Error("This clip has no video track to bake.");
+    if (!await track.canDecode()) throw new Error("This browser cannot decode this video.");
+    audio = await openMediaAudio(request.audio ?? request.source, {
+      startSec: request.clipStart ?? 0,
+      endSec: request.clipEnd
+    });
+    const sourceDuration = Math.max(await track.computeDuration(), audio?.trackDurationSec ?? 0);
+    const map = timeMapFor(request, sourceDuration);
+    const crop = bakeCropRectangle(request.crop, track.displayWidth, track.displayHeight);
+    const width = crop?.width ?? track.displayWidth;
+    const height = crop?.height ?? track.displayHeight;
+    const target = await pickVideoTarget(width, height, audio);
+    const buffer = new BufferTarget();
+    const output = new Output({ format: target.format, target: buffer });
+    const videoSource = new VideoSampleSource({
+      codec: target.video,
+      quality: QUALITY_HIGH,
+      // A screen recording can change size mid-take; keep the first frame's box.
+      sizeChangeBehavior: "contain",
+      ...crop ? { transform: { crop } } : {}
+    });
+    output.addVideoTrack(videoSource);
+    const audioSource = audio ? new AudioSampleSource({ codec: target.audio, bitrate: audioBitrate(audio.channels) }) : null;
+    if (audioSource) output.addAudioTrack(audioSource);
+    await output.start();
+    const pumpVideo = async () => {
+      const sink = new VideoSampleSink(track);
+      let lastEnd = 0;
+      for (const run of bakeDecodeRuns(map.keptRanges())) {
+        for await (const sample of sink.samples(run.start, run.end)) {
+          try {
+            options.signal?.throwIfAborted();
+            const length = sample.duration > 0 ? sample.duration : FALLBACK_FRAME_SEC;
+            const start = Math.max(lastEnd, map.snapSourceToPlayed(sample.timestamp));
+            const end = map.snapSourceToPlayed(sample.timestamp + length);
+            if (end - start < 1e-4) continue;
+            sample.setTimestamp(start);
+            sample.setDuration(end - start);
+            await videoSource.add(sample);
+            lastEnd = end;
+            options.onProgress?.(Math.min(1, end / map.playedDuration));
+          } finally {
+            sample.close();
+          }
+        }
+      }
+      videoSource.close();
+    };
+    const pumpSound = async () => {
+      if (!audio || !audioSource) return;
+      await pumpAudio(audio, audioStageFor(request, map, audio.sampleRate), audioSource, options);
+      audioSource.close();
+    };
+    try {
+      await Promise.all([pumpVideo(), pumpSound()]);
+      await output.finalize();
+    } catch (err) {
+      await output.cancel().catch(() => {
+      });
+      throw err;
+    }
+    if (!buffer.buffer) throw new Error("The bake produced no output.");
+    options.onProgress?.(1);
+    return {
+      bytes: buffer.buffer,
+      mimeType: target.mimeType,
+      extension: target.extension,
+      durationSec: map.playedDuration,
+      engine: MEDIA_BAKE_ENGINE
+    };
+  } finally {
+    audio?.dispose();
+    input.dispose();
+  }
+}
+async function bakeMediaClip(request, options = {}) {
+  options.signal?.throwIfAborted();
+  return request.kind === "video" ? bakeVideoClip(request, options) : bakeAudioClip(request, options);
+}
+
+export {
+  bakeCropRectangle,
+  bakeDecodeRuns,
+  bakeMediaClip
+};

package/dist/{chunk-VE3OUBRG.js → chunk-XDJ2FPQQ.js}

@@ -92,7 +92,7 @@ function createWavStreamWriter(sampleRate, channels, options = {}) {
 // src/audioFile/audioFileEncoder.ts
 var lossyModule = null;
 function loadLossyModule() {
-  lossyModule ?? (lossyModule = import("./lossyEncoder-27NI5K4Y.js"));
+  lossyModule ?? (lossyModule = import("./lossyEncoder-U4V3AER7.js"));
   return lossyModule;
 }
 function validateOptions(options) {