@remotion/webcodecs 4.0.210

package/dist/get-config.d.ts

@@ -0,0 +1 @@
+export declare const getVideoDecoderConfigWithHardwareAcceleration: (config: VideoDecoderConfig) => Promise<VideoDecoderConfig | null>;

package/dist/get-config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoDecoderConfigWithHardwareAcceleration = void 0;
+const getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
+    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;
+};
+exports.getVideoDecoderConfigWithHardwareAcceleration = getVideoDecoderConfigWithHardwareAcceleration;

package/dist/get-description.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../src/types/mp4box.d.ts" />
+import type { MP4File, MP4MediaTrack } from 'mp4box';
+export declare const getDescription: ({ mp4File, track, }: {
+    mp4File: MP4File;
+    track: MP4MediaTrack;
+}) => Uint8Array | undefined;

package/dist/get-description.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDescription = void 0;
+const mp4box_1 = require("mp4box");
+const getDescription = ({ mp4File, track, }) => {
+    const trak = mp4File.getTrackById(track.id);
+    for (const entry of trak.mdia.minf.stbl.stsd.entries) {
+        if (entry.avcC || entry.hvcC) {
+            const stream = new mp4box_1.DataStream(undefined, 0, mp4box_1.DataStream.BIG_ENDIAN);
+            if (entry.avcC) {
+                entry.avcC.write(stream);
+            }
+            else if (entry.hvcC) {
+                entry.hvcC.write(stream);
+            }
+            return new Uint8Array(stream.buffer, 8); // Remove the box header.
+        }
+    }
+};
+exports.getDescription = getDescription;

package/dist/get-samples.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../src/types/mp4box.d.ts" />
+import type { MP4File, MP4MediaTrack, Sample } from 'mp4box';
+export declare const getSamples: ({ mp4File, track, }: {
+    mp4File: MP4File;
+    track: MP4MediaTrack;
+}) => Promise<Sample[]>;

package/dist/get-samples.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamples = void 0;
+const getSamples = ({ mp4File, track, }) => {
+    mp4File.setExtractionOptions(track.id, null, {
+        nbSamples: Infinity,
+    });
+    return new Promise((resolve, reject) => {
+        mp4File.onSamples = (track_id, _ref, samples) => {
+            if (track_id === track.id) {
+                resolve(samples);
+                mp4File.onSamples = undefined;
+                mp4File.onError = undefined;
+            }
+        };
+        mp4File.onError = (e) => {
+            reject(e);
+            mp4File.onSamples = undefined;
+            mp4File.onError = undefined;
+        };
+        mp4File.start();
+    });
+};
+exports.getSamples = getSamples;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createAudioDecoder } from './audio-decoder';
+export { createAudioEncoder } from './audio-encoder';
+export { ConvertMediaState, ConvertMediaTo, convertMedia } from './convert-media';
+export { createVideoDecoder } from './video-decoder';
+export { createVideoEncoder } from './video-encoder';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVideoEncoder = exports.createVideoDecoder = exports.convertMedia = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+var audio_decoder_1 = require("./audio-decoder");
+Object.defineProperty(exports, "createAudioDecoder", { enumerable: true, get: function () { return audio_decoder_1.createAudioDecoder; } });
+var audio_encoder_1 = require("./audio-encoder");
+Object.defineProperty(exports, "createAudioEncoder", { enumerable: true, get: function () { return audio_encoder_1.createAudioEncoder; } });
+var convert_media_1 = require("./convert-media");
+Object.defineProperty(exports, "convertMedia", { enumerable: true, get: function () { return convert_media_1.convertMedia; } });
+var video_decoder_1 = require("./video-decoder");
+Object.defineProperty(exports, "createVideoDecoder", { enumerable: true, get: function () { return video_decoder_1.createVideoDecoder; } });
+var video_encoder_1 = require("./video-encoder");
+Object.defineProperty(exports, "createVideoEncoder", { enumerable: true, get: function () { return video_encoder_1.createVideoEncoder; } });

package/dist/load-mp4-file.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../src/types/mp4box.d.ts" />
+import type { MP4File, MP4Info } from 'mp4box';
+type ReturnType = {
+    mp4File: MP4File;
+    info: MP4Info;
+};
+export declare const loadMp4File: (file: File) => Promise<ReturnType>;
+export {};

package/dist/load-mp4-file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMp4File = void 0;
+const mp4box_1 = require("mp4box");
+const readFile = (file) => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            reader.result.fileStart = 0;
+            resolve(reader.result);
+            reader.onerror = null;
+            reader.onload = null;
+        };
+        reader.onerror = (error) => {
+            reject(error);
+            reader.onerror = null;
+            reader.onload = null;
+        };
+        reader.readAsArrayBuffer(file);
+    });
+};
+const loadMp4File = async (file) => {
+    const mp4File = (0, mp4box_1.createFile)();
+    const arrayBuffer = await readFile(file);
+    const prom = new Promise((resolve, reject) => {
+        mp4File.onError = (error) => {
+            reject(error);
+        };
+        mp4File.onReady = (info) => {
+            resolve({ mp4File, info });
+        };
+    });
+    mp4File.appendBuffer(arrayBuffer);
+    mp4File.flush();
+    return prom;
+};
+exports.loadMp4File = loadMp4File;

package/dist/on-audio-track.d.ts

@@ -0,0 +1,15 @@
+import type { MediaFn, OnAudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaState } from './convert-media';
+import Error from './error-cause';
+import type { ResolveAudioActionFn } from './resolve-audio-action';
+export declare const makeAudioTrackHandler: ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, }: {
+    state: MediaFn;
+    audioCodec: ConvertMediaAudioCodec;
+    convertMediaState: ConvertMediaState;
+    controller: AbortController;
+    abortConversion: (errCause: Error) => void;
+    onMediaStateUpdate: ((state: ConvertMediaState) => void) | null;
+    onAudioTrack: ResolveAudioActionFn;
+    bitrate: number;
+}) => OnAudioTrack;

package/dist/on-audio-track.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAudioTrackHandler = void 0;
+const audio_decoder_1 = require("./audio-decoder");
+const audio_decoder_config_1 = require("./audio-decoder-config");
+const audio_encoder_1 = require("./audio-encoder");
+const audio_encoder_config_1 = require("./audio-encoder-config");
+const error_cause_1 = __importDefault(require("./error-cause"));
+const resolve_audio_action_1 = require("./resolve-audio-action");
+const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, }) => async (track) => {
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
+    const audioOperation = await (0, resolve_audio_action_1.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 === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+        };
+    }
+    if (!audioEncoderConfig) {
+        abortConversion(new error_cause_1.default(`Could not configure audio encoder of track ${track.trackId}`));
+        return null;
+    }
+    if (!audioDecoderConfig) {
+        abortConversion(new error_cause_1.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 = (0, audio_encoder_1.createAudioEncoder)({
+        onChunk: async (chunk) => {
+            await state.addSample(chunk, trackNumber);
+            convertMediaState.encodedAudioFrames++;
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+        },
+        onError: (err) => {
+            abortConversion(new error_cause_1.default(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
+                cause: err,
+            }));
+        },
+        codec: audioCodec,
+        signal: controller.signal,
+        config: audioEncoderConfig,
+    });
+    const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
+        onFrame: async (frame) => {
+            await audioEncoder.encodeFrame(frame);
+            convertMediaState.decodedAudioFrames++;
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
+            frame.close();
+        },
+        onError(error) {
+            abortConversion(new error_cause_1.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);
+    };
+};
+exports.makeAudioTrackHandler = makeAudioTrackHandler;

package/dist/on-video-track.d.ts

@@ -0,0 +1,15 @@
+import type { MediaFn, OnVideoTrack, VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaState } from './convert-media';
+import Error from './error-cause';
+import type { ResolveVideoActionFn } from './resolve-video-action';
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, }: {
+    state: MediaFn;
+    onVideoFrame: ((frame: VideoFrame, track: VideoTrack) => Promise<void>) | null;
+    onMediaStateUpdate: ((state: ConvertMediaState) => void) | null;
+    abortConversion: (errCause: Error) => void;
+    convertMediaState: ConvertMediaState;
+    controller: AbortController;
+    videoCodec: ConvertMediaVideoCodec;
+    onVideoTrack: ResolveVideoActionFn;
+}) => OnVideoTrack;

package/dist/on-video-track.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeVideoTrackHandler = void 0;
+const error_cause_1 = __importDefault(require("./error-cause"));
+const resolve_video_action_1 = require("./resolve-video-action");
+const video_decoder_1 = require("./video-decoder");
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_1 = require("./video-encoder");
+const video_encoder_config_1 = require("./video-encoder-config");
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, }) => async (track) => {
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoCodec,
+        height: track.displayAspectHeight,
+        width: track.displayAspectWidth,
+    });
+    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
+    const videoOperation = await (0, resolve_video_action_1.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 === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+        };
+    }
+    if (videoEncoderConfig === null) {
+        abortConversion(new error_cause_1.default(`Could not configure video encoder of track ${track.trackId}`));
+        return null;
+    }
+    if (videoDecoderConfig === null) {
+        abortConversion(new error_cause_1.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 = (0, video_encoder_1.createVideoEncoder)({
+        onChunk: async (chunk) => {
+            await state.addSample(chunk, trackNumber);
+            convertMediaState.encodedVideoFrames++;
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+        },
+        onError: (err) => {
+            abortConversion(new error_cause_1.default(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
+                cause: err,
+            }));
+        },
+        signal: controller.signal,
+        config: videoEncoderConfig,
+    });
+    const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
+        config: videoDecoderConfig,
+        onFrame: async (frame) => {
+            await (onVideoFrame === null || onVideoFrame === void 0 ? void 0 : onVideoFrame(frame, track));
+            await videoEncoder.encodeFrame(frame);
+            convertMediaState.decodedVideoFrames++;
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+            frame.close();
+        },
+        onError: (err) => {
+            abortConversion(new error_cause_1.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);
+    };
+};
+exports.makeVideoTrackHandler = makeVideoTrackHandler;

package/dist/reencode-video.d.ts

@@ -0,0 +1 @@
+export declare const reencodeVideo: (file: File) => Promise<void>;

package/dist/reencode-video.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reencodeVideo = void 0;
+const create_encoder_1 = require("./create-encoder");
+const create_video_decoder_1 = require("./create-video-decoder");
+const get_description_1 = require("./get-description");
+const get_samples_1 = require("./get-samples");
+const load_mp4_file_1 = require("./load-mp4-file");
+const reencodeVideo = async (file) => {
+    const { info, mp4File } = await (0, load_mp4_file_1.loadMp4File)(file);
+    const track = info.videoTracks[0];
+    if (!track) {
+        throw new Error('No video track found in the file');
+    }
+    const { encoder, outputMp4 } = (0, create_encoder_1.createEncoder)({
+        width: track.track_width,
+        height: track.track_height,
+        onProgress: (encoded) => {
+            const encodingProgress = Math.round((100 * encoded) / track.nb_samples);
+            console.log(`Encoding frame ${encoded} (${encodingProgress}%)`);
+        },
+    });
+    let nextKeyFrameTimestamp = 0;
+    let keyFrame = false;
+    const keyFrameEveryHowManySeconds = 2;
+    const { decoder } = (0, create_video_decoder_1.createVideoDecoder)({
+        onFrame: (frame) => {
+            if (frame.timestamp >= nextKeyFrameTimestamp) {
+                keyFrame = true;
+                nextKeyFrameTimestamp =
+                    frame.timestamp + keyFrameEveryHowManySeconds * 1e6;
+            }
+            encoder.encode(frame, { keyFrame });
+            frame.close();
+        },
+        onProgress: (decoded) => {
+            const decodingProgress = Math.round((100 * decoded) / track.nb_samples);
+            console.log(`Decoding frame ${decoded} (${decodingProgress}%)`);
+        },
+    });
+    decoder.configure({
+        codec: track.codec,
+        codedWidth: track.track_width,
+        codedHeight: track.track_height,
+        // TODO: Check first if hardware acceleration is supported
+        hardwareAcceleration: 'prefer-hardware',
+        description: (0, get_description_1.getDescription)({ mp4File, track }),
+    });
+    const samples = await (0, get_samples_1.getSamples)({ mp4File, track });
+    console.log(samples);
+    for (const sample of samples) {
+        const duration = (sample.duration * 1000000) / sample.timescale;
+        const timestamp = (sample.cts * 1000000) / sample.timescale;
+        const chunk = new EncodedVideoChunk({
+            type: sample.is_sync ? 'key' : 'delta',
+            timestamp,
+            duration,
+            data: sample.data,
+        });
+        decoder.decode(chunk);
+    }
+    await decoder.flush();
+    await encoder.flush();
+    encoder.close();
+    decoder.close();
+    outputMp4.save('mp4box.mp4');
+};
+exports.reencodeVideo = reencodeVideo;

package/dist/resolve-audio-action.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="dom-webcodecs" />
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export type AudioOperation = 'reencode' | 'copy' | 'drop';
+export type ResolveAudioActionFn = (options: {
+    canReencode: boolean;
+    canCopy: boolean;
+}) => AudioOperation | Promise<AudioOperation>;
+export declare const defaultResolveAudioAction: ResolveAudioActionFn;
+export declare const resolveAudioAction: ({ audioDecoderConfig, audioEncoderConfig, track, audioCodec, resolverFunction, }: {
+    audioDecoderConfig: AudioDecoderConfig | null;
+    audioEncoderConfig: AudioEncoderConfig | null;
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    resolverFunction: ResolveAudioActionFn;
+}) => Promise<AudioOperation>;

package/dist/resolve-audio-action.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAudioAction = exports.defaultResolveAudioAction = void 0;
+const canCopyAudioTrack = (inputCodec, outputCodec) => {
+    if (outputCodec === 'opus') {
+        return inputCodec === 'opus';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+const defaultResolveAudioAction = ({ canReencode, canCopy, }) => {
+    if (canCopy) {
+        return 'copy';
+    }
+    if (canReencode) {
+        return 'reencode';
+    }
+    // TODO: Make a fail option?
+    return 'drop';
+};
+exports.defaultResolveAudioAction = defaultResolveAudioAction;
+const 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;
+};
+exports.resolveAudioAction = resolveAudioAction;

package/dist/resolve-video-action.d.ts

@@ -0,0 +1,15 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export type VideoOperation = 'reencode' | 'copy' | 'drop';
+export type ResolveVideoActionFn = (options: {
+    canReencode: boolean;
+    canCopy: boolean;
+}) => VideoOperation | Promise<VideoOperation>;
+export declare const defaultResolveVideoAction: ResolveVideoActionFn;
+export declare const resolveVideoAction: ({ videoDecoderConfig, videoEncoderConfig, track, videoCodec, resolverFunction, }: {
+    videoDecoderConfig: VideoDecoderConfig | null;
+    videoEncoderConfig: VideoEncoderConfig | null;
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+    resolverFunction: ResolveVideoActionFn;
+}) => Promise<VideoOperation>;

package/dist/resolve-video-action.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVideoAction = exports.defaultResolveVideoAction = void 0;
+const canCopyVideoTrack = (inputCodec, outputCodec) => {
+    if (outputCodec === 'vp8') {
+        return inputCodec === 'vp8';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+const defaultResolveVideoAction = ({ canReencode, canCopy, }) => {
+    if (canCopy) {
+        return 'copy';
+    }
+    if (canReencode) {
+        return 'reencode';
+    }
+    // TODO: Make a fail option?
+    return 'drop';
+};
+exports.defaultResolveVideoAction = defaultResolveVideoAction;
+const 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;
+};
+exports.resolveVideoAction = resolveVideoAction;

package/dist/video-decoder-config.d.ts

@@ -0,0 +1 @@
+export declare const getVideoDecoderConfigWithHardwareAcceleration: (config: VideoDecoderConfig) => Promise<VideoDecoderConfig | null>;

package/dist/video-decoder-config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoDecoderConfigWithHardwareAcceleration = void 0;
+const 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;
+};
+exports.getVideoDecoderConfigWithHardwareAcceleration = getVideoDecoderConfigWithHardwareAcceleration;

package/dist/video-decoder.d.ts

@@ -0,0 +1,14 @@
+import type { VideoSample } from '@remotion/media-parser';
+export type WebCodecsVideoDecoder = {
+    processSample: (videoSample: VideoSample) => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    close: () => void;
+    getQueueSize: () => number;
+    flush: () => Promise<void>;
+};
+export declare const createVideoDecoder: ({ onFrame, onError, signal, config, }: {
+    onFrame: (frame: VideoFrame) => Promise<void>;
+    onError: (error: DOMException) => void;
+    signal: AbortSignal;
+    config: VideoDecoderConfig;
+}) => WebCodecsVideoDecoder;