@bendyline/squisq-video-react 2.4.20 → 2.4.22

package/dist/lossyEncoder-EIXBAOLG.js

@@ -0,0 +1,236 @@
+import {
+  AudioSample,
+  AudioSampleSource,
+  BufferTarget,
+  Mp4OutputFormat,
+  Output,
+  WebMOutputFormat,
+  canEncodeAudio
+} from "./chunk-C7NEHV5X.js";
+import {
+  assertOpen,
+  blockFrames,
+  createSerialQueue
+} from "./chunk-2W6JQSIY.js";
+
+// src/audioFile/resampler.ts
+var HALF_TAPS = 16;
+var ROLLOFF = 0.94;
+var MAX_PHASES = 4096;
+function gcd(a, b) {
+  let x = a;
+  let y = b;
+  while (y !== 0) {
+    const t = x % y;
+    x = y;
+    y = t;
+  }
+  return x;
+}
+function assertRate(name, rate) {
+  if (!Number.isInteger(rate) || rate <= 0) {
+    throw new RangeError(`${name} must be a positive integer number of hertz (got ${rate}).`);
+  }
+}
+function resampledLength(inputFrames, inputRate, outputRate) {
+  return Math.ceil(inputFrames * outputRate / inputRate);
+}
+function createResampler(inputRate, outputRate) {
+  assertRate("inputRate", inputRate);
+  assertRate("outputRate", outputRate);
+  const divisor = gcd(inputRate, outputRate);
+  const stepNum = inputRate / divisor;
+  const phaseDen = outputRate / divisor;
+  const phaseCount = Math.min(phaseDen, MAX_PHASES);
+  const ratio = Math.min(1, outputRate / inputRate);
+  const cutoff = ratio * ROLLOFF;
+  const halfWidth = Math.ceil(HALF_TAPS / ratio);
+  const taps = halfWidth * 2;
+  const filters = new Array(phaseCount);
+  const buildFilter = (frac) => {
+    const filter = new Float32Array(taps);
+    let sum = 0;
+    for (let j = 0; j < taps; j++) {
+      const d = frac + (halfWidth - 1 - j);
+      const x = d / halfWidth;
+      const window = 0.42 + 0.5 * Math.cos(Math.PI * x) + 0.08 * Math.cos(2 * Math.PI * x);
+      const arg = Math.PI * cutoff * d;
+      const sinc = arg === 0 ? 1 : Math.sin(arg) / arg;
+      const weight = cutoff * sinc * window;
+      filter[j] = weight;
+      sum += weight;
+    }
+    for (let j = 0; j < taps; j++) filter[j] /= sum;
+    return filter;
+  };
+  let buffer = new Float32Array(Math.max(1024, taps * 4));
+  let bufferStart = -(halfWidth - 1);
+  let bufferLength = halfWidth - 1;
+  let received = 0;
+  let nextOutput = 0;
+  let flushed = false;
+  const append = (input) => {
+    const needed = bufferLength + input.length;
+    if (needed > buffer.length) {
+      let capacity = buffer.length;
+      while (capacity < needed) capacity *= 2;
+      const grown = new Float32Array(capacity);
+      grown.set(buffer.subarray(0, bufferLength));
+      buffer = grown;
+    }
+    buffer.set(input, bufferLength);
+    bufferLength += input.length;
+  };
+  const quantized = phaseCount !== phaseDen;
+  const drain = (limit, maxOutputs) => {
+    const estimate = Math.max(
+      0,
+      Math.ceil((limit - halfWidth) * phaseDen / stepNum) - nextOutput + 2
+    );
+    const out = new Float32Array(Math.min(estimate, Math.max(0, maxOutputs - nextOutput)));
+    let count = 0;
+    while (nextOutput < maxOutputs && count < out.length) {
+      const position = nextOutput * stepNum;
+      let base = Math.floor(position / phaseDen);
+      const remainder = position - base * phaseDen;
+      let key = quantized ? Math.round(remainder * phaseCount / phaseDen) : remainder;
+      if (key >= phaseCount) {
+        base += 1;
+        key = 0;
+      }
+      if (base + halfWidth >= limit) break;
+      const filter = filters[key] ?? (filters[key] = buildFilter(key / phaseCount));
+      const offset = base - halfWidth + 1 - bufferStart;
+      let acc = 0;
+      for (let j = 0; j < taps; j++) acc += buffer[offset + j] * filter[j];
+      out[count++] = acc;
+      nextOutput += 1;
+    }
+    const keepFrom = Math.floor(nextOutput * stepNum / phaseDen) - halfWidth + 1;
+    const drop = Math.min(bufferLength, Math.max(0, keepFrom - bufferStart));
+    if (drop > 0) {
+      buffer.copyWithin(0, drop, bufferLength);
+      bufferLength -= drop;
+      bufferStart += drop;
+    }
+    return count === out.length ? out : out.slice(0, count);
+  };
+  return {
+    inputRate,
+    outputRate,
+    process(input) {
+      if (flushed) throw new Error("The resampler was already flushed.");
+      if (input.length === 0) return new Float32Array(0);
+      append(input);
+      received += input.length;
+      return drain(received, Number.POSITIVE_INFINITY);
+    },
+    flush() {
+      if (flushed) return new Float32Array(0);
+      flushed = true;
+      append(new Float32Array(halfWidth + 1));
+      return drain(received + halfWidth + 1, resampledLength(received, inputRate, outputRate));
+    }
+  };
+}
+
+// src/audioFile/lossyEncoder.ts
+var FALLBACK_ENCODE_RATES = [48e3, 44100];
+var SLICE_SECONDS = 0.5;
+async function pickEncodeRate(codec, channels, inputRate, bitrate) {
+  const candidates = [inputRate, ...FALLBACK_ENCODE_RATES.filter((rate) => rate !== inputRate)];
+  for (const sampleRate of candidates) {
+    if (await canEncodeAudio(codec, { numberOfChannels: channels, sampleRate, bitrate })) {
+      return sampleRate;
+    }
+  }
+  return null;
+}
+async function canEncodeLossyFormat(info) {
+  for (const channels of [2, 1]) {
+    if (await pickEncodeRate(info.codec, channels, 48e3, info.bitrate[channels]) !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+async function createLossyEncoder(options, info) {
+  const channels = options.channels;
+  const bitrate = options.bitrate ?? info.bitrate[channels];
+  const encodeRate = await pickEncodeRate(info.codec, channels, options.sampleRate, bitrate);
+  if (encodeRate === null) {
+    throw new Error(`This browser cannot encode ${info.label} audio.`);
+  }
+  const target = new BufferTarget();
+  const output = new Output({
+    // Audio-only MP4 (no video track), metadata up front for progressive playback.
+    format: info.codec === "aac" ? new Mp4OutputFormat({ fastStart: "in-memory" }) : new WebMOutputFormat(),
+    target
+  });
+  const source = new AudioSampleSource({ codec: info.codec, bitrate });
+  output.addAudioTrack(source);
+  await output.start();
+  const resamplers = encodeRate === options.sampleRate ? null : Array.from({ length: channels }, () => createResampler(options.sampleRate, encodeRate));
+  const sliceFrames = Math.max(1024, Math.round(options.sampleRate * SLICE_SECONDS));
+  const serial = createSerialQueue();
+  let state = "open";
+  let written = 0;
+  const encodeBlock = async (planar) => {
+    const frames = planar[0]?.length ?? 0;
+    if (frames === 0) return;
+    const data = new Float32Array(frames * channels);
+    for (let c = 0; c < channels; c++) data.set(planar[c], c * frames);
+    const sample = new AudioSample({
+      data,
+      format: "f32-planar",
+      numberOfChannels: channels,
+      sampleRate: encodeRate,
+      timestamp: written / encodeRate
+    });
+    try {
+      await source.add(sample);
+    } finally {
+      sample.close();
+    }
+    written += frames;
+  };
+  return {
+    format: info.format,
+    mimeType: info.mimeType,
+    extension: info.extension,
+    append: (block) => serial(async () => {
+      assertOpen(state);
+      const frames = blockFrames(block, channels);
+      for (let start = 0; start < frames; start += sliceFrames) {
+        assertOpen(state);
+        const end = Math.min(frames, start + sliceFrames);
+        const slice = block.map((channel) => channel.subarray(start, end));
+        await encodeBlock(resamplers ? slice.map((s, c) => resamplers[c].process(s)) : slice);
+      }
+    }),
+    finish: () => serial(async () => {
+      assertOpen(state);
+      if (resamplers) await encodeBlock(resamplers.map((resampler) => resampler.flush()));
+      if (written === 0) {
+        state = "cancelled";
+        await output.cancel();
+        throw new Error("Cannot finish an empty audio file: no samples were appended.");
+      }
+      state = "finished";
+      source.close();
+      await output.finalize();
+      if (!target.buffer) throw new Error("The audio encoder produced no output.");
+      return new Blob([target.buffer], { type: info.mimeType });
+    }),
+    cancel: async () => {
+      if (state !== "open") return;
+      state = "cancelled";
+      await output.cancel();
+    }
+  };
+}
+export {
+  canEncodeLossyFormat,
+  createLossyEncoder,
+  pickEncodeRate
+};

package/dist/media-edit/index.js

@@ -4,7 +4,7 @@ import {
   useMediaEditRenders,
   useMediaEditStatus,
   useProcessedAudio
-} from "../chunk-JKWCZION.js";
+} from "../chunk-OLFWEKY5.js";
 import "../chunk-TL2IMDIZ.js";
 export {
   createMediaEditRenderManager,

package/dist/{mediaEditEngine-ZLG7D3TB.js → mediaEditEngine-JLZ4Z5BB.js}

@@ -3,8 +3,8 @@ import {
   analyzeMediaEditPauses,
   previewMediaEditAudio,
   renderMediaEditAudio
-} from "./chunk-IFQJAW4V.js";
-import "./chunk-4GFZ3GUE.js";
+} from "./chunk-BNNLPKT2.js";
+import "./chunk-C7NEHV5X.js";
 export {
   analyzeMediaEditAudio,
   analyzeMediaEditPauses,

package/dist/workers/mediaEdit.worker.js

@@ -3,8 +3,8 @@ import {
   analyzeMediaEditPauses,
   previewMediaEditAudio,
   renderMediaEditAudio
-} from "../chunk-IFQJAW4V.js";
-import "../chunk-4GFZ3GUE.js";
+} from "../chunk-BNNLPKT2.js";
+import "../chunk-C7NEHV5X.js";
 import {
   createRnnoiseDenoiserFactory
 } from "../chunk-TL2IMDIZ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-video-react",
-  "version": "2.4.20",
+  "version": "2.4.22",
   "description": "React components for browser-based MP4 and animated-GIF export of Squisq documents",
   "license": "MIT",
   "author": "Bendyline",
@@ -77,9 +77,9 @@
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
-    "@bendyline/squisq": "2.11.14",
-    "@bendyline/squisq-video": "2.3.18",
-    "@bendyline/squisq-react": "2.11.16",
+    "@bendyline/squisq": "2.11.16",
+    "@bendyline/squisq-video": "2.3.20",
+    "@bendyline/squisq-react": "2.11.18",
     "@ffmpeg/core": "0.12.9",
     "@ffmpeg/ffmpeg": "0.12.15",
     "@ffmpeg/util": "0.12.2",