@remotion/media-parser 4.0.280 → 4.0.282

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositionBounds = void 0;
+const getSamplePositionBounds = (samplePositions, timescale) => {
+    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);
+        if (timestampMin < min) {
+            min = timestampMin;
+        }
+        if (timestampMax > max) {
+            max = timestampMax;
+        }
+    }
+    return { min: min / timescale, max: max / timescale };
+};
+exports.getSamplePositionBounds = getSamplePositionBounds;

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

@@ -1,7 +1,12 @@
 import type { SamplePosition } from '../../get-sample-positions';
 import type { IsoBaseMediaBox } from './base-media-box';
+import type { TfraBox } from './mfra/tfra';
 import type { TrakBox } from './trak/trak';
-export declare const getSamplePositionsFromTrack: ({ trakBox, moofBoxes, }: {
+export declare const getSamplePositionsFromTrack: ({ trakBox, moofBoxes, tfraBoxes, }: {
     trakBox: TrakBox;
     moofBoxes: IsoBaseMediaBox[];
-}) => SamplePosition[];
+    tfraBoxes: TfraBox[];
+}) => {
+    samplePositions: SamplePosition[];
+    isComplete: boolean;
+};

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

@@ -1,58 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositionsFromTrack = void 0;
-const get_audio_codec_1 = require("../../get-audio-codec");
-const get_fps_1 = require("../../get-fps");
-const get_sample_positions_1 = require("../../get-sample-positions");
-const get_sample_positions_from_lpcm_1 = require("../../get-sample-positions-from-lpcm");
-const samples_from_moof_1 = require("../../samples-from-moof");
+const collect_sample_positions_from_moof_boxes_1 = require("./collect-sample-positions-from-moof-boxes");
+const collect_sample_positions_from_trak_1 = require("./collect-sample-positions-from-trak");
 const traversal_1 = require("./traversal");
-const getSamplePositionsFromTrack = ({ trakBox, moofBoxes, }) => {
-    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
-    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
-    if (isLpcm) {
-        return (0, get_sample_positions_from_lpcm_1.getSamplePositionsFromLpcm)(trakBox);
-    }
-    const stszBox = (0, traversal_1.getStszBox)(trakBox);
-    const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
-    const stscBox = (0, traversal_1.getStscBox)(trakBox);
-    const stssBox = (0, traversal_1.getStssBox)(trakBox);
-    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+const getSamplePositionsFromTrack = ({ trakBox, moofBoxes, tfraBoxes, }) => {
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
-    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
     if (!tkhdBox) {
         throw new Error('Expected tkhd box in trak box');
     }
-    if (!stszBox) {
-        throw new Error('Expected stsz box in trak box');
-    }
-    if (!stcoBox) {
-        throw new Error('Expected stco box in trak box');
-    }
-    if (!stscBox) {
-        throw new Error('Expected stsc box in trak box');
-    }
-    if (!sttsBox) {
-        throw new Error('Expected stts box in trak box');
-    }
-    if (!timescaleAndDuration) {
-        throw new Error('Expected timescale and duration in trak box');
-    }
-    let samplePositions = (0, get_sample_positions_1.getSamplePositions)({
-        stcoBox,
-        stscBox,
-        stszBox,
-        stssBox,
-        sttsBox,
-        cttsBox,
-    });
-    if (samplePositions.length === 0 && moofBoxes.length > 0) {
-        samplePositions = moofBoxes
-            .map((m) => {
-            return (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox: m, trackId: tkhdBox.trackId });
-        })
-            .flat(1);
-    }
-    return samplePositions;
+    if (moofBoxes.length > 0) {
+        const { isComplete, samplePositions } = (0, collect_sample_positions_from_moof_boxes_1.collectSamplePositionsFromMoofBoxes)({
+            moofBoxes,
+            tfraBoxes,
+            tkhdBox,
+        });
+        return {
+            samplePositions: samplePositions.flat(1),
+            isComplete,
+        };
+    }
+    return {
+        samplePositions: (0, collect_sample_positions_from_trak_1.collectSamplePositionsFromTrak)(trakBox),
+        isComplete: true,
+    };
 };
 exports.getSamplePositionsFromTrack = getSamplePositionsFromTrack;

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

@@ -1,5 +1,11 @@
-import type { SamplePosition } from '../../get-sample-positions';
-import type { IsoBaseMediaSeekingInfo, SeekingInfo } from '../../seeking-info';
-import type { ParserState } from '../../state/parser-state';
-export declare const getSeekingInfoFromMp4: (state: ParserState) => SeekingInfo | null;
-export declare const getSeekingByteFromIsoBaseMedia: (info: IsoBaseMediaSeekingInfo, time: number) => SamplePosition;
+import type { LogLevel } from '../../log';
+import type { IsoBaseMediaSeekingInfo } from '../../seeking-info';
+import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { SeekResolution } from '../../work-on-seek-request';
+export declare const getSeekingByteFromIsoBaseMedia: ({ info, time, logLevel, currentPosition, isoState, }: {
+    info: IsoBaseMediaSeekingInfo;
+    time: number;
+    logLevel: LogLevel;
+    currentPosition: number;
+    isoState: IsoBaseMediaState;
+}) => Promise<SeekResolution>;

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

@@ -1,56 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSeekingByteFromIsoBaseMedia = exports.getSeekingInfoFromMp4 = void 0;
+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 traversal_1 = require("./traversal");
-const getSeekingInfoFromMp4 = (state) => {
-    const structure = state.getIsoStructure();
-    const moovAtom = (0, traversal_1.getMoovBoxFromState)(state);
-    const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
-    if (!moovAtom) {
-        return null;
-    }
-    return {
-        type: 'iso-base-media-seeking-info',
-        moovBox: moovAtom,
-        moofBoxes,
-    };
-};
-exports.getSeekingInfoFromMp4 = getSeekingInfoFromMp4;
-const getSeekingByteFromIsoBaseMedia = (info, time) => {
+const getSeekingByteFromIsoBaseMedia = async ({ info, time, logLevel, currentPosition, isoState, }) => {
     const tracks = (0, get_tracks_1.getTracksFromMoovBox)(info.moovBox);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,
         ...tracks.otherTracks,
     ];
-    let byte = 0;
-    let sam = null;
-    for (const t of allTracks) {
-        const { timescale: ts, type } = t;
-        if (type !== 'video') {
-            continue;
+    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 = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
-            trakBox: t.trakBox,
+        const { samplePositions: samplePositionsArray } = (0, collect_sample_positions_from_moof_boxes_1.collectSamplePositionsFromMoofBoxes)({
             moofBoxes: info.moofBoxes,
+            tfraBoxes: info.tfraBoxes,
+            tkhdBox,
         });
-        for (const sample of samplePositions) {
-            const ctsInSeconds = sample.cts / ts;
-            const dtsInSeconds = sample.dts / ts;
-            if ((ctsInSeconds <= time || dtsInSeconds <= time) &&
-                byte <= sample.offset &&
-                type === 'video' &&
-                sample.isKeyframe) {
-                byte = sample.offset;
-                sam = sample;
+        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 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,
+        });
+        if (!mediaSection) {
+            throw new Error('No video section defined');
+        }
+        return {
+            type: 'intermediary-seek',
+            byte: mediaSection.start + mediaSection.size,
+        };
     }
-    if (!sam) {
-        throw new Error('No sample found');
+    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');
     }
-    return sam;
+    const keyframe = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
+        samplePositions,
+        time,
+        timescale,
+        logLevel,
+        mediaSections: info.mediaSections,
+    });
+    if (keyframe) {
+        return {
+            type: 'do-seek',
+            byte: keyframe,
+        };
+    }
+    return {
+        type: 'invalid',
+    };
 };
 exports.getSeekingByteFromIsoBaseMedia = getSeekingByteFromIsoBaseMedia;

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

@@ -0,0 +1,11 @@
+import type { IsoBaseMediaStructure } from '../../parse-result';
+import type { IsoBaseMediaSeekingInfo } from '../../seeking-info';
+import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { StructureState } from '../../state/structure';
+import type { MediaSectionState } from '../../state/video-section';
+export declare const getSeekingInfoFromMp4: ({ structureState, isoState, mp4HeaderSegment, mediaSectionState, }: {
+    structureState: StructureState;
+    isoState: IsoBaseMediaState;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    mediaSectionState: MediaSectionState;
+}) => IsoBaseMediaSeekingInfo | null;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingInfoFromMp4 = void 0;
+const traversal_1 = require("./traversal");
+const getSeekingInfoFromMp4 = ({ structureState, isoState, mp4HeaderSegment, mediaSectionState, }) => {
+    const structure = structureState.getIsoStructure();
+    const moovAtom = (0, traversal_1.getMoovBoxFromState)({
+        isoState,
+        mp4HeaderSegment,
+        structureState,
+    });
+    const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
+    const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure);
+    if (!moovAtom) {
+        return null;
+    }
+    return {
+        type: 'iso-base-media-seeking-info',
+        moovBox: moovAtom,
+        moofBoxes,
+        tfraBoxes,
+        mediaSections: mediaSectionState.getMediaSections(),
+    };
+};
+exports.getSeekingInfoFromMp4 = getSeekingInfoFromMp4;

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

@@ -7,10 +7,18 @@ const get_tracks_1 = require("../../../get-tracks");
 const skip_1 = require("../../../skip");
 const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
 const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
+const video_section_1 = require("../../../state/video-section");
+const work_on_seek_request_1 = require("../../../work-on-seek-request");
 const get_moov_atom_1 = require("../get-moov-atom");
 const parseMdatSection = async (state) => {
-    const videoSection = state.videoSection.getVideoSection();
-    const endOfMdat = videoSection.size + videoSection.start;
+    const mediaSection = (0, video_section_1.getCurrentMediaSection)({
+        offset: state.iterator.counter.getOffset(),
+        mediaSections: state.mediaSection.getMediaSections(),
+    });
+    if (!mediaSection) {
+        throw new Error('No video section defined');
+    }
+    const endOfMdat = mediaSection.size + mediaSection.start;
     // don't need mdat at all, can skip
     if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
         return (0, skip_1.makeSkip)(endOfMdat);
@@ -23,13 +31,13 @@ const parseMdatSection = async (state) => {
         });
         state.iso.moov.setMoovBox(moov);
         state.callbacks.tracks.setIsDone(state.logLevel);
-        state.getIsoStructure().boxes.push(moov);
+        state.structure.getIsoStructure().boxes.push(moov);
         return (0, exports.parseMdatSection)(state);
     }
-    if (!state.iso.flatSamples.getSamples(videoSection.start)) {
-        state.iso.flatSamples.setSamples(videoSection.start, (0, cached_sample_positions_1.calculateFlatSamples)(state));
+    if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
+        state.iso.flatSamples.setSamples(mediaSection.start, (0, cached_sample_positions_1.calculateFlatSamples)(state));
     }
-    const flatSamples = state.iso.flatSamples.getSamples(videoSection.start);
+    const flatSamples = state.iso.flatSamples.getSamples(mediaSection.start);
     const { iterator } = state;
     const samplesWithIndex = flatSamples.find((sample) => {
         return sample.samplePosition.offset === iterator.counter.getOffset();
@@ -58,17 +66,21 @@ const parseMdatSection = async (state) => {
         await (0, emit_audio_sample_1.emitAudioSample)({
             trackId: samplesWithIndex.track.trackId,
             audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                data: bytes,
-                timestamp: cts,
-                duration,
-                cts,
-                dts,
-                trackId: samplesWithIndex.track.trackId,
-                type: isKeyframe ? 'key' : 'delta',
-                offset,
+                sample: {
+                    data: bytes,
+                    timestamp: cts,
+                    duration,
+                    cts,
+                    dts,
+                    trackId: samplesWithIndex.track.trackId,
+                    type: isKeyframe ? 'key' : 'delta',
+                    offset,
+                    timescale: samplesWithIndex.track.timescale,
+                },
                 timescale: samplesWithIndex.track.timescale,
-            }, samplesWithIndex.track.timescale),
-            state,
+            }),
+            workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+            callbacks: state.callbacks,
         });
     }
     if (samplesWithIndex.track.type === 'video') {
@@ -87,17 +99,21 @@ const parseMdatSection = async (state) => {
         await (0, emit_audio_sample_1.emitVideoSample)({
             trackId: samplesWithIndex.track.trackId,
             videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                data: bytes,
-                timestamp: cts,
-                duration,
-                cts,
-                dts,
-                trackId: samplesWithIndex.track.trackId,
-                type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
-                offset,
+                sample: {
+                    data: bytes,
+                    timestamp: cts,
+                    duration,
+                    cts,
+                    dts,
+                    trackId: samplesWithIndex.track.trackId,
+                    type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
+                    offset,
+                    timescale: samplesWithIndex.track.timescale,
+                },
                 timescale: samplesWithIndex.track.timescale,
-            }, samplesWithIndex.track.timescale),
-            state,
+            }),
+            workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
+            callbacks: state.callbacks,
         });
     }
     return null;

package/dist/containers/iso-base-media/mfra/find-best-segment-from-tfra.d.ts

@@ -0,0 +1,11 @@
+import type { VideoTrack } from '../../../get-tracks';
+import type { IsoBaseMediaBox } from '../base-media-box';
+export declare const findBestSegmentFromTfra: ({ mfra, time, firstVideoTrack, timescale, }: {
+    mfra: IsoBaseMediaBox[];
+    time: number;
+    firstVideoTrack: VideoTrack;
+    timescale: number;
+}) => {
+    start: number;
+    end: number;
+} | null;

package/dist/containers/iso-base-media/mfra/find-best-segment-from-tfra.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBestSegmentFromTfra = void 0;
+const findBestSegmentFromTfra = ({ mfra, time, firstVideoTrack, timescale, }) => {
+    const tfra = mfra.find((b) => b.type === 'tfra-box' && b.trackId === firstVideoTrack.trackId);
+    if (!tfra) {
+        return null;
+    }
+    let bestSegment = null;
+    for (const segment of tfra.entries) {
+        if (segment.time / timescale <= time) {
+            bestSegment = segment;
+        }
+    }
+    if (!bestSegment) {
+        return null;
+    }
+    const currentSegmentIndex = tfra.entries.indexOf(bestSegment);
+    const offsetOfNext = currentSegmentIndex === tfra.entries.length - 1
+        ? Infinity
+        : tfra.entries[currentSegmentIndex + 1].moofOffset;
+    return {
+        start: bestSegment.moofOffset,
+        end: offsetOfNext,
+    };
+};
+exports.findBestSegmentFromTfra = findBestSegmentFromTfra;

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

@@ -0,0 +1,81 @@
+import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { ParseMediaSrc } from '../../../options';
+import type { ReaderInterface } from '../../../readers/reader';
+export declare const getMfraAtom: ({ src, contentLength, readerInterface, controller, parentSize, }: {
+    src: ParseMediaSrc;
+    contentLength: number;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+    parentSize: number;
+}) => Promise<{
+    startReadingBits: () => void;
+    stopReadingBits: () => void;
+    skipTo: (offset: number) => void;
+    addData: (newData: Uint8Array) => void;
+    counter: {
+        getOffset: () => number;
+        discardBytes: (bytes: number) => void;
+        increment: (bytes: number) => void;
+        getDiscardedBytes: () => number;
+        setDiscardedOffset: (bytes: number) => void;
+        getDiscardedOffset: () => number;
+        decrement: (bytes: number) => void;
+    };
+    peekB: (length: number) => void;
+    peekD: (length: number) => void;
+    getBits: (bits: number) => number;
+    bytesRemaining: () => number;
+    leb128: () => number;
+    removeBytesRead: (force: boolean, mode: import("../../../options").ParseMediaMode) => {
+        bytesRemoved: number;
+        removedData: Uint8Array | null;
+    };
+    discard: (length: number) => void;
+    getEightByteNumber: (littleEndian?: boolean) => number;
+    getFourByteNumber: () => number;
+    getSlice: (amount: number) => Uint8Array;
+    getAtom: () => string;
+    detectFileType: () => import("../../../file-types/detect-file-type").FileType;
+    getPaddedFourByteNumber: () => number;
+    getMatroskaSegmentId: () => string | null;
+    getVint: () => number | null;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getUint16Le: () => number;
+    getUint24: () => number;
+    getInt24: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getUint64: (littleEndian?: boolean) => bigint;
+    getInt64: (littleEndian?: boolean) => bigint;
+    getFixedPointUnsigned1616Number: () => number;
+    getFixedPointSigned1616Number: () => number;
+    getFixedPointSigned230Number: () => number;
+    getPascalString: () => number[];
+    getUint(length: number): number;
+    getByteString(length: number, trimTrailingZeroes: boolean): string;
+    planBytes: (size: number) => {
+        discardRest: () => Uint8Array;
+    };
+    getFloat64: () => number;
+    readUntilNullTerminator: () => string;
+    getFloat32: () => number;
+    getUint32Le: () => number;
+    getInt32Le: () => number;
+    getInt32: () => number;
+    destroy: () => void;
+    startBox: (size: number) => {
+        discardRest: () => void;
+        expectNoMoreBytes: () => void;
+    };
+    readExpGolomb: () => number;
+    startCheckpoint: () => {
+        returnToCheckpoint: () => void;
+    };
+    getFlacCodecNumber: () => number;
+    readUntilLineEnd: () => string | null;
+    getSyncSafeInt32: () => number;
+    replaceData: (newData: Uint8Array, seekTo: number) => void;
+}>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMfraAtom = void 0;
+const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
+const getMfraAtom = async ({ src, contentLength, readerInterface, controller, parentSize, }) => {
+    const result = await readerInterface.read({
+        controller,
+        range: [contentLength - parentSize, contentLength - 1],
+        src,
+    });
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), parentSize);
+    while (true) {
+        const res = await result.reader.reader.read();
+        if (res.value) {
+            iterator.addData(res.value);
+        }
+        if (res.done) {
+            break;
+        }
+    }
+    return iterator;
+};
+exports.getMfraAtom = getMfraAtom;

package/dist/containers/iso-base-media/mfra/get-mfro-atom.d.ts

@@ -0,0 +1,9 @@
+import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { ParseMediaSrc } from '../../../options';
+import type { ReaderInterface } from '../../../readers/reader';
+export declare const getMfroAtom: ({ src, contentLength, readerInterface, controller, }: {
+    src: ParseMediaSrc;
+    contentLength: number;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+}) => Promise<number | null>;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMfroAtom = void 0;
+const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
+const getMfroAtom = async ({ src, contentLength, readerInterface, controller, }) => {
+    const result = await readerInterface.read({
+        controller,
+        range: [contentLength - 16, contentLength - 1],
+        src,
+    });
+    const { value } = await result.reader.reader.read();
+    if (!value) {
+        return null;
+    }
+    result.reader.abort();
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(value, value.length);
+    const size = iterator.getUint32();
+    if (size !== 16) {
+        iterator.destroy();
+        return null;
+    }
+    const atom = iterator.getByteString(4, false);
+    if (atom !== 'mfro') {
+        iterator.destroy();
+        return null;
+    }
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        iterator.destroy();
+        return null;
+    }
+    // flags
+    iterator.discard(3);
+    const parentSize = iterator.getUint32();
+    iterator.destroy();
+    return parentSize;
+};
+exports.getMfroAtom = getMfroAtom;

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

@@ -0,0 +1,2 @@
+import type { IsoBaseMediaBox } from '../base-media-box';
+export declare const parseMfraBox: ({ iterator, size, offset }: IsoBaseMediaBox) => null;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMfraBox = void 0;
+const parseMfraBox = ({ iterator, size, offset }) => {
+    const mfraBox = iterator.readBox();
+    if (mfraBox.type !== 'mfra') {
+        throw new Error('Expected mfra box');
+    }
+    return null;
+};
+exports.parseMfraBox = parseMfraBox;