@remotion/media-parser 4.0.290 → 4.0.292

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBox = void 0;
 const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
+const skip_1 = require("../../skip");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const get_children_1 = require("./get-children");
@@ -41,8 +42,11 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
     const boxSizeRaw = iterator.getFourByteNumber();
     if (boxSizeRaw === 0) {
         return {
-            type: 'void-box',
-            boxSize: 0,
+            type: 'box',
+            box: {
+                type: 'void-box',
+                boxSize: 0,
+            },
         };
     }
     // If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
@@ -58,120 +62,177 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
     const headerLength = iterator.counter.getOffset() - startOff;
     if (boxType === 'mdat') {
         if (!onlyIfMdatAtomExpected) {
-            return null;
+            return { type: 'nothing' };
         }
         const { mediaSectionState } = onlyIfMdatAtomExpected;
         mediaSectionState.addMediaSection({
             size: boxSize - headerLength,
             start: iterator.counter.getOffset(),
         });
-        return null;
+        return { type: 'nothing' };
     }
     if (bytesRemaining < boxSize) {
         returnToCheckpoint();
-        return null;
+        return {
+            type: 'fetch-more-data',
+            bytesNeeded: (0, skip_1.makeFetchMoreData)(boxSize - bytesRemaining),
+        };
     }
     if (boxType === 'ftyp') {
-        return (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
+        return {
+            type: 'box',
+            box: await (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset }),
+        };
     }
     if (boxType === 'colr') {
-        return (0, colr_1.parseColorParameterBox)({
-            iterator,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, colr_1.parseColorParameterBox)({
+                iterator,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'mvhd') {
-        return (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize });
+        return {
+            type: 'box',
+            box: await (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize }),
+        };
     }
     if (boxType === 'tkhd') {
-        return (0, tkhd_1.parseTkhd)({ iterator, offset: fileOffset, size: boxSize });
+        return {
+            type: 'box',
+            box: await (0, tkhd_1.parseTkhd)({ iterator, offset: fileOffset, size: boxSize }),
+        };
     }
     if (boxType === 'trun') {
-        return (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize });
+        return {
+            type: 'box',
+            box: await (0, trun_1.parseTrun)({ iterator, offset: fileOffset, size: boxSize }),
+        };
     }
     if (boxType === 'tfdt') {
-        return (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset });
+        return {
+            type: 'box',
+            box: await (0, tfdt_1.parseTfdt)({ iterator, size: boxSize, offset: fileOffset }),
+        };
     }
     if (boxType === 'stsd') {
-        return (0, stsd_1.parseStsd)({
-            offset: fileOffset,
-            size: boxSize,
-            iterator,
-            logLevel,
-            contentLength,
-        });
+        return {
+            type: 'box',
+            box: await (0, stsd_1.parseStsd)({
+                offset: fileOffset,
+                size: boxSize,
+                iterator,
+                logLevel,
+                contentLength,
+            }),
+        };
     }
     if (boxType === 'stsz') {
-        return (0, stsz_1.parseStsz)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, stsz_1.parseStsz)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'stco' || boxType === 'co64') {
-        return (0, stco_1.parseStco)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-            mode64Bit: boxType === 'co64',
-        });
+        return {
+            type: 'box',
+            box: await (0, stco_1.parseStco)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+                mode64Bit: boxType === 'co64',
+            }),
+        };
     }
     if (boxType === 'pasp') {
-        return (0, pasp_1.parsePasp)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, pasp_1.parsePasp)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'stss') {
-        return (0, stss_1.parseStss)({
-            iterator,
-            offset: fileOffset,
-            boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, stss_1.parseStss)({
+                iterator,
+                offset: fileOffset,
+                boxSize,
+            }),
+        };
     }
     if (boxType === 'ctts') {
-        return (0, ctts_1.parseCtts)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, ctts_1.parseCtts)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'stsc') {
-        return (0, stsc_1.parseStsc)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, stsc_1.parseStsc)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'mebx') {
-        return (0, mebx_1.parseMebx)({
-            offset: fileOffset,
-            size: boxSize,
-            iterator,
-            logLevel,
-            contentLength,
-        });
+        return {
+            type: 'box',
+            box: await (0, mebx_1.parseMebx)({
+                offset: fileOffset,
+                size: boxSize,
+                iterator,
+                logLevel,
+                contentLength,
+            }),
+        };
     }
     if (boxType === 'hdlr') {
-        return (0, hdlr_1.parseHdlr)({ iterator, size: boxSize, offset: fileOffset });
+        return {
+            type: 'box',
+            box: await (0, hdlr_1.parseHdlr)({ iterator, size: boxSize, offset: fileOffset }),
+        };
     }
     if (boxType === 'keys') {
-        return (0, keys_1.parseKeys)({ iterator, size: boxSize, offset: fileOffset });
+        return {
+            type: 'box',
+            box: await (0, keys_1.parseKeys)({ iterator, size: boxSize, offset: fileOffset }),
+        };
     }
     if (boxType === 'ilst') {
-        return (0, ilst_1.parseIlstBox)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, ilst_1.parseIlstBox)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'tfra') {
-        return (0, tfra_1.parseTfraBox)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, tfra_1.parseTfraBox)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'moov') {
         if (!onlyIfMoovAtomExpected) {
@@ -180,14 +241,14 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
         const { tracks, isoState } = onlyIfMoovAtomExpected;
         if (tracks.hasAllTracks()) {
             iterator.discard(boxSize - 8);
-            return null;
+            return { type: 'nothing' };
         }
         if (isoState &&
             isoState.moov.getMoovBoxAndPrecomputed() &&
             !((_a = isoState.moov.getMoovBoxAndPrecomputed()) === null || _a === void 0 ? void 0 : _a.precomputed)) {
             log_1.Log.verbose(logLevel, 'Moov box already parsed, skipping');
             iterator.discard(boxSize - 8);
-            return null;
+            return { type: 'nothing' };
         }
         const box = await (0, moov_1.parseMoov)({
             offset: fileOffset,
@@ -198,7 +259,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             contentLength,
         });
         tracks.setIsDone(logLevel);
-        return box;
+        return { type: 'box', box };
     }
     if (boxType === 'trak') {
         if (!onlyIfMoovAtomExpected) {
@@ -233,54 +294,75 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
                 onAudioTrack,
             });
         }
-        return box;
+        return { type: 'box', box };
     }
     if (boxType === 'stts') {
-        return (0, stts_1.parseStts)({
-            data: iterator,
-            size: boxSize,
-            fileOffset,
-        });
+        return {
+            type: 'box',
+            box: await (0, stts_1.parseStts)({
+                data: iterator,
+                size: boxSize,
+                fileOffset,
+            }),
+        };
     }
     if (boxType === 'avcC') {
-        return (0, avcc_1.parseAvcc)({
-            data: iterator,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, avcc_1.parseAvcc)({
+                data: iterator,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'av1C') {
-        return (0, av1c_1.parseAv1C)({
-            data: iterator,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, av1c_1.parseAv1C)({
+                data: iterator,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'hvcC') {
-        return (0, hvcc_1.parseHvcc)({
-            data: iterator,
-            size: boxSize,
-            offset: fileOffset,
-        });
+        return {
+            type: 'box',
+            box: await (0, hvcc_1.parseHvcc)({
+                data: iterator,
+                size: boxSize,
+                offset: fileOffset,
+            }),
+        };
     }
     if (boxType === 'tfhd') {
-        return (0, tfhd_1.getTfhd)({
-            iterator,
-            offset: fileOffset,
-            size: boxSize,
-        });
+        return {
+            type: 'box',
+            box: await (0, tfhd_1.getTfhd)({
+                iterator,
+                offset: fileOffset,
+                size: boxSize,
+            }),
+        };
     }
     if (boxType === 'mdhd') {
-        return (0, mdhd_1.parseMdhd)({
-            data: iterator,
-            size: boxSize,
-            fileOffset,
-        });
+        return {
+            type: 'box',
+            box: await (0, mdhd_1.parseMdhd)({
+                data: iterator,
+                size: boxSize,
+                fileOffset,
+            }),
+        };
     }
     if (boxType === 'esds') {
-        return (0, esds_1.parseEsds)({
-            data: iterator,
-            size: boxSize,
-            fileOffset,
-        });
+        return {
+            type: 'box',
+            box: await (0, esds_1.parseEsds)({
+                data: iterator,
+                size: boxSize,
+                fileOffset,
+            }),
+        };
     }
     if (boxType === 'moof') {
         (_b = onlyIfMoovAtomExpected === null || onlyIfMoovAtomExpected === void 0 ? void 0 : onlyIfMoovAtomExpected.isoState) === null || _b === void 0 ? void 0 : _b.mfra.triggerLoad();
@@ -304,20 +386,26 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             contentLength,
         });
         return {
-            type: 'regular-box',
-            boxType,
-            boxSize,
-            children,
-            offset: fileOffset,
+            type: 'box',
+            box: {
+                type: 'regular-box',
+                boxType,
+                boxSize,
+                children,
+                offset: fileOffset,
+            },
         };
     }
     iterator.discard(boxSize - 8);
     return {
-        type: 'regular-box',
-        boxType,
-        boxSize,
-        children: [],
-        offset: fileOffset,
+        type: 'box',
+        box: {
+            type: 'regular-box',
+            boxType,
+            boxSize,
+            children: [],
+            offset: fileOffset,
+        },
     };
 };
 exports.processBox = processBox;

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

@@ -0,0 +1,25 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { CttsBox } from './stsd/ctts';
+import type { StcoBox } from './stsd/stco';
+import type { StscBox } from './stsd/stsc';
+import type { StssBox } from './stsd/stss';
+import type { StszBox } from './stsd/stsz';
+import type { SttsBox } from './stsd/stts';
+export type GroupOfSamplePositions = {
+    type: 'array';
+    boxes: SamplePosition[];
+} | {
+    type: 'map';
+    boxes: {
+        stszBox: StszBox;
+        stcoBox: StcoBox;
+        stscBox: StscBox;
+        sttsBox: SttsBox;
+        stssBox: StssBox | null;
+        cttsBox: CttsBox | null;
+    };
+};
+export declare const hasNoSamplePositions: (samplePositions: GroupOfSamplePositions) => boolean;
+export declare const hasNoSamplePositionsGroup: (samplePositions: GroupOfSamplePositions[]) => boolean;
+export declare const getKeyframesFromGroupOfSamplePositions: (samplePositions: GroupOfSamplePositions) => SamplePosition[];
+export declare const groupGetKeyframesFromGroupOfSamplePositions: (samplePositions: GroupOfSamplePositions[]) => SamplePosition[];

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupGetKeyframesFromGroupOfSamplePositions = exports.getKeyframesFromGroupOfSamplePositions = exports.hasNoSamplePositionsGroup = exports.hasNoSamplePositions = void 0;
+const turn_sample_positions_into_array_1 = require("./turn-sample-positions-into-array");
+const hasNoSamplePositions = (samplePositions) => {
+    if (samplePositions.type === 'array') {
+        return samplePositions.boxes.length === 0;
+    }
+    return samplePositions.boxes.stcoBox.entryCount === 0;
+};
+exports.hasNoSamplePositions = hasNoSamplePositions;
+const hasNoSamplePositionsGroup = (samplePositions) => {
+    return samplePositions.every((s) => (0, exports.hasNoSamplePositions)(s));
+};
+exports.hasNoSamplePositionsGroup = hasNoSamplePositionsGroup;
+const getKeyframesFromGroupOfSamplePositions = (samplePositions) => {
+    if (samplePositions.type === 'array') {
+        return samplePositions.boxes.filter((s) => s.isKeyframe);
+    }
+    if (!samplePositions.boxes.stssBox) {
+        return (0, turn_sample_positions_into_array_1.turnSamplePositionsIntoArraySlow)({
+            ...samplePositions.boxes,
+            onlyKeyframes: true,
+        });
+    }
+    return (0, turn_sample_positions_into_array_1.turnSamplePositionsIntoArraySlow)({
+        ...samplePositions.boxes,
+        onlyKeyframes: false,
+    });
+};
+exports.getKeyframesFromGroupOfSamplePositions = getKeyframesFromGroupOfSamplePositions;
+const groupGetKeyframesFromGroupOfSamplePositions = (samplePositions) => {
+    return samplePositions
+        .map((s) => (0, exports.getKeyframesFromGroupOfSamplePositions)(s))
+        .flat();
+};
+exports.groupGetKeyframesFromGroupOfSamplePositions = groupGetKeyframesFromGroupOfSamplePositions;

package/dist/containers/iso-base-media/stsd/samples.js

@@ -62,6 +62,7 @@ const audioTags = [
     '.mp3',
     'mp4a',
     'ac-3',
+    'Opus',
 ];
 const processIsoFormatBox = async ({ iterator, logLevel, contentLength, }) => {
     const fileOffset = iterator.counter.getOffset();

package/dist/containers/iso-base-media/stsd/stsc.d.ts

@@ -1,19 +1,14 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
 import type { BaseBox } from '../base-type';
-type StscEntry = {
-    firstChunk: number;
-    samplesPerChunk: number;
-};
 export interface StscBox extends BaseBox {
     type: 'stsc-box';
     version: number;
     flags: number[];
     entryCount: number;
-    entries: StscEntry[];
+    entries: Map<number, number>;
 }
 export declare const parseStsc: ({ iterator, offset, size, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
 }) => StscBox;
-export {};

package/dist/containers/iso-base-media/stsd/stsc.js

@@ -8,7 +8,7 @@ const parseStsc = ({ iterator, offset, size, }) => {
     }
     const flags = iterator.getSlice(3);
     const entryCount = iterator.getUint32();
-    const entries = [];
+    const entries = new Map();
     for (let i = 0; i < entryCount; i++) {
         const firstChunk = iterator.getUint32();
         const samplesPerChunk = iterator.getUint32();
@@ -16,10 +16,7 @@ const parseStsc = ({ iterator, offset, size, }) => {
         if (sampleDescriptionIndex !== 1) {
             throw new Error(`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`);
         }
-        entries.push({
-            firstChunk,
-            samplesPerChunk,
-        });
+        entries.set(firstChunk, samplesPerChunk);
     }
     return {
         type: 'stsc-box',

package/dist/containers/iso-base-media/stsd/stss.d.ts

@@ -4,7 +4,7 @@ export interface StssBox extends BaseBox {
     type: 'stss-box';
     version: number;
     flags: number[];
-    sampleNumber: number[];
+    sampleNumber: Set<number>;
 }
 export declare const parseStss: ({ iterator, offset, boxSize, }: {
     iterator: BufferIterator;

package/dist/containers/iso-base-media/stsd/stss.js

@@ -8,9 +8,9 @@ const parseStss = ({ iterator, offset, boxSize, }) => {
     }
     const flags = iterator.getSlice(3);
     const sampleCount = iterator.getUint32();
-    const sampleNumber = [];
+    const sampleNumber = new Set();
     for (let i = 0; i < sampleCount; i++) {
-        sampleNumber.push(iterator.getUint32());
+        sampleNumber.add(iterator.getUint32());
     }
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - offset);
     if (bytesRemainingInBox > 0) {

package/dist/containers/iso-base-media/turn-sample-positions-into-array.d.ts

@@ -0,0 +1,19 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { GroupOfSamplePositions } from './sample-positions';
+import type { CttsBox } from './stsd/ctts';
+import type { StcoBox } from './stsd/stco';
+import type { StscBox } from './stsd/stsc';
+import type { StssBox } from './stsd/stss';
+import type { StszBox } from './stsd/stsz';
+import type { SttsBox } from './stsd/stts';
+export declare const turnSamplePositionsIntoArraySlow: ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, onlyKeyframes, }: {
+    stcoBox: StcoBox;
+    stszBox: StszBox;
+    stscBox: StscBox;
+    stssBox: StssBox | null;
+    sttsBox: SttsBox;
+    cttsBox: CttsBox | null;
+    onlyKeyframes: boolean;
+}) => SamplePosition[];
+export declare const turnIntoOld: (samplePositions: GroupOfSamplePositions) => SamplePosition[];
+export declare const turnGroupIntoOld: (samplePositions: GroupOfSamplePositions[]) => SamplePosition[];

package/dist/containers/iso-base-media/turn-sample-positions-into-array.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turnGroupIntoOld = exports.turnIntoOld = exports.turnSamplePositionsIntoArraySlow = void 0;
+const turnSamplePositionsIntoArraySlow = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, onlyKeyframes, }) => {
+    var _a;
+    const sttsDeltas = [];
+    for (const distribution of sttsBox.sampleDistribution) {
+        for (let i = 0; i < distribution.sampleCount; i++) {
+            sttsDeltas.push(distribution.sampleDelta);
+        }
+    }
+    const cttsEntries = [];
+    for (const entry of (_a = cttsBox === null || cttsBox === void 0 ? void 0 : cttsBox.entries) !== null && _a !== void 0 ? _a : [
+        { sampleCount: sttsDeltas.length, sampleOffset: 0 },
+    ]) {
+        for (let i = 0; i < entry.sampleCount; i++) {
+            cttsEntries.push(entry.sampleOffset);
+        }
+    }
+    let dts = 0;
+    const samples = [];
+    let samplesPerChunk = 1;
+    for (let i = 0; i < stcoBox.entries.length; i++) {
+        const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+        if (hasEntry) {
+            samplesPerChunk = hasEntry.samplesPerChunk;
+        }
+        let offsetInThisChunk = 0;
+        for (let j = 0; j < samplesPerChunk; j++) {
+            const isKeyframe = stssBox
+                ? stssBox.sampleNumber.includes(samples.length + 1)
+                : true;
+            if (onlyKeyframes && !isKeyframe) {
+                continue;
+            }
+            const size = stszBox.countType === 'fixed'
+                ? stszBox.sampleSize
+                : stszBox.entries[samples.length];
+            const delta = sttsDeltas[samples.length];
+            const ctsOffset = cttsEntries[samples.length];
+            const cts = dts + ctsOffset;
+            samples.push({
+                offset: Number(stcoBox.entries[i]) + offsetInThisChunk,
+                size,
+                isKeyframe,
+                dts,
+                cts,
+                duration: delta,
+                chunk: i,
+                bigEndian: false,
+                chunkSize: null,
+            });
+            dts += delta;
+            offsetInThisChunk += size;
+        }
+    }
+    return samples;
+};
+exports.turnSamplePositionsIntoArraySlow = turnSamplePositionsIntoArraySlow;
+const turnIntoOld = (samplePositions) => {
+    if (samplePositions.type === 'map') {
+        return (0, exports.turnSamplePositionsIntoArraySlow)({
+            ...samplePositions.boxes,
+            onlyKeyframes: false,
+        });
+    }
+    return samplePositions.boxes;
+};
+exports.turnIntoOld = turnIntoOld;
+const turnGroupIntoOld = (samplePositions) => {
+    return samplePositions.map((s) => (0, exports.turnIntoOld)(s)).flat();
+};
+exports.turnGroupIntoOld = turnGroupIntoOld;