@remotion/media-parser 4.0.194 → 4.0.195

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

@@ -1,17 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoxes = void 0;
+exports.parseBoxes = exports.processBox = exports.parseMdatPartially = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const traversal_1 = require("../../traversal");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
+const make_track_1 = require("./make-track");
+const mdat_1 = require("./mdat/mdat");
 const mdhd_1 = require("./mdhd");
 const moov_1 = require("./moov/moov");
 const mvhd_1 = require("./mvhd");
+const av1c_1 = require("./stsd/av1c");
+const avcc_1 = require("./stsd/avcc");
+const colr_1 = require("./stsd/colr");
+const ctts_1 = require("./stsd/ctts");
+const hvcc_1 = require("./stsd/hvcc");
 const mebx_1 = require("./stsd/mebx");
+const pasp_1 = require("./stsd/pasp");
+const stco_1 = require("./stsd/stco");
+const stsc_1 = require("./stsd/stsc");
 const stsd_1 = require("./stsd/stsd");
-const stts_1 = require("./stts/stts");
+const stss_1 = require("./stsd/stss");
+const stsz_1 = require("./stsd/stsz");
+const stts_1 = require("./stsd/stts");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
-const getChildren = ({ boxType, iterator, bytesRemainingInBox, }) => {
+const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, }) => {
     const parseChildren = boxType === 'mdia' ||
         boxType === 'minf' ||
         boxType === 'stbl' ||
@@ -19,11 +33,13 @@ const getChildren = ({ boxType, iterator, bytesRemainingInBox, }) => {
         boxType === 'wave' ||
         boxType === 'stsb';
     if (parseChildren) {
-        const parsed = (0, exports.parseBoxes)({
+        const parsed = await (0, exports.parseBoxes)({
             iterator,
             maxBytes: bytesRemainingInBox,
             allowIncompleteBoxes: false,
             initialBoxes: [],
+            options,
+            continueMdat: false,
         });
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
@@ -36,34 +52,79 @@ const getChildren = ({ boxType, iterator, bytesRemainingInBox, }) => {
     iterator.discard(bytesRemainingInBox);
     return [];
 };
-const processBox = ({ iterator, allowIncompleteBoxes, }) => {
+const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, options, }) => {
+    const box = await (0, mdat_1.parseMdat)({
+        data: iterator,
+        size: boxSize,
+        fileOffset,
+        existingBoxes: parsedBoxes,
+        options,
+    });
+    if (box.samplesProcessed &&
+        box.fileOffset + boxSize === iterator.counter.getOffset()) {
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    return {
+        type: 'partial-mdat-box',
+        boxSize,
+        fileOffset,
+    };
+};
+exports.parseMdatPartially = parseMdatPartially;
+const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, }) => {
+    var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getFourByteNumber();
     if (boxSize === 0) {
-        throw new Error(`Expected box size of not 0, got ${boxSize}`);
+        return {
+            type: 'complete',
+            box: {
+                type: 'void-box',
+                boxSize: 0,
+            },
+            size: 4,
+            skipTo: null,
+        };
     }
     if (bytesRemaining < boxSize) {
         if (bytesRemaining >= 4) {
             const type = iterator.getByteString(4);
             iterator.counter.decrement(4);
             if (type === 'mdat') {
-                const skipTo = fileOffset + boxSize;
-                const bytesToSkip = skipTo - iterator.counter.getOffset();
-                // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-                if (bytesToSkip > 1000000) {
-                    return {
-                        type: 'complete',
-                        box: {
-                            type: 'regular-box',
-                            boxType: 'mdat',
-                            children: [],
-                            boxSize,
-                            offset: fileOffset,
-                        },
-                        size: boxSize,
-                        skipTo: fileOffset + boxSize,
-                    };
+                const shouldSkip = options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes);
+                if (shouldSkip) {
+                    const skipTo = fileOffset + boxSize;
+                    const bytesToSkip = skipTo - iterator.counter.getOffset();
+                    // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+                    if (bytesToSkip > 1000000) {
+                        return {
+                            type: 'complete',
+                            box: {
+                                type: 'mdat-box',
+                                boxSize,
+                                fileOffset,
+                                samplesProcessed: false,
+                            },
+                            size: boxSize,
+                            skipTo: fileOffset + boxSize,
+                        };
+                    }
+                }
+                else {
+                    iterator.discard(4);
+                    return (0, exports.parseMdatPartially)({
+                        iterator,
+                        boxSize,
+                        fileOffset,
+                        parsedBoxes,
+                        options,
+                    });
                 }
             }
         }
@@ -85,6 +146,17 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             skipTo: null,
         };
     }
+    if (boxType === 'colr') {
+        const box = (0, colr_1.parseColorParameterBox)({
+            iterator,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
     if (boxType === 'mvhd') {
         const box = (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize });
         return {
@@ -104,7 +176,90 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         };
     }
     if (boxType === 'stsd') {
-        const box = (0, stsd_1.parseStsd)({ iterator, offset: fileOffset, size: boxSize });
+        const box = await (0, stsd_1.parseStsd)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+            options,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'stsz') {
+        const box = (0, stsz_1.parseStsz)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'stco') {
+        const box = (0, stco_1.parseStco)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'pasp') {
+        const box = (0, pasp_1.parsePasp)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'stss') {
+        const box = (0, stss_1.parseStss)({
+            iterator,
+            offset: fileOffset,
+            boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'ctts') {
+        const box = (0, ctts_1.parseCtts)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'stsc') {
+        const box = (0, stsc_1.parseStsc)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
         return {
             type: 'complete',
             box,
@@ -113,7 +268,12 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         };
     }
     if (boxType === 'mebx') {
-        const box = (0, mebx_1.parseMebx)({ iterator, offset: fileOffset, size: boxSize });
+        const box = await (0, mebx_1.parseMebx)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+            options,
+        });
         return {
             type: 'complete',
             box,
@@ -122,7 +282,12 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         };
     }
     if (boxType === 'moov') {
-        const box = (0, moov_1.parseMoov)({ iterator, offset: fileOffset, size: boxSize });
+        const box = await (0, moov_1.parseMoov)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+            options,
+        });
         return {
             type: 'complete',
             box,
@@ -131,11 +296,23 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         };
     }
     if (boxType === 'trak') {
-        const box = (0, trak_1.parseTrak)({
+        const box = await (0, trak_1.parseTrak)({
             data: iterator,
             size: boxSize,
             offsetAtStart: fileOffset,
+            options,
         });
+        const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
+        if (transformedTrack) {
+            if (transformedTrack.type === 'audio') {
+                const callback = await ((_a = options.onAudioTrack) === null || _a === void 0 ? void 0 : _a.call(options, transformedTrack));
+                await options.parserState.registerAudioSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
+            }
+            if (transformedTrack.type === 'video') {
+                const callback = await ((_b = options.onVideoTrack) === null || _b === void 0 ? void 0 : _b.call(options, transformedTrack));
+                await options.parserState.registerVideoSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
+            }
+        }
         return {
             type: 'complete',
             box,
@@ -156,6 +333,43 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             skipTo: null,
         };
     }
+    if (boxType === 'avcC') {
+        const box = (0, avcc_1.parseAvcc)({
+            data: iterator,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'av1C') {
+        const box = (0, av1c_1.parseAv1C)({
+            data: iterator,
+            size: boxSize,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
+    if (boxType === 'hvcC') {
+        const box = (0, hvcc_1.parseHvcc)({
+            data: iterator,
+            size: boxSize,
+            offset: fileOffset,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
     if (boxType === 'mdhd') {
         const box = (0, mdhd_1.parseMdhd)({
             data: iterator,
@@ -182,11 +396,27 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             skipTo: null,
         };
     }
+    if (boxType === 'mdat') {
+        const box = await (0, mdat_1.parseMdat)({
+            data: iterator,
+            size: boxSize,
+            fileOffset,
+            existingBoxes: parsedBoxes,
+            options,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+            skipTo: null,
+        };
+    }
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-    const children = getChildren({
+    const children = await getChildren({
         boxType,
         iterator,
         bytesRemainingInBox,
+        options,
     });
     return {
         type: 'complete',
@@ -201,15 +431,27 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         skipTo: null,
     };
 };
-const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, }) => {
-    const boxes = initialBoxes;
+exports.processBox = processBox;
+const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, }) => {
+    let boxes = initialBoxes;
     const initialOffset = iterator.counter.getOffset();
+    const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
-        const result = processBox({
-            iterator,
-            allowIncompleteBoxes,
-        });
+        const result = continueMdat
+            ? await (0, exports.parseMdatPartially)({
+                iterator,
+                boxSize: continueMdat.boxSize,
+                fileOffset: continueMdat.fileOffset,
+                parsedBoxes: initialBoxes,
+                options,
+            })
+            : await (0, exports.processBox)({
+                iterator,
+                allowIncompleteBoxes,
+                parsedBoxes: initialBoxes,
+                options,
+            });
         if (result.type === 'incomplete') {
             if (Number.isFinite(maxBytes)) {
                 throw new Error('maxBytes must be Infinity for top-level boxes');
@@ -223,12 +465,38 @@ const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, })
                         maxBytes,
                         allowIncompleteBoxes,
                         initialBoxes: boxes,
+                        options,
+                        continueMdat: false,
                     });
                 },
                 skipTo: null,
             };
         }
-        boxes.push(result.box);
+        if (result.type === 'partial-mdat-box') {
+            return {
+                status: 'incomplete',
+                segments: boxes,
+                continueParsing: () => {
+                    return Promise.resolve((0, exports.parseBoxes)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes: boxes,
+                        options,
+                        continueMdat: result,
+                    }));
+                },
+                skipTo: null,
+            };
+        }
+        if (result.box.type === 'mdat-box' && alreadyHasMdat) {
+            boxes = boxes.filter((b) => b.type !== 'mdat-box');
+            boxes.push(result.box);
+            break;
+        }
+        else {
+            boxes.push(result.box);
+        }
         if (result.skipTo !== null) {
             return {
                 status: 'incomplete',
@@ -239,6 +507,8 @@ const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, })
                         maxBytes,
                         allowIncompleteBoxes,
                         initialBoxes: boxes,
+                        options,
+                        continueMdat: false,
                     });
                 },
                 skipTo: result.skipTo,
@@ -246,6 +516,24 @@ const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, })
         }
         iterator.discardFirstBytes();
     }
+    const mdatState = (0, traversal_1.hasSkippedMdatProcessing)(boxes);
+    if (mdatState.skipped && !options.canSkipVideoData) {
+        return {
+            status: 'incomplete',
+            segments: boxes,
+            continueParsing: () => {
+                return (0, exports.parseBoxes)({
+                    iterator,
+                    maxBytes,
+                    allowIncompleteBoxes,
+                    initialBoxes: boxes,
+                    options,
+                    continueMdat: false,
+                });
+            },
+            skipTo: mdatState.fileOffset,
+        };
+    }
     return {
         status: 'done',
         segments: boxes,

package/dist/boxes/iso-base-media/stsd/av1c.d.ts

@@ -0,0 +1,9 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface Av1CBox {
+    type: 'av1C-box';
+    privateData: Uint8Array;
+}
+export declare const parseAv1C: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => Av1CBox;

package/dist/boxes/iso-base-media/stsd/av1c.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1C = void 0;
+const parseAv1C = ({ data, size, }) => {
+    return {
+        type: 'av1C-box',
+        privateData: data.getSlice(size - 8),
+    };
+};
+exports.parseAv1C = parseAv1C;

package/dist/boxes/iso-base-media/stsd/avcc-hvcc.d.ts

@@ -0,0 +1,20 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseAvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => AvccBox;
+export interface HvccBox {
+    type: 'hvcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseHvcc: ({ data, size, offset, }: {
+    data: BufferIterator;
+    size: number;
+    offset: number;
+}) => HvccBox;

package/dist/boxes/iso-base-media/stsd/avcc-hvcc.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = exports.parseAvcc = void 0;
+const parseAvcc = ({ data, size, }) => {
+    const confVersion = data.getUint8();
+    if (confVersion !== 1) {
+        throw new Error(`Unsupported AVCC version ${confVersion}`);
+    }
+    const profile = data.getUint8();
+    const profileCompatibility = data.getUint8();
+    const level = data.getUint8();
+    const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+    data.counter.decrement(4);
+    return {
+        type: 'avcc-box',
+        data: data.getSlice(size - 8),
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;
+const parseHvcc = ({ data, size, offset, }) => {
+    const raw = data.getSlice(size - 8);
+    data.counter.decrement(size - 8);
+    const configurationVersion = data.getUint8();
+    if (configurationVersion !== 1) {
+        throw new Error(`Unsupported HVCC version ${configurationVersion}`);
+    }
+    const generalProfileSpaceTierFlagAndIdc = data.getUint8();
+    let generalProfileCompatibility = data.getUint32();
+    //  unsigned int(2) general_profile_space;
+    // 	unsigned int(1) general_tier_flag;
+    //	unsigned int(5) general_profile_idc;
+    const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
+    const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
+    const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+    // general_constraint_indicator_flags(48)
+    const generalConstraintIndicator = data.getSlice(6);
+    const generalLevelIdc = data.getUint8();
+    let reversedGeneralProfileSpace = 0;
+    for (let i = 0; i < 32; i++) {
+        reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+        if (i === 31)
+            break;
+        reversedGeneralProfileSpace <<= 1;
+        generalProfileCompatibility >>= 1;
+    }
+    const profileSpaceChar = generalProfileSpace === 0
+        ? ''
+        : generalProfileSpace === 1
+            ? 'A'
+            : generalProfileSpace === 2
+                ? 'B'
+                : 'C';
+    const generalTierChar = generalTierFlag === 0 ? 'L' : 'H';
+    let hasByte = false;
+    let generalConstraintString = '';
+    for (let i = 5; i >= 0; i--) {
+        if (generalConstraintIndicator[i] || hasByte) {
+            generalConstraintString =
+                generalConstraintIndicator[i].toString(16) + generalConstraintString;
+            hasByte = true;
+        }
+    }
+    const constraintString = `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+    const remaining = size - (data.counter.getOffset() - offset);
+    data.discard(remaining);
+    return {
+        type: 'hvcc-box',
+        data: raw,
+        configurationString: constraintString,
+    };
+};
+exports.parseHvcc = parseHvcc;

package/dist/boxes/iso-base-media/stsd/avcc.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    description: Uint8Array;
+    configurationString: string;
+}
+export declare const parseAvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => AvccBox;

package/dist/boxes/iso-base-media/stsd/avcc.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAvcc = void 0;
+const parseAvcc = ({ data, size, }) => {
+    const confVersion = data.getUint8();
+    if (confVersion !== 1) {
+        throw new Error(`Unsupported AVCC version ${confVersion}`);
+    }
+    const profile = data.getUint8();
+    const profileCompatibility = data.getUint8();
+    const level = data.getUint8();
+    const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+    data.counter.decrement(4);
+    const description = data.getSlice(size - 8);
+    return {
+        type: 'avcc-box',
+        description,
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;

package/dist/boxes/iso-base-media/stsd/colr.d.ts

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface ColorParameterBox {
+    type: 'colr-box';
+    primaries: number;
+    transfer: number;
+    matrixIndex: number;
+    fullRangeFlag: boolean;
+}
+export declare const parseColorParameterBox: ({ iterator, }: {
+    iterator: BufferIterator;
+}) => ColorParameterBox;

package/dist/boxes/iso-base-media/stsd/colr.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseColorParameterBox = void 0;
+const parseColorParameterBox = ({ iterator, }) => {
+    const byteString = iterator.getByteString(4);
+    if (byteString === 'nclx') {
+        const primaries = iterator.getUint16();
+        const transfer = iterator.getUint16();
+        const matrixIndex = iterator.getUint16();
+        iterator.startReadingBits();
+        const fullRangeFlag = Boolean(iterator.getBits(1));
+        iterator.stopReadingBits();
+        return {
+            type: 'colr-box',
+            fullRangeFlag,
+            matrixIndex,
+            primaries,
+            transfer,
+        };
+    }
+    if (byteString === 'nclc') {
+        const primaries = iterator.getUint16();
+        const transfer = iterator.getUint16();
+        const matrixIndex = iterator.getUint16();
+        return {
+            type: 'colr-box',
+            fullRangeFlag: false,
+            matrixIndex,
+            primaries,
+            transfer,
+        };
+    }
+    throw new Error('Unexpected box type ' + byteString);
+};
+exports.parseColorParameterBox = parseColorParameterBox;