@remotion/media-parser 4.0.280 → 4.0.284

package/dist/esm/worker.mjs

@@ -1,3 +1,14 @@
+// src/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
 // src/errors.ts
 class IsAGifError extends Error {
   mimeType;
@@ -219,16 +230,12 @@ var convertToWorkerPayload = (payload) => {
 var post = (worker, payload) => {
   worker.postMessage(payload);
 };
-var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, workerUrlEntry, apiName) => {
-  if (typeof Worker === "undefined") {
-    throw new Error('"Worker" is not available. Cannot call workerClient()');
-  }
+var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, worker, apiName) => {
   if (reader) {
     throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
   }
-  const worker = new Worker(workerUrlEntry);
   post(worker, convertToWorkerPayload(params));
-  const { promise, resolve, reject } = Promise.withResolvers();
+  const { promise, resolve, reject } = withResolvers();
   const onAbort = () => {
     post(worker, { type: "request-abort" });
   };
@@ -238,6 +245,10 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
   const onPause = () => {
     post(worker, { type: "request-pause" });
   };
+  const onSeek = ({ detail: { seek } }) => {
+    post(worker, { type: "request-seek", payload: seek });
+    controller?._internals.seekSignal.clearSeekIfStillSame(seek);
+  };
   const callbacks = {};
   function onMessage(message) {
     const data = message.data;
@@ -425,13 +436,16 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
   controller?.addEventListener("abort", onAbort);
   controller?.addEventListener("resume", onResume);
   controller?.addEventListener("pause", onPause);
+  controller?.addEventListener("seek", onSeek);
   function cleanup() {
     worker.removeEventListener("message", onMessage);
     controller?.removeEventListener("abort", onAbort);
     controller?.removeEventListener("resume", onResume);
     controller?.removeEventListener("pause", onPause);
+    controller?.removeEventListener("seek", onSeek);
     worker.terminate();
   }
+  controller?._internals.markAsReadyToEmitEvents();
   const val = await promise;
   cleanup();
   return val;
@@ -439,12 +453,12 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
 
 // src/worker.module.ts
 var parseMediaOnWebWorker = (params) => {
-  return parseMediaOnWorkerImplementation(params, new URL("./worker-web-entry", import.meta.url), "parseMediaOnWebWorker");
-};
-var parseMediaOnServerWorker = (params) => {
-  return parseMediaOnWorkerImplementation(params, new URL("./worker-server-entry", import.meta.url), "parseMediaOnServerWorker");
+  if (typeof Worker === "undefined") {
+    throw new Error('"Worker" is not available. Cannot call parseMediaOnWebWorker()');
+  }
+  const worker = new Worker(new URL("./worker-web-entry", import.meta.url));
+  return parseMediaOnWorkerImplementation(params, worker, "parseMediaOnWebWorker");
 };
 export {
-  parseMediaOnWebWorker,
-  parseMediaOnServerWorker
+  parseMediaOnWebWorker
 };

package/dist/forward-controller.d.ts

@@ -1,4 +1,4 @@
-import type { MediaParserController } from './media-parser-controller';
+import type { MediaParserController } from './controller/media-parser-controller';
 export declare const forwardMediaParserController: ({ parentController, childController, }: {
     parentController: MediaParserController;
     childController: MediaParserController;

package/dist/get-dimensions.js

@@ -4,7 +4,7 @@ exports.hasDimensions = exports.getDimensions = void 0;
 const get_tracks_1 = require("./get-tracks");
 const is_audio_structure_1 = require("./is-audio-structure");
 const getDimensions = (state) => {
-    const structure = state.getStructureOrNull();
+    const structure = state.structure.getStructureOrNull();
     if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
         return null;
     }
@@ -23,7 +23,7 @@ const getDimensions = (state) => {
 };
 exports.getDimensions = getDimensions;
 const hasDimensions = (state) => {
-    const structure = state.getStructureOrNull();
+    const structure = state.structure.getStructureOrNull();
     if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
         return true;
     }

package/dist/get-duration.js

@@ -38,35 +38,18 @@ const isMatroska = (boxes) => {
     return matroskaBox;
 };
 exports.isMatroska = isMatroska;
-const isoHasDuration = (parserState) => {
-    const structure = parserState.getIsoStructure();
-    const moovBox = (0, traversal_1.getMoovBoxFromState)(parserState);
-    if (!moovBox) {
-        return false;
-    }
-    const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
-    if (!mvhdBox) {
-        return false;
-    }
-    if (mvhdBox.type !== 'mvhd-box') {
-        throw new Error('Expected mvhd-box');
-    }
-    if (mvhdBox.durationInSeconds > 0) {
-        return true;
-    }
-    // Checking if this is a fragmented mp4
-    const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
-    const hasMvex = moovBox.children.some((b) => b.type === 'regular-box' && b.boxType === 'mvex');
-    const isFragmented = moofBoxes.length > 0 || hasMvex;
-    return !isFragmented;
-};
 const getDurationFromIsoBaseMedia = (parserState) => {
-    const structure = parserState.getIsoStructure();
-    const moovBox = (0, traversal_1.getMoovBoxFromState)(parserState);
+    const structure = parserState.structure.getIsoStructure();
+    const moovBox = (0, traversal_1.getMoovBoxFromState)({
+        structureState: parserState.structure,
+        isoState: parserState.iso,
+        mp4HeaderSegment: parserState.mp4HeaderSegment,
+    });
     if (!moovBox) {
         return null;
     }
     const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
+    const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure);
     const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvhdBox) {
         return null;
@@ -85,18 +68,28 @@ const getDurationFromIsoBaseMedia = (parserState) => {
     ];
     const allSamples = allTracks.map((t) => {
         const { timescale: ts } = t;
-        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+        const { samplePositions, isComplete } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
             trakBox: t.trakBox,
             moofBoxes,
+            tfraBoxes,
         });
+        if (!isComplete) {
+            return null;
+        }
+        if (samplePositions.length === 0) {
+            return null;
+        }
         const highest = samplePositions === null || samplePositions === void 0 ? void 0 : samplePositions.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
         return highest !== null && highest !== void 0 ? highest : 0;
     });
-    const highestTimestamp = Math.max(...allSamples);
+    if (allSamples.every((s) => s === null)) {
+        return null;
+    }
+    const highestTimestamp = Math.max(...allSamples.filter((s) => s !== null));
     return highestTimestamp;
 };
 const getDuration = (parserState) => {
-    const structure = parserState.getStructure();
+    const structure = parserState.structure.getStructure();
     if (structure.type === 'matroska') {
         return getDurationFromMatroska(structure.boxes);
     }
@@ -130,13 +123,10 @@ exports.getDuration = getDuration;
 // `duration` just grabs from metadata, and otherwise returns null
 // Therefore just checking if we have tracks
 const hasDuration = (parserState) => {
-    const structure = parserState.getStructureOrNull();
+    const structure = parserState.structure.getStructureOrNull();
     if (structure === null) {
         return false;
     }
-    if (structure.type === 'iso-base-media') {
-        return isoHasDuration(parserState);
-    }
     return (0, get_tracks_1.getHasTracks)(parserState);
 };
 exports.hasDuration = hasDuration;

package/dist/get-fps.js

@@ -65,7 +65,11 @@ const getFpsFromMp4TrakBox = (trakBox) => {
 };
 exports.getFpsFromMp4TrakBox = getFpsFromMp4TrakBox;
 const getFpsFromIsoMaseMedia = (state) => {
-    const moovBox = (0, traversal_1.getMoovBoxFromState)(state);
+    const moovBox = (0, traversal_1.getMoovBoxFromState)({
+        structureState: state.structure,
+        isoState: state.iso,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+    });
     if (!moovBox) {
         return null;
     }
@@ -91,7 +95,7 @@ const getFpsFromAvi = (structure) => {
     return null;
 };
 const getFps = (state) => {
-    const segments = state.getStructure();
+    const segments = state.structure.getStructure();
     if (segments.type === 'iso-base-media') {
         return getFpsFromIsoMaseMedia(state);
     }
@@ -133,7 +137,7 @@ const hasFps = (state) => {
     // Not bothering to parse
     // Users should use `slowFps` field
     // same goes for audio
-    const structure = state.getStructure();
+    const structure = state.structure.getStructure();
     if ((0, is_audio_structure_1.isAudioStructure)(structure)) {
         return true;
     }

package/dist/get-keyframes.js

@@ -4,7 +4,7 @@ exports.hasKeyframes = exports.getKeyframes = void 0;
 const get_keyframes_1 = require("./containers/iso-base-media/get-keyframes");
 const get_tracks_1 = require("./get-tracks");
 const getKeyframes = (state) => {
-    const structure = state.getStructure();
+    const structure = state.structure.getStructure();
     if (structure.type === 'iso-base-media') {
         return (0, get_keyframes_1.getKeyframesFromIsoBaseMedia)(state);
     }
@@ -12,7 +12,7 @@ const getKeyframes = (state) => {
 };
 exports.getKeyframes = getKeyframes;
 const hasKeyframes = (parserState) => {
-    const structure = parserState.getStructure();
+    const structure = parserState.structure.getStructure();
     if (structure.type === 'iso-base-media') {
         return (0, get_tracks_1.getHasTracks)(parserState);
     }

package/dist/get-seeking-info.d.ts

@@ -1,4 +1,20 @@
+import type { LogLevel } from './log';
+import type { IsoBaseMediaStructure } from './parse-result';
 import type { SeekingInfo } from './seeking-info';
-import type { ParserState } from './state/parser-state';
-export declare const getSeekingInfo: (state: ParserState) => SeekingInfo | null;
-export declare const getSeekingByte: (info: SeekingInfo, time: number) => number;
+import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
+import type { StructureState } from './state/structure';
+import type { MediaSectionState } from './state/video-section';
+import type { SeekResolution } from './work-on-seek-request';
+export declare const getSeekingInfo: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, }: {
+    structureState: StructureState;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    mediaSectionState: MediaSectionState;
+    isoState: IsoBaseMediaState;
+}) => SeekingInfo | null;
+export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, }: {
+    info: SeekingInfo;
+    time: number;
+    logLevel: LogLevel;
+    currentPosition: number;
+    isoState: IsoBaseMediaState;
+}) => Promise<SeekResolution>;

package/dist/get-seeking-info.js

@@ -2,21 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingByte = exports.getSeekingInfo = void 0;
 const get_seeking_from_mp4_1 = require("./containers/iso-base-media/get-seeking-from-mp4");
-const getSeekingInfo = (state) => {
-    const structure = state.getStructureOrNull();
+const get_seeking_info_from_mp4_1 = require("./containers/iso-base-media/get-seeking-info-from-mp4");
+const get_seeking_byte_1 = require("./containers/wav/get-seeking-byte");
+const get_seeking_info_1 = require("./containers/wav/get-seeking-info");
+const getSeekingInfo = ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, }) => {
+    const structure = structureState.getStructureOrNull();
     if (!structure) {
         return null;
     }
     if (structure.type === 'iso-base-media') {
-        return (0, get_seeking_from_mp4_1.getSeekingInfoFromMp4)(state);
+        return (0, get_seeking_info_from_mp4_1.getSeekingInfoFromMp4)({
+            structureState,
+            isoState,
+            mp4HeaderSegment,
+            mediaSectionState,
+        });
     }
-    return null;
+    if (structure.type === 'wav') {
+        return (0, get_seeking_info_1.getSeekingInfoFromWav)({
+            structure,
+            mediaSectionState,
+        });
+    }
+    throw new Error(`Seeking is not supported for this format: ${structure.type}`);
 };
 exports.getSeekingInfo = getSeekingInfo;
-const getSeekingByte = (info, time) => {
+const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, }) => {
     if (info.type === 'iso-base-media-seeking-info') {
-        return (0, get_seeking_from_mp4_1.getSeekingByteFromIsoBaseMedia)(info, time).offset;
+        return (0, get_seeking_from_mp4_1.getSeekingByteFromIsoBaseMedia)({
+            info,
+            time,
+            logLevel,
+            currentPosition,
+            isoState,
+        });
+    }
+    if (info.type === 'wav-seeking-info') {
+        return (0, get_seeking_byte_1.getSeekingByteFromWav)({
+            info,
+            time,
+        });
     }
-    throw new Error(`Unknown seeking info type: ${info.type}`);
+    throw new Error(`Unknown seeking info type: ${info}`);
 };
 exports.getSeekingByte = getSeekingByte;

package/dist/get-tracks.js

@@ -15,11 +15,15 @@ const getNumberOfTracks = (moovBox) => {
 };
 exports.getNumberOfTracks = getNumberOfTracks;
 const isoBaseMediaHasTracks = (state) => {
-    return Boolean((0, traversal_1.getMoovBoxFromState)(state));
+    return Boolean((0, traversal_1.getMoovBoxFromState)({
+        structureState: state.structure,
+        isoState: state.iso,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+    }));
 };
 exports.isoBaseMediaHasTracks = isoBaseMediaHasTracks;
 const getHasTracks = (state) => {
-    const structure = state.getStructure();
+    const structure = state.structure.getStructure();
     if (structure.type === 'matroska') {
         return (0, get_ready_tracks_1.matroskaHasTracks)(state);
     }
@@ -102,7 +106,11 @@ const getTracksFromMoovBox = (moovBox) => {
 };
 exports.getTracksFromMoovBox = getTracksFromMoovBox;
 const getTracksFromIsoBaseMedia = (state) => {
-    const moovBox = (0, traversal_1.getMoovBoxFromState)(state);
+    const moovBox = (0, traversal_1.getMoovBoxFromState)({
+        structureState: state.structure,
+        isoState: state.iso,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+    });
     if (!moovBox) {
         return {
             videoTracks: [],
@@ -136,7 +144,7 @@ const defaultHasallTracks = (parserState) => {
 };
 exports.defaultHasallTracks = defaultHasallTracks;
 const getTracks = (state) => {
-    const structure = state.getStructure();
+    const structure = state.structure.getStructure();
     if (structure.type === 'matroska') {
         return getCategorizedTracksFromMatroska(state);
     }

package/dist/has-all-info.js

@@ -17,7 +17,7 @@ const get_metadata_1 = require("./metadata/get-metadata");
 const may_skip_video_data_1 = require("./state/may-skip-video-data");
 const getAvailableInfo = ({ state, }) => {
     const keys = Object.entries(state.fields).filter(([, value]) => value);
-    const structure = state.getStructureOrNull();
+    const structure = state.structure.getStructureOrNull();
     const infos = keys.map(([_key]) => {
         const key = _key;
         if (key === 'structure') {