@remotion/media-parser 4.0.251 → 4.0.252

package/dist/containers/iso-base-media/process-box.js

@@ -36,14 +36,12 @@ const processBox = async (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.
@@ -55,200 +53,126 @@ const processBox = async (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)({
+        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)({
+        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)({
             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)({
@@ -264,85 +188,54 @@ const processBox = async (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' ||
@@ -359,26 +252,20 @@ const processBox = async (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/containers/iso-base-media/stsd/samples.js

@@ -31,6 +31,7 @@ const videoTags = [
     'v410',
     'v210',
     'hvc1',
+    'hev1',
     'ap4h',
     'av01',
 ];

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

@@ -1,4 +1,5 @@
 import type { AnySegment } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
 import type { IsoBaseMediaBox, RegularBox } from './base-media-box';
 import type { FtypBox } from './ftyp';
 import type { MdhdBox } from './mdhd';
@@ -17,7 +18,7 @@ import type { TkhdBox } from './tkhd';
 import type { TrakBox } from './trak/trak';
 import type { TrunBox } from './trun';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
-export declare const getMoovBox: (segments: IsoBaseMediaBox[]) => MoovBox | null;
+export declare const getMoovBox: (state: ParserState) => MoovBox | null;
 export declare const getMoofBox: (main: AnySegment[]) => IsoBaseMediaBox | null;
 export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
 export declare const getTraks: (moovBox: MoovBox) => TrakBox[];

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

@@ -9,8 +9,12 @@ const getFtypBox = (segments) => {
     return ftypBox;
 };
 exports.getFtypBox = getFtypBox;
-const getMoovBox = (segments) => {
-    const moovBox = segments.find((s) => s.type === 'moov-box');
+const getMoovBox = (state) => {
+    if (state.iso.moov.getMoovBox()) {
+        return state.iso.moov.getMoovBox();
+    }
+    const structure = state.getIsoStructure();
+    const moovBox = structure.boxes.find((s) => s.type === 'moov-box');
     if (!moovBox || moovBox.type !== 'moov-box') {
         return null;
     }

package/dist/containers/mp3/get-duration.js

@@ -4,9 +4,6 @@ exports.getDurationFromMp3 = void 0;
 const get_frame_length_1 = require("./get-frame-length");
 const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
 const getDurationFromMp3 = (state) => {
-    if (state.contentLength === null) {
-        return null;
-    }
     const mp3Info = state.mp3Info.getMp3Info();
     if (!mp3Info) {
         throw new Error('No mp3 info');

package/dist/containers/mp3/id3.js

@@ -69,7 +69,7 @@ const parseId3 = ({ state }) => {
             });
         }
     }
-    state.structure.getStructure().boxes.push({
+    state.getMp3Structure().boxes.push({
         type: 'id3-header',
         flags,
         size,

package/dist/containers/mp3/parse-mp3.js

@@ -7,9 +7,7 @@ const parse_mpeg_header_1 = require("./parse-mpeg-header");
 const parseMp3 = async (state) => {
     const { iterator } = state;
     if (iterator.bytesRemaining() < 3) {
-        return {
-            skipTo: null,
-        };
+        return null;
     }
     const { returnToCheckpoint } = iterator.startCheckpoint();
     const bytes = iterator.getSlice(3);
@@ -17,24 +15,18 @@ const parseMp3 = async (state) => {
     // ID3 v1
     if (bytes[0] === 0x54 && bytes[1] === 0x41 && bytes[2] === 0x47) {
         (0, id3_v1_1.parseID3V1)(iterator);
-        return {
-            skipTo: null,
-        };
+        return null;
     }
     // ID3 v2 or v3
     if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) {
         (0, id3_1.parseId3)({ state });
-        return {
-            skipTo: null,
-        };
+        return null;
     }
     if (bytes[0] === 0xff) {
         await (0, parse_mpeg_header_1.parseMpegHeader)({
             state,
         });
-        return {
-            skipTo: null,
-        };
+        return null;
     }
     throw new Error('Unknown MP3 header ' + JSON.stringify(bytes));
 };

package/dist/containers/mp3/parse-mpeg-header.js

@@ -243,7 +243,7 @@ const parseMpegHeader = async ({ state, }) => {
                 trakBox: null,
             },
         });
-        state.callbacks.tracks.setIsDone();
+        state.callbacks.tracks.setIsDone(state.logLevel);
     }
     const mp3Info = state.mp3Info.getMp3Info();
     if (!mp3Info) {

package/dist/containers/riff/expect-riff-box.d.ts

@@ -2,6 +2,5 @@ import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
 export type RiffResult = {
     box: RiffBox | null;
-    skipTo: number | null;
 };
-export declare const expectRiffBox: (state: ParserState) => Promise<RiffResult>;
+export declare const expectRiffBox: (state: ParserState) => Promise<RiffBox | null>;

package/dist/containers/riff/expect-riff-box.js

@@ -5,15 +5,11 @@ const register_track_1 = require("../../register-track");
 const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
 const is_movi_1 = require("./is-movi");
 const parse_riff_box_1 = require("./parse-riff-box");
-const parse_video_section_1 = require("./parse-video-section");
 const expectRiffBox = async (state) => {
     const { iterator } = state;
     // Need at least 16 bytes to read LIST,size,movi,size
     if (state.iterator.bytesRemaining() < 16) {
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return null;
     }
     const checkpoint = iterator.startCheckpoint();
     const ckId = iterator.getByteString(4, false);
@@ -24,14 +20,11 @@ const expectRiffBox = async (state) => {
             start: iterator.counter.getOffset(),
             size: ckSize - 4,
         });
-        return (0, parse_video_section_1.parseVideoSection)(state);
+        return null;
     }
     if (iterator.bytesRemaining() < ckSize) {
         checkpoint.returnToCheckpoint();
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return null;
     }
     const box = await (0, parse_riff_box_1.parseRiffBox)({
         id: ckId,
@@ -64,9 +57,6 @@ const expectRiffBox = async (state) => {
         }
         state.riff.incrementNextTrackIndex();
     }
-    return {
-        box,
-        skipTo: null,
-    };
+    return box;
 };
 exports.expectRiffBox = expectRiffBox;

package/dist/containers/riff/get-tracks-from-avi.js

@@ -94,7 +94,7 @@ const getTracksFromAvi = (structure, state) => {
 exports.getTracksFromAvi = getTracksFromAvi;
 const hasAllTracksFromAvi = (state) => {
     try {
-        const structure = state.structure.getStructure();
+        const structure = state.getRiffStructure();
         const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
         const tracks = (0, exports.getTracksFromAvi)(structure, state);
         return (tracks.videoTracks.length +

package/dist/containers/riff/parse-list-box.js

@@ -12,13 +12,11 @@ const parseListBox = async ({ size, state, }) => {
     const boxes = [];
     const maxOffset = counter + size;
     while (iterator.counter.getOffset() < maxOffset) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)(state);
-        if (result.box !== null) {
-            boxes.push(result.box);
-        }
-        else {
+        const box = await (0, expect_riff_box_1.expectRiffBox)(state);
+        if (box === null) {
             throw new Error('Unexpected result');
         }
+        boxes.push(box);
     }
     return {
         type: 'list-box',

package/dist/containers/riff/parse-movi.d.ts

@@ -1,11 +1,9 @@
 import type { ParserState } from '../../state/parser-state';
-import type { RiffResult } from './expect-riff-box';
 export declare const handleChunk: ({ state, ckId, ckSize, }: {
     state: ParserState;
     ckId: string;
     ckSize: number;
 }) => Promise<void>;
-export declare const parseMovi: ({ maxOffset, state, }: {
-    maxOffset: number;
+export declare const parseMovi: ({ state, }: {
     state: ParserState;
-}) => Promise<RiffResult>;
+}) => Promise<void>;

package/dist/containers/riff/parse-movi.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMovi = exports.handleChunk = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const traversal_1 = require("./traversal");
@@ -24,7 +23,7 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
         const trackId = parseInt(videoChunk[1], 10);
-        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
+        const strh = getStrhForIndex(state.getRiffStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -34,9 +33,9 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
         const keyOrDelta = (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(infos);
         const avcProfile = infos.find((i) => i.type === 'avc-profile');
         const ppsProfile = infos.find((i) => i.type === 'avc-pps');
-        if (avcProfile && ppsProfile) {
+        if (avcProfile && ppsProfile && !state.riff.getAvcProfile()) {
             await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
-            state.callbacks.tracks.setIsDone();
+            state.callbacks.tracks.setIsDone(state.logLevel);
         }
         // We must also NOT pass a duration because if the the next sample is 0,
         // this sample would be longer. Chrome will pad it with silence.
@@ -57,7 +56,7 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
     if (audioChunk) {
         const trackId = parseInt(audioChunk[1], 10);
-        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
+        const strh = getStrhForIndex(state.getRiffStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -82,34 +81,21 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
     }
 };
 exports.handleChunk = handleChunk;
-const parseMovi = async ({ maxOffset, state, }) => {
-    if ((0, may_skip_video_data_1.maySkipVideoData)({
-        state,
-    }) &&
-        state.riff.getAvcProfile()) {
-        return {
-            box: null,
-            skipTo: maxOffset,
-        };
-    }
+const parseMovi = async ({ state, }) => {
     const { iterator } = state;
     if (iterator.bytesRemaining() < 8) {
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return Promise.resolve();
     }
     const checkpoint = iterator.startCheckpoint();
     const ckId = iterator.getByteString(4, false);
     const ckSize = iterator.getUint32Le();
     if (iterator.bytesRemaining() < ckSize) {
         checkpoint.returnToCheckpoint();
-        return {
-            box: null,
-            skipTo: null,
-        };
+        return Promise.resolve();
     }
     await (0, exports.handleChunk)({ state, ckId, ckSize });
+    const videoSection = state.videoSection.getVideoSection();
+    const maxOffset = videoSection.start + videoSection.size;
     // Discard added zeroes
     while (iterator.counter.getOffset() < maxOffset &&
         iterator.bytesRemaining() > 0) {
@@ -118,9 +104,5 @@ const parseMovi = async ({ maxOffset, state, }) => {
             break;
         }
     }
-    return {
-        box: null,
-        skipTo: null,
-    };
 };
 exports.parseMovi = parseMovi;