@remotion/webcodecs 4.0.236 → 4.0.239

package/dist/audio-decoder.js

@@ -17,10 +17,11 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
     });
     let outputQueue = Promise.resolve();
     const audioDecoder = new AudioDecoder({
-        output(inputFrame) {
-            ioSynchronizer.onOutput(inputFrame.timestamp);
+        output(frame) {
+            var _a;
+            ioSynchronizer.onOutput(frame.timestamp + ((_a = frame.duration) !== null && _a !== void 0 ? _a : 0));
             const abortHandler = () => {
-                inputFrame.close();
+                frame.close();
             };
             signal.addEventListener('abort', abortHandler, { once: true });
             outputQueue = outputQueue
@@ -28,7 +29,7 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
                 if (signal.aborted) {
                     return;
                 }
-                return onFrame(inputFrame);
+                return onFrame(frame);
             })
                 .then(() => {
                 ioSynchronizer.onProcessed();
@@ -36,7 +37,7 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
                 return Promise.resolve();
             })
                 .catch((err) => {
-                inputFrame.close();
+                frame.close();
                 onError(err);
             });
         },
@@ -58,13 +59,16 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
     signal.addEventListener('abort', onAbort);
     audioDecoder.configure(config);
     const processSample = async (audioSample) => {
+        var _a, _b;
         if (audioDecoder.state === 'closed') {
             return;
         }
+        progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, (_a = audioSample.dts) !== null && _a !== void 0 ? _a : Infinity, (_b = audioSample.cts) !== null && _b !== void 0 ? _b : Infinity));
         await ioSynchronizer.waitFor({
             unemitted: 20,
-            _unprocessed: 20,
+            unprocessed: 20,
             minimumProgress: audioSample.timestamp - 10000000,
+            signal,
         });
         // Don't flush, it messes up the audio
         const chunk = new EncodedAudioChunk(audioSample);
@@ -89,7 +93,7 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
             }
             catch (_a) { }
             await queue;
-            await ioSynchronizer.waitForFinish();
+            await ioSynchronizer.waitForFinish(signal);
             await outputQueue;
         },
         close,

package/dist/audio-encoder.js

@@ -58,10 +58,12 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         if (encoder.state === 'closed') {
             return;
         }
+        progressTracker.setPossibleLowestTimestamp(audioData.timestamp);
         await ioSynchronizer.waitFor({
             unemitted: 20,
-            _unprocessed: 20,
+            unprocessed: 20,
             minimumProgress: audioData.timestamp - 10000000,
+            signal,
         });
         // @ts-expect-error - can have changed in the meanwhile
         if (encoder.state === 'closed') {
@@ -90,7 +92,7 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         },
         waitForFinish: async () => {
             await encoder.flush();
-            await ioSynchronizer.waitForFinish();
+            await ioSynchronizer.waitForFinish(signal);
             await prom;
         },
         close,

package/dist/auto-select-writer.d.ts

@@ -1,3 +1,3 @@
-import type { WriterInterface } from '@remotion/media-parser';
+import { type WriterInterface } from '@remotion/media-parser';
 import type { LogLevel } from './log';
 export declare const autoSelectWriter: (writer: WriterInterface | undefined, logLevel: LogLevel) => Promise<WriterInterface>;

package/dist/auto-select-writer.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autoSelectWriter = void 0;
-const buffer_1 = require("@remotion/media-parser/buffer");
 const web_fs_1 = require("@remotion/media-parser/web-fs");
+const media_parser_1 = require("@remotion/media-parser");
+const buffer_1 = require("@remotion/media-parser/buffer");
 const log_1 = require("./log");
 const autoSelectWriter = async (writer, logLevel) => {
     if (writer) {
@@ -10,11 +11,27 @@ const autoSelectWriter = async (writer, logLevel) => {
         return writer;
     }
     log_1.Log.verbose(logLevel, 'Determining best writer');
-    if (await (0, web_fs_1.canUseWebFsWriter)()) {
-        log_1.Log.verbose(logLevel, 'Using WebFS writer because it is supported');
-        return web_fs_1.webFsWriter;
+    // Check if we're offline using the navigator API
+    const isOffline = !navigator.onLine;
+    if (isOffline) {
+        log_1.Log.verbose(logLevel, 'Offline mode detected, using buffer writer');
+        return buffer_1.bufferWriter;
+    }
+    try {
+        const { promise: timeout, reject, resolve, } = media_parser_1.MediaParserInternals.withResolvers();
+        const time = setTimeout(() => reject(new Error('WebFS check timeout')), 2000);
+        const webFsSupported = await Promise.race([(0, web_fs_1.canUseWebFsWriter)(), timeout]);
+        resolve();
+        clearTimeout(time);
+        if (webFsSupported) {
+            log_1.Log.verbose(logLevel, 'Using WebFS writer because it is supported');
+            return web_fs_1.webFsWriter;
+        }
+    }
+    catch (err) {
+        log_1.Log.verbose(logLevel, `WebFS check failed: ${err}. Falling back to buffer writer`);
     }
-    log_1.Log.verbose(logLevel, 'Using buffer writer because WebFS writer is not supported');
+    log_1.Log.verbose(logLevel, 'Using buffer writer because WebFS writer is not supported or unavailable');
     return buffer_1.bufferWriter;
 };
 exports.autoSelectWriter = autoSelectWriter;

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

@@ -1,6 +1,7 @@
-import type { MediaParserAudioCodec } from '@remotion/media-parser';
+import type { MediaParserAudioCodec, ParseMediaContainer } from '@remotion/media-parser';
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const canCopyAudioTrack: ({ inputCodec, container, }: {
+export declare const canCopyAudioTrack: ({ inputCodec, outputContainer, inputContainer, }: {
     inputCodec: MediaParserAudioCodec;
-    container: ConvertMediaContainer;
+    outputContainer: ConvertMediaContainer;
+    inputContainer: ParseMediaContainer;
 }) => boolean;

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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyAudioTrack = void 0;
-const canCopyAudioTrack = ({ inputCodec, container, }) => {
-    if (container === 'webm') {
+const canCopyAudioTrack = ({ inputCodec, outputContainer, inputContainer, }) => {
+    if (outputContainer === 'webm') {
         return inputCodec === 'opus';
     }
-    if (container === 'mp4') {
-        return inputCodec === 'aac';
+    if (outputContainer === 'mp4') {
+        return (inputCodec === 'aac' &&
+            (inputContainer === 'mp4' || inputContainer === 'avi'));
     }
-    if (container === 'wav') {
+    if (outputContainer === 'wav') {
         return false;
     }
-    throw new Error(`Unhandled codec: ${container}`);
+    throw new Error(`Unhandled container: ${outputContainer}`);
 };
 exports.canCopyAudioTrack = canCopyAudioTrack;

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

@@ -1,8 +1,9 @@
-import type { MediaParserVideoCodec } from '@remotion/media-parser';
+import type { MediaParserVideoCodec, ParseMediaContainer } from '@remotion/media-parser';
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const canCopyVideoTrack: ({ inputCodec, container, inputRotation, rotationToApply, }: {
+export declare const canCopyVideoTrack: ({ inputCodec, outputContainer, inputRotation, rotationToApply, inputContainer, }: {
+    inputContainer: ParseMediaContainer;
     inputCodec: MediaParserVideoCodec;
     inputRotation: number;
     rotationToApply: number;
-    container: ConvertMediaContainer;
+    outputContainer: ConvertMediaContainer;
 }) => boolean;

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

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyVideoTrack = void 0;
 const rotate_video_frame_1 = require("./rotate-video-frame");
-const canCopyVideoTrack = ({ inputCodec, container, inputRotation, rotationToApply, }) => {
+const canCopyVideoTrack = ({ inputCodec, outputContainer, inputRotation, rotationToApply, inputContainer, }) => {
     if ((0, rotate_video_frame_1.normalizeVideoRotation)(inputRotation) !==
         (0, rotate_video_frame_1.normalizeVideoRotation)(rotationToApply)) {
         return false;
     }
-    if (container === 'webm') {
+    if (outputContainer === 'webm') {
         return inputCodec === 'vp8' || inputCodec === 'vp9';
     }
-    if (container === 'mp4') {
-        return inputCodec === 'h264';
+    if (outputContainer === 'mp4') {
+        return (inputCodec === 'h264' &&
+            (inputContainer === 'mp4' || inputContainer === 'avi'));
     }
-    if (container === 'wav') {
+    if (outputContainer === 'wav') {
         return false;
     }
-    throw new Error(`Unhandled codec: ${container}`);
+    throw new Error(`Unhandled codec: ${outputContainer}`);
 };
 exports.canCopyVideoTrack = canCopyVideoTrack;

package/dist/convert-media.js

@@ -87,7 +87,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         defaultVideoCodec: videoCodec !== null && videoCodec !== void 0 ? videoCodec : null,
         onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : null,
         logLevel,
-        container,
+        outputContainer: container,
         rotate: rotate !== null && rotate !== void 0 ? rotate : 0,
         progress: progressTracker,
     });
@@ -99,7 +99,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         state,
         onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : null,
         logLevel,
-        container,
+        outputContainer: container,
         progressTracker,
     });
     (0, media_parser_1.parseMedia)({

package/dist/default-on-audio-track-handler.js

@@ -2,23 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOnAudioTrackHandler = void 0;
 const media_parser_1 = require("@remotion/media-parser");
-const can_copy_audio_track_1 = require("./can-copy-audio-track");
 const can_reencode_audio_track_1 = require("./can-reencode-audio-track");
-const get_default_audio_codec_1 = require("./get-default-audio-codec");
 const DEFAULT_BITRATE = 128000;
-const defaultOnAudioTrackHandler = async ({ track, defaultAudioCodec, logLevel, container, }) => {
+const defaultOnAudioTrackHandler = async ({ track, defaultAudioCodec, logLevel, canCopyTrack, }) => {
     const bitrate = DEFAULT_BITRATE;
-    const canCopy = (0, can_copy_audio_track_1.canCopyAudioTrack)({
-        inputCodec: track.codecWithoutConfig,
-        container,
-    });
-    if (canCopy) {
+    if (canCopyTrack) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
         return Promise.resolve({ type: 'copy' });
     }
-    const audioCodec = defaultAudioCodec !== null && defaultAudioCodec !== void 0 ? defaultAudioCodec : (0, get_default_audio_codec_1.getDefaultAudioCodec)({ container });
+    // The idea is that for example for GIFs, we will return defaultAudioCodec = null
+    if (defaultAudioCodec === null) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Container does not support audio, dropping audio`);
+        return Promise.resolve({ type: 'drop' });
+    }
     const canReencode = await (0, can_reencode_audio_track_1.canReencodeAudioTrack)({
-        audioCodec,
+        audioCodec: defaultAudioCodec,
         track,
         bitrate,
     });
@@ -27,7 +25,7 @@ const defaultOnAudioTrackHandler = async ({ track, defaultAudioCodec, logLevel,
         return Promise.resolve({
             type: 'reencode',
             bitrate,
-            audioCodec,
+            audioCodec: defaultAudioCodec,
         });
     }
     media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);

package/dist/default-on-video-track-handler.js

@@ -2,34 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOnVideoTrackHandler = void 0;
 const media_parser_1 = require("@remotion/media-parser");
-const can_copy_video_track_1 = require("./can-copy-video-track");
 const can_reencode_video_track_1 = require("./can-reencode-video-track");
-const get_default_video_codec_1 = require("./get-default-video-codec");
-const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, container, rotate, }) => {
-    const canCopy = (0, can_copy_video_track_1.canCopyVideoTrack)({
-        inputCodec: track.codecWithoutConfig,
-        container,
-        inputRotation: track.rotation,
-        rotationToApply: rotate,
-    });
-    if (canCopy) {
+const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, rotate, canCopyTrack, }) => {
+    if (canCopyTrack) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
         return Promise.resolve({ type: 'copy' });
     }
-    const videoCodec = defaultVideoCodec !== null && defaultVideoCodec !== void 0 ? defaultVideoCodec : (0, get_default_video_codec_1.getDefaultVideoCodec)({ container });
-    if (videoCodec === null) {
-        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+    if (defaultVideoCodec === null) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Is audio container, therefore dropping video`);
         return Promise.resolve({ type: 'drop' });
     }
     const canReencode = await (0, can_reencode_video_track_1.canReencodeVideoTrack)({
-        videoCodec,
+        videoCodec: defaultVideoCodec,
         track,
     });
     if (canReencode) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
         return Promise.resolve({
             type: 'reencode',
-            videoCodec,
+            videoCodec: defaultVideoCodec,
             rotation: rotate - track.rotation,
         });
     }