@remotion/media-utils 4.0.453 → 4.0.454

package/dist/esm/index.mjs

@@ -0,0 +1,1252 @@
+// src/audio-buffer/audio-buffer-to-wav.ts
+function interleave(inputL, inputR) {
+  const length = inputL.length + inputR.length;
+  const result = new Float32Array(length);
+  let index = 0;
+  let inputIndex = 0;
+  while (index < length) {
+    result[index++] = inputL[inputIndex];
+    result[index++] = inputR[inputIndex];
+    inputIndex++;
+  }
+  return result;
+}
+function writeFloat32(output, offset, input) {
+  for (let i = 0;i < input.length; i++, offset += 4) {
+    output.setFloat32(offset, input[i], true);
+  }
+}
+function floatTo16BitPCM(output, offset, input) {
+  for (let i = 0;i < input.length; i++, offset += 2) {
+    const s = Math.max(-1, Math.min(1, input[i]));
+    output.setInt16(offset, s < 0 ? s * 32768 : s * 32767, true);
+  }
+}
+function writeString(view, offset, string) {
+  for (let i = 0;i < string.length; i++) {
+    view.setUint8(offset + i, string.charCodeAt(i));
+  }
+}
+function encodeWAV({
+  samples,
+  format,
+  sampleRate,
+  numChannels,
+  bitDepth
+}) {
+  const bytesPerSample = bitDepth / 8;
+  const blockAlign = numChannels * bytesPerSample;
+  const buffer = new ArrayBuffer(44 + samples.length * bytesPerSample);
+  const view = new DataView(buffer);
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, 36 + samples.length * bytesPerSample, true);
+  writeString(view, 8, "WAVE");
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, format, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitDepth, true);
+  writeString(view, 36, "data");
+  view.setUint32(40, samples.length * bytesPerSample, true);
+  if (format === 1) {
+    floatTo16BitPCM(view, 44, samples);
+  } else {
+    writeFloat32(view, 44, samples);
+  }
+  return buffer;
+}
+function audioBufferToWav(buffer, opt) {
+  const numChannels = buffer.numberOfChannels;
+  const { sampleRate } = buffer;
+  const format = opt.float32 ? 3 : 1;
+  const bitDepth = format === 3 ? 32 : 16;
+  let result;
+  if (numChannels === 2) {
+    result = interleave(buffer.getChannelData(0), buffer.getChannelData(1));
+  } else {
+    result = buffer.getChannelData(0);
+  }
+  return encodeWAV({
+    samples: result,
+    format,
+    sampleRate,
+    numChannels,
+    bitDepth
+  });
+}
+
+// src/audio-buffer/audio-url-helpers.ts
+var audioBufferToDataUrl = (buffer) => {
+  const wavAsArrayBuffer = audioBufferToWav(buffer, {
+    float32: true
+  });
+  let binary = "";
+  const bytes = new Uint8Array(wavAsArrayBuffer);
+  const len = bytes.byteLength;
+  for (let i = 0;i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return "data:audio/wav;base64," + window.btoa(binary);
+};
+// src/create-smooth-svg-path.ts
+var line = (pointA, pointB) => {
+  const lengthX = pointB.x - pointA.x;
+  const lengthY = pointB.y - pointA.y;
+  return {
+    length: Math.sqrt(lengthX ** 2 + lengthY ** 2),
+    angle: Math.atan2(lengthY, lengthX)
+  };
+};
+var controlPoint = ({
+  current,
+  previous,
+  next,
+  reverse
+}) => {
+  const p = previous || current;
+  const n = next || current;
+  const smoothing = 0.2;
+  const o = line(p, n);
+  const angle = o.angle + (reverse ? Math.PI : 0);
+  const length = o.length * smoothing;
+  const x = current.x + Math.cos(angle) * length;
+  const y = current.y + Math.sin(angle) * length;
+  return { x, y };
+};
+var createSmoothSvgPath = ({ points }) => {
+  return points.reduce((acc, current, i, a) => {
+    if (i === 0) {
+      return `M ${current.x},${current.y}`;
+    }
+    const { x, y } = current;
+    const previous = a[i - 1];
+    const twoPrevious = a[i - 2];
+    const next = a[i + 1];
+    const { x: cp1x, y: cp1y } = controlPoint({
+      current: previous,
+      previous: twoPrevious,
+      next: current,
+      reverse: false
+    });
+    const { x: cp2x, y: cp2y } = controlPoint({
+      current,
+      previous,
+      next,
+      reverse: true
+    });
+    return `${acc} C ${cp1x},${cp1y} ${cp2x},${cp2y} ${x},${y}`;
+  }, "");
+};
+// src/fetch-with-cors-catch.ts
+var fetchWithCorsCatch = async (src, init) => {
+  try {
+    const response = await fetch(src, {
+      mode: "cors",
+      referrerPolicy: "no-referrer-when-downgrade",
+      ...init
+    });
+    return response;
+  } catch (err) {
+    const error = err;
+    if (error.message.includes("Failed to fetch") || error.message.includes("Load failed") || error.message.includes("NetworkError when attempting to fetch resource")) {
+      throw new TypeError(`Failed to read from ${src}: ${error.message}. Does the resource support CORS?`);
+    }
+    throw err;
+  }
+};
+
+// src/is-remote-asset.ts
+var isRemoteAsset = (asset) => !asset.startsWith(window.origin) && !asset.startsWith("data");
+
+// src/p-limit.ts
+var pLimit = (concurrency) => {
+  const queue = [];
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.length > 0) {
+      queue.shift()?.();
+    }
+  };
+  const run = async (fn, resolve, ...args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (fn, resolve, ...args) => {
+    queue.push(() => run(fn, resolve, ...args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.length > 0) {
+        queue.shift()?.();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, ...args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.length
+    },
+    clearQueue: {
+      value: () => {
+        queue.length = 0;
+      }
+    }
+  });
+  return generator;
+};
+
+// src/get-audio-data.ts
+var metadataCache = {};
+var limit = pLimit(3);
+var fn = async (src, options) => {
+  if (metadataCache[src]) {
+    return metadataCache[src];
+  }
+  if (typeof document === "undefined") {
+    throw new Error("getAudioData() is only available in the browser.");
+  }
+  const audioContext = new AudioContext({
+    sampleRate: options?.sampleRate ?? 48000
+  });
+  const response = await fetchWithCorsCatch(src);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch audio data from ${src}: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const wave = await audioContext.decodeAudioData(arrayBuffer);
+  const channelWaveforms = new Array(wave.numberOfChannels).fill(true).map((_, channel) => {
+    return wave.getChannelData(channel);
+  });
+  const metadata = {
+    channelWaveforms,
+    sampleRate: wave.sampleRate,
+    durationInSeconds: wave.duration,
+    numberOfChannels: wave.numberOfChannels,
+    resultId: String(Math.random()),
+    isRemote: isRemoteAsset(src)
+  };
+  metadataCache[src] = metadata;
+  return metadata;
+};
+var getAudioData = (src, options) => {
+  return limit(fn, src, options);
+};
+// src/media-tag-error-handling.ts
+async function fetchWithTimeout(url, options, timeout = 3000) {
+  const controller = new AbortController;
+  const id = setTimeout(() => controller.abort(), timeout);
+  options.signal = controller.signal;
+  try {
+    const response = await fetch(url, options);
+    clearTimeout(id);
+    return response;
+  } catch {
+    clearTimeout(id);
+    throw new Error(`Fetch timed out after ${timeout}ms`);
+  }
+}
+var checkFor404 = (src) => {
+  return fetchWithTimeout(src, {
+    method: "HEAD",
+    mode: "no-cors"
+  }).then((res) => res.status);
+};
+var checkFor404OrSkip = async ({
+  suspecting404,
+  sameOrigin,
+  src
+}) => {
+  if (!suspecting404) {
+    return Promise.resolve(null);
+  }
+  if (!sameOrigin) {
+    return Promise.resolve(null);
+  }
+  try {
+    return await checkFor404(src);
+  } catch {
+    return Promise.resolve(null);
+  }
+};
+var onMediaError = ({
+  error,
+  src,
+  reject,
+  cleanup,
+  api
+}) => {
+  const suspecting404 = error.MEDIA_ERR_SRC_NOT_SUPPORTED === error.code;
+  const isSrcSameOriginAsCurrent = new URL(src, window.location.origin).toString().startsWith(window.location.origin);
+  checkFor404OrSkip({
+    suspecting404,
+    sameOrigin: isSrcSameOriginAsCurrent,
+    src
+  }).then((status) => {
+    const err = status === 404 ? new Error([
+      `Failed to execute ${api}: Received a 404 error loading "${src}".`,
+      "Correct the URL of the file."
+    ].join(" ")) : new Error([
+      `Failed to execute ${api}, Received a MediaError loading "${src}". Consider using parseMedia() instead which supports more codecs: https://www.remotion.dev/docs/miscellaneous/parse-media-vs-get-video-metadata`,
+      status === null ? null : `HTTP Status code of the file: ${status}.`,
+      error.message ? `Browser error message: ${error.message}` : null,
+      "Check the path of the file and if it is a valid video."
+    ].filter(Boolean).join(" "));
+    reject(err);
+    cleanup();
+  }).catch((e) => {
+    reject(e);
+    cleanup();
+  });
+};
+
+// src/get-audio-duration-in-seconds.ts
+var limit2 = pLimit(3);
+var metadataCache2 = {};
+var fn2 = (src) => {
+  if (metadataCache2[src]) {
+    return Promise.resolve(metadataCache2[src]);
+  }
+  if (typeof document === "undefined") {
+    throw new Error("getAudioDuration() is only available in the browser.");
+  }
+  const audio = document.createElement("audio");
+  audio.src = src;
+  return new Promise((resolve, reject) => {
+    const onError = () => {
+      onMediaError({
+        error: audio.error,
+        src,
+        cleanup,
+        reject,
+        api: "getAudioDurationInSeconds()"
+      });
+    };
+    const onLoadedMetadata = () => {
+      metadataCache2[src] = audio.duration;
+      resolve(audio.duration);
+      cleanup();
+    };
+    const cleanup = () => {
+      audio.removeEventListener("loadedmetadata", onLoadedMetadata);
+      audio.removeEventListener("error", onError);
+      audio.remove();
+    };
+    audio.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    audio.addEventListener("error", onError, { once: true });
+  });
+};
+var getAudioDurationInSeconds = (src) => {
+  return limit2(fn2, src);
+};
+var getAudioDuration = (src) => getAudioDurationInSeconds(src);
+// src/get-image-dimensions.ts
+var imageDimensionsCache = {};
+var limit3 = pLimit(3);
+var fn3 = async (src) => {
+  if (imageDimensionsCache[src]) {
+    return imageDimensionsCache[src];
+  }
+  if (typeof document === "undefined") {
+    throw new Error("getImageDimensions() is only available in the browser.");
+  }
+  const imageDimensions = await new Promise((resolved, reject) => {
+    const image = new Image;
+    image.onload = () => {
+      const { width, height } = image;
+      resolved({ width, height });
+    };
+    image.onerror = reject;
+    image.src = src;
+  });
+  imageDimensionsCache[src] = imageDimensions;
+  return imageDimensions;
+};
+function getImageDimensions(src) {
+  return limit3(fn3, src);
+}
+// src/get-video-metadata.ts
+var cache = {};
+var limit4 = pLimit(3);
+var fn4 = (src) => {
+  if (cache[src]) {
+    return Promise.resolve(cache[src]);
+  }
+  if (typeof document === "undefined") {
+    throw new Error("getVideoMetadata() is only available in the browser.");
+  }
+  const video = document.createElement("video");
+  video.src = src;
+  return new Promise((resolve, reject) => {
+    const onError = () => {
+      onMediaError({
+        error: video.error,
+        src,
+        cleanup,
+        reject,
+        api: "getVideoMetadata()"
+      });
+    };
+    const onLoadedMetadata = () => {
+      const pixels = video.videoHeight * video.videoWidth;
+      if (pixels === 0) {
+        reject(new Error(`Unable to determine video metadata for ${src}`));
+        return;
+      }
+      if (!Number.isFinite(video.duration)) {
+        reject(new Error(`Unable to determine video duration for ${src} - got Infinity. Re-encoding this video may fix this issue.`));
+        return;
+      }
+      const metadata = {
+        durationInSeconds: video.duration,
+        width: video.videoWidth,
+        height: video.videoHeight,
+        aspectRatio: video.videoWidth / video.videoHeight,
+        isRemote: isRemoteAsset(src)
+      };
+      resolve(metadata);
+      cache[src] = metadata;
+      cleanup();
+    };
+    const cleanup = () => {
+      video.removeEventListener("loadedmetadata", onLoadedMetadata);
+      video.removeEventListener("error", onError);
+      video.remove();
+    };
+    video.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    video.addEventListener("error", onError, { once: true });
+  });
+};
+var getVideoMetadata = (src) => {
+  return limit4(fn4, src);
+};
+// src/get-waveform-portion.ts
+import { NoReactInternals } from "remotion/no-react";
+
+// src/normalize-data.ts
+var normalizeData = (filteredData) => {
+  const max = Math.max(...filteredData);
+  const multiplier = max === 0 ? 0 : max ** -1;
+  return filteredData.map((n) => n * multiplier);
+};
+
+// src/get-wave-form-samples.ts
+var getWaveformSamples = ({
+  audioBuffer,
+  numberOfSamples,
+  outputRange,
+  normalize
+}) => {
+  const blockSize = Math.floor(audioBuffer.length / numberOfSamples);
+  if (blockSize === 0) {
+    return [];
+  }
+  const filteredData = [];
+  for (let i = 0;i < numberOfSamples; i++) {
+    const blockStart = blockSize * i;
+    let sum = 0;
+    for (let j = 0;j < blockSize; j++) {
+      sum += Math.abs(audioBuffer[blockStart + j]);
+    }
+    filteredData.push(sum / blockSize);
+  }
+  if (normalize) {
+    if (outputRange === "minus-one-to-one") {
+      return normalizeData(filteredData).map((n, i) => {
+        if (i % 2 === 0) {
+          return n * -1;
+        }
+        return n;
+      });
+    }
+    return normalizeData(filteredData);
+  }
+  if (outputRange === "minus-one-to-one") {
+    return filteredData.map((n, i) => {
+      if (i % 2 === 0) {
+        return n * -1;
+      }
+      return n;
+    });
+  }
+  return filteredData;
+};
+
+// src/validate-channel.ts
+var validateChannel = (channel, numberOfChannels) => {
+  if (typeof channel !== "number") {
+    throw new TypeError(`"channel" must be a number`);
+  }
+  if (channel % 1 !== 0) {
+    throw new TypeError(`"channel" must an integer, got ${channel}`);
+  }
+  if (Number.isNaN(channel)) {
+    throw new TypeError(`The channel parameter is NaN.`);
+  }
+  if (channel < 0) {
+    throw new TypeError('"channel" cannot be negative');
+  }
+  if (channel > numberOfChannels - 1) {
+    throw new TypeError(`"channel" must be ${numberOfChannels - 1} or lower. The audio has ${numberOfChannels} channels`);
+  }
+};
+
+// src/get-waveform-portion.ts
+var concatArrays = (arrays) => {
+  const totalLength = arrays.reduce((acc, value) => acc + value.length, 0);
+  const result = new Float32Array(totalLength);
+  let length = 0;
+  for (const array of arrays) {
+    result.set(array, length);
+    length += array.length;
+  }
+  return result;
+};
+var getWaveformPortion = ({
+  audioData,
+  startTimeInSeconds,
+  durationInSeconds,
+  numberOfSamples,
+  channel = 0,
+  outputRange = "zero-to-one",
+  dataOffsetInSeconds,
+  normalize = true
+}) => {
+  validateChannel(channel, audioData.numberOfChannels);
+  const waveform = audioData.channelWaveforms[channel];
+  const startSample = Math.floor((startTimeInSeconds - (dataOffsetInSeconds ?? 0)) * audioData.sampleRate);
+  const endSample = Math.floor((startTimeInSeconds - (dataOffsetInSeconds ?? 0) + durationInSeconds) * audioData.sampleRate);
+  const samplesBeforeStart = 0 - startSample;
+  const samplesAfterEnd = endSample - waveform.length;
+  const clampedStart = Math.max(startSample, 0);
+  const clampedEnd = Math.min(waveform.length, endSample);
+  const padStart = samplesBeforeStart > 0 ? new Float32Array(samplesBeforeStart).fill(0) : null;
+  const padEnd = samplesAfterEnd > 0 ? new Float32Array(samplesAfterEnd).fill(0) : null;
+  const arrs = [
+    padStart,
+    waveform.slice(clampedStart, clampedEnd),
+    padEnd
+  ].filter(NoReactInternals.truthy);
+  const audioBuffer = arrs.length === 1 ? arrs[0] : concatArrays(arrs);
+  return getWaveformSamples({
+    audioBuffer,
+    numberOfSamples,
+    outputRange,
+    normalize
+  }).map((w, i) => {
+    return {
+      index: i,
+      amplitude: w
+    };
+  });
+};
+// src/use-audio-data.ts
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { cancelRender, useDelayRender } from "remotion";
+var useAudioData = (src) => {
+  if (!src) {
+    throw new TypeError("useAudioData requires a 'src' parameter");
+  }
+  const mountState = useRef({ isMounted: true });
+  useEffect(() => {
+    const { current } = mountState;
+    current.isMounted = true;
+    return () => {
+      current.isMounted = false;
+    };
+  }, []);
+  const [metadata, setMetadata] = useState(null);
+  const { delayRender, continueRender } = useDelayRender();
+  const fetchMetadata = useCallback(async () => {
+    const handle = delayRender(`Waiting for audio metadata with src="${src}" to be loaded`);
+    try {
+      const data = await getAudioData(src);
+      if (mountState.current.isMounted) {
+        setMetadata(data);
+      }
+    } catch (err) {
+      cancelRender(err);
+    }
+    continueRender(handle);
+  }, [src, delayRender, continueRender]);
+  useLayoutEffect(() => {
+    fetchMetadata();
+  }, [fetchMetadata]);
+  return metadata;
+};
+// src/use-windowed-audio-data.ts
+import {
+  ALL_FORMATS,
+  Input,
+  InputDisposedError,
+  MATROSKA,
+  UrlSource,
+  WEBM
+} from "mediabunny";
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useLayoutEffect as useLayoutEffect2,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { cancelRender as cancelRender2, Internals, useDelayRender as useDelayRender2 } from "remotion";
+
+// src/combine-float32-arrays.ts
+var combineFloat32Arrays = (arrays) => {
+  if (arrays.length === 0) {
+    return new Float32Array([]);
+  }
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  let totalLength = 0;
+  for (const array of arrays) {
+    totalLength += array.length;
+  }
+  const result = new Float32Array(totalLength);
+  let offset = 0;
+  for (const array of arrays) {
+    result.set(array, offset);
+    offset += array.length;
+  }
+  return result;
+};
+
+// src/get-partial-audio-data.ts
+import { AudioBufferSink } from "mediabunny";
+var EXTRA_THRESHOLD_IN_SECONDS = 1.5;
+var getPartialAudioData = async ({
+  track,
+  fromSeconds,
+  toSeconds,
+  channelIndex,
+  signal,
+  isMatroska = false
+}) => {
+  if (signal.aborted) {
+    throw new Error("Operation was aborted");
+  }
+  const audioSamples = [];
+  const actualFromSeconds = isMatroska ? 0 : Math.max(0, fromSeconds - EXTRA_THRESHOLD_IN_SECONDS);
+  const sink = new AudioBufferSink(track);
+  const iterator = sink.buffers(actualFromSeconds, toSeconds);
+  for await (const { buffer, timestamp, duration } of iterator) {
+    if (signal.aborted) {
+      break;
+    }
+    const channelData = buffer.getChannelData(channelIndex);
+    const bufferStartSeconds = timestamp;
+    const bufferEndSeconds = timestamp + duration;
+    const overlapStartSecond = Math.max(bufferStartSeconds, fromSeconds);
+    const overlapEndSecond = Math.min(bufferEndSeconds, toSeconds);
+    if (overlapStartSecond >= overlapEndSecond) {
+      continue;
+    }
+    const startSampleInBuffer = Math.floor((overlapStartSecond - bufferStartSeconds) * buffer.sampleRate);
+    const endSampleInBuffer = Math.ceil((overlapEndSecond - bufferStartSeconds) * buffer.sampleRate);
+    const trimmedData = channelData.slice(startSampleInBuffer, endSampleInBuffer);
+    audioSamples.push(trimmedData);
+  }
+  await iterator.return();
+  const totalSamples = audioSamples.reduce((sum, sample) => sum + sample.length, 0);
+  const result = new Float32Array(totalSamples);
+  let offset = 0;
+  for (const audioSample of audioSamples) {
+    result.set(audioSample, offset);
+    offset += audioSample.length;
+  }
+  return result;
+};
+
+// src/use-windowed-audio-data.ts
+var warnedMatroska = {};
+var useWindowedAudioData = ({
+  src,
+  frame,
+  fps,
+  windowInSeconds,
+  channelIndex = 0
+}) => {
+  const isMounted = useRef2(true);
+  const [audioUtils, setAudioUtils] = useState2(null);
+  const [waveFormMap, setWaveformMap] = useState2({});
+  const requests = useRef2({});
+  const [initialWindowInSeconds] = useState2(windowInSeconds);
+  if (windowInSeconds !== initialWindowInSeconds) {
+    throw new Error("windowInSeconds cannot be changed dynamically");
+  }
+  useEffect2(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+      Object.values(requests.current).forEach((controller) => {
+        if (controller) {
+          controller.abort();
+        }
+      });
+      requests.current = {};
+      setWaveformMap({});
+      if (audioUtils) {
+        audioUtils.input.dispose();
+      }
+    };
+  }, [audioUtils]);
+  const { delayRender, continueRender } = useDelayRender2();
+  const fetchMetadata = useCallback2(async (signal) => {
+    const handle = delayRender(`Waiting for audio metadata with src="${src}" to be loaded`);
+    const cont = () => {
+      continueRender(handle);
+    };
+    signal.addEventListener("abort", cont, { once: true });
+    const input = new Input({
+      formats: ALL_FORMATS,
+      source: new UrlSource(src)
+    });
+    const onAbort = () => {
+      input.dispose();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      const durationInSeconds = await input.computeDuration();
+      const audioTrack = await input.getPrimaryAudioTrack();
+      if (!audioTrack) {
+        throw new Error("No audio track found");
+      }
+      if (await audioTrack.isLive()) {
+        throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + src);
+      }
+      if (await audioTrack.isRelativeToUnixEpoch()) {
+        throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + src);
+      }
+      const canDecode = await audioTrack.canDecode();
+      if (!canDecode) {
+        throw new Error("Audio track cannot be decoded");
+      }
+      if (channelIndex >= audioTrack.numberOfChannels || channelIndex < 0) {
+        throw new Error(`Invalid channel index ${channelIndex} for audio with ${audioTrack.numberOfChannels} channels`);
+      }
+      const numberOfChannels = await audioTrack.getNumberOfChannels();
+      const sampleRate = await audioTrack.getSampleRate();
+      const format = await input.getFormat();
+      const isMatroska = format === MATROSKA || format === WEBM;
+      if (isMounted.current) {
+        setAudioUtils({
+          input,
+          track: audioTrack,
+          metadata: {
+            durationInSeconds,
+            numberOfChannels,
+            sampleRate
+          },
+          isMatroska
+        });
+      }
+      continueRender(handle);
+    } catch (err) {
+      if (err instanceof InputDisposedError) {
+        continueRender(handle);
+        return;
+      }
+      cancelRender2(err);
+    } finally {
+      signal.removeEventListener("abort", cont);
+      signal.removeEventListener("abort", onAbort);
+    }
+  }, [src, delayRender, continueRender, channelIndex]);
+  useLayoutEffect2(() => {
+    const controller = new AbortController;
+    fetchMetadata(controller.signal);
+    return () => {
+      controller.abort();
+    };
+  }, [fetchMetadata]);
+  const currentTime = frame / fps;
+  const currentWindowIndex = Math.floor(currentTime / windowInSeconds);
+  const windowsToFetch = useMemo(() => {
+    if (!audioUtils?.metadata) {
+      return [];
+    }
+    const maxWindowIndex = Math.floor(audioUtils.metadata.durationInSeconds / windowInSeconds - 0.000000000001);
+    return [
+      currentWindowIndex === 0 ? null : currentWindowIndex - 1,
+      currentWindowIndex,
+      currentWindowIndex + 1 > maxWindowIndex ? null : currentWindowIndex + 1
+    ].filter((i) => i !== null).filter((i) => i >= 0);
+  }, [currentWindowIndex, audioUtils, windowInSeconds]);
+  const fetchAndSetWaveformData = useCallback2(async (windowIndex) => {
+    if (!audioUtils?.metadata || !audioUtils) {
+      throw new Error("MediaBunny context is not loaded yet");
+    }
+    const existingController = requests.current[windowIndex];
+    if (existingController) {
+      existingController.abort();
+    }
+    const controller = new AbortController;
+    requests.current[windowIndex] = controller;
+    if (controller.signal.aborted) {
+      return;
+    }
+    const fromSeconds = windowIndex * windowInSeconds;
+    const toSeconds = (windowIndex + 1) * windowInSeconds;
+    if (fromSeconds >= audioUtils.metadata.durationInSeconds || toSeconds <= 0) {
+      return;
+    }
+    try {
+      const { isMatroska } = audioUtils;
+      if (isMatroska && !warnedMatroska[src]) {
+        warnedMatroska[src] = true;
+        Internals.Log.warn({ logLevel: "info", tag: "@remotion/media-utils" }, `[useWindowedAudioData] Matroska/WebM file detected at "${src}".
+
+Due to format limitation, audio decoding must start from the beginning of the file, which may lead to increased memory usage and slower performance for large files. Consider converting the audio to a more suitable format like MP3 or AAC for better performance.`);
+      }
+      const partialWaveData = await getPartialAudioData({
+        track: audioUtils.track,
+        fromSeconds,
+        toSeconds,
+        channelIndex,
+        signal: controller.signal,
+        isMatroska
+      });
+      if (!controller.signal.aborted) {
+        setWaveformMap((prev) => {
+          const entries = Object.keys(prev);
+          const windowsToClear = entries.filter((entry) => !windowsToFetch.includes(Number(entry)));
+          return {
+            ...prev,
+            ...windowsToClear.reduce((acc, key) => {
+              acc[key] = null;
+              return acc;
+            }, {}),
+            [windowIndex]: partialWaveData
+          };
+        });
+      }
+    } catch (err) {
+      if (controller.signal.aborted) {
+        return;
+      }
+      if (err instanceof InputDisposedError) {
+        return;
+      }
+      throw err;
+    } finally {
+      if (requests.current[windowIndex] === controller) {
+        requests.current[windowIndex] = null;
+      }
+    }
+  }, [channelIndex, audioUtils, windowInSeconds, windowsToFetch, src]);
+  useEffect2(() => {
+    if (!audioUtils?.metadata) {
+      return;
+    }
+    const windowsToClear = Object.keys(requests.current).filter((entry) => !windowsToFetch.includes(Number(entry)));
+    for (const windowIndex of windowsToClear) {
+      const controller = requests.current[windowIndex];
+      if (controller) {
+        controller.abort();
+        requests.current[windowIndex] = null;
+      }
+    }
+    const windowsToActuallyFetch = windowsToFetch.filter((windowIndex) => !waveFormMap[windowIndex] && !requests.current[windowIndex]);
+    if (windowsToActuallyFetch.length === 0) {
+      return;
+    }
+    const currentWindowNeedsFetch = windowsToActuallyFetch.includes(currentWindowIndex);
+    const otherWindowsToFetch = windowsToActuallyFetch.filter((w) => w !== currentWindowIndex);
+    const fetchWindows = async () => {
+      if (currentWindowNeedsFetch) {
+        await fetchAndSetWaveformData(currentWindowIndex);
+      }
+      if (otherWindowsToFetch.length > 0) {
+        await Promise.all(otherWindowsToFetch.map((windowIndex) => {
+          return fetchAndSetWaveformData(windowIndex);
+        }));
+      }
+    };
+    fetchWindows().catch((err) => {
+      if (err.stack?.includes("Cancelled")) {
+        return;
+      }
+      if (err.stack?.toLowerCase()?.includes("aborted")) {
+        return;
+      }
+      if (err.message?.toLowerCase()?.includes("aborted")) {
+        return;
+      }
+      cancelRender2(err);
+    });
+  }, [
+    fetchAndSetWaveformData,
+    audioUtils,
+    windowsToFetch,
+    waveFormMap,
+    currentWindowIndex
+  ]);
+  const availableWindows = useMemo(() => {
+    return windowsToFetch.filter((i) => waveFormMap[i]);
+  }, [windowsToFetch, waveFormMap]);
+  const currentAudioData = useMemo(() => {
+    if (!audioUtils?.metadata) {
+      return null;
+    }
+    if (availableWindows.length === 0) {
+      return null;
+    }
+    const windows = availableWindows.map((i) => waveFormMap[i]);
+    const data = combineFloat32Arrays(windows);
+    return {
+      channelWaveforms: [data],
+      durationInSeconds: audioUtils.metadata.durationInSeconds,
+      isRemote: isRemoteAsset(src),
+      numberOfChannels: 1,
+      resultId: `${src}-windows-${availableWindows.join(",")}`,
+      sampleRate: audioUtils.metadata.sampleRate
+    };
+  }, [src, waveFormMap, audioUtils, availableWindows]);
+  const isBeyondAudioDuration = audioUtils ? currentTime >= audioUtils.metadata.durationInSeconds : false;
+  useLayoutEffect2(() => {
+    if (currentAudioData) {
+      return;
+    }
+    if (isBeyondAudioDuration) {
+      return;
+    }
+    const handle = delayRender(`Waiting for audio data with src="${src}" to be loaded`);
+    return () => {
+      continueRender(handle);
+    };
+  }, [
+    currentAudioData,
+    src,
+    delayRender,
+    continueRender,
+    isBeyondAudioDuration
+  ]);
+  const audioData = isBeyondAudioDuration ? null : currentAudioData;
+  return {
+    audioData,
+    dataOffsetInSeconds: availableWindows.length > 0 ? availableWindows[0] * windowInSeconds : 0
+  };
+};
+// src/visualize-audio.ts
+import { NoReactInternals as NoReactInternals2 } from "remotion/no-react";
+
+// src/fft/complex.ts
+var complexAdd = function(a, b) {
+  return [a[0] + b[0], a[1] + b[1]];
+};
+var complexSubtract = function(a, b) {
+  return [a[0] - b[0], a[1] - b[1]];
+};
+var complexMultiply = function(a, b) {
+  return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]];
+};
+var complexMagnitude = function(c) {
+  return Math.sqrt(c[0] * c[0] + c[1] * c[1]);
+};
+
+// src/fft/exponent.ts
+var mapExponent = {};
+var exponent = function(k, N) {
+  const x = -2 * Math.PI * (k / N);
+  mapExponent[N] = mapExponent[N] || {};
+  mapExponent[N][k] = mapExponent[N][k] || [Math.cos(x), Math.sin(x)];
+  return mapExponent[N][k];
+};
+
+// src/fft/fft-accurate.ts
+var fftAccurate = function(vector) {
+  const X = [];
+  const N = vector.length;
+  if (N === 1) {
+    if (Array.isArray(vector[0])) {
+      return [[vector[0][0], vector[0][1]]];
+    }
+    return [[vector[0], 0]];
+  }
+  const X_evens = fftAccurate(vector.filter((_, ix) => ix % 2 === 0));
+  const X_odds = fftAccurate(vector.filter((__, ix) => ix % 2 === 1));
+  for (let k = 0;k < N / 2; k++) {
+    const t = X_evens[k];
+    const e = complexMultiply(exponent(k, N), X_odds[k]);
+    X[k] = complexAdd(t, e);
+    X[k + N / 2] = complexSubtract(t, e);
+  }
+  return X;
+};
+
+// src/fft/fft-fast.ts
+function reverseBits(num, numBits) {
+  let result = 0;
+  for (let i = 0;i < numBits; i++) {
+    result = result << 1 | num >> i & 1;
+  }
+  return result;
+}
+function hammingWindow(N) {
+  const win = new Array(N);
+  for (let i = 0;i < N; i++) {
+    win[i] = 0.8 - 0.46 * Math.cos(2 * Math.PI * i / (N - 1));
+  }
+  return win;
+}
+function bitReversePermutation(N) {
+  const bitReversed = new Array(N);
+  for (let i = 0;i < N; i++) {
+    bitReversed[i] = reverseBits(i, Math.log2(N));
+  }
+  return bitReversed;
+}
+var fftFast = function(vector) {
+  const N = vector.length;
+  const X = new Array(N);
+  if (N <= 1) {
+    for (let i = 0;i < vector.length; i++) {
+      const value = vector[i];
+      X[i] = [value * 2, 0];
+    }
+    return X;
+  }
+  const window2 = hammingWindow(N);
+  for (let i = 0;i < N; i++) {
+    X[i] = [vector[i] * window2[i], 0];
+  }
+  const bitReversed = bitReversePermutation(N);
+  for (let i = 0;i < N; i++) {
+    X[i] = [vector[bitReversed[i]], 0];
+  }
+  for (let s = 1;s <= Math.log2(N); s++) {
+    const m = 1 << s;
+    const mHalf = m / 2;
+    const angleIncrement = 2 * Math.PI / m;
+    for (let k = 0;k < N; k += m) {
+      let omegaReal = 1;
+      let omegaImag = 0;
+      for (let j = 0;j < mHalf; j++) {
+        const tReal = omegaReal * X[k + j + mHalf][0] - omegaImag * X[k + j + mHalf][1];
+        const tImag = omegaReal * X[k + j + mHalf][1] + omegaImag * X[k + j + mHalf][0];
+        const uReal = X[k + j][0];
+        const uImag = X[k + j][1];
+        X[k + j] = [uReal + tReal, uImag + tImag];
+        X[k + j + mHalf] = [uReal - tReal, uImag - tImag];
+        const tempReal = omegaReal * Math.cos(angleIncrement) - omegaImag * Math.sin(angleIncrement);
+        omegaImag = omegaReal * Math.sin(angleIncrement) + omegaImag * Math.cos(angleIncrement);
+        omegaReal = tempReal;
+      }
+    }
+  }
+  return X;
+};
+
+// src/fft/mag.ts
+var fftMag = function(fftBins) {
+  const ret = fftBins.map((f) => complexMagnitude(f));
+  return ret.slice(0, ret.length / 2);
+};
+
+// src/fft/smoothing.ts
+var smoothingPasses = 3;
+var smoothingPoints = 3;
+var smoothen = function(array) {
+  let lastArray = array;
+  const newArr = [];
+  for (let pass = 0;pass < smoothingPasses; pass++) {
+    const sidePoints = Math.floor(smoothingPoints / 2);
+    const cn = 1 / (2 * sidePoints + 1);
+    for (let i = 0;i < sidePoints; i++) {
+      newArr[i] = lastArray[i];
+      newArr[lastArray.length - i - 1] = lastArray[lastArray.length - i - 1];
+    }
+    for (let i = sidePoints;i < lastArray.length - sidePoints; i++) {
+      let sum = 0;
+      for (let n = -sidePoints;n <= sidePoints; n++) {
+        sum += cn * lastArray[i + n] + n;
+      }
+      newArr[i] = sum;
+    }
+    lastArray = newArr;
+  }
+  return newArr;
+};
+
+// src/fft/to-int-16.ts
+var toInt16 = (x) => x > 0 ? x * 32767 : x * 32768;
+
+// src/fft/get-visualization.ts
+var getVisualization = ({
+  sampleSize,
+  data,
+  sampleRate,
+  frame,
+  fps,
+  maxInt,
+  optimizeFor,
+  dataOffsetInSeconds
+}) => {
+  const isPowerOfTwo = sampleSize > 0 && (sampleSize & sampleSize - 1) === 0;
+  if (!isPowerOfTwo) {
+    throw new TypeError(`The argument "bars" must be a power of two. For example: 64, 128. Got instead: ${sampleSize}`);
+  }
+  if (!fps) {
+    throw new TypeError('The argument "fps" was not provided');
+  }
+  if (data.length < sampleSize) {
+    throw new TypeError("Audio data is not big enough to provide " + sampleSize + " bars.");
+  }
+  const start = Math.floor((frame / fps - dataOffsetInSeconds) * sampleRate);
+  const actualStart = Math.max(0, start - sampleSize / 2);
+  const ints = new Int16Array({
+    length: sampleSize
+  });
+  ints.set(data.subarray(actualStart, actualStart + sampleSize).map((x) => toInt16(x)));
+  const alg = optimizeFor === "accuracy" ? fftAccurate : fftFast;
+  const phasors = alg(ints);
+  const magnitudes = fftMag(phasors).map((p) => p);
+  return smoothen(magnitudes).map((m) => m / (sampleSize / 2) / maxInt);
+};
+
+// src/fft/max-value-cached.ts
+var getMax = (array) => {
+  let max = 0;
+  for (let i = 0;i < array.length; i++) {
+    const val = array[i];
+    if (val > max) {
+      max = val;
+    }
+  }
+  return max;
+};
+var cache2 = {};
+var getMaxPossibleMagnitude = (metadata) => {
+  if (cache2[metadata.resultId]) {
+    return cache2[metadata.resultId];
+  }
+  const result = toInt16(getMax(metadata.channelWaveforms[0]));
+  cache2[metadata.resultId] = result;
+  return result;
+};
+
+// src/visualize-audio.ts
+var cache3 = {};
+var visualizeAudioFrame = ({
+  audioData,
+  frame,
+  fps,
+  numberOfSamples,
+  optimizeFor,
+  dataOffsetInSeconds
+}) => {
+  const cacheKey = audioData.resultId + frame + fps + numberOfSamples;
+  if (cache3[cacheKey]) {
+    return cache3[cacheKey];
+  }
+  const maxInt = getMaxPossibleMagnitude(audioData);
+  return getVisualization({
+    sampleSize: numberOfSamples * 2,
+    data: audioData.channelWaveforms[0],
+    frame,
+    fps,
+    sampleRate: audioData.sampleRate,
+    maxInt,
+    optimizeFor,
+    dataOffsetInSeconds
+  });
+};
+var visualizeAudio = ({
+  smoothing = true,
+  optimizeFor = NoReactInternals2.ENABLE_V5_BREAKING_CHANGES ? "speed" : "accuracy",
+  dataOffsetInSeconds = 0,
+  ...parameters
+}) => {
+  if (!smoothing) {
+    return visualizeAudioFrame({
+      ...parameters,
+      optimizeFor,
+      dataOffsetInSeconds,
+      smoothing
+    });
+  }
+  const toSmooth = [
+    parameters.frame - 1,
+    parameters.frame,
+    parameters.frame + 1
+  ];
+  const all = toSmooth.map((s) => {
+    return visualizeAudioFrame({
+      ...parameters,
+      frame: s,
+      dataOffsetInSeconds,
+      optimizeFor,
+      smoothing
+    });
+  });
+  return new Array(parameters.numberOfSamples).fill(true).map((_x, i) => {
+    return new Array(toSmooth.length).fill(true).map((_, j) => {
+      return all[j][i];
+    }).reduce((a, b) => a + b, 0) / toSmooth.length;
+  });
+};
+// src/visualize-audio-waveform.ts
+var cache4 = {};
+var visualizeAudioWaveformFrame = ({
+  audioData,
+  frame,
+  fps,
+  numberOfSamples,
+  windowInSeconds,
+  channel,
+  dataOffsetInSeconds,
+  normalize = false
+}) => {
+  if (windowInSeconds * audioData.sampleRate < numberOfSamples) {
+    throw new TypeError(windowInSeconds + "s audiodata does not have " + numberOfSamples + " bars. Increase windowInSeconds or decrease numberOfSamples");
+  }
+  const cacheKey = audioData.resultId + frame + fps + numberOfSamples + "waveform" + dataOffsetInSeconds;
+  if (cache4[cacheKey]) {
+    return cache4[cacheKey];
+  }
+  const time = frame / fps;
+  const startTimeInSeconds = time - windowInSeconds / 2;
+  return getWaveformPortion({
+    audioData,
+    startTimeInSeconds,
+    durationInSeconds: windowInSeconds,
+    numberOfSamples,
+    outputRange: "minus-one-to-one",
+    channel,
+    dataOffsetInSeconds,
+    normalize
+  });
+};
+var visualizeAudioWaveform = (parameters) => {
+  const data = visualizeAudioWaveformFrame(parameters);
+  return data.map((value) => value.amplitude);
+};
+export {
+  visualizeAudioWaveform,
+  visualizeAudio,
+  useWindowedAudioData,
+  useAudioData,
+  getWaveformPortion,
+  getVideoMetadata,
+  getImageDimensions,
+  getAudioDurationInSeconds,
+  getAudioDuration,
+  getAudioData,
+  createSmoothSvgPath,
+  audioBufferToDataUrl
+};

package/dist/use-windowed-audio-data.js

@@ -54,6 +54,14 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
             if (!audioTrack) {
                 throw new Error('No audio track found');
             }
+            if (await audioTrack.isLive()) {
+                throw new Error('Live streams are not currently supported by Remotion. Sorry! Source: ' +
+                    src);
+            }
+            if (await audioTrack.isRelativeToUnixEpoch()) {
+                throw new Error('Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: ' +
+                    src);
+            }
             const canDecode = await audioTrack.canDecode();
             if (!canDecode) {
                 throw new Error('Audio track cannot be decoded');
@@ -61,7 +69,8 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
             if (channelIndex >= audioTrack.numberOfChannels || channelIndex < 0) {
                 throw new Error(`Invalid channel index ${channelIndex} for audio with ${audioTrack.numberOfChannels} channels`);
             }
-            const { numberOfChannels, sampleRate } = audioTrack;
+            const numberOfChannels = await audioTrack.getNumberOfChannels();
+            const sampleRate = await audioTrack.getSampleRate();
             const format = await input.getFormat();
             const isMatroska = format === mediabunny_1.MATROSKA || format === mediabunny_1.WEBM;
             if (isMounted.current) {

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-utils"
 	},
 	"name": "@remotion/media-utils",
-	"version": "4.0.453",
+	"version": "4.0.454",
 	"description": "Utilities for working with media files",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -11,23 +11,25 @@
 		"formatting": "oxfmt src --check",
 		"format": "oxfmt src",
 		"lint": "eslint src",
-		"make": "tsgo -d"
+		"make": "tsgo -d && bun --env-file=../.env.bundle bundle.ts"
 	},
+	"types": "dist/index.d.ts",
+	"module": "dist/esm/index.mjs",
 	"author": "Jonny Burger <jonny@remotion.dev>",
 	"license": "MIT",
 	"bugs": {
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"remotion": "4.0.453",
-		"mediabunny": "1.39.2"
+		"remotion": "4.0.454",
+		"mediabunny": "1.42.0"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.453",
+		"@remotion/eslint-config-internal": "4.0.454",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},
@@ -41,5 +43,14 @@
 	"publishConfig": {
 		"access": "public"
 	},
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/index.d.ts",
+			"module": "./dist/esm/index.mjs",
+			"import": "./dist/esm/index.mjs",
+			"require": "./dist/index.js"
+		}
+	},
 	"homepage": "https://www.remotion.dev/docs/media-utils"
 }