@remotion/webcodecs 4.0.311 → 4.0.313

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

@@ -6,6 +6,10 @@ export type WebCodecsAudioDecoder = {
     flush: () => Promise<void>;
     waitForQueueToBeLessThan: (items: number) => Promise<void>;
     reset: () => void;
+    checkReset: () => {
+        wasReset: () => boolean;
+    };
+    getMostRecentSampleInput: () => number | null;
 };
 export type CreateAudioDecoderInit = {
     onFrame: (frame: AudioData) => Promise<void> | void;

package/dist/create-audio-decoder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioDecoder = exports.internalCreateAudioDecoder = void 0;
+const flush_pending_1 = require("./flush-pending");
 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, }) => {
@@ -13,6 +14,7 @@ const internalCreateAudioDecoder = ({ onFrame, onError, controller, config, logL
         label: 'Audio decoder',
         controller,
     });
+    let mostRecentSampleReceived = null;
     if (config.codec === 'pcm-s16') {
         return (0, get_wave_audio_decoder_1.getWaveAudioDecoder)({
             onFrame,
@@ -67,6 +69,7 @@ const internalCreateAudioDecoder = ({ onFrame, onError, controller, config, logL
             onError(err);
             return;
         }
+        mostRecentSampleReceived = audioSample.timestamp;
         // Don't flush, it messes up the audio
         const chunk = audioSample instanceof EncodedAudioChunk
             ? audioSample
@@ -81,22 +84,44 @@ const internalCreateAudioDecoder = ({ onFrame, onError, controller, config, logL
             ioSynchronizer.inputItem(chunk.timestamp);
         }
     };
+    let flushPending = null;
+    const lastReset = null;
     return {
         decode,
         close,
-        flush: async () => {
-            // Firefox might throw "Needs to be configured first"
-            try {
-                await audioDecoder.flush();
+        flush: () => {
+            if (flushPending) {
+                throw new Error('Flush already pending');
             }
-            catch { }
-            await ioSynchronizer.waitForQueueSize(0);
+            const pendingFlush = (0, flush_pending_1.makeFlushPending)();
+            flushPending = pendingFlush;
+            Promise.resolve()
+                .then(() => {
+                return audioDecoder.flush();
+            })
+                .catch(() => {
+                // Firefox might throw "Needs to be configured first"
+            })
+                .finally(() => {
+                pendingFlush.resolve();
+                flushPending = null;
+            });
+            return pendingFlush.promise;
         },
         waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
         reset: () => {
             audioDecoder.reset();
             audioDecoder.configure(config);
         },
+        checkReset: () => {
+            const initTime = Date.now();
+            return {
+                wasReset: () => lastReset !== null && lastReset > initTime,
+            };
+        },
+        getMostRecentSampleInput() {
+            return mostRecentSampleReceived;
+        },
     };
 };
 exports.internalCreateAudioDecoder = internalCreateAudioDecoder;

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

@@ -6,6 +6,10 @@ export type WebCodecsVideoDecoder = {
     flush: () => Promise<void>;
     waitForQueueToBeLessThan: (items: number) => Promise<void>;
     reset: () => void;
+    checkReset: () => {
+        wasReset: () => boolean;
+    };
+    getMostRecentSampleInput: () => number | null;
 };
 export declare const internalCreateVideoDecoder: ({ onFrame, onError, controller, config, logLevel, }: {
     onFrame: (frame: VideoFrame) => Promise<void> | void;

package/dist/create-video-decoder.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoDecoder = exports.internalCreateVideoDecoder = void 0;
+const flush_pending_1 = require("./flush-pending");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
 const internalCreateVideoDecoder = ({ 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: 'Video decoder',
         controller,
     });
+    let mostRecentSampleReceived = null;
     const videoDecoder = new VideoDecoder({
         async output(frame) {
             try {
@@ -52,28 +58,54 @@ const internalCreateVideoDecoder = ({ onFrame, onError, controller, config, logL
             onError(err);
             return;
         }
+        mostRecentSampleReceived = sample.timestamp;
         const encodedChunk = sample instanceof EncodedVideoChunk
             ? sample
             : new EncodedVideoChunk(sample);
         videoDecoder.decode(encodedChunk);
         ioSynchronizer.inputItem(sample.timestamp);
     };
+    let flushPending = null;
+    let lastReset = null;
     return {
         decode,
         close,
-        flush: async () => {
-            // Firefox might throw "Needs to be configured first"
-            try {
-                await videoDecoder.flush();
+        flush: () => {
+            if (flushPending) {
+                throw new Error('Flush already pending');
             }
-            catch { }
-            await ioSynchronizer.waitForQueueSize(0);
+            const pendingFlush = (0, flush_pending_1.makeFlushPending)();
+            flushPending = pendingFlush;
+            Promise.resolve()
+                .then(() => {
+                return videoDecoder.flush();
+            })
+                .catch(() => {
+                // Firefox might throw "Needs to be configured first"
+            })
+                .finally(() => {
+                pendingFlush.resolve();
+                flushPending = null;
+            });
+            return pendingFlush.promise;
         },
         waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
         reset: () => {
+            lastReset = Date.now();
+            flushPending?.resolve();
+            ioSynchronizer.clearQueue();
             videoDecoder.reset();
             videoDecoder.configure(config);
         },
+        checkReset: () => {
+            const initTime = Date.now();
+            return {
+                wasReset: () => lastReset !== null && lastReset > initTime,
+            };
+        },
+        getMostRecentSampleInput() {
+            return mostRecentSampleReceived;
+        },
     };
 };
 exports.internalCreateVideoDecoder = internalCreateVideoDecoder;

package/dist/esm/index.mjs

@@ -538,6 +538,7 @@ var makeIoSynchronizer = ({
   let lastOutput = 0;
   let inputsSinceLastOutput = 0;
   let inputs = [];
+  let resolvers = [];
   const getQueuedItems = () => {
     inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput) + 1);
     return inputs.length;
@@ -567,8 +568,10 @@ var makeIoSynchronizer = ({
     const on = () => {
       eventEmitter.removeEventListener("output", on);
       resolve();
+      resolvers = resolvers.filter((resolver) => resolver !== resolve);
     };
     eventEmitter.addEventListener("output", on);
+    resolvers.push(resolve);
     return promise;
   };
   const makeErrorBanner = () => {
@@ -608,10 +611,22 @@ var makeIoSynchronizer = ({
       controller._internals._mediaParserController._internals.signal.removeEventListener("abort", clear);
     }
   };
+  const clearQueue = () => {
+    inputs.length = 0;
+    lastInput = 0;
+    lastOutput = 0;
+    inputsSinceLastOutput = 0;
+    resolvers.forEach((resolver) => {
+      return resolver();
+    });
+    resolvers.length = 0;
+    inputs.length = 0;
+  };
   return {
     inputItem,
     onOutput,
-    waitForQueueSize
+    waitForQueueSize,
+    clearQueue
   };
 };
 
@@ -4135,6 +4150,16 @@ var convertEncodedChunk = (chunk) => {
   };
 };
 
+// src/flush-pending.ts
+var makeFlushPending = () => {
+  const { promise, resolve, reject } = withResolvers();
+  return {
+    promise,
+    resolve,
+    reject
+  };
+};
+
 // src/get-wave-audio-decoder.ts
 var getBytesPerSample = (sampleFormat) => {
   if (sampleFormat === "s16") {
@@ -4196,16 +4221,25 @@ var getWaveAudioDecoder = ({
       onError(err);
     }
   };
+  let lastReset = null;
+  let mostRecentSampleInput = null;
   return {
     close() {
       return Promise.resolve();
     },
     decode(audioSample) {
+      mostRecentSampleInput = audioSample.timestamp;
       return processSample(audioSample);
     },
     flush: () => Promise.resolve(),
     waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
-    reset: () => {}
+    reset: () => {
+      lastReset = Date.now();
+    },
+    checkReset: () => ({
+      wasReset: () => lastReset !== null && lastReset > Date.now()
+    }),
+    getMostRecentSampleInput: () => mostRecentSampleInput
   };
 };
 
@@ -4225,6 +4259,7 @@ var internalCreateAudioDecoder = ({
     label: "Audio decoder",
     controller
   });
+  let mostRecentSampleReceived = null;
   if (config.codec === "pcm-s16") {
     return getWaveAudioDecoder({
       onFrame,
@@ -4275,25 +4310,45 @@ var internalCreateAudioDecoder = ({
       onError(err);
       return;
     }
+    mostRecentSampleReceived = audioSample.timestamp;
     const chunk = audioSample instanceof EncodedAudioChunk ? audioSample : new EncodedAudioChunk(audioSample);
     audioDecoder.decode(chunk);
     if (chunk.byteLength > 16) {
       ioSynchronizer.inputItem(chunk.timestamp);
     }
   };
+  let flushPending = null;
+  const lastReset = null;
   return {
     decode,
     close,
-    flush: async () => {
-      try {
-        await audioDecoder.flush();
-      } catch {}
-      await ioSynchronizer.waitForQueueSize(0);
+    flush: () => {
+      if (flushPending) {
+        throw new Error("Flush already pending");
+      }
+      const pendingFlush = makeFlushPending();
+      flushPending = pendingFlush;
+      Promise.resolve().then(() => {
+        return audioDecoder.flush();
+      }).catch(() => {}).finally(() => {
+        pendingFlush.resolve();
+        flushPending = null;
+      });
+      return pendingFlush.promise;
     },
     waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
     reset: () => {
       audioDecoder.reset();
       audioDecoder.configure(config);
+    },
+    checkReset: () => {
+      const initTime = Date.now();
+      return {
+        wasReset: () => lastReset !== null && lastReset > initTime
+      };
+    },
+    getMostRecentSampleInput() {
+      return mostRecentSampleReceived;
     }
   };
 };
@@ -4672,11 +4727,15 @@ var internalCreateVideoDecoder = ({
   config,
   logLevel
 }) => {
+  if (controller && controller._internals._mediaParserController._internals.signal.aborted) {
+    throw new Error("Not creating audio decoder, already aborted");
+  }
   const ioSynchronizer = makeIoSynchronizer({
     logLevel,
     label: "Video decoder",
     controller
   });
+  let mostRecentSampleReceived = null;
   const videoDecoder = new VideoDecoder({
     async output(frame) {
       try {
@@ -4717,23 +4776,46 @@ var internalCreateVideoDecoder = ({
       onError(err);
       return;
     }
+    mostRecentSampleReceived = sample.timestamp;
     const encodedChunk = sample instanceof EncodedVideoChunk ? sample : new EncodedVideoChunk(sample);
     videoDecoder.decode(encodedChunk);
     ioSynchronizer.inputItem(sample.timestamp);
   };
+  let flushPending = null;
+  let lastReset = null;
   return {
     decode,
     close,
-    flush: async () => {
-      try {
-        await videoDecoder.flush();
-      } catch {}
-      await ioSynchronizer.waitForQueueSize(0);
+    flush: () => {
+      if (flushPending) {
+        throw new Error("Flush already pending");
+      }
+      const pendingFlush = makeFlushPending();
+      flushPending = pendingFlush;
+      Promise.resolve().then(() => {
+        return videoDecoder.flush();
+      }).catch(() => {}).finally(() => {
+        pendingFlush.resolve();
+        flushPending = null;
+      });
+      return pendingFlush.promise;
     },
     waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
     reset: () => {
+      lastReset = Date.now();
+      flushPending?.resolve();
+      ioSynchronizer.clearQueue();
       videoDecoder.reset();
       videoDecoder.configure(config);
+    },
+    checkReset: () => {
+      const initTime = Date.now();
+      return {
+        wasReset: () => lastReset !== null && lastReset > initTime
+      };
+    },
+    getMostRecentSampleInput() {
+      return mostRecentSampleReceived;
     }
   };
 };

package/dist/flush-pending.d.ts

@@ -0,0 +1,10 @@
+export type FlushPending = {
+    resolve: (value: void | PromiseLike<void>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<void>;
+};
+export declare const makeFlushPending: () => {
+    promise: Promise<void>;
+    resolve: (value: void | PromiseLike<void>) => void;
+    reject: (reason?: any) => void;
+};

package/dist/flush-pending.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFlushPending = void 0;
+const with_resolvers_1 = require("./create/with-resolvers");
+const makeFlushPending = () => {
+    const { promise, resolve, reject } = (0, with_resolvers_1.withResolvers)();
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+};
+exports.makeFlushPending = makeFlushPending;

package/dist/get-wave-audio-decoder.js

@@ -56,16 +56,25 @@ const getWaveAudioDecoder = ({ onFrame, config, sampleFormat, ioSynchronizer, on
             onError(err);
         }
     };
+    let lastReset = null;
+    let mostRecentSampleInput = null;
     return {
         close() {
             return Promise.resolve();
         },
         decode(audioSample) {
+            mostRecentSampleInput = audioSample.timestamp;
             return processSample(audioSample);
         },
         flush: () => Promise.resolve(),
         waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
-        reset: () => { },
+        reset: () => {
+            lastReset = Date.now();
+        },
+        checkReset: () => ({
+            wasReset: () => lastReset !== null && lastReset > Date.now(),
+        }),
+        getMostRecentSampleInput: () => mostRecentSampleInput,
     };
 };
 exports.getWaveAudioDecoder = getWaveAudioDecoder;

package/dist/io-manager/io-synchronizer.d.ts

@@ -8,5 +8,6 @@ export declare const makeIoSynchronizer: ({ logLevel, label, controller, }: {
     inputItem: (timestamp: number) => void;
     onOutput: (timestamp: number) => void;
     waitForQueueSize: (queueSize: number) => Promise<void>;
+    clearQueue: () => void;
 };
 export type IoSynchronizer = ReturnType<typeof makeIoSynchronizer>;

package/dist/io-manager/io-synchronizer.js

@@ -11,6 +11,7 @@ const makeIoSynchronizer = ({ logLevel, label, controller, }) => {
     let lastOutput = 0;
     let inputsSinceLastOutput = 0;
     let inputs = [];
+    let resolvers = [];
     const getQueuedItems = () => {
         inputs = inputs.filter(
         // In chrome, the last output sometimes shifts the timestamp by 1 macrosecond - allowing this to happen
@@ -42,8 +43,10 @@ const makeIoSynchronizer = ({ logLevel, label, controller, }) => {
         const on = () => {
             eventEmitter.removeEventListener('output', on);
             resolve();
+            resolvers = resolvers.filter((resolver) => resolver !== resolve);
         };
         eventEmitter.addEventListener('output', on);
+        resolvers.push(resolve);
         return promise;
     };
     const makeErrorBanner = () => {
@@ -82,10 +85,22 @@ const makeIoSynchronizer = ({ logLevel, label, controller, }) => {
             controller._internals._mediaParserController._internals.signal.removeEventListener('abort', clear);
         }
     };
+    const clearQueue = () => {
+        inputs.length = 0;
+        lastInput = 0;
+        lastOutput = 0;
+        inputsSinceLastOutput = 0;
+        resolvers.forEach((resolver) => {
+            return resolver();
+        });
+        resolvers.length = 0;
+        inputs.length = 0;
+    };
     return {
         inputItem,
         onOutput,
         waitForQueueSize,
+        clearQueue,
     };
 };
 exports.makeIoSynchronizer = makeIoSynchronizer;

package/dist/processing-queue.d.ts

@@ -13,6 +13,7 @@ export declare function processingQueue<T extends Processable>({ onOutput, logLe
         inputItem: (timestamp: number) => void;
         onOutput: (timestamp: number) => void;
         waitForQueueSize: (queueSize: number) => Promise<void>;
+        clearQueue: () => void;
     };
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.311",
+  "version": "4.0.313",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -19,8 +19,8 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.311",
-    "@remotion/licensing": "4.0.311"
+    "@remotion/licensing": "4.0.313",
+    "@remotion/media-parser": "4.0.313"
   },
   "peerDependencies": {},
   "devDependencies": {
@@ -29,8 +29,8 @@
     "vite": "5.4.19",
     "@playwright/test": "1.51.1",
     "eslint": "9.19.0",
-    "@remotion/example-videos": "4.0.311",
-    "@remotion/eslint-config-internal": "4.0.311"
+    "@remotion/eslint-config-internal": "4.0.313",
+    "@remotion/example-videos": "4.0.313"
   },
   "keywords": [],
   "publishConfig": {