@remotion/media-parser 4.0.286 → 4.0.288

package/dist/esm/worker.mjs

@@ -235,6 +235,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     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().`);
   }
   post(worker, convertToWorkerPayload(params));
+  let workerTerminated = false;
   const { promise, resolve, reject } = withResolvers();
   const onAbort = () => {
     post(worker, { type: "request-abort" });
@@ -249,15 +250,48 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     post(worker, { type: "request-seek", payload: seek });
     controller?._internals.seekSignal.clearSeekIfStillSame(seek);
   };
+  const seekingHintPromises = [];
+  let finalSeekingHints = null;
+  controller?._internals.attachSeekingHintResolution(() => {
+    if (finalSeekingHints) {
+      return Promise.resolve(finalSeekingHints);
+    }
+    if (workerTerminated) {
+      return Promise.reject(new Error("Worker terminated"));
+    }
+    const prom = withResolvers();
+    post(worker, { type: "request-get-seeking-hints" });
+    seekingHintPromises.push(prom);
+    return prom.promise;
+  });
   const callbacks = {};
   function onMessage(message) {
     const data = message.data;
     if (data.type === "response-done") {
       resolve(data.payload);
+      if (data.seekingHints) {
+        finalSeekingHints = data.seekingHints;
+        for (const prom of seekingHintPromises) {
+          prom.resolve(finalSeekingHints);
+        }
+      }
+      return;
     }
     if (data.type === "response-error") {
       cleanup();
-      reject(deserializeError(data));
+      const error = deserializeError(data);
+      reject(error);
+      if (data.errorName === "MediaParserAbortError") {
+        finalSeekingHints = data.seekingHints;
+        for (const prom of seekingHintPromises) {
+          prom.resolve(finalSeekingHints);
+        }
+      } else {
+        for (const prom of seekingHintPromises) {
+          prom.reject(error);
+        }
+      }
+      return;
     }
     if (data.type === "response-on-callback-request") {
       Promise.resolve().then(async () => {
@@ -430,7 +464,17 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
           nonce: data.nonce
         });
       });
+      return;
+    }
+    if (data.type === "response-get-seeking-hints") {
+      const firstPromise = seekingHintPromises.shift();
+      if (!firstPromise) {
+        throw new Error("No seeking hint promise found");
+      }
+      firstPromise.resolve(data.payload);
+      return;
     }
+    throw new Error(`Unknown response type: ${JSON.stringify(data)}`);
   }
   worker.addEventListener("message", onMessage);
   controller?.addEventListener("abort", onAbort);
@@ -443,6 +487,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     controller?.removeEventListener("resume", onResume);
     controller?.removeEventListener("pause", onPause);
     controller?.removeEventListener("seek", onSeek);
+    workerTerminated = true;
     worker.terminate();
   }
   controller?._internals.markAsReadyToEmitEvents();

package/dist/{forward-controller.d.ts → forward-controller-pause-resume-abort.d.ts}

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

package/dist/{forward-controller.js → forward-controller-pause-resume-abort.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forwardMediaParserController = void 0;
-const forwardMediaParserController = ({ parentController, childController, }) => {
+exports.forwardMediaParserControllerPauseResume = void 0;
+const forwardMediaParserControllerPauseResume = ({ parentController, childController, }) => {
     const onAbort = ({ detail }) => {
         childController.abort(detail.reason);
     };
@@ -22,4 +22,4 @@ const forwardMediaParserController = ({ parentController, childController, }) =>
         },
     };
 };
-exports.forwardMediaParserController = forwardMediaParserController;
+exports.forwardMediaParserControllerPauseResume = forwardMediaParserControllerPauseResume;

package/dist/get-audio-codec.d.ts

@@ -16,6 +16,7 @@ export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const isLpcmAudioCodec: (trak: TrakBox) => boolean;
 export declare const isIn24AudioCodec: (trak: TrakBox) => boolean;
+export declare const isTwosAudioCodec: (trak: TrakBox) => boolean;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;

package/dist/get-audio-codec.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAudioCodecFromTrack = exports.getAudioCodecStringFromTrak = exports.getAudioCodecFromIso = exports.isIn24AudioCodec = exports.isLpcmAudioCodec = exports.getAudioCodecFromTrak = exports.getSampleRate = exports.getNumberOfChannelsFromTrak = exports.getCodecPrivateFromTrak = exports.hasAudioCodec = exports.getAudioCodec = void 0;
+exports.getAudioCodecFromTrack = exports.getAudioCodecStringFromTrak = exports.getAudioCodecFromIso = exports.isTwosAudioCodec = exports.isIn24AudioCodec = exports.isLpcmAudioCodec = exports.getAudioCodecFromTrak = exports.getSampleRate = exports.getNumberOfChannelsFromTrak = exports.getCodecPrivateFromTrak = exports.hasAudioCodec = exports.getAudioCodec = void 0;
 const traversal_1 = require("./containers/iso-base-media/traversal");
 const get_fps_1 = require("./get-fps");
 const get_tracks_1 = require("./get-tracks");
 const getAudioCodec = (parserState) => {
-    const tracks = (0, get_tracks_1.getTracks)(parserState);
+    const tracks = (0, get_tracks_1.getTracks)(parserState, true);
     const allTracks = tracks.audioTracks.length +
         tracks.otherTracks.length +
         tracks.videoTracks.length;
@@ -23,7 +23,7 @@ const getAudioCodec = (parserState) => {
 };
 exports.getAudioCodec = getAudioCodec;
 const hasAudioCodec = (state) => {
-    return (0, get_tracks_1.getHasTracks)(state);
+    return (0, get_tracks_1.getHasTracks)(state, true);
 };
 exports.hasAudioCodec = hasAudioCodec;
 const getCodecSpecificatorFromEsdsBox = ({ child, }) => {
@@ -153,6 +153,11 @@ const isIn24AudioCodec = (trak) => {
     return ((_a = (0, exports.getAudioCodecFromTrak)(trak)) === null || _a === void 0 ? void 0 : _a.format) === 'in24';
 };
 exports.isIn24AudioCodec = isIn24AudioCodec;
+const isTwosAudioCodec = (trak) => {
+    var _a;
+    return ((_a = (0, exports.getAudioCodecFromTrak)(trak)) === null || _a === void 0 ? void 0 : _a.format) === 'twos';
+};
+exports.isTwosAudioCodec = isTwosAudioCodec;
 const getAudioCodecFromIso = (moov) => {
     const traks = (0, traversal_1.getTraks)(moov);
     const trakBox = traks.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsAudio)(b));
@@ -173,10 +178,16 @@ const getAudioCodecStringFromTrak = (trak) => {
             description: codec.description,
         };
     }
+    if (codec.format === 'twos') {
+        return {
+            codecString: 'pcm-s16',
+            description: codec.description,
+        };
+    }
     if (codec.format === 'in24') {
         return {
             codecString: 'pcm-s24',
-            description: undefined,
+            description: codec.description,
         };
     }
     const codecStringWithoutMp3Exception = [

package/dist/get-dimensions.js

@@ -8,7 +8,7 @@ const getDimensions = (state) => {
     if (structure && (0, is_audio_structure_1.isAudioStructure)(structure)) {
         return null;
     }
-    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state, true);
     if (!videoTracks.length) {
         return null;
     }

package/dist/get-duration.js

@@ -44,6 +44,7 @@ const getDurationFromIsoBaseMedia = (parserState) => {
         structureState: parserState.structure,
         isoState: parserState.iso,
         mp4HeaderSegment: parserState.mp4HeaderSegment,
+        mayUsePrecomputed: true,
     });
     if (!moovBox) {
         return null;
@@ -60,7 +61,7 @@ const getDurationFromIsoBaseMedia = (parserState) => {
     if (mvhdBox.durationInSeconds > 0) {
         return mvhdBox.durationInSeconds;
     }
-    const tracks = (0, get_tracks_1.getTracks)(parserState);
+    const tracks = (0, get_tracks_1.getTracks)(parserState, true);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
@@ -127,7 +128,7 @@ const hasDuration = (parserState) => {
     if (structure === null) {
         return false;
     }
-    return (0, get_tracks_1.getHasTracks)(parserState);
+    return (0, get_tracks_1.getHasTracks)(parserState, true);
 };
 exports.hasDuration = hasDuration;
 // `slowDuration` goes through everything, and therefore is false

package/dist/get-fps.js

@@ -69,6 +69,7 @@ const getFpsFromIsoMaseMedia = (state) => {
         structureState: state.structure,
         isoState: state.iso,
         mp4HeaderSegment: state.mp4HeaderSegment,
+        mayUsePrecomputed: true,
     });
     if (!moovBox) {
         return null;

package/dist/get-is-hdr.js

@@ -8,11 +8,11 @@ const isVideoTrackHdr = (track) => {
         track.color.primaries === 'bt2020');
 };
 const getIsHdr = (state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracks)(state);
+    const { videoTracks } = (0, get_tracks_1.getTracks)(state, true);
     return videoTracks.some((track) => isVideoTrackHdr(track));
 };
 exports.getIsHdr = getIsHdr;
 const hasHdr = (state) => {
-    return (0, get_tracks_1.getHasTracks)(state);
+    return (0, get_tracks_1.getHasTracks)(state, true);
 };
 exports.hasHdr = hasHdr;

package/dist/get-keyframes.js

@@ -14,7 +14,7 @@ exports.getKeyframes = getKeyframes;
 const hasKeyframes = (parserState) => {
     const structure = parserState.structure.getStructure();
     if (structure.type === 'iso-base-media') {
-        return (0, get_tracks_1.getHasTracks)(parserState);
+        return (0, get_tracks_1.getHasTracks)(parserState, true);
     }
     // Has, but will be null
     return true;

package/dist/get-sample-positions-from-mp4.d.ts

@@ -1,3 +1,6 @@
 import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { SamplePosition } from './get-sample-positions';
-export declare const getGroupedSamplesPositionsFromMp4: (trakBox: TrakBox) => SamplePosition[];
+export declare const getGroupedSamplesPositionsFromMp4: ({ trakBox, bigEndian, }: {
+    trakBox: TrakBox;
+    bigEndian: boolean;
+}) => SamplePosition[];

package/dist/get-sample-positions-from-mp4.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGroupedSamplesPositionsFromMp4 = void 0;
 const traversal_1 = require("./containers/iso-base-media/traversal");
 // example video: mehmet.mov
-const getGroupedSamplesPositionsFromMp4 = (trakBox) => {
+const getGroupedSamplesPositionsFromMp4 = ({ trakBox, bigEndian, }) => {
     const stscBox = (0, traversal_1.getStscBox)(trakBox);
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
@@ -38,6 +38,8 @@ const getGroupedSamplesPositionsFromMp4 = (trakBox) => {
             size: stszBox.sampleSize * stscEntry.samplesPerChunk,
             duration: stscEntry.samplesPerChunk,
             isKeyframe: true,
+            bigEndian,
+            chunkSize: stszBox.sampleSize,
         });
         timestamp += stscEntry.samplesPerChunk;
     }

package/dist/get-sample-positions.d.ts

@@ -12,6 +12,8 @@ export type SamplePosition = {
     cts: number;
     duration: number;
     chunk: number;
+    bigEndian: boolean;
+    chunkSize: number | null;
 };
 export declare const getSamplePositions: ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, }: {
     stcoBox: StcoBox;

package/dist/get-sample-positions.js

@@ -45,6 +45,8 @@ const getSamplePositions = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsB
                 cts,
                 duration: delta,
                 chunk: i,
+                bigEndian: false,
+                chunkSize: null,
             });
             dts += delta;
             offsetInThisChunk += size;

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

@@ -1,13 +1,14 @@
 import type { LogLevel } from './log';
-import type { SeekingInfo } from './seeking-info';
+import type { IsoBaseMediaStructure } from './parse-result';
+import type { SeekingHints } from './seeking-hints';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
-import type { KeyframesState } from './state/keyframes';
 import type { WebmState } from './state/matroska/webm';
+import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
 import type { SeekResolution } from './work-on-seek-request';
-export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, keyframes, }: {
-    info: SeekingInfo;
+export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, }: {
+    info: SeekingHints;
     time: number;
     logLevel: LogLevel;
     currentPosition: number;
@@ -15,5 +16,6 @@ export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, i
     transportStream: TransportStreamState;
     webmState: WebmState;
     mediaSection: MediaSectionState;
-    keyframes: KeyframesState;
+    structure: StructureState;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
 }) => Promise<SeekResolution>;

package/dist/get-seeking-byte.js

@@ -1,38 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingByte = void 0;
-const get_seeking_from_mp4_1 = require("./containers/iso-base-media/get-seeking-from-mp4");
-const get_seeking_byte_1 = require("./containers/wav/get-seeking-byte");
-const get_seeking_byte_2 = require("./containers/webm/seek/get-seeking-byte");
+const get_seeking_byte_1 = require("./containers/iso-base-media/get-seeking-byte");
+const get_seeking_byte_2 = require("./containers/wav/get-seeking-byte");
+const get_seeking_byte_3 = require("./containers/webm/seek/get-seeking-byte");
 const observed_pes_header_1 = require("./state/transport-stream/observed-pes-header");
-const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, keyframes, }) => {
+const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, }) => {
     var _a;
-    if (info.type === 'iso-base-media-seeking-info') {
-        return (0, get_seeking_from_mp4_1.getSeekingByteFromIsoBaseMedia)({
+    if (info.type === 'iso-base-media-seeking-hints') {
+        return (0, get_seeking_byte_1.getSeekingByteFromIsoBaseMedia)({
             info,
             time,
             logLevel,
             currentPosition,
             isoState,
+            mp4HeaderSegment,
+            structure,
         });
     }
-    if (info.type === 'wav-seeking-info') {
-        return (0, get_seeking_byte_1.getSeekingByteFromWav)({
+    if (info.type === 'wav-seeking-hints') {
+        return (0, get_seeking_byte_2.getSeekingByteFromWav)({
             info,
             time,
         });
     }
-    if (info.type === 'webm-seeking-info') {
-        return (0, get_seeking_byte_2.getSeekingByteFromMatroska)({
+    if (info.type === 'webm-seeking-hints') {
+        return (0, get_seeking_byte_3.getSeekingByteFromMatroska)({
             info,
             time,
             webmState,
             logLevel,
             mediaSection,
-            keyframes,
         });
     }
-    if (info.type === 'transport-stream-seeking-info') {
+    if (info.type === 'transport-stream-seeking-hints') {
         const lastKeyframeBeforeTimeInSeconds = (0, observed_pes_header_1.getLastKeyFrameBeforeTimeInSeconds)({
             observedPesHeaders: info.observedPesHeaders,
             timeInSeconds: time,

package/dist/{get-seeking-info.d.ts → get-seeking-hints.d.ts}

@@ -1,15 +1,19 @@
 import type { IsoBaseMediaStructure } from './parse-result';
-import type { SeekingInfo } from './seeking-info';
+import type { SeekingHints } from './seeking-hints';
 import type { TracksState } from './state/has-tracks-section';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
+import type { KeyframesState } from './state/keyframes';
+import type { WebmState } from './state/matroska/webm';
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
-export declare const getSeekingInfo: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, }: {
+export declare const getSeekingHints: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, }: {
     structureState: StructureState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
     mediaSectionState: MediaSectionState;
     isoState: IsoBaseMediaState;
     transportStream: TransportStreamState;
     tracksState: TracksState;
-}) => SeekingInfo | null;
+    keyframesState: KeyframesState;
+    webmState: WebmState;
+}) => SeekingHints | null;

package/dist/get-seeking-hints.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingHints = void 0;
+const seeking_hints_1 = require("./containers/iso-base-media/seeking-hints");
+const seeking_hints_2 = require("./containers/transport-stream/seeking-hints");
+const seeking_hints_3 = require("./containers/wav/seeking-hints");
+const seeking_hints_4 = require("./containers/webm/seek/seeking-hints");
+const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, }) => {
+    const structure = structureState.getStructureOrNull();
+    if (!structure) {
+        return null;
+    }
+    if (structure.type === 'iso-base-media') {
+        return (0, seeking_hints_1.getSeekingHintsFromMp4)({
+            structureState,
+            isoState,
+            mp4HeaderSegment,
+            mediaSectionState,
+        });
+    }
+    if (structure.type === 'wav') {
+        return (0, seeking_hints_3.getSeekingHintsFromWav)({
+            structure,
+            mediaSectionState,
+        });
+    }
+    if (structure.type === 'matroska') {
+        return (0, seeking_hints_4.getSeekingHintsFromMatroska)(tracksState, keyframesState, webmState);
+    }
+    if (structure.type === 'transport-stream') {
+        return (0, seeking_hints_2.getSeekingHintsFromTransportStream)(transportStream, tracksState);
+    }
+    throw new Error(`Seeking is not supported for this format: ${structure.type}`);
+};
+exports.getSeekingHints = getSeekingHints;

package/dist/get-tracks.d.ts

@@ -56,19 +56,19 @@ export type OtherTrack = {
 };
 export type Track = VideoTrack | AudioTrack | OtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;
-export declare const isoBaseMediaHasTracks: (state: ParserState) => boolean;
-export declare const getHasTracks: (state: ParserState) => boolean;
+export declare const isoBaseMediaHasTracks: (state: ParserState, mayUsePrecomputed: boolean) => boolean;
+export declare const getHasTracks: (state: ParserState, mayUsePrecomputed: boolean) => boolean;
 export declare const getTracksFromMoovBox: (moovBox: MoovBox) => {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];
 };
-export declare const getTracksFromIsoBaseMedia: (state: ParserState) => {
+export declare const getTracksFromIsoBaseMedia: (state: ParserState, mayUsePrecomputed: boolean) => {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];
 };
 export declare const defaultGetTracks: (parserState: ParserState) => AllTracks;
 export declare const defaultHasallTracks: (parserState: ParserState) => boolean;
-export declare const getTracks: (state: ParserState) => AllTracks;
+export declare const getTracks: (state: ParserState, mayUsePrecomputed: boolean) => AllTracks;
 export {};

package/dist/get-tracks.js

@@ -14,15 +14,16 @@ const getNumberOfTracks = (moovBox) => {
     return mvHdBox.nextTrackId - 1;
 };
 exports.getNumberOfTracks = getNumberOfTracks;
-const isoBaseMediaHasTracks = (state) => {
+const isoBaseMediaHasTracks = (state, mayUsePrecomputed) => {
     return Boolean((0, traversal_1.getMoovBoxFromState)({
         structureState: state.structure,
         isoState: state.iso,
         mp4HeaderSegment: state.mp4HeaderSegment,
+        mayUsePrecomputed,
     }));
 };
 exports.isoBaseMediaHasTracks = isoBaseMediaHasTracks;
-const getHasTracks = (state) => {
+const getHasTracks = (state, mayUsePrecomputed) => {
     const structure = state.structure.getStructure();
     if (structure.type === 'matroska') {
         return (0, get_ready_tracks_1.matroskaHasTracks)({
@@ -31,7 +32,7 @@ const getHasTracks = (state) => {
         });
     }
     if (structure.type === 'iso-base-media') {
-        return (0, exports.isoBaseMediaHasTracks)(state);
+        return (0, exports.isoBaseMediaHasTracks)(state, mayUsePrecomputed);
     }
     if (structure.type === 'riff') {
         return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(state);
@@ -109,11 +110,12 @@ const getTracksFromMoovBox = (moovBox) => {
     };
 };
 exports.getTracksFromMoovBox = getTracksFromMoovBox;
-const getTracksFromIsoBaseMedia = (state) => {
+const getTracksFromIsoBaseMedia = (state, mayUsePrecomputed) => {
     const moovBox = (0, traversal_1.getMoovBoxFromState)({
         structureState: state.structure,
         isoState: state.iso,
         mp4HeaderSegment: state.mp4HeaderSegment,
+        mayUsePrecomputed,
     });
     if (!moovBox) {
         return {
@@ -147,13 +149,13 @@ const defaultHasallTracks = (parserState) => {
     }
 };
 exports.defaultHasallTracks = defaultHasallTracks;
-const getTracks = (state) => {
+const getTracks = (state, mayUsePrecomputed) => {
     const structure = state.structure.getStructure();
     if (structure.type === 'matroska') {
         return getCategorizedTracksFromMatroska(state);
     }
     if (structure.type === 'iso-base-media') {
-        return (0, exports.getTracksFromIsoBaseMedia)(state);
+        return (0, exports.getTracksFromIsoBaseMedia)(state, mayUsePrecomputed);
     }
     if (structure.type === 'riff') {
         return (0, get_tracks_from_avi_1.getTracksFromAvi)(structure, state);

package/dist/get-video-codec.js

@@ -7,12 +7,12 @@ const get_sample_aspect_ratio_1 = require("./get-sample-aspect-ratio");
 const get_tracks_1 = require("./get-tracks");
 const getVideoCodec = (state) => {
     var _a, _b;
-    const track = (0, get_tracks_1.getTracks)(state);
+    const track = (0, get_tracks_1.getTracks)(state, true);
     return (_b = (_a = track.videoTracks[0]) === null || _a === void 0 ? void 0 : _a.codecWithoutConfig) !== null && _b !== void 0 ? _b : null;
 };
 exports.getVideoCodec = getVideoCodec;
 const hasVideoCodec = (state) => {
-    return (0, get_tracks_1.getHasTracks)(state);
+    return (0, get_tracks_1.getHasTracks)(state, true);
 };
 exports.hasVideoCodec = hasVideoCodec;
 const getVideoPrivateData = (trakBox) => {

package/dist/has-all-info.js

@@ -51,7 +51,7 @@ const getAvailableInfo = ({ state, }) => {
             return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(state));
         }
         if (key === 'tracks') {
-            return Boolean(structure && (0, get_tracks_1.getHasTracks)(state));
+            return Boolean(structure && (0, get_tracks_1.getHasTracks)(state, true));
         }
         if (key === 'keyframes') {
             return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(state));

package/dist/index.d.ts

@@ -778,11 +778,15 @@ export declare const MediaParserInternals: {
                 addPesHeader: (pesHeader: import("./containers/transport-stream/parse-pes").PacketPes) => void;
                 markPtsAsKeyframe: (pts: number) => void;
                 getPesKeyframeHeaders: () => import("./containers/transport-stream/parse-pes").PacketPes[];
+                setPesKeyframesFromSeekingHints: (hints: import("./seeking-hints").TransportStreamSeekingHints) => void;
             };
             streamBuffers: Map<number, import("./containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
             startOffset: {
                 getOffset: (trackId: number) => number;
-                setOffset: (trackId: number, newOffset: number) => void;
+                setOffset: ({ newOffset, trackId }: {
+                    trackId: number;
+                    newOffset: number;
+                }) => void;
             };
             resetBeforeSeek: () => void;
             lastEmittedSample: {
@@ -798,11 +802,18 @@ export declare const MediaParserInternals: {
                     cues: import("./containers/webm/seek/format-cues").MatroskaCue[];
                     segmentOffset: number;
                 } | null>;
+                getIfAlreadyLoaded: () => {
+                    cues: import("./containers/webm/seek/format-cues").MatroskaCue[];
+                    segmentOffset: number;
+                } | null;
+                setFromSeekingHints: (hints: import("./seeking-hints").WebmSeekingHints) => void;
             };
             onTrackEntrySegment: import("./containers/webm/segments").OnTrackEntrySegment;
             getTrackInfoByNumber: (id: number) => import("./containers/webm/segments/track-entry").TrackInfo;
             setTimestampOffset: (byteOffset: number, timestamp: number) => void;
             getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+            getTimeStampMapForSeekingHints: () => Map<number, number>;
+            setTimeStampMapForSeekingHints: (newTimestampMap: Map<number, number>) => void;
             getTimescale: () => number;
             setTimescale: (newTimescale: number) => void;
             addSegment: (seg: Omit<import("./state/matroska/webm").SegmentSection, "index">) => void;
@@ -819,11 +830,27 @@ export declare const MediaParserInternals: {
                 setSamples: (mdatStart: number, samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
             };
             moov: {
-                setMoovBox: (moov: import("./containers/iso-base-media/moov/moov").MoovBox) => void;
-                getMoovBox: () => import("./containers/iso-base-media/moov/moov").MoovBox | null;
+                setMoovBox: (moov: {
+                    moovBox: import("./containers/iso-base-media/moov/moov").MoovBox;
+                    precomputed: boolean;
+                }) => void;
+                getMoovBoxAndPrecomputed: () => {
+                    moovBox: import("./containers/iso-base-media/moov/moov").MoovBox;
+                    precomputed: boolean;
+                } | null;
             };
             mfra: {
                 triggerLoad: () => Promise<import("./containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null>;
+                getIfAlreadyLoaded: () => import("./containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null;
+                setFromSeekingHints: (hints: import("./seeking-hints").IsoBaseMediaSeekingHints) => void;
+            };
+            moof: {
+                getMoofBoxes: () => import("./state/iso-base-media/precomputed-moof").MoofBox[];
+                setMoofBoxes: (boxes: import("./state/iso-base-media/precomputed-moof").MoofBox[]) => void;
+            };
+            tfra: {
+                getTfraBoxes: () => import("./containers/iso-base-media/mfra/tfra").TfraBox[];
+                setTfraBoxes: (boxes: import("./containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
             };
         };
         mp3Info: {
@@ -923,6 +950,7 @@ export declare const MediaParserInternals: {
         keyframes: {
             addKeyframe: (keyframe: import("./options").MediaParserKeyframe) => void;
             getKeyframes: () => import("./options").MediaParserKeyframe[];
+            setFromSeekingHints: (hints: import("./seeking-hints").WebmSeekingHints) => void;
         };
         structure: {
             getStructureOrNull: () => import("./parse-result").MediaParserStructureUnstable | null;