@remotion/media-parser 4.0.289 → 4.0.291

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 2 | 1 | 4 | 3 | 5 | 6 | 8 | 7;
+export declare const getChannelCount: (iterator: BufferIterator) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

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

@@ -34,5 +34,4 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type BoxAndNext = IsoBaseMediaBox | null;
 export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox | TfraBox;

package/dist/containers/iso-base-media/collect-sample-positions-from-moof-boxes.d.ts

@@ -6,6 +6,9 @@ export declare const collectSamplePositionsFromMoofBoxes: ({ moofBoxes, tfraBoxe
     tfraBoxes: TfraBox[];
     tkhdBox: TkhdBox;
 }) => {
-    samplePositions: import("../..").SamplePosition[][];
+    samplePositions: {
+        isLastFragment: boolean;
+        samples: import("../..").SamplePosition[];
+    }[];
     isComplete: boolean;
 };

package/dist/containers/iso-base-media/collect-sample-positions-from-moof-boxes.js

@@ -5,11 +5,15 @@ const samples_from_moof_1 = require("../../samples-from-moof");
 const collectSamplePositionsFromMoofBoxes = ({ moofBoxes, tfraBoxes, tkhdBox, }) => {
     const isComplete = tfraBoxes.length > 0 &&
         tfraBoxes.every((t) => t.entries.length === moofBoxes.length);
-    const samplePositions = moofBoxes.map((m) => {
-        return (0, samples_from_moof_1.getSamplesFromMoof)({
-            moofBox: m,
-            trackId: tkhdBox.trackId,
-        });
+    const samplePositions = moofBoxes.map((m, index) => {
+        const isLastFragment = index === moofBoxes.length - 1 && isComplete;
+        return {
+            isLastFragment,
+            samples: (0, samples_from_moof_1.getSamplesFromMoof)({
+                moofBox: m,
+                trackId: tkhdBox.trackId,
+            }),
+        };
     });
     return { samplePositions, isComplete };
 };

package/dist/containers/iso-base-media/find-keyframe-before-time.js

@@ -3,26 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findKeyframeBeforeTime = void 0;
 const log_1 = require("../../log");
 const findKeyframeBeforeTime = ({ samplePositions, time, timescale, mediaSections, logLevel, }) => {
-    let byte = 0;
-    let sam = null;
+    let videoByte = 0;
+    let videoSample = null;
     for (const sample of samplePositions) {
         const ctsInSeconds = sample.cts / timescale;
         const dtsInSeconds = sample.dts / timescale;
-        if ((ctsInSeconds <= time || dtsInSeconds <= time) &&
-            byte <= sample.offset &&
-            sample.isKeyframe) {
-            byte = sample.offset;
-            sam = sample;
+        if (!sample.isKeyframe) {
+            continue;
+        }
+        if (!(ctsInSeconds <= time || dtsInSeconds <= time)) {
+            continue;
+        }
+        if (videoByte <= sample.offset) {
+            videoByte = sample.offset;
+            videoSample = sample;
         }
     }
-    if (!sam) {
+    if (!videoSample) {
         throw new Error('No sample found');
     }
-    const mediaSection = mediaSections.find((section) => sam.offset >= section.start && sam.offset < section.start + section.size);
+    const mediaSection = mediaSections.find((section) => videoSample.offset >= section.start &&
+        videoSample.offset < section.start + section.size);
     if (!mediaSection) {
-        log_1.Log.trace(logLevel, 'Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.', sam);
+        log_1.Log.trace(logLevel, 'Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.', videoSample);
         return null;
     }
-    return sam.offset;
+    return videoSample.offset;
 };
 exports.findKeyframeBeforeTime = findKeyframeBeforeTime;

package/dist/containers/iso-base-media/find-track-to-seek.d.ts

@@ -0,0 +1,14 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { IsoBaseMediaStructure } from '../../parse-result';
+import type { StructureState } from '../../state/structure';
+export declare const findAnyTrackWithSamplePositions: (allTracks: (VideoTrack | AudioTrack | OtherTrack)[], struc: IsoBaseMediaStructure) => {
+    track: VideoTrack | AudioTrack;
+    samplePositions: SamplePosition[];
+} | null;
+type TrackWithSamplePositions = {
+    track: VideoTrack | AudioTrack;
+    samplePositions: SamplePosition[];
+};
+export declare const findTrackToSeek: (allTracks: (VideoTrack | AudioTrack | OtherTrack)[], structure: StructureState) => TrackWithSamplePositions | null;
+export {};

package/dist/containers/iso-base-media/find-track-to-seek.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTrackToSeek = exports.findAnyTrackWithSamplePositions = void 0;
+const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
+const traversal_1 = require("./traversal");
+const findAnyTrackWithSamplePositions = (allTracks, struc) => {
+    for (const track of allTracks) {
+        if (track.type === 'video' || track.type === 'audio') {
+            const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+                trakBox: track.trakBox,
+                moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),
+                tfraBoxes: (0, traversal_1.getTfraBoxes)(struc),
+            });
+            if (samplePositions.length === 0) {
+                continue;
+            }
+            return { track, samplePositions };
+        }
+    }
+    return null;
+};
+exports.findAnyTrackWithSamplePositions = findAnyTrackWithSamplePositions;
+const findTrackToSeek = (allTracks, structure) => {
+    const firstVideoTrack = allTracks.find((t) => t.type === 'video');
+    const struc = structure.getIsoStructure();
+    if (!firstVideoTrack) {
+        return (0, exports.findAnyTrackWithSamplePositions)(allTracks, struc);
+    }
+    const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
+        trakBox: firstVideoTrack.trakBox,
+        moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),
+        tfraBoxes: (0, traversal_1.getTfraBoxes)(struc),
+    });
+    if (samplePositions.length === 0) {
+        return (0, exports.findAnyTrackWithSamplePositions)(allTracks, struc);
+    }
+    return { track: firstVideoTrack, samplePositions };
+};
+exports.findTrackToSeek = findTrackToSeek;

package/dist/containers/iso-base-media/get-children.js

@@ -13,10 +13,10 @@ const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAto
             onlyIfMdatAtomExpected: null,
             contentLength,
         });
-        if (!parsed) {
+        if (parsed.type !== 'box') {
             throw new Error('Expected box');
         }
-        boxes.push(parsed);
+        boxes.push(parsed.box);
     }
     if (iterator.counter.getOffset() > size + initial) {
         throw new Error(`read too many bytes - size: ${size}, read: ${iterator.counter.getOffset() - initial}. initial offset: ${initial}`);

package/dist/containers/iso-base-media/get-keyframes.js

@@ -5,7 +5,12 @@ const get_tracks_1 = require("../../get-tracks");
 const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
 const traversal_1 = require("./traversal");
 const getKeyframesFromIsoBaseMedia = (state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)(state, true);
+    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)({
+        isoState: state.iso,
+        m3uPlaylistContext: state.m3uPlaylistContext,
+        structure: state.structure,
+        mayUsePrecomputed: true,
+    });
     const structure = state.structure.getIsoStructure();
     const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
     const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure);

package/dist/containers/iso-base-media/get-mfra-seeking-box.d.ts

@@ -1,4 +1,5 @@
 import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../fetch';
 import type { LogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
 import type { ReaderInterface } from '../../readers/reader';
@@ -9,5 +10,6 @@ export type MfraSeekingBoxOptions = {
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
     logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 };
-export declare const getMfraSeekingBox: ({ contentLength, controller, readerInterface, src, logLevel, }: MfraSeekingBoxOptions) => Promise<IsoBaseMediaBox[] | null>;
+export declare const getMfraSeekingBox: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: MfraSeekingBoxOptions) => Promise<IsoBaseMediaBox[] | null>;

package/dist/containers/iso-base-media/get-mfra-seeking-box.js

@@ -4,12 +4,14 @@ exports.getMfraSeekingBox = void 0;
 const get_children_1 = require("./get-children");
 const get_mfra_atom_1 = require("./mfra/get-mfra-atom");
 const get_mfro_atom_1 = require("./mfra/get-mfro-atom");
-const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }) => {
     const parentSize = await (0, get_mfro_atom_1.getMfroAtom)({
         contentLength,
         controller,
         readerInterface,
         src,
+        logLevel,
+        prefetchCache,
     });
     if (!parentSize) {
         return null;
@@ -20,6 +22,8 @@ const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, s
         readerInterface,
         src,
         parentSize,
+        logLevel,
+        prefetchCache,
     });
     mfraAtom.discard(8);
     return (0, get_children_1.getIsoBaseMediaChildren)({

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -10,7 +10,8 @@ const structure_1 = require("../../state/structure");
 const process_box_1 = require("./process-box");
 const traversal_1 = require("./traversal");
 const getMoovAtom = async ({ endOfMdat, state, }) => {
-    const headerSegment = state.mp4HeaderSegment;
+    var _a;
+    const headerSegment = (_a = state.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment;
     if (headerSegment) {
         const segment = (0, traversal_1.getMoovFromFromIsoStructure)(headerSegment);
         if (!segment) {
@@ -24,6 +25,8 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
         src: state.src,
         range: endOfMdat,
         controller: state.controller,
+        logLevel: state.logLevel,
+        prefetchCache: state.prefetchCache,
     });
     const onAudioTrack = state.onAudioTrack
         ? async ({ track, container }) => {
@@ -84,8 +87,8 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
             onlyIfMdatAtomExpected: null,
             contentLength: state.contentLength - endOfMdat,
         });
-        if (box) {
-            boxes.push(box);
+        if (box.type === 'box') {
+            boxes.push(box.box);
         }
         if (iterator.counter.getOffset() + endOfMdat > state.contentLength) {
             throw new Error('Read past end of file');

package/dist/containers/iso-base-media/get-sample-position-bounds.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositionBounds = void 0;
 const getSamplePositionBounds = (samplePositions, timescale) => {
+    var _a;
     let min = Infinity;
     let max = -Infinity;
     for (const samplePosition of samplePositions) {
         const timestampMin = Math.min(samplePosition.cts, samplePosition.dts);
-        const timestampMax = Math.max(samplePosition.cts, samplePosition.dts);
+        const timestampMax = Math.max(samplePosition.cts, samplePosition.dts) +
+            ((_a = samplePosition.duration) !== null && _a !== void 0 ? _a : 0);
         if (timestampMin < min) {
             min = timestampMin;
         }

package/dist/containers/iso-base-media/get-sample-positions-from-track.js

@@ -16,7 +16,7 @@ const getSamplePositionsFromTrack = ({ trakBox, moofBoxes, tfraBoxes, }) => {
             tkhdBox,
         });
         return {
-            samplePositions: samplePositions.flat(1),
+            samplePositions: samplePositions.map((s) => s.samples).flat(1),
             isComplete,
         };
     }

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.d.ts

@@ -0,0 +1,14 @@
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { LogLevel } from '../../log';
+import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
+import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { SeekResolution } from '../../work-on-seek-request';
+export declare const getSeekingByteFromFragmentedMp4: ({ info, time, logLevel, currentPosition, isoState, allTracks, isLastChunkInPlaylist, }: {
+    info: IsoBaseMediaSeekingHints;
+    time: number;
+    logLevel: LogLevel;
+    currentPosition: number;
+    isoState: IsoBaseMediaState;
+    allTracks: (VideoTrack | AudioTrack | OtherTrack)[];
+    isLastChunkInPlaylist: boolean;
+}) => Promise<SeekResolution>;

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteFromFragmentedMp4 = void 0;
+const log_1 = require("../../log");
+const video_section_1 = require("../../state/video-section");
+const collect_sample_positions_from_moof_boxes_1 = require("./collect-sample-positions-from-moof-boxes");
+const find_keyframe_before_time_1 = require("./find-keyframe-before-time");
+const get_sample_position_bounds_1 = require("./get-sample-position-bounds");
+const find_best_segment_from_tfra_1 = require("./mfra/find-best-segment-from-tfra");
+const traversal_1 = require("./traversal");
+const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPosition, isoState, allTracks, isLastChunkInPlaylist, }) => {
+    const firstVideoTrack = allTracks.find((t) => t.type === 'video');
+    // If there is both video and audio, seek based on video, but if not then audio is also okay
+    const firstTrack = firstVideoTrack !== null && firstVideoTrack !== void 0 ? firstVideoTrack : allTracks.find((t) => t.type === 'audio');
+    if (!firstTrack) {
+        throw new Error('no video and no audio tracks');
+    }
+    const tkhdBox = (0, traversal_1.getTkhdBox)(firstTrack.trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    const { samplePositions: samplePositionsArray } = (0, collect_sample_positions_from_moof_boxes_1.collectSamplePositionsFromMoofBoxes)({
+        moofBoxes: info.moofBoxes,
+        tfraBoxes: info.tfraBoxes,
+        tkhdBox,
+    });
+    log_1.Log.trace(logLevel, 'Fragmented MP4 - Checking if we have seeking info for this time range');
+    for (const positions of samplePositionsArray) {
+        const { min, max } = (0, get_sample_position_bounds_1.getSamplePositionBounds)(positions.samples, firstTrack.timescale);
+        if (min <= time &&
+            (positions.isLastFragment || isLastChunkInPlaylist || time <= max)) {
+            log_1.Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
+            const kf = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
+                samplePositions: positions.samples,
+                time,
+                timescale: firstTrack.timescale,
+                logLevel,
+                mediaSections: info.mediaSections,
+            });
+            if (kf) {
+                return {
+                    type: 'do-seek',
+                    byte: kf,
+                };
+            }
+        }
+    }
+    const atom = await (info.mfraAlreadyLoaded
+        ? Promise.resolve(info.mfraAlreadyLoaded)
+        : isoState.mfra.triggerLoad());
+    if (atom) {
+        const moofOffset = (0, find_best_segment_from_tfra_1.findBestSegmentFromTfra)({
+            mfra: atom,
+            time,
+            firstTrack,
+            timescale: firstTrack.timescale,
+        });
+        if (moofOffset !== null &&
+            !(moofOffset.start <= currentPosition && currentPosition < moofOffset.end)) {
+            log_1.Log.verbose(logLevel, `Fragmented MP4 - Found based on mfra information that we should seek to: ${moofOffset.start} ${moofOffset.end}`);
+            return {
+                type: 'intermediary-seek',
+                byte: moofOffset.start,
+            };
+        }
+    }
+    log_1.Log.trace(logLevel, 'Fragmented MP4 - No seeking info found for this time range.');
+    if ((0, video_section_1.isByteInMediaSection)({
+        position: currentPosition,
+        mediaSections: info.mediaSections,
+    }) !== 'in-section') {
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    log_1.Log.trace(logLevel, 'Fragmented MP4 - Inside the wrong video section, skipping to the end of the section');
+    const mediaSection = (0, video_section_1.getCurrentMediaSection)({
+        offset: currentPosition,
+        mediaSections: info.mediaSections,
+    });
+    if (!mediaSection) {
+        throw new Error('No video section defined');
+    }
+    return {
+        type: 'intermediary-seek',
+        byte: mediaSection.start + mediaSection.size,
+    };
+};
+exports.getSeekingByteFromFragmentedMp4 = getSeekingByteFromFragmentedMp4;

package/dist/containers/iso-base-media/get-seeking-byte.d.ts

@@ -1,15 +1,15 @@
 import type { LogLevel } from '../../log';
-import type { IsoBaseMediaStructure } from '../../parse-result';
+import type { M3uPlaylistContext } from '../../options';
 import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
 import type { StructureState } from '../../state/structure';
 import type { SeekResolution } from '../../work-on-seek-request';
-export declare const getSeekingByteFromIsoBaseMedia: ({ info, time, logLevel, currentPosition, isoState, mp4HeaderSegment, structure, }: {
+export declare const getSeekingByteFromIsoBaseMedia: ({ info, time, logLevel, currentPosition, isoState, m3uPlaylistContext, structure, }: {
     info: IsoBaseMediaSeekingHints;
     time: number;
     logLevel: LogLevel;
     currentPosition: number;
     isoState: IsoBaseMediaState;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     structure: StructureState;
 }) => Promise<SeekResolution>;

package/dist/containers/iso-base-media/get-seeking-byte.js

@@ -3,132 +3,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSeekingByteFromIsoBaseMedia = void 0;
 const get_tracks_1 = require("../../get-tracks");
 const log_1 = require("../../log");
-const video_section_1 = require("../../state/video-section");
-const collect_sample_positions_from_moof_boxes_1 = require("./collect-sample-positions-from-moof-boxes");
 const find_keyframe_before_time_1 = require("./find-keyframe-before-time");
-const get_sample_position_bounds_1 = require("./get-sample-position-bounds");
-const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
-const find_best_segment_from_tfra_1 = require("./mfra/find-best-segment-from-tfra");
+const find_track_to_seek_1 = require("./find-track-to-seek");
+const get_seeking_byte_from_fragmented_mp4_1 = require("./get-seeking-byte-from-fragmented-mp4");
 const traversal_1 = require("./traversal");
-const getSeekingByteFromIsoBaseMedia = async ({ info, time, logLevel, currentPosition, isoState, mp4HeaderSegment, structure, }) => {
-    const tracks = (0, get_tracks_1.getTracksFromMoovBox)(info.moovBox);
+const getSeekingByteFromIsoBaseMedia = ({ info, time, logLevel, currentPosition, isoState, m3uPlaylistContext, structure, }) => {
+    var _a, _b;
+    const tracks = (0, get_tracks_1.getTracksFromIsoBaseMedia)({
+        isoState,
+        m3uPlaylistContext,
+        structure,
+        mayUsePrecomputed: false,
+    });
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
         ...tracks.otherTracks,
     ];
     const hasMoov = Boolean((0, traversal_1.getMoovBoxFromState)({
-        mp4HeaderSegment,
         structureState: structure,
         isoState,
         mayUsePrecomputed: false,
+        mp4HeaderSegment: (_a = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.mp4HeaderSegment) !== null && _a !== void 0 ? _a : null,
     }));
     if (!hasMoov) {
         log_1.Log.trace(logLevel, 'No moov box found, must wait');
-        return {
+        return Promise.resolve({
             type: 'valid-but-must-wait',
-        };
-    }
-    const firstVideoTrack = allTracks.find((t) => t.type === 'video');
-    if (!firstVideoTrack) {
-        throw new Error('No video track found');
+        });
     }
-    const { timescale } = firstVideoTrack;
     if (info.moofBoxes.length > 0) {
-        const tkhdBox = (0, traversal_1.getTkhdBox)(firstVideoTrack.trakBox);
-        if (!tkhdBox) {
-            throw new Error('Expected tkhd box in trak box');
-        }
-        const { samplePositions: samplePositionsArray } = (0, collect_sample_positions_from_moof_boxes_1.collectSamplePositionsFromMoofBoxes)({
-            moofBoxes: info.moofBoxes,
-            tfraBoxes: info.tfraBoxes,
-            tkhdBox,
-        });
-        log_1.Log.trace(logLevel, 'Fragmented MP4 - Checking if we have seeking info for this time range');
-        for (const positions of samplePositionsArray) {
-            const { min, max } = (0, get_sample_position_bounds_1.getSamplePositionBounds)(positions, timescale);
-            if (min <= time && time <= max) {
-                log_1.Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
-                const kf = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
-                    samplePositions: positions,
-                    time,
-                    timescale,
-                    logLevel,
-                    mediaSections: info.mediaSections,
-                });
-                if (kf) {
-                    return {
-                        type: 'do-seek',
-                        byte: kf,
-                    };
-                }
-            }
-        }
-        const atom = await (info.mfraAlreadyLoaded
-            ? Promise.resolve(info.mfraAlreadyLoaded)
-            : isoState.mfra.triggerLoad());
-        if (atom) {
-            const moofOffset = (0, find_best_segment_from_tfra_1.findBestSegmentFromTfra)({
-                mfra: atom,
-                time,
-                firstVideoTrack,
-                timescale,
-            });
-            if (moofOffset !== null &&
-                !(moofOffset.start <= currentPosition &&
-                    currentPosition < moofOffset.end)) {
-                log_1.Log.verbose(logLevel, `Fragmented MP4 - Found based on mfra information that we should seek to: ${moofOffset.start} ${moofOffset.end}`);
-                return {
-                    type: 'intermediary-seek',
-                    byte: moofOffset.start,
-                };
-            }
-        }
-        log_1.Log.trace(logLevel, 'Fragmented MP4 - No seeking info found for this time range.');
-        if ((0, video_section_1.isByteInMediaSection)({
-            position: currentPosition,
-            mediaSections: info.mediaSections,
-        }) !== 'in-section') {
-            return {
-                type: 'valid-but-must-wait',
-            };
-        }
-        log_1.Log.trace(logLevel, 'Fragmented MP4 - Inside the wrong video section, skipping to the end of the section');
-        const mediaSection = (0, video_section_1.getCurrentMediaSection)({
-            offset: currentPosition,
-            mediaSections: info.mediaSections,
+        return (0, get_seeking_byte_from_fragmented_mp4_1.getSeekingByteFromFragmentedMp4)({
+            info,
+            time,
+            logLevel,
+            currentPosition,
+            isoState,
+            allTracks,
+            isLastChunkInPlaylist: (_b = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.isLastChunkInPlaylist) !== null && _b !== void 0 ? _b : false,
         });
-        if (!mediaSection) {
-            throw new Error('No video section defined');
-        }
-        return {
-            type: 'intermediary-seek',
-            byte: mediaSection.start + mediaSection.size,
-        };
     }
-    const { samplePositions, isComplete } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
-        trakBox: firstVideoTrack.trakBox,
-        moofBoxes: info.moofBoxes,
-        tfraBoxes: info.tfraBoxes,
-    });
-    if (!isComplete) {
-        throw new Error('Incomplete sample positions');
+    const trackWithSamplePositions = (0, find_track_to_seek_1.findTrackToSeek)(allTracks, structure);
+    if (!trackWithSamplePositions) {
+        return Promise.resolve({
+            type: 'valid-but-must-wait',
+        });
     }
+    const { track, samplePositions } = trackWithSamplePositions;
     const keyframe = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
         samplePositions,
         time,
-        timescale,
+        timescale: track.timescale,
         logLevel,
         mediaSections: info.mediaSections,
     });
     if (keyframe) {
-        return {
+        return Promise.resolve({
             type: 'do-seek',
             byte: keyframe,
-        };
+        });
     }
-    return {
+    return Promise.resolve({
         type: 'invalid',
-    };
+    });
 };
 exports.getSeekingByteFromIsoBaseMedia = getSeekingByteFromIsoBaseMedia;

package/dist/containers/iso-base-media/get-video-codec-from-iso-track.d.ts

@@ -1,2 +1,2 @@
 import type { TrakBox } from './trak/trak';
-export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h265" | "h264" | "av1" | "prores";
+export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h264" | "av1" | "h265" | "prores";

package/dist/containers/iso-base-media/mdat/calculate-jump-marks.d.ts

@@ -0,0 +1,6 @@
+import type { MinimalFlatSampleForTesting } from '../../../state/iso-base-media/cached-sample-positions';
+export type JumpMark = {
+    afterSampleWithOffset: number;
+    jumpToOffset: number;
+};
+export declare const calculateJumpMarks: (samplePositionTracks: MinimalFlatSampleForTesting[][], endOfMdat: number) => JumpMark[];