@remotion/webcodecs 4.0.228 → 4.0.229

package/dist/audio-decoder-config.js

@@ -5,6 +5,9 @@ const getAudioDecoderConfig = async (config) => {
     if (typeof AudioDecoder === 'undefined') {
         return null;
     }
+    if (typeof EncodedAudioChunk === 'undefined') {
+        return null;
+    }
     if ((await AudioDecoder.isConfigSupported(config)).supported) {
         return config;
     }

package/dist/calculate-progress.d.ts

@@ -1,4 +1,4 @@
-export declare const calculateProgress: ({ millisecondsWritten, expectedOutputMilliseconds, }: {
+export declare const calculateProgress: ({ millisecondsWritten, expectedOutputDurationInMs, }: {
     millisecondsWritten: number;
-    expectedOutputMilliseconds: number | null;
+    expectedOutputDurationInMs: number | null;
 }) => number | null;

package/dist/calculate-progress.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateProgress = void 0;
-const calculateProgress = ({ millisecondsWritten, expectedOutputMilliseconds, }) => {
-    if (expectedOutputMilliseconds === null) {
+const calculateProgress = ({ millisecondsWritten, expectedOutputDurationInMs, }) => {
+    if (expectedOutputDurationInMs === null) {
         return null;
     }
-    return millisecondsWritten / expectedOutputMilliseconds;
+    return millisecondsWritten / expectedOutputDurationInMs;
 };
 exports.calculateProgress = calculateProgress;

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

@@ -0,0 +1,8 @@
+import type { MediaParserAudioCodec } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaContainer } from './convert-media';
+export declare const canCopyAudioTrack: ({ inputCodec, outputCodec, container, }: {
+    inputCodec: MediaParserAudioCodec;
+    outputCodec: ConvertMediaAudioCodec;
+    container: ConvertMediaContainer;
+}) => boolean;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCopyAudioTrack = void 0;
+const canCopyAudioTrack = ({ inputCodec, outputCodec, container, }) => {
+    if (outputCodec === 'opus') {
+        return inputCodec === 'opus' && container === 'webm';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+exports.canCopyAudioTrack = canCopyAudioTrack;

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

@@ -0,0 +1,8 @@
+import type { MediaParserVideoCodec } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './convert-media';
+export declare const canCopyVideoTrack: ({ inputCodec, outputCodec, container, }: {
+    inputCodec: MediaParserVideoCodec;
+    outputCodec: ConvertMediaVideoCodec;
+    container: ConvertMediaContainer;
+}) => boolean;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCopyVideoTrack = void 0;
+const canCopyVideoTrack = ({ inputCodec, outputCodec, container, }) => {
+    if (outputCodec === 'vp8') {
+        return inputCodec === 'vp8' && container === 'webm';
+    }
+    if (outputCodec === 'vp9') {
+        return inputCodec === 'vp9' && container === 'webm';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+exports.canCopyVideoTrack = canCopyVideoTrack;

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

@@ -0,0 +1,7 @@
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    bitrate: number;
+}) => Promise<boolean>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeAudioTrack = void 0;
+const audio_decoder_config_1 = require("./audio-decoder-config");
+const audio_encoder_config_1 = require("./audio-encoder-config");
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+exports.canReencodeAudioTrack = canReencodeAudioTrack;

package/dist/can-reencode-audio.d.ts

@@ -0,0 +1,7 @@
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    bitrate: number;
+}) => Promise<boolean>;

package/dist/can-reencode-audio.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeAudioTrack = void 0;
+const audio_decoder_config_1 = require("./audio-decoder-config");
+const audio_encoder_config_1 = require("./audio-encoder-config");
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+exports.canReencodeAudioTrack = canReencodeAudioTrack;

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

@@ -0,0 +1,6 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+}) => Promise<boolean>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeVideoTrack = void 0;
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_config_1 = require("./video-encoder-config");
+const canReencodeVideoTrack = async ({ videoCodec, 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);
+    return Boolean(videoDecoderConfig && videoEncoderConfig);
+};
+exports.canReencodeVideoTrack = canReencodeVideoTrack;

package/dist/can-reencode-video.d.ts

@@ -0,0 +1,6 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+}) => Promise<boolean>;

package/dist/can-reencode-video.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeVideoTrack = void 0;
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_config_1 = require("./video-encoder-config");
+const canReencodeVideoTrack = async ({ videoCodec, 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);
+    return Boolean(videoDecoderConfig && videoEncoderConfig);
+};
+exports.canReencodeVideoTrack = canReencodeVideoTrack;

package/dist/codec-id.d.ts

@@ -1,2 +1,7 @@
-export type ConvertMediaVideoCodec = 'vp8' | 'vp9';
-export type ConvertMediaAudioCodec = 'opus';
+declare const availableVideoCodecs: readonly ["vp8", "vp9"];
+export declare const getAvailableVideoCodecs: () => readonly ["vp8", "vp9"];
+export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
+declare const availableAudioCodecs: readonly ["opus"];
+export declare const getAvailableAudioCodecs: () => readonly ["opus"];
+export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
+export {};

package/dist/codec-id.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableAudioCodecs = exports.getAvailableVideoCodecs = void 0;
+const availableVideoCodecs = ['vp8', 'vp9'];
+const getAvailableVideoCodecs = () => availableVideoCodecs;
+exports.getAvailableVideoCodecs = getAvailableVideoCodecs;
+const availableAudioCodecs = ['opus'];
+const getAvailableAudioCodecs = () => availableAudioCodecs;
+exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/convert-encoded-chunk.d.ts

@@ -0,0 +1,2 @@
+import type { AudioOrVideoSample } from '@remotion/media-parser';
+export declare const convertEncodedChunk: (chunk: EncodedAudioChunk | EncodedVideoChunk) => AudioOrVideoSample;

package/dist/convert-encoded-chunk.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEncodedChunk = void 0;
+const convertEncodedChunk = (chunk) => {
+    var _a;
+    const arr = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(arr);
+    return {
+        data: arr,
+        duration: (_a = chunk.duration) !== null && _a !== void 0 ? _a : undefined,
+        timestamp: chunk.timestamp,
+        type: chunk.type,
+    };
+};
+exports.convertEncodedChunk = convertEncodedChunk;

package/dist/convert-media.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Copyright (c) 2024 Remotion AG
+ * For licensing, see: https://remotion.dev/docs/webcodecs#license
+ */
 import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec, ConvertMediaVideoCodec } from './codec-id';
 import { type ResolveAudioActionFn } from './resolve-audio-action';
@@ -9,19 +13,24 @@ export type ConvertMediaState = {
     encodedAudioFrames: number;
     bytesWritten: number;
     millisecondsWritten: number;
-    expectedOutputMilliseconds: number | null;
+    expectedOutputDurationInMs: number | null;
     overallProgress: number | null;
 };
-export type ConvertMediaTo = 'webm';
+export type ConvertMediaContainer = 'webm';
 export type ConvertMediaResult = {
-    save: () => Promise<File>;
+    save: () => Promise<Blob>;
     remove: () => Promise<void>;
 };
-export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...more }: {
+export type ConvertMediaOnMediaStateUpdate = (state: ConvertMediaState) => void;
+export type ConvertMediaOnVideoFrame = (options: {
+    frame: VideoFrame;
+    track: VideoTrack;
+}) => Promise<VideoFrame> | VideoFrame;
+export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...more }: {
     src: ParseMediaOptions<F>["src"];
-    to: ConvertMediaTo;
-    onVideoFrame?: (inputFrame: VideoFrame, track: VideoTrack) => Promise<void>;
-    onMediaStateUpdate?: (state: ConvertMediaState) => void;
+    container: ConvertMediaContainer;
+    onVideoFrame?: ConvertMediaOnVideoFrame;
+    onMediaStateUpdate?: ConvertMediaOnMediaStateUpdate;
     videoCodec: ConvertMediaVideoCodec;
     audioCodec: ConvertMediaAudioCodec;
     signal?: AbortSignal;

package/dist/convert-media.js

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ * Copyright (c) 2024 Remotion AG
+ * For licensing, see: https://remotion.dev/docs/webcodecs#license
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,14 +14,12 @@ const calculate_progress_1 = require("./calculate-progress");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const on_audio_track_1 = require("./on-audio-track");
 const on_video_track_1 = require("./on-video-track");
-const resolve_audio_action_1 = require("./resolve-audio-action");
-const resolve_video_action_1 = require("./resolve-video-action");
 const with_resolvers_1 = require("./with-resolvers");
-const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
+const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
     }
-    if (to !== 'webm') {
+    if (container !== 'webm') {
         return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
     }
     if (audioCodec !== 'opus') {
@@ -45,7 +47,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         encodedAudioFrames: 0,
         bytesWritten: 0,
         millisecondsWritten: 0,
-        expectedOutputMilliseconds: null,
+        expectedOutputDurationInMs: null,
         overallProgress: 0,
     };
     const onMediaStateUpdate = (newState) => {
@@ -65,7 +67,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
                 convertMediaState.millisecondsWritten = millisecondsWritten;
                 convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
                     millisecondsWritten: convertMediaState.millisecondsWritten,
-                    expectedOutputMilliseconds: convertMediaState.expectedOutputMilliseconds,
+                    expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs,
                 });
                 onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
             }
@@ -79,8 +81,9 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         convertMediaState,
         controller,
         videoCodec,
-        onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : resolve_video_action_1.defaultResolveVideoAction,
+        onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : null,
         logLevel,
+        container,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
         abortConversion,
@@ -89,9 +92,9 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         convertMediaState,
         onMediaStateUpdate: onMediaStateUpdate !== null && onMediaStateUpdate !== void 0 ? onMediaStateUpdate : null,
         state,
-        onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : resolve_audio_action_1.defaultResolveAudioAction,
-        bitrate: 128000,
+        onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : null,
         logLevel,
+        container,
     });
     (0, media_parser_1.parseMedia)({
         src,
@@ -112,11 +115,11 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
             if (casted.onDurationInSeconds) {
                 casted.onDurationInSeconds(durationInSeconds);
             }
-            const expectedOutputMilliseconds = durationInSeconds * 1000;
-            convertMediaState.expectedOutputMilliseconds = expectedOutputMilliseconds;
+            const expectedOutputDurationInMs = durationInSeconds * 1000;
+            convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
             convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
                 millisecondsWritten: convertMediaState.millisecondsWritten,
-                expectedOutputMilliseconds,
+                expectedOutputDurationInMs,
             });
             onMediaStateUpdate(convertMediaState);
         },