@remotion/media-parser 4.0.250 → 4.0.252

package/dist/{boxes → containers}/iso-base-media/mdat/mdat.js

@@ -3,27 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdatSection = void 0;
 const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video-sample");
 const get_tracks_1 = require("../../../get-tracks");
-const may_skip_video_data_1 = require("../../../may-skip-video-data/may-skip-video-data");
+const skip_1 = require("../../../skip");
 const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
-const parseMdatSection = async ({ iterator, state, }) => {
+const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
+const get_moov_atom_1 = require("../get-moov-atom");
+const parseMdatSection = async (state) => {
     const videoSection = state.videoSection.getVideoSection();
+    const endOfMdat = videoSection.size + videoSection.start;
     // don't need mdat at all, can skip
     if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
-        return videoSection.size + videoSection.start;
+        return (0, skip_1.makeSkip)(endOfMdat);
     }
-    const alreadyHas = (0, get_tracks_1.getHasTracks)(state.structure.getStructure(), state);
+    const alreadyHas = (0, get_tracks_1.getHasTracks)(state);
     if (!alreadyHas) {
-        // Will first read the end and then return
-        if (state.supportsContentRange) {
-            state.iso.setShouldReturnToVideoSectionAfterEnd(true);
-            return videoSection.size + videoSection.start;
-        }
-        throw new Error('Source does not support reading partially, but metadata is at the end of the file. This would require buffering the entire file in memory, leading to a leak. Remotion does not currently support this scenario, make sure to pass a source that supports Content-Range.');
+        const moov = await (0, get_moov_atom_1.getMoovAtom)({
+            endOfMdat,
+            state,
+        });
+        state.iso.moov.setMoovBox(moov);
+        state.callbacks.tracks.setIsDone(state.logLevel);
+        state.getIsoStructure().boxes.push(moov);
+        return (0, exports.parseMdatSection)(state);
     }
     if (!state.iso.flatSamples.getSamples()) {
         state.iso.flatSamples.setSamples((0, cached_sample_positions_1.calculateFlatSamples)(state));
     }
     const flatSamples = state.iso.flatSamples.getSamples();
+    const { iterator } = state;
     const samplesWithIndex = flatSamples.find((sample) => {
         return sample.samplePosition.offset === iterator.counter.getOffset();
     });
@@ -40,7 +46,7 @@ const parseMdatSection = async ({ iterator, state, }) => {
         }
         // guess we reached the end!
         // iphonevideo.mov has extra padding here, so let's make sure to jump ahead
-        return videoSection.size + videoSection.start;
+        return (0, skip_1.makeSkip)(endOfMdat);
     }
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
         return null;
@@ -85,7 +91,6 @@ const parseMdatSection = async ({ iterator, state, }) => {
             timescale: samplesWithIndex.track.timescale,
         }, samplesWithIndex.track.timescale));
     }
-    iterator.removeBytesRead();
     return null;
 };
 exports.parseMdatSection = parseMdatSection;

package/dist/{boxes → containers}/iso-base-media/moov/moov.d.ts

@@ -1,4 +1,3 @@
-import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
@@ -6,8 +5,7 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, state, }: {
-    iterator: BufferIterator;
+export declare const parseMoov: ({ offset, size, state, }: {
     offset: number;
     size: number;
     state: ParserState;

package/dist/{boxes → containers}/iso-base-media/moov/moov.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const get_children_1 = require("../get-children");
-const parseMoov = async ({ iterator, offset, size, state, }) => {
+const parseMoov = async ({ offset, size, state, }) => {
     const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-        iterator,
         state,
         size: size - 8,
     });

package/dist/containers/iso-base-media/parse-boxes.d.ts

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseIsoBaseMedia: (state: ParserState) => Promise<ParseResult>;

package/dist/containers/iso-base-media/parse-boxes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsoBaseMedia = void 0;
+const mdat_1 = require("./mdat/mdat");
+const process_box_1 = require("./process-box");
+const parseIsoBaseMedia = async (state) => {
+    const videoSectionState = state.videoSection.isInVideoSectionState(state.iterator);
+    if (videoSectionState === 'in-section') {
+        const skipTo = await (0, mdat_1.parseMdatSection)(state);
+        return skipTo;
+    }
+    const result = await (0, process_box_1.processBox)(state);
+    if (result) {
+        state.getIsoStructure().boxes.push(result);
+    }
+    return null;
+};
+exports.parseIsoBaseMedia = parseIsoBaseMedia;

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

@@ -0,0 +1,3 @@
+import type { ParserState } from '../../state/parser-state';
+import type { BoxAndNext } from './base-media-box';
+export declare const processBox: (state: ParserState) => Promise<BoxAndNext>;

package/dist/{boxes → containers}/iso-base-media/process-box.js

@@ -31,18 +31,17 @@ const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
 const trun_1 = require("./trun");
-const processBox = async ({ iterator, state, }) => {
+const processBox = async (state) => {
+    const { iterator } = state;
     const fileOffset = iterator.counter.getOffset();
     const { returnToCheckpoint } = iterator.startCheckpoint();
     const bytesRemaining = iterator.bytesRemaining();
+    const startOff = iterator.counter.getOffset();
     const boxSizeRaw = iterator.getFourByteNumber();
     if (boxSizeRaw === 0) {
         return {
-            box: {
-                type: 'void-box',
-                boxSize: 0,
-            },
-            skipTo: null,
+            type: 'void-box',
+            boxSize: 0,
         };
     }
     // If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
@@ -54,207 +53,129 @@ const processBox = async ({ iterator, state, }) => {
     const boxType = iterator.getByteString(4, false);
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
     log_1.Log.trace(state.logLevel, 'Found box', boxType, boxSize);
+    const headerLength = iterator.counter.getOffset() - startOff;
     if (boxType === 'mdat') {
         state.videoSection.setVideoSection({
-            size: boxSize - 8,
+            size: boxSize - headerLength,
             start: iterator.counter.getOffset(),
         });
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return null;
     }
     if (bytesRemaining < boxSize) {
         returnToCheckpoint();
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return null;
     }
     if (boxType === 'ftyp') {
-        const box = (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
     }
     if (boxType === 'colr') {
-        const box = (0, colr_1.parseColorParameterBox)({
+        return (0, colr_1.parseColorParameterBox)({
             iterator,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'mvhd') {
-        const box = (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize });
     }
     if (boxType === 'tkhd') {
-        const box = (0, tkhd_1.parseTkhd)({ iterator, offset: fileOffset, size: boxSize });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, tkhd_1.parseTkhd)({ iterator, offset: fileOffset, size: boxSize });
     }
     if (boxType === 'trun') {
-        const box = (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize });
     }
     if (boxType === 'tfdt') {
-        const box = (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset });
     }
     if (boxType === 'stsd') {
-        const box = await (0, stsd_1.parseStsd)({
-            iterator,
+        return (0, stsd_1.parseStsd)({
             offset: fileOffset,
             size: boxSize,
             state,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'stsz') {
-        const box = (0, stsz_1.parseStsz)({
+        return (0, stsz_1.parseStsz)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'stco' || boxType === 'co64') {
-        const box = (0, stco_1.parseStco)({
+        return (0, stco_1.parseStco)({
             iterator,
             offset: fileOffset,
             size: boxSize,
             mode64Bit: boxType === 'co64',
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'pasp') {
-        const box = (0, pasp_1.parsePasp)({
+        return (0, pasp_1.parsePasp)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'stss') {
-        const box = (0, stss_1.parseStss)({
+        return (0, stss_1.parseStss)({
             iterator,
             offset: fileOffset,
             boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'ctts') {
-        const box = (0, ctts_1.parseCtts)({
+        return (0, ctts_1.parseCtts)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'stsc') {
-        const box = (0, stsc_1.parseStsc)({
+        return (0, stsc_1.parseStsc)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'mebx') {
-        const box = await (0, mebx_1.parseMebx)({
-            iterator,
+        return (0, mebx_1.parseMebx)({
             offset: fileOffset,
             size: boxSize,
             state,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'hdlr') {
-        const box = await (0, hdlr_1.parseHdlr)({ iterator, size: boxSize, offset: fileOffset });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, hdlr_1.parseHdlr)({ iterator, size: boxSize, offset: fileOffset });
     }
     if (boxType === 'keys') {
-        const box = (0, keys_1.parseKeys)({ iterator, size: boxSize, offset: fileOffset });
-        return {
-            box,
-            skipTo: null,
-        };
+        return (0, keys_1.parseKeys)({ iterator, size: boxSize, offset: fileOffset });
     }
     if (boxType === 'ilst') {
-        const box = (0, ilst_1.parseIlstBox)({
+        return (0, ilst_1.parseIlstBox)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'moov') {
         if (state.callbacks.tracks.hasAllTracks()) {
             iterator.discard(boxSize - 8);
-            return {
-                box: null,
-                skipTo: null,
-            };
+            return null;
+        }
+        if (state.iso.moov.getMoovBox()) {
+            log_1.Log.verbose(state.logLevel, 'Moov box already parsed, skipping');
+            iterator.discard(boxSize - 8);
+            return null;
         }
         const box = await (0, moov_1.parseMoov)({
-            iterator,
             offset: fileOffset,
             size: boxSize,
             state,
         });
-        state.callbacks.tracks.setIsDone();
-        return {
-            box,
-            skipTo: null,
-        };
+        state.callbacks.tracks.setIsDone(state.logLevel);
+        return box;
     }
     if (boxType === 'trak') {
         const box = await (0, trak_1.parseTrak)({
-            data: iterator,
             size: boxSize,
             offsetAtStart: fileOffset,
             state,
@@ -267,85 +188,54 @@ const processBox = async ({ iterator, state, }) => {
                 container: 'mp4',
             });
         }
-        return {
-            box,
-            skipTo: null,
-        };
+        return box;
     }
     if (boxType === 'stts') {
-        const box = (0, stts_1.parseStts)({
+        return (0, stts_1.parseStts)({
             data: iterator,
             size: boxSize,
             fileOffset,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'avcC') {
-        const box = (0, avcc_1.parseAvcc)({
+        return (0, avcc_1.parseAvcc)({
             data: iterator,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'av1C') {
-        const box = (0, av1c_1.parseAv1C)({
+        return (0, av1c_1.parseAv1C)({
             data: iterator,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'hvcC') {
-        const box = (0, hvcc_1.parseHvcc)({
+        return (0, hvcc_1.parseHvcc)({
             data: iterator,
             size: boxSize,
             offset: fileOffset,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'tfhd') {
-        const box = (0, tfhd_1.getTfhd)({
+        return (0, tfhd_1.getTfhd)({
             iterator,
             offset: fileOffset,
             size: boxSize,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'mdhd') {
-        const box = (0, mdhd_1.parseMdhd)({
+        return (0, mdhd_1.parseMdhd)({
             data: iterator,
             size: boxSize,
             fileOffset,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'esds') {
-        const box = (0, esds_1.parseEsds)({
+        return (0, esds_1.parseEsds)({
             data: iterator,
             size: boxSize,
             fileOffset,
         });
-        return {
-            box,
-            skipTo: null,
-        };
     }
     if (boxType === 'mdia' ||
         boxType === 'minf' ||
@@ -358,31 +248,24 @@ const processBox = async ({ iterator, state, }) => {
         boxType === 'traf' ||
         boxType === 'stsb') {
         const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-            iterator,
             state,
             size: boxSize - 8,
         });
         return {
-            box: {
-                type: 'regular-box',
-                boxType,
-                boxSize,
-                children,
-                offset: fileOffset,
-            },
-            skipTo: null,
-        };
-    }
-    iterator.discard(boxSize - 8);
-    return {
-        box: {
             type: 'regular-box',
             boxType,
             boxSize,
-            children: [],
+            children,
             offset: fileOffset,
-        },
-        skipTo: null,
+        };
+    }
+    iterator.discard(boxSize - 8);
+    return {
+        type: 'regular-box',
+        boxType,
+        boxSize,
+        children: [],
+        offset: fileOffset,
     };
 };
 exports.processBox = processBox;

package/dist/{boxes → containers}/iso-base-media/stsd/mebx.d.ts

@@ -1,4 +1,3 @@
-import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
@@ -8,8 +7,7 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, state, }: {
-    iterator: BufferIterator;
+export declare const parseMebx: ({ offset, size, state, }: {
     offset: number;
     size: number;
     state: ParserState;

package/dist/{boxes → containers}/iso-base-media/stsd/mebx.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const get_children_1 = require("../get-children");
-const parseMebx = async ({ iterator, offset, size, state, }) => {
+const parseMebx = async ({ offset, size, state, }) => {
     // reserved, 6 bit
-    iterator.discard(6);
-    const dataReferenceIndex = iterator.getUint16();
+    state.iterator.discard(6);
+    const dataReferenceIndex = state.iterator.getUint16();
     const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-        iterator,
         state,
         size: size - 8,
     });

package/dist/{boxes → containers}/iso-base-media/stsd/samples.d.ts

@@ -1,6 +1,6 @@
-import type { BufferIterator } from '../../../buffer-iterator';
-import type { AnySegment, IsoBaseMediaBox } from '../../../parse-result';
+import type { AnySegment } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
+import type { IsoBaseMediaBox } from '../base-media-box';
 type SampleBase = {
     format: string;
     offset: number;
@@ -48,12 +48,10 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type FormatBoxAndNext = {
     sample: Sample | null;
 };
-export declare const processIsoFormatBox: ({ iterator, state, }: {
-    iterator: BufferIterator;
+export declare const processIsoFormatBox: ({ state, }: {
     state: ParserState;
 }) => Promise<FormatBoxAndNext>;
-export declare const parseIsoFormatBoxes: ({ iterator, maxBytes, state, }: {
-    iterator: BufferIterator;
+export declare const parseIsoFormatBoxes: ({ maxBytes, state, }: {
     maxBytes: number;
     state: ParserState;
 }) => Promise<Sample[]>;

package/dist/{boxes → containers}/iso-base-media/stsd/samples.js

@@ -31,6 +31,7 @@ const videoTags = [
     'v410',
     'v210',
     'hvc1',
+    'hev1',
     'ap4h',
     'av01',
 ];
@@ -62,7 +63,8 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processIsoFormatBox = async ({ iterator, state, }) => {
+const processIsoFormatBox = async ({ state, }) => {
+    const { iterator } = state;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -99,7 +101,6 @@ const processIsoFormatBox = async ({ iterator, state, }) => {
             const packetSize = iterator.getUint16();
             const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-                iterator,
                 state,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
             });
@@ -137,7 +138,6 @@ const processIsoFormatBox = async ({ iterator, state, }) => {
             const bytesPerFrame = iterator.getUint32();
             const bytesPerSample = iterator.getUint32();
             const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-                iterator,
                 state,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
             });
@@ -179,7 +179,6 @@ const processIsoFormatBox = async ({ iterator, state, }) => {
             const bytesPerFrame = iterator.getUint32();
             const samplesPerPacket = iterator.getUint32();
             const children = await (0, get_children_1.getIsoBaseMediaChildren)({
-                iterator,
                 state,
                 size: boxSize - (iterator.counter.getOffset() - fileOffset),
             });
@@ -226,7 +225,6 @@ const processIsoFormatBox = async ({ iterator, state, }) => {
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
         const children = bytesRemainingInBox > 8
             ? await (0, get_children_1.getIsoBaseMediaChildren)({
-                iterator,
                 state,
                 size: bytesRemainingInBox,
             })
@@ -259,13 +257,13 @@ const processIsoFormatBox = async ({ iterator, state, }) => {
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processIsoFormatBox = processIsoFormatBox;
-const parseIsoFormatBoxes = async ({ iterator, maxBytes, state, }) => {
+const parseIsoFormatBoxes = async ({ maxBytes, state, }) => {
+    const { iterator } = state;
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const { sample } = await (0, exports.processIsoFormatBox)({
-            iterator,
             state,
         });
         if (sample) {

package/dist/{boxes → containers}/iso-base-media/stsd/stsd.d.ts

@@ -1,4 +1,3 @@
-import type { BufferIterator } from '../../../buffer-iterator';
 import type { ParserState } from '../../../state/parser-state';
 import type { BaseBox } from '../base-type';
 import type { Sample } from './samples';
@@ -7,8 +6,7 @@ export interface StsdBox extends BaseBox {
     numberOfEntries: number;
     samples: Sample[];
 }
-export declare const parseStsd: ({ iterator, offset, size, state, }: {
-    iterator: BufferIterator;
+export declare const parseStsd: ({ offset, size, state, }: {
     offset: number;
     size: number;
     state: ParserState;

package/dist/{boxes → containers}/iso-base-media/stsd/stsd.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStsd = void 0;
 const samples_1 = require("./samples");
-const parseStsd = async ({ iterator, offset, size, state, }) => {
+const parseStsd = async ({ offset, size, state, }) => {
+    const { iterator } = state;
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -12,7 +13,6 @@ const parseStsd = async ({ iterator, offset, size, state, }) => {
     const numberOfEntries = iterator.getUint32();
     const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
     const boxes = await (0, samples_1.parseIsoFormatBoxes)({
-        iterator,
         maxBytes: bytesRemainingInBox,
         state,
     });