@bendyline/squisq-video-react 2.5.28 → 2.5.30

package/dist/{captureVideoCodecs-HVCZBBNT.js → captureVideoCodecs-3QXX66ZI.js}

@@ -6,7 +6,7 @@ import {
   QTFF,
   VideoSampleSink,
   WEBM
-} from "./chunk-EJ3DVPFF.js";
+} from "./chunk-MOIVICAD.js";
 export {
   BlobSource,
   Input,

package/dist/chunk-AARDBHRJ.js

@@ -0,0 +1,129 @@
+import {
+  ADTS,
+  AudioSampleSink,
+  BlobSource,
+  FLAC,
+  Input,
+  MATROSKA,
+  MP3,
+  MP4,
+  OGG,
+  QTFF,
+  WAVE,
+  WEBM
+} from "./chunk-MOIVICAD.js";
+
+// src/mediaEdit/mediaAudioSource.ts
+import {
+  MEDIA_FX_SAMPLE_RATE,
+  createResampler
+} from "@bendyline/squisq/mediaEdit";
+var MEDIA_INPUT_FORMATS = [MP4, QTFF, WEBM, MATROSKA, WAVE, MP3, OGG, FLAC, ADTS];
+async function probeMediaDuration(blob) {
+  const input = new Input({ source: new BlobSource(blob), formats: MEDIA_INPUT_FORMATS });
+  try {
+    return await input.computeDuration();
+  } finally {
+    input.dispose();
+  }
+}
+async function openMediaAudio(blob, options = {}) {
+  const input = new Input({ source: new BlobSource(blob), formats: MEDIA_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,
+    // The same Input has already indexed the file for the audio track.
+    mediaDuration: async () => Math.max(trackDurationSec, await input.computeDuration()),
+    dispose: () => input.dispose()
+  };
+}
+
+export {
+  MEDIA_INPUT_FORMATS,
+  probeMediaDuration,
+  openMediaAudio
+};