@remotion/webcodecs 4.0.306 → 4.0.308

package/dist/audio-decoder.d.ts

@@ -1,7 +1,7 @@
-import type { MediaParserAudioSample, MediaParserLogLevel } from '@remotion/media-parser';
+import type { MediaParserLogLevel } from '@remotion/media-parser';
 import type { WebCodecsController } from './webcodecs-controller';
 export type WebCodecsAudioDecoder = {
-    decode: (audioSample: MediaParserAudioSample) => void;
+    decode: (audioSample: EncodedAudioChunkInit | EncodedAudioChunk) => void;
     close: () => void;
     flush: () => Promise<void>;
     waitForFinish: () => Promise<void>;
@@ -17,7 +17,7 @@ export type CreateAudioDecoderInit = {
 export declare const internalCreateAudioDecoder: ({ onFrame, onError, controller, config, logLevel, }: CreateAudioDecoderInit) => WebCodecsAudioDecoder;
 export declare const createAudioDecoder: ({ onFrame, onError, controller, track, logLevel, }: {
     track: AudioDecoderConfig;
-    onFrame: (frame: AudioData | EncodedAudioChunk) => Promise<void> | void;
+    onFrame: (frame: AudioData) => Promise<void> | void;
     onError: (error: Error) => void;
     controller?: WebCodecsController | null;
     logLevel?: MediaParserLogLevel;

package/dist/audio-encoder.js

@@ -77,7 +77,7 @@ const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audio
         },
         waitForFinish: async () => {
             await encoder.flush();
-            await ioSynchronizer.waitForFinish();
+            await ioSynchronizer.waitForQueueSize(0);
         },
         close,
         flush: async () => {

package/dist/can-copy-audio-track.d.ts

@@ -1,7 +1,9 @@
 import type { MediaParserAudioCodec, MediaParserContainer } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const canCopyAudioTrack: ({ inputCodec, outputContainer, inputContainer, }: {
+export declare const canCopyAudioTrack: ({ inputCodec, outputContainer, inputContainer, outputAudioCodec, }: {
     inputCodec: MediaParserAudioCodec;
     outputContainer: ConvertMediaContainer;
     inputContainer: MediaParserContainer;
+    outputAudioCodec: ConvertMediaAudioCodec | null;
 }) => boolean;

package/dist/can-copy-audio-track.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyAudioTrack = void 0;
-const canCopyAudioTrack = ({ inputCodec, outputContainer, inputContainer, }) => {
+const is_different_video_codec_1 = require("./is-different-video-codec");
+const canCopyAudioTrack = ({ inputCodec, outputContainer, inputContainer, outputAudioCodec, }) => {
+    if (outputAudioCodec) {
+        if (!(0, is_different_video_codec_1.isSameAudioCodec)({
+            inputAudioCodec: inputCodec,
+            outputCodec: outputAudioCodec,
+        })) {
+            return false;
+        }
+    }
     if (outputContainer === 'webm') {
         return inputCodec === 'opus';
     }

package/dist/can-copy-video-track.d.ts

@@ -1,10 +1,12 @@
 import type { MediaParserContainer, MediaParserVideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { ResizeOperation } from './resizing/mode';
-export declare const canCopyVideoTrack: ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, }: {
+export declare const canCopyVideoTrack: ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, outputVideoCodec, }: {
     inputContainer: MediaParserContainer;
     inputTrack: MediaParserVideoTrack;
     rotationToApply: number;
     outputContainer: ConvertMediaContainer;
+    outputVideoCodec: ConvertMediaVideoCodec | null;
     resizeOperation: ResizeOperation | null;
 }) => boolean;

package/dist/can-copy-video-track.js

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyVideoTrack = void 0;
+const is_different_video_codec_1 = require("./is-different-video-codec");
 const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
 const rotation_1 = require("./rotation");
-const canCopyVideoTrack = ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, }) => {
+const canCopyVideoTrack = ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, outputVideoCodec, }) => {
     if ((0, rotate_and_resize_video_frame_1.normalizeVideoRotation)(inputTrack.rotation) !==
         (0, rotate_and_resize_video_frame_1.normalizeVideoRotation)(rotationToApply)) {
         return false;
     }
+    if (outputVideoCodec) {
+        if (!(0, is_different_video_codec_1.isSameVideoCodec)({
+            inputVideoCodec: inputTrack.codecEnum,
+            outputCodec: outputVideoCodec,
+        })) {
+            return false;
+        }
+    }
     const newDimensions = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
         height: inputTrack.height,
         resizeOperation,

package/dist/create/matroska/matroska-utils.d.ts

@@ -22,7 +22,7 @@ export type EbmlParsedOrUint8Array<T extends MediaParserInternalTypes['Ebml']> =
     value: EbmlValueOrUint8Array<T>;
     minVintWidth: number | null;
 };
-export declare const measureEBMLVarInt: (value: number) => 2 | 4 | 1 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 4 | 3 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array<ArrayBuffer>;
 export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
 export type PossibleEbmlOrUint8Array = Prettify<{

package/dist/create-audio-decoder.d.ts

@@ -0,0 +1,24 @@
+import type { MediaParserLogLevel } from '@remotion/media-parser';
+import type { WebCodecsController } from './webcodecs-controller';
+export type WebCodecsAudioDecoder = {
+    decode: (audioSample: EncodedAudioChunkInit | EncodedAudioChunk) => Promise<void>;
+    close: () => void;
+    flush: () => Promise<void>;
+    waitForQueueToBeLessThan: (items: number) => Promise<void>;
+    reset: () => void;
+};
+export type CreateAudioDecoderInit = {
+    onFrame: (frame: AudioData) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller: WebCodecsController | null;
+    config: AudioDecoderConfig;
+    logLevel: MediaParserLogLevel;
+};
+export declare const internalCreateAudioDecoder: ({ onFrame, onError, controller, config, logLevel, }: CreateAudioDecoderInit) => WebCodecsAudioDecoder;
+export declare const createAudioDecoder: ({ track, onFrame, onError, controller, logLevel, }: {
+    track: AudioDecoderConfig;
+    onFrame: (frame: AudioData) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller?: WebCodecsController | null;
+    logLevel?: MediaParserLogLevel;
+}) => WebCodecsAudioDecoder;

package/dist/create-audio-decoder.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAudioDecoder = exports.internalCreateAudioDecoder = void 0;
+const get_wave_audio_decoder_1 = require("./get-wave-audio-decoder");
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const internalCreateAudioDecoder = ({ onFrame, onError, controller, config, logLevel, }) => {
+    if (controller &&
+        controller._internals._mediaParserController._internals.signal.aborted) {
+        throw new Error('Not creating audio decoder, already aborted');
+    }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label: 'Audio decoder',
+        controller,
+    });
+    if (config.codec === 'pcm-s16') {
+        return (0, get_wave_audio_decoder_1.getWaveAudioDecoder)({
+            onFrame,
+            config,
+            sampleFormat: 's16',
+            logLevel,
+            ioSynchronizer,
+            onError,
+        });
+    }
+    const audioDecoder = new AudioDecoder({
+        async output(frame) {
+            try {
+                await onFrame(frame);
+            }
+            catch (err) {
+                frame.close();
+                onError(err);
+            }
+            ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
+        },
+        error(error) {
+            onError(error);
+        },
+    });
+    const close = () => {
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', 
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            onAbort);
+        }
+        if (audioDecoder.state === 'closed') {
+            return;
+        }
+        audioDecoder.close();
+    };
+    const onAbort = () => {
+        close();
+    };
+    if (controller) {
+        controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    }
+    audioDecoder.configure(config);
+    const decode = async (audioSample) => {
+        if (audioDecoder.state === 'closed') {
+            return;
+        }
+        try {
+            await controller?._internals._mediaParserController._internals.checkForAbortAndPause();
+        }
+        catch (err) {
+            onError(err);
+            return;
+        }
+        // Don't flush, it messes up the audio
+        const chunk = audioSample instanceof EncodedAudioChunk
+            ? audioSample
+            : new EncodedAudioChunk(audioSample);
+        audioDecoder.decode(chunk);
+        // https://test-streams.mux.dev/x36xhzz/url_0/url_525/193039199_mp4_h264_aac_hd_7.ts
+        // has a 16 byte audio sample at the end which chrome does not decode
+        // Might be empty audio
+        // For now only reporting chunks that are bigger than that
+        // 16 was chosen arbitrarily, can be improved
+        if (chunk.byteLength > 16) {
+            ioSynchronizer.inputItem(chunk.timestamp);
+        }
+    };
+    return {
+        decode,
+        close,
+        flush: async () => {
+            // Firefox might throw "Needs to be configured first"
+            try {
+                await audioDecoder.flush();
+            }
+            catch { }
+            await ioSynchronizer.waitForQueueSize(0);
+        },
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+        reset: () => {
+            audioDecoder.reset();
+            audioDecoder.configure(config);
+        },
+    };
+};
+exports.internalCreateAudioDecoder = internalCreateAudioDecoder;
+const createAudioDecoder = ({ track, onFrame, onError, controller, logLevel, }) => {
+    return (0, exports.internalCreateAudioDecoder)({
+        onFrame,
+        onError,
+        controller: controller ?? null,
+        config: track,
+        logLevel: logLevel ?? 'error',
+    });
+};
+exports.createAudioDecoder = createAudioDecoder;

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

@@ -0,0 +1,23 @@
+import type { MediaParserLogLevel } from '@remotion/media-parser';
+import type { WebCodecsController } from './webcodecs-controller';
+export type WebCodecsVideoDecoder = {
+    decode: (videoSample: EncodedVideoChunkInit | EncodedVideoChunk) => void;
+    close: () => void;
+    flush: () => Promise<void>;
+    waitForQueueToBeLessThan: (items: number) => Promise<void>;
+    reset: () => void;
+};
+export declare const internalCreateVideoDecoder: ({ onFrame, onError, controller, config, logLevel, }: {
+    onFrame: (frame: VideoFrame) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller: WebCodecsController | null;
+    config: VideoDecoderConfig;
+    logLevel: MediaParserLogLevel;
+}) => WebCodecsVideoDecoder;
+export declare const createVideoDecoder: ({ onFrame, onError, controller, track, logLevel, }: {
+    track: VideoDecoderConfig;
+    onFrame: (frame: VideoFrame) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller?: WebCodecsController;
+    logLevel?: MediaParserLogLevel;
+}) => WebCodecsVideoDecoder;

package/dist/create-video-decoder.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVideoDecoder = exports.internalCreateVideoDecoder = void 0;
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const internalCreateVideoDecoder = ({ onFrame, onError, controller, config, logLevel, }) => {
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label: 'Video decoder',
+        controller,
+    });
+    const videoDecoder = new VideoDecoder({
+        async output(frame) {
+            try {
+                await onFrame(frame);
+            }
+            catch (err) {
+                onError(err);
+                frame.close();
+            }
+            ioSynchronizer.onOutput(frame.timestamp);
+        },
+        error(error) {
+            onError(error);
+        },
+    });
+    const close = () => {
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', 
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            onAbort);
+        }
+        if (videoDecoder.state === 'closed') {
+            return;
+        }
+        videoDecoder.close();
+    };
+    const onAbort = () => {
+        close();
+    };
+    if (controller) {
+        controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    }
+    videoDecoder.configure(config);
+    const decode = async (sample) => {
+        if (videoDecoder.state === 'closed') {
+            return;
+        }
+        try {
+            await controller?._internals._mediaParserController._internals.checkForAbortAndPause();
+        }
+        catch (err) {
+            onError(err);
+            return;
+        }
+        const encodedChunk = sample instanceof EncodedVideoChunk
+            ? sample
+            : new EncodedVideoChunk(sample);
+        videoDecoder.decode(encodedChunk);
+        ioSynchronizer.inputItem(sample.timestamp);
+    };
+    return {
+        decode,
+        close,
+        flush: async () => {
+            // Firefox might throw "Needs to be configured first"
+            try {
+                await videoDecoder.flush();
+            }
+            catch { }
+            await ioSynchronizer.waitForQueueSize(0);
+        },
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+        reset: () => {
+            videoDecoder.reset();
+            videoDecoder.configure(config);
+        },
+    };
+};
+exports.internalCreateVideoDecoder = internalCreateVideoDecoder;
+const createVideoDecoder = ({ onFrame, onError, controller, track, logLevel, }) => {
+    return (0, exports.internalCreateVideoDecoder)({
+        onFrame,
+        onError,
+        controller: controller ?? null,
+        config: track,
+        logLevel: logLevel ?? 'info',
+    });
+};
+exports.createVideoDecoder = createVideoDecoder;