@remotion/webcodecs 4.0.210

package/dist/esm/index.mjs

@@ -0,0 +1,793 @@
+// src/audio-decoder.ts
+var createAudioDecoder = ({
+  onFrame,
+  onError,
+  signal,
+  config
+}) => {
+  if (signal.aborted) {
+    throw new Error("Not creating audio decoder, already aborted");
+  }
+  let outputQueue = Promise.resolve();
+  let outputQueueSize = 0;
+  let dequeueResolver = () => {
+  };
+  const audioDecoder = new AudioDecoder({
+    output(inputFrame) {
+      outputQueueSize++;
+      outputQueue = outputQueue.then(() => onFrame(inputFrame)).then(() => {
+        dequeueResolver();
+        outputQueueSize--;
+        return Promise.resolve();
+      });
+    },
+    error(error) {
+      onError(error);
+    }
+  });
+  const close = () => {
+    signal.removeEventListener("abort", onAbort);
+    if (audioDecoder.state === "closed") {
+      return;
+    }
+    audioDecoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  signal.addEventListener("abort", onAbort);
+  const getQueueSize = () => {
+    return audioDecoder.decodeQueueSize + outputQueueSize;
+  };
+  audioDecoder.configure(config);
+  const waitForDequeue = async () => {
+    await new Promise((r) => {
+      dequeueResolver = r;
+      audioDecoder.addEventListener("dequeue", () => r(), {
+        once: true
+      });
+    });
+  };
+  const waitForFinish = async () => {
+    while (getQueueSize() > 0) {
+      await waitForDequeue();
+    }
+  };
+  const processSample = async (audioSample) => {
+    if (audioDecoder.state === "closed") {
+      return;
+    }
+    while (getQueueSize() > 10) {
+      await waitForDequeue();
+    }
+    const chunk = new EncodedAudioChunk(audioSample);
+    audioDecoder.decode(chunk);
+  };
+  let queue = Promise.resolve();
+  return {
+    processSample: (sample) => {
+      queue = queue.then(() => processSample(sample));
+      return queue;
+    },
+    waitForFinish: async () => {
+      await audioDecoder.flush();
+      await waitForFinish();
+      await outputQueue;
+    },
+    close,
+    getQueueSize,
+    flush: async () => {
+      await audioDecoder.flush();
+    }
+  };
+};
+// src/audio-encoder.ts
+var createAudioEncoder = ({
+  onChunk,
+  onError,
+  codec,
+  signal,
+  config: audioEncoderConfig
+}) => {
+  if (signal.aborted) {
+    throw new Error("Not creating audio encoder, already aborted");
+  }
+  let prom = Promise.resolve();
+  let outputQueue = 0;
+  let dequeueResolver = () => {
+  };
+  const encoder = new AudioEncoder({
+    output: (chunk) => {
+      outputQueue++;
+      prom = prom.then(() => onChunk(chunk)).then(() => {
+        outputQueue--;
+        dequeueResolver();
+        return Promise.resolve();
+      });
+    },
+    error(error) {
+      onError(error);
+    }
+  });
+  const close = () => {
+    signal.removeEventListener("abort", onAbort);
+    if (encoder.state === "closed") {
+      return;
+    }
+    encoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  signal.addEventListener("abort", onAbort);
+  if (codec !== "opus") {
+    throw new Error('Only `codec: "opus"` is supported currently');
+  }
+  const getQueueSize = () => {
+    return encoder.encodeQueueSize + outputQueue;
+  };
+  encoder.configure(audioEncoderConfig);
+  const waitForDequeue = async () => {
+    await new Promise((r) => {
+      dequeueResolver = r;
+      encoder.addEventListener("dequeue", () => r(), {
+        once: true
+      });
+    });
+  };
+  const waitForFinish = async () => {
+    while (getQueueSize() > 0) {
+      await waitForDequeue();
+    }
+  };
+  const encodeFrame = async (audioData) => {
+    if (encoder.state === "closed") {
+      return;
+    }
+    while (getQueueSize() > 10) {
+      await waitForDequeue();
+    }
+    if (encoder.state === "closed") {
+      return;
+    }
+    encoder.encode(audioData);
+  };
+  let queue = Promise.resolve();
+  return {
+    encodeFrame: (audioData) => {
+      queue = queue.then(() => encodeFrame(audioData));
+      return queue;
+    },
+    waitForFinish: async () => {
+      await encoder.flush();
+      await waitForFinish();
+      await prom;
+    },
+    close,
+    getQueueSize,
+    flush: async () => {
+      await encoder.flush();
+    }
+  };
+};
+// src/convert-media.ts
+import {
+MediaParserInternals,
+parseMedia
+} from "@remotion/media-parser";
+import {bufferWriter} from "@remotion/media-parser/buffer";
+import {canUseWebFsWriter, webFsWriter} from "@remotion/media-parser/web-fs";
+
+// src/error-cause.ts
+var error_cause_default = Error;
+
+// src/audio-decoder-config.ts
+var getAudioDecoderConfig = async (config) => {
+  if (typeof AudioDecoder === "undefined") {
+    return null;
+  }
+  if ((await AudioDecoder.isConfigSupported(config)).supported) {
+    return config;
+  }
+  return null;
+};
+
+// src/audio-encoder-config.ts
+var getAudioEncoderConfig = async (config) => {
+  if (typeof AudioEncoder === "undefined") {
+    return null;
+  }
+  if ((await AudioEncoder.isConfigSupported(config)).supported) {
+    return config;
+  }
+  return null;
+};
+
+// src/resolve-audio-action.ts
+var canCopyAudioTrack = (inputCodec, outputCodec) => {
+  if (outputCodec === "opus") {
+    return inputCodec === "opus";
+  }
+  throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+var defaultResolveAudioAction = ({
+  canReencode,
+  canCopy
+}) => {
+  if (canCopy) {
+    return "copy";
+  }
+  if (canReencode) {
+    return "reencode";
+  }
+  return "drop";
+};
+var resolveAudioAction = async ({
+  audioDecoderConfig,
+  audioEncoderConfig,
+  track,
+  audioCodec,
+  resolverFunction
+}) => {
+  const canReencode = Boolean(audioDecoderConfig && audioEncoderConfig);
+  const canCopy = canCopyAudioTrack(track.codecWithoutConfig, audioCodec);
+  const resolved = await resolverFunction({
+    canReencode,
+    canCopy
+  });
+  return resolved;
+};
+
+// src/on-audio-track.ts
+var makeAudioTrackHandler = ({
+  state,
+  audioCodec,
+  convertMediaState,
+  controller,
+  abortConversion,
+  onMediaStateUpdate,
+  onAudioTrack,
+  bitrate
+}) => async (track) => {
+  const audioEncoderConfig = await getAudioEncoderConfig({
+    codec: audioCodec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    bitrate
+  });
+  const audioDecoderConfig = await getAudioDecoderConfig({
+    codec: track.codec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    description: track.description
+  });
+  const audioOperation = await resolveAudioAction({
+    audioDecoderConfig,
+    audioEncoderConfig,
+    audioCodec,
+    track,
+    resolverFunction: onAudioTrack
+  });
+  if (audioOperation === "drop") {
+    return null;
+  }
+  if (audioOperation === "copy") {
+    const addedTrack = await state.addTrack({
+      type: "audio",
+      codec: audioCodec,
+      numberOfChannels: track.numberOfChannels,
+      sampleRate: track.sampleRate,
+      codecPrivate: track.codecPrivate
+    });
+    return async (audioSample) => {
+      await state.addSample(new EncodedAudioChunk(audioSample), addedTrack.trackNumber);
+      convertMediaState.encodedAudioFrames++;
+      onMediaStateUpdate?.({ ...convertMediaState });
+    };
+  }
+  if (!audioEncoderConfig) {
+    abortConversion(new error_cause_default(`Could not configure audio encoder of track ${track.trackId}`));
+    return null;
+  }
+  if (!audioDecoderConfig) {
+    abortConversion(new error_cause_default(`Could not configure audio decoder of track ${track.trackId}`));
+    return null;
+  }
+  const { trackNumber } = await state.addTrack({
+    type: "audio",
+    codec: audioCodec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    codecPrivate: null
+  });
+  const audioEncoder = createAudioEncoder({
+    onChunk: async (chunk) => {
+      await state.addSample(chunk, trackNumber);
+      convertMediaState.encodedAudioFrames++;
+      onMediaStateUpdate?.({ ...convertMediaState });
+    },
+    onError: (err) => {
+      abortConversion(new error_cause_default(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
+        cause: err
+      }));
+    },
+    codec: audioCodec,
+    signal: controller.signal,
+    config: audioEncoderConfig
+  });
+  const audioDecoder = createAudioDecoder({
+    onFrame: async (frame) => {
+      await audioEncoder.encodeFrame(frame);
+      convertMediaState.decodedAudioFrames++;
+      onMediaStateUpdate?.(convertMediaState);
+      frame.close();
+    },
+    onError(error) {
+      abortConversion(new error_cause_default(`Audio decoder of track ${track.trackId} failed (see .cause of this error)`, {
+        cause: error
+      }));
+    },
+    signal: controller.signal,
+    config: audioDecoderConfig
+  });
+  state.addWaitForFinishPromise(async () => {
+    await audioDecoder.waitForFinish();
+    await audioEncoder.waitForFinish();
+    audioDecoder.close();
+    audioEncoder.close();
+  });
+  return async (audioSample) => {
+    await audioDecoder.processSample(audioSample);
+  };
+};
+
+// src/resolve-video-action.ts
+var canCopyVideoTrack = (inputCodec, outputCodec) => {
+  if (outputCodec === "vp8") {
+    return inputCodec === "vp8";
+  }
+  throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+var defaultResolveVideoAction = ({
+  canReencode,
+  canCopy
+}) => {
+  if (canCopy) {
+    return "copy";
+  }
+  if (canReencode) {
+    return "reencode";
+  }
+  return "drop";
+};
+var resolveVideoAction = async ({
+  videoDecoderConfig,
+  videoEncoderConfig,
+  track,
+  videoCodec,
+  resolverFunction
+}) => {
+  const canReencode = Boolean(videoDecoderConfig && videoEncoderConfig);
+  const canCopy = canCopyVideoTrack(track.codecWithoutConfig, videoCodec);
+  const resolved = await resolverFunction({
+    canReencode,
+    canCopy
+  });
+  return resolved;
+};
+
+// src/video-decoder.ts
+var createVideoDecoder = ({
+  onFrame,
+  onError,
+  signal,
+  config
+}) => {
+  let outputQueue = Promise.resolve();
+  let outputQueueSize = 0;
+  let dequeueResolver = () => {
+  };
+  const videoDecoder = new VideoDecoder({
+    output(inputFrame) {
+      outputQueueSize++;
+      outputQueue = outputQueue.then(() => onFrame(inputFrame)).then(() => {
+        outputQueueSize--;
+        dequeueResolver();
+        return Promise.resolve();
+      });
+    },
+    error(error) {
+      onError(error);
+    }
+  });
+  const close = () => {
+    signal.removeEventListener("abort", onAbort);
+    if (videoDecoder.state === "closed") {
+      return;
+    }
+    videoDecoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  signal.addEventListener("abort", onAbort);
+  const getQueueSize = () => {
+    return videoDecoder.decodeQueueSize + outputQueueSize;
+  };
+  videoDecoder.configure(config);
+  const waitForDequeue = async () => {
+    await new Promise((r) => {
+      dequeueResolver = r;
+      videoDecoder.addEventListener("dequeue", () => r(), {
+        once: true
+      });
+    });
+  };
+  const waitForFinish = async () => {
+    while (getQueueSize() > 0) {
+      await waitForDequeue();
+    }
+  };
+  const processSample = async (sample) => {
+    if (videoDecoder.state === "closed") {
+      return;
+    }
+    while (getQueueSize() > 10) {
+      await waitForDequeue();
+    }
+    if (videoDecoder.state === "closed") {
+      return;
+    }
+    if (sample.type === "key") {
+      await videoDecoder.flush();
+    }
+    videoDecoder.decode(new EncodedVideoChunk(sample));
+  };
+  let inputQueue = Promise.resolve();
+  return {
+    processSample: (sample) => {
+      inputQueue = inputQueue.then(() => processSample(sample));
+      return inputQueue;
+    },
+    waitForFinish: async () => {
+      await videoDecoder.flush();
+      await waitForFinish();
+      await outputQueue;
+      await inputQueue;
+    },
+    close,
+    getQueueSize,
+    flush: async () => {
+      await videoDecoder.flush();
+    }
+  };
+};
+
+// src/video-decoder-config.ts
+var getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
+  if (typeof VideoDecoder === "undefined") {
+    return null;
+  }
+  const hardware = {
+    ...config,
+    hardwareAcceleration: "prefer-hardware"
+  };
+  if ((await VideoDecoder.isConfigSupported(hardware)).supported) {
+    return hardware;
+  }
+  const software = {
+    ...config,
+    hardwareAcceleration: "prefer-software"
+  };
+  if ((await VideoDecoder.isConfigSupported(software)).supported) {
+    return software;
+  }
+  return null;
+};
+
+// src/video-encoder.ts
+var createVideoEncoder = ({
+  onChunk,
+  onError,
+  signal,
+  config
+}) => {
+  if (signal.aborted) {
+    throw new Error("Not creating video encoder, already aborted");
+  }
+  let outputQueue = Promise.resolve();
+  let outputQueueSize = 0;
+  let dequeueResolver = () => {
+  };
+  const encoder = new VideoEncoder({
+    error(error) {
+      onError(error);
+    },
+    output(chunk) {
+      outputQueueSize++;
+      outputQueue = outputQueue.then(() => onChunk(chunk)).then(() => {
+        outputQueueSize--;
+        dequeueResolver();
+        return Promise.resolve();
+      });
+    }
+  });
+  const close = () => {
+    signal.removeEventListener("abort", onAbort);
+    if (encoder.state === "closed") {
+      return;
+    }
+    encoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  signal.addEventListener("abort", onAbort);
+  const getQueueSize = () => {
+    return encoder.encodeQueueSize + outputQueueSize;
+  };
+  encoder.configure(config);
+  let framesProcessed = 0;
+  const waitForDequeue = async () => {
+    await new Promise((r) => {
+      dequeueResolver = r;
+      encoder.addEventListener("dequeue", () => r(), {
+        once: true
+      });
+    });
+  };
+  const waitForFinish = async () => {
+    while (getQueueSize() > 0) {
+      await waitForDequeue();
+    }
+  };
+  const encodeFrame = async (frame) => {
+    if (encoder.state === "closed") {
+      return;
+    }
+    while (getQueueSize() > 10) {
+      await waitForDequeue();
+    }
+    if (encoder.state === "closed") {
+      return;
+    }
+    encoder.encode(frame, {
+      keyFrame: framesProcessed % 40 === 0
+    });
+    framesProcessed++;
+  };
+  let inputQueue = Promise.resolve();
+  return {
+    encodeFrame: (frame) => {
+      inputQueue = inputQueue.then(() => encodeFrame(frame));
+      return inputQueue;
+    },
+    waitForFinish: async () => {
+      await encoder.flush();
+      await outputQueue;
+      await waitForFinish();
+    },
+    close,
+    getQueueSize,
+    flush: async () => {
+      await encoder.flush();
+    }
+  };
+};
+
+// src/video-encoder-config.ts
+var getVideoEncoderConfig = async (config) => {
+  if (typeof VideoEncoder === "undefined") {
+    return null;
+  }
+  const hardware = {
+    ...config,
+    hardwareAcceleration: "prefer-hardware"
+  };
+  if ((await VideoEncoder.isConfigSupported(hardware)).supported) {
+    return hardware;
+  }
+  const software = {
+    ...config,
+    hardwareAcceleration: "prefer-software"
+  };
+  if ((await VideoEncoder.isConfigSupported(software)).supported) {
+    return software;
+  }
+  return null;
+};
+
+// src/on-video-track.ts
+var makeVideoTrackHandler = ({
+  state,
+  onVideoFrame,
+  onMediaStateUpdate,
+  abortConversion,
+  convertMediaState,
+  controller,
+  videoCodec,
+  onVideoTrack
+}) => async (track) => {
+  const videoEncoderConfig = await getVideoEncoderConfig({
+    codec: videoCodec,
+    height: track.displayAspectHeight,
+    width: track.displayAspectWidth
+  });
+  const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
+  const videoOperation = await resolveVideoAction({
+    videoDecoderConfig,
+    videoEncoderConfig,
+    track,
+    videoCodec,
+    resolverFunction: onVideoTrack
+  });
+  if (videoOperation === "drop") {
+    return null;
+  }
+  if (videoOperation === "copy") {
+    const videoTrack = await state.addTrack({
+      type: "video",
+      color: track.color,
+      width: track.codedWidth,
+      height: track.codedHeight,
+      codec: track.codecWithoutConfig,
+      codecPrivate: track.codecPrivate
+    });
+    return (sample) => {
+      state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber);
+      convertMediaState.decodedVideoFrames++;
+      onMediaStateUpdate?.({ ...convertMediaState });
+    };
+  }
+  if (videoEncoderConfig === null) {
+    abortConversion(new error_cause_default(`Could not configure video encoder of track ${track.trackId}`));
+    return null;
+  }
+  if (videoDecoderConfig === null) {
+    abortConversion(new error_cause_default(`Could not configure video decoder of track ${track.trackId}`));
+    return null;
+  }
+  const { trackNumber } = await state.addTrack({
+    type: "video",
+    color: track.color,
+    width: track.codedWidth,
+    height: track.codedHeight,
+    codec: videoCodec,
+    codecPrivate: null
+  });
+  const videoEncoder = createVideoEncoder({
+    onChunk: async (chunk) => {
+      await state.addSample(chunk, trackNumber);
+      convertMediaState.encodedVideoFrames++;
+      onMediaStateUpdate?.({ ...convertMediaState });
+    },
+    onError: (err) => {
+      abortConversion(new error_cause_default(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
+        cause: err
+      }));
+    },
+    signal: controller.signal,
+    config: videoEncoderConfig
+  });
+  const videoDecoder = createVideoDecoder({
+    config: videoDecoderConfig,
+    onFrame: async (frame) => {
+      await onVideoFrame?.(frame, track);
+      await videoEncoder.encodeFrame(frame);
+      convertMediaState.decodedVideoFrames++;
+      onMediaStateUpdate?.({ ...convertMediaState });
+      frame.close();
+    },
+    onError: (err) => {
+      abortConversion(new error_cause_default(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
+        cause: err
+      }));
+    },
+    signal: controller.signal
+  });
+  state.addWaitForFinishPromise(async () => {
+    await videoDecoder.waitForFinish();
+    await videoEncoder.waitForFinish();
+    videoDecoder.close();
+    videoEncoder.close();
+  });
+  return async (chunk) => {
+    await videoDecoder.processSample(chunk);
+  };
+};
+
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
+// src/convert-media.ts
+var convertMedia = async ({
+  src,
+  onVideoFrame,
+  onMediaStateUpdate,
+  audioCodec,
+  to,
+  videoCodec,
+  signal: userPassedAbortSignal,
+  onAudioTrack: userAudioResolver,
+  onVideoTrack: userVideoResolver
+}) => {
+  if (to !== "webm") {
+    return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
+  }
+  if (audioCodec !== "opus") {
+    return Promise.reject(new TypeError('Only `audioCodec: "opus"` is supported currently'));
+  }
+  if (videoCodec !== "vp8") {
+    return Promise.reject(new TypeError('Only `videoCodec: "vp8"` is supported currently'));
+  }
+  const { promise, resolve, reject } = withResolvers();
+  const controller = new AbortController;
+  const abortConversion = (errCause) => {
+    reject(errCause);
+    if (!controller.signal.aborted) {
+      controller.abort();
+    }
+  };
+  const onUserAbort = () => {
+    abortConversion(new error_cause_default("Conversion aborted by user"));
+  };
+  userPassedAbortSignal?.addEventListener("abort", onUserAbort);
+  const convertMediaState = {
+    decodedAudioFrames: 0,
+    decodedVideoFrames: 0,
+    encodedVideoFrames: 0,
+    encodedAudioFrames: 0
+  };
+  const canUseWebFs = await canUseWebFsWriter();
+  const state = await MediaParserInternals.createMedia(canUseWebFs ? webFsWriter : bufferWriter);
+  const onVideoTrack = makeVideoTrackHandler({
+    state,
+    onVideoFrame: onVideoFrame ?? null,
+    onMediaStateUpdate: onMediaStateUpdate ?? null,
+    abortConversion,
+    convertMediaState,
+    controller,
+    videoCodec,
+    onVideoTrack: userVideoResolver ?? defaultResolveVideoAction
+  });
+  const onAudioTrack = makeAudioTrackHandler({
+    abortConversion,
+    audioCodec,
+    controller,
+    convertMediaState,
+    onMediaStateUpdate: onMediaStateUpdate ?? null,
+    state,
+    onAudioTrack: userAudioResolver ?? defaultResolveAudioAction,
+    bitrate: 128000
+  });
+  parseMedia({
+    src,
+    onVideoTrack,
+    onAudioTrack,
+    signal: controller.signal
+  }).then(() => {
+    return state.waitForFinish();
+  }).then(() => {
+    resolve({ save: state.save, remove: state.remove });
+  }).catch((err) => {
+    reject(err);
+  }).finally(() => {
+    userPassedAbortSignal?.removeEventListener("abort", onUserAbort);
+  });
+  return promise;
+};
+export {
+  createVideoEncoder,
+  createVideoDecoder,
+  createAudioEncoder,
+  createAudioDecoder,
+  convertMedia
+};