@remotion/media-parser 4.0.319 → 4.0.320

package/dist/containers/iso-base-media/mvhd.d.ts

@@ -0,0 +1,30 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { BaseBox } from './base-type';
+export type ThreeDMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export interface MvhdBox extends BaseBox {
+    durationInUnits: number;
+    durationInSeconds: number;
+    creationTime: number | null;
+    modificationTime: number | null;
+    timeScale: number;
+    rate: number;
+    volume: number;
+    matrix: ThreeDMatrix;
+    nextTrackId: number;
+    type: 'mvhd-box';
+}
+export declare const parseMvhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => MvhdBox;

package/dist/containers/iso-base-media/mvhd.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMvhd = void 0;
+const buffer_iterator_1 = require("../../iterator/buffer-iterator");
+const to_date_1 = require("./to-date");
+const parseMvhd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    // Flags, we discard them
+    iterator.discard(3);
+    const creationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const modificationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const timeScale = iterator.getUint32();
+    const durationInUnits = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const durationInSeconds = Number(durationInUnits) / timeScale;
+    const rateArray = iterator.getSlice(4);
+    const rateView = (0, buffer_iterator_1.getArrayBufferIterator)(rateArray, rateArray.length);
+    const rate = rateView.getInt8() * 10 +
+        rateView.getInt8() +
+        rateView.getInt8() * 0.1 +
+        rateView.getInt8() * 0.01;
+    const volumeArray = iterator.getSlice(2);
+    const volumeView = (0, buffer_iterator_1.getArrayBufferIterator)(volumeArray, volumeArray.length);
+    const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
+    // reserved 16bit
+    iterator.discard(2);
+    // reserved 32bit x2
+    iterator.discard(4);
+    iterator.discard(4);
+    // matrix
+    const matrix = [
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+    ];
+    // pre-defined
+    iterator.discard(4 * 6);
+    // next track id
+    const nextTrackId = iterator.getUint32();
+    volumeView.destroy();
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        creationTime: (0, to_date_1.toUnixTimestamp)(Number(creationTime)),
+        modificationTime: (0, to_date_1.toUnixTimestamp)(Number(modificationTime)),
+        timeScale,
+        durationInUnits: Number(durationInUnits),
+        durationInSeconds,
+        rate,
+        volume,
+        matrix: matrix,
+        nextTrackId,
+        type: 'mvhd-box',
+        boxSize: size,
+        offset,
+    };
+};
+exports.parseMvhd = parseMvhd;

package/dist/esm/index.mjs

@@ -18105,7 +18105,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.319";
+var VERSION = "4.0.320";
 
 // src/index.ts
 var MediaParserInternals = {

package/dist/esm/server-worker.mjs

@@ -252,6 +252,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     return prom.promise;
   });
   const callbacks = {};
+  const trackDoneCallbacks = {};
   function onMessage(message) {
     const data = message.data;
     if (data.type === "response-done") {
@@ -435,15 +436,35 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
           if (!callback) {
             throw new Error(`No callback registered for track ${data.payload.trackId}`);
           }
-          await callback(data.payload.value);
-          return { payloadType: "void" };
+          const trackDoneCallback = await callback(data.payload.value);
+          if (trackDoneCallback) {
+            trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+          }
+          return {
+            payloadType: "on-sample-response",
+            registeredTrackDoneCallback: Boolean(trackDoneCallback)
+          };
         }
         if (data.payload.callbackType === "on-video-sample") {
           const callback = callbacks[data.payload.trackId];
           if (!callback) {
             throw new Error(`No callback registered for track ${data.payload.trackId}`);
           }
-          await callback(data.payload.value);
+          const trackDoneCallback = await callback(data.payload.value);
+          if (trackDoneCallback) {
+            trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+          }
+          return {
+            payloadType: "on-sample-response",
+            registeredTrackDoneCallback: Boolean(trackDoneCallback)
+          };
+        }
+        if (data.payload.callbackType === "track-done") {
+          const trackDoneCallback = trackDoneCallbacks[data.payload.trackId];
+          if (!trackDoneCallback) {
+            throw new Error(`No track done callback registered for track ${data.payload.trackId}`);
+          }
+          trackDoneCallback();
           return { payloadType: "void" };
         }
         throw new Error(`Unknown callback type: ${data.payload}`);

package/dist/esm/worker-server-entry.mjs

@@ -18585,11 +18585,23 @@ var startParsing = async (message, reader) => {
           return null;
         }
         return async (sample) => {
-          await executeCallback({
+          const audioSampleRes = await executeCallback({
             callbackType: "on-audio-sample",
             value: sample,
             trackId: params.track.trackId
           });
+          if (audioSampleRes.payloadType !== "on-sample-response") {
+            throw new Error("Invalid response from callback");
+          }
+          if (!audioSampleRes.registeredTrackDoneCallback) {
+            return;
+          }
+          return async () => {
+            await executeCallback({
+              callbackType: "track-done",
+              trackId: params.track.trackId
+            });
+          };
         };
       } : null,
       onVideoTrack: postOnVideoTrack ? async (params) => {
@@ -18604,11 +18616,23 @@ var startParsing = async (message, reader) => {
           return null;
         }
         return async (sample) => {
-          await executeCallback({
+          const videoSampleRes = await executeCallback({
             callbackType: "on-video-sample",
             value: sample,
             trackId: params.track.trackId
           });
+          if (videoSampleRes.payloadType !== "on-sample-response") {
+            throw new Error("Invalid response from callback");
+          }
+          if (!videoSampleRes.registeredTrackDoneCallback) {
+            return;
+          }
+          return async () => {
+            await executeCallback({
+              callbackType: "track-done",
+              trackId: params.track.trackId
+            });
+          };
         };
       } : null,
       onDiscardedData: null,

package/dist/esm/worker-web-entry.mjs

@@ -18454,11 +18454,23 @@ var startParsing = async (message, reader) => {
           return null;
         }
         return async (sample) => {
-          await executeCallback({
+          const audioSampleRes = await executeCallback({
             callbackType: "on-audio-sample",
             value: sample,
             trackId: params.track.trackId
           });
+          if (audioSampleRes.payloadType !== "on-sample-response") {
+            throw new Error("Invalid response from callback");
+          }
+          if (!audioSampleRes.registeredTrackDoneCallback) {
+            return;
+          }
+          return async () => {
+            await executeCallback({
+              callbackType: "track-done",
+              trackId: params.track.trackId
+            });
+          };
         };
       } : null,
       onVideoTrack: postOnVideoTrack ? async (params) => {
@@ -18473,11 +18485,23 @@ var startParsing = async (message, reader) => {
           return null;
         }
         return async (sample) => {
-          await executeCallback({
+          const videoSampleRes = await executeCallback({
             callbackType: "on-video-sample",
             value: sample,
             trackId: params.track.trackId
           });
+          if (videoSampleRes.payloadType !== "on-sample-response") {
+            throw new Error("Invalid response from callback");
+          }
+          if (!videoSampleRes.registeredTrackDoneCallback) {
+            return;
+          }
+          return async () => {
+            await executeCallback({
+              callbackType: "track-done",
+              trackId: params.track.trackId
+            });
+          };
         };
       } : null,
       onDiscardedData: null,

package/dist/esm/worker.mjs

@@ -252,6 +252,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     return prom.promise;
   });
   const callbacks = {};
+  const trackDoneCallbacks = {};
   function onMessage(message) {
     const data = message.data;
     if (data.type === "response-done") {
@@ -435,15 +436,35 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
           if (!callback) {
             throw new Error(`No callback registered for track ${data.payload.trackId}`);
           }
-          await callback(data.payload.value);
-          return { payloadType: "void" };
+          const trackDoneCallback = await callback(data.payload.value);
+          if (trackDoneCallback) {
+            trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+          }
+          return {
+            payloadType: "on-sample-response",
+            registeredTrackDoneCallback: Boolean(trackDoneCallback)
+          };
         }
         if (data.payload.callbackType === "on-video-sample") {
           const callback = callbacks[data.payload.trackId];
           if (!callback) {
             throw new Error(`No callback registered for track ${data.payload.trackId}`);
           }
-          await callback(data.payload.value);
+          const trackDoneCallback = await callback(data.payload.value);
+          if (trackDoneCallback) {
+            trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+          }
+          return {
+            payloadType: "on-sample-response",
+            registeredTrackDoneCallback: Boolean(trackDoneCallback)
+          };
+        }
+        if (data.payload.callbackType === "track-done") {
+          const trackDoneCallback = trackDoneCallbacks[data.payload.trackId];
+          if (!trackDoneCallback) {
+            throw new Error(`No track done callback registered for track ${data.payload.trackId}`);
+          }
+          trackDoneCallback();
           return { payloadType: "void" };
         }
         throw new Error(`Unknown callback type: ${data.payload}`);

package/dist/parse-media-on-worker-entry.js

@@ -93,6 +93,7 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
         return prom.promise;
     });
     const callbacks = {};
+    const trackDoneCallbacks = {};
     function onMessage(message) {
         const data = message.data;
         if (data.type === 'response-done') {
@@ -284,15 +285,35 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
                     if (!callback) {
                         throw new Error(`No callback registered for track ${data.payload.trackId}`);
                     }
-                    await callback(data.payload.value);
-                    return { payloadType: 'void' };
+                    const trackDoneCallback = await callback(data.payload.value);
+                    if (trackDoneCallback) {
+                        trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+                    }
+                    return {
+                        payloadType: 'on-sample-response',
+                        registeredTrackDoneCallback: Boolean(trackDoneCallback),
+                    };
                 }
                 if (data.payload.callbackType === 'on-video-sample') {
                     const callback = callbacks[data.payload.trackId];
                     if (!callback) {
                         throw new Error(`No callback registered for track ${data.payload.trackId}`);
                     }
-                    await callback(data.payload.value);
+                    const trackDoneCallback = await callback(data.payload.value);
+                    if (trackDoneCallback) {
+                        trackDoneCallbacks[data.payload.trackId] = trackDoneCallback;
+                    }
+                    return {
+                        payloadType: 'on-sample-response',
+                        registeredTrackDoneCallback: Boolean(trackDoneCallback),
+                    };
+                }
+                if (data.payload.callbackType === 'track-done') {
+                    const trackDoneCallback = trackDoneCallbacks[data.payload.trackId];
+                    if (!trackDoneCallback) {
+                        throw new Error(`No track done callback registered for track ${data.payload.trackId}`);
+                    }
+                    trackDoneCallback();
                     return { payloadType: 'void' };
                 }
                 throw new Error(`Unknown callback type: ${data.payload}`);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.319";
+export declare const VERSION = "4.0.320";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.319';
+exports.VERSION = '4.0.320';

package/dist/worker/worker-types.d.ts

@@ -240,6 +240,9 @@ export type ResponseCallbackPayload = {
     callbackType: 'on-video-sample';
     value: MediaParserVideoSample;
     trackId: number;
+} | {
+    callbackType: 'track-done';
+    trackId: number;
 } | {
     callbackType: 'm3u-associated-playlists-selection';
     value: SelectM3uAssociatedPlaylistsFnOptions;
@@ -263,6 +266,9 @@ export type AcknowledgePayload = {
 } | {
     payloadType: 'on-video-track-response';
     registeredCallback: boolean;
+} | {
+    payloadType: 'on-sample-response';
+    registeredTrackDoneCallback: boolean;
 };
 export type AcknowledgeCallback = {
     type: 'acknowledge-callback';

package/dist/worker-server.js

@@ -328,11 +328,23 @@ const startParsing = async (message, reader) => {
                         return null;
                     }
                     return async (sample) => {
-                        await executeCallback({
+                        const audioSampleRes = await executeCallback({
                             callbackType: 'on-audio-sample',
                             value: sample,
                             trackId: params.track.trackId,
                         });
+                        if (audioSampleRes.payloadType !== 'on-sample-response') {
+                            throw new Error('Invalid response from callback');
+                        }
+                        if (!audioSampleRes.registeredTrackDoneCallback) {
+                            return;
+                        }
+                        return async () => {
+                            await executeCallback({
+                                callbackType: 'track-done',
+                                trackId: params.track.trackId,
+                            });
+                        };
                     };
                 }
                 : null,
@@ -349,11 +361,23 @@ const startParsing = async (message, reader) => {
                         return null;
                     }
                     return async (sample) => {
-                        await executeCallback({
+                        const videoSampleRes = await executeCallback({
                             callbackType: 'on-video-sample',
                             value: sample,
                             trackId: params.track.trackId,
                         });
+                        if (videoSampleRes.payloadType !== 'on-sample-response') {
+                            throw new Error('Invalid response from callback');
+                        }
+                        if (!videoSampleRes.registeredTrackDoneCallback) {
+                            return;
+                        }
+                        return async () => {
+                            await executeCallback({
+                                callbackType: 'track-done',
+                                trackId: params.track.trackId,
+                            });
+                        };
                     };
                 }
                 : null,

package/package.json

@@ -3,15 +3,15 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.319",
+  "version": "4.0.320",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.19.0",
     "@types/bun": "1.2.8",
-    "@remotion/example-videos": "4.0.319",
-    "@remotion/eslint-config-internal": "4.0.319"
+    "@remotion/example-videos": "4.0.320",
+    "@remotion/eslint-config-internal": "4.0.320"
   },
   "publishConfig": {
     "access": "public"