@remotion/media-parser 4.0.193 → 4.0.195

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;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type CttsEntry = {
+    sampleCount: number;
+    sampleOffset: number;
+};
+export interface CttsBox extends BaseBox {
+    type: 'ctts-box';
+    version: number;
+    flags: number[];
+    entryCount: number;
+    entries: CttsEntry[];
+}
+export declare const parseCtts: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => CttsBox;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCtts = void 0;
+const parseCtts = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported CTTS version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const sampleCount = iterator.getUint32();
+        const sampleOffset = iterator.getUint32();
+        entries.push({
+            sampleCount,
+            sampleOffset,
+        });
+    }
+    return {
+        type: 'ctts-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entryCount,
+        entries,
+    };
+};
+exports.parseCtts = parseCtts;

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

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+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/hvcc.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = void 0;
+const make_hvc1_codec_strings_1 = require("../../../make-hvc1-codec-strings");
+const parseHvcc = ({ data, size, offset, }) => {
+    const raw = data.getSlice(size - 8);
+    data.counter.decrement(size - 8);
+    const constraintString = (0, make_hvc1_codec_strings_1.getHvc1CodecString)(data);
+    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/keys.js

@@ -12,6 +12,7 @@ const parseKeys = (data, offset) => {
     if (atom !== 'keys') {
         throw new Error(`Expected keys type of keys, got ${atom}`);
     }
+    iterator.destroy();
     return {
         type: 'keys-box',
         boxSize: data.byteLength,

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

@@ -1,5 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 export interface MebxBox extends BaseBox {
     type: 'mebx-box';
@@ -7,8 +8,9 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-}) => MebxBox;
+    options: ParserContext;
+}) => Promise<MebxBox>;

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

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = ({ iterator, offset, size, }) => {
+const parseMebx = async ({ iterator, offset, size, options, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
-    const children = (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
         initialBoxes: [],
+        options,
+        continueMdat: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface PaspBox extends BaseBox {
+    type: 'pasp-box';
+    hSpacing: number;
+    vSpacing: number;
+}
+export declare const parsePasp: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => PaspBox;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePasp = void 0;
+const parsePasp = ({ iterator, offset, size, }) => {
+    const hSpacing = iterator.getUint32();
+    const vSpacing = iterator.getUint32();
+    const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
+    iterator.discard(bytesRemainingInBox);
+    return {
+        type: 'pasp-box',
+        boxSize: size,
+        offset,
+        hSpacing,
+        vSpacing,
+    };
+};
+exports.parsePasp = parsePasp;

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

@@ -1,5 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
     format: string;
     offset: number;
@@ -9,7 +10,7 @@ type SampleBase = {
     vendor: number[];
     size: number;
 };
-type AudioSample = SampleBase & {
+export type AudioSample = SampleBase & {
     type: 'audio';
     numberOfChannels: number;
     sampleSize: number;
@@ -22,7 +23,7 @@ type AudioSample = SampleBase & {
     bitsPerSample: number | null;
     children: AnySegment[];
 };
-type VideoSample = SampleBase & {
+export type VideoSample = SampleBase & {
     type: 'video';
     temporalQuality: number;
     spacialQuality: number;
@@ -35,6 +36,7 @@ type VideoSample = SampleBase & {
     frameCountPerSample: number;
     depth: number;
     colorTableId: number;
+    descriptors: AnySegment[];
 };
 type UnknownSample = SampleBase & {
     type: 'unknown';
@@ -43,8 +45,13 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type SampleAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, }: {
+export declare const processSample: ({ iterator, options, }: {
     iterator: BufferIterator;
-}) => SampleAndNext;
-export declare const parseSamples: (iterator: BufferIterator, maxBytes: number) => Sample[];
+    options: ParserContext;
+}) => Promise<SampleAndNext>;
+export declare const parseSamples: ({ iterator, maxBytes, options, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    options: ParserContext;
+}) => Promise<Sample[]>;
 export {};

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

@@ -32,6 +32,7 @@ const videoTags = [
     'v210',
     'hvc1',
     'ap4h',
+    'av01',
 ];
 // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
 const audioTags = [
@@ -60,7 +61,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processSample = ({ iterator, }) => {
+const processSample = async ({ iterator, options, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -98,13 +99,15 @@ const processSample = ({ iterator, }) => {
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getUint16();
             const packetSize = iterator.getUint16();
-            const sampleRate = iterator.getFixedPoint1616Number();
+            const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes: [],
+                options,
+                continueMdat: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -137,17 +140,19 @@ const processSample = ({ iterator, }) => {
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getInt16();
             const packetSize = iterator.getUint16();
-            const sampleRate = iterator.getFixedPoint1616Number();
+            const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const samplesPerPacket = iterator.getUint32();
             const bytesPerPacket = iterator.getUint32();
             const bytesPerFrame = iterator.getUint32();
             const bytesPerSample = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes: [],
+                options,
+                continueMdat: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -182,15 +187,25 @@ const processSample = ({ iterator, }) => {
         const spacialQuality = iterator.getUint32();
         const width = iterator.getUint16();
         const height = iterator.getUint16();
-        const horizontalResolution = iterator.getFixedPoint1616Number();
-        const verticalResolution = iterator.getFixedPoint1616Number();
+        const horizontalResolution = iterator.getFixedPointUnsigned1616Number();
+        const verticalResolution = iterator.getFixedPointUnsigned1616Number();
         const dataSize = iterator.getUint32();
         const frameCountPerSample = iterator.getUint16();
         const compressorName = iterator.getPascalString();
         const depth = iterator.getUint16();
         const colorTableId = iterator.getInt16();
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-        iterator.discard(bytesRemainingInBox);
+        const children = await (0, process_box_1.parseBoxes)({
+            iterator,
+            allowIncompleteBoxes: false,
+            maxBytes: bytesRemainingInBox,
+            initialBoxes: [],
+            options,
+            continueMdat: false,
+        });
+        if (children.status === 'incomplete') {
+            throw new Error('Incomplete boxes are not allowed');
+        }
         return {
             sample: {
                 format: boxFormat,
@@ -212,19 +227,21 @@ const processSample = ({ iterator, }) => {
                 compressorName,
                 depth,
                 colorTableId,
+                descriptors: children.segments,
             },
         };
     }
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processSample = processSample;
-const parseSamples = (iterator, maxBytes) => {
+const parseSamples = async ({ iterator, maxBytes, options, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
-        const { sample } = (0, exports.processSample)({
+        const { sample } = await (0, exports.processSample)({
             iterator,
+            options,
         });
         if (sample) {
             samples.push(sample);

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

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface StcoBox extends BaseBox {
+    type: 'stco-box';
+    version: number;
+    flags: number[];
+    entryCount: number;
+    entries: number[];
+}
+export declare const parseStco: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StcoBox;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStco = void 0;
+const parseStco = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+        if (bytesRemaining < 4) {
+            break;
+        }
+        entries.push(iterator.getUint32());
+    }
+    iterator.discard(size - (iterator.counter.getOffset() - offset));
+    return {
+        type: 'stco-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entries,
+        entryCount,
+    };
+};
+exports.parseStco = parseStco;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../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[];
+}
+export declare const parseStsc: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StscBox;
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsc = void 0;
+const parseStsc = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const firstChunk = iterator.getUint32();
+        const samplesPerChunk = iterator.getUint32();
+        const sampleDescriptionIndex = iterator.getUint32();
+        if (sampleDescriptionIndex !== 1) {
+            throw new Error(`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`);
+        }
+        entries.push({
+            firstChunk,
+            samplesPerChunk,
+        });
+    }
+    return {
+        type: 'stsc-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entryCount,
+        entries,
+    };
+};
+exports.parseStsc = parseStsc;

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

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 import type { Sample } from './samples';
 export interface StsdBox extends BaseBox {
@@ -6,8 +7,9 @@ export interface StsdBox extends BaseBox {
     numberOfEntries: number;
     samples: Sample[];
 }
-export declare const parseStsd: ({ iterator, offset, size, }: {
+export declare const parseStsd: ({ iterator, offset, size, options, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-}) => StsdBox;
+    options: ParserContext;
+}) => Promise<StsdBox>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStsd = void 0;
 const samples_1 = require("./samples");
-const parseStsd = ({ iterator, offset, size, }) => {
+const parseStsd = async ({ iterator, offset, size, options, }) => {
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -11,7 +11,11 @@ const parseStsd = ({ iterator, offset, size, }) => {
     iterator.discard(3);
     const numberOfEntries = iterator.getUint32();
     const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
-    const boxes = (0, samples_1.parseSamples)(iterator, bytesRemainingInBox);
+    const boxes = await (0, samples_1.parseSamples)({
+        iterator,
+        maxBytes: bytesRemainingInBox,
+        options,
+    });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
     }

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface StssBox extends BaseBox {
+    type: 'stss-box';
+    version: number;
+    flags: number[];
+    sampleNumber: number[];
+}
+export declare const parseStss: ({ iterator, offset, boxSize, }: {
+    iterator: BufferIterator;
+    offset: number;
+    boxSize: number;
+}) => StssBox;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStss = void 0;
+const parseStss = ({ iterator, offset, boxSize, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSS version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const sampleCount = iterator.getUint32();
+    const sampleNumber = [];
+    for (let i = 0; i < sampleCount; i++) {
+        sampleNumber.push(iterator.getUint32());
+    }
+    const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - offset);
+    if (bytesRemainingInBox > 0) {
+        throw new Error(`Unexpected bytes remaining in box stss`);
+    }
+    return {
+        type: 'stss-box',
+        version,
+        flags: [...flags],
+        sampleNumber,
+        boxSize,
+        offset,
+    };
+};
+exports.parseStss = parseStss;

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

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type Discriminated = {
+    countType: 'fixed';
+    sampleSize: number;
+} | {
+    countType: 'variable';
+    entries: number[];
+};
+export type StszBox = BaseBox & {
+    type: 'stsz-box';
+    version: number;
+    flags: number[];
+    sampleCount: number;
+} & Discriminated;
+export declare const parseStsz: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StszBox;
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsz = void 0;
+const parseStsz = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const sampleSize = iterator.getUint32();
+    const sampleCount = iterator.getUint32();
+    if (sampleSize !== 0) {
+        return {
+            type: 'stsz-box',
+            boxSize: size,
+            offset,
+            version,
+            flags: [...flags],
+            sampleCount,
+            countType: 'fixed',
+            sampleSize,
+        };
+    }
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+        if (bytesRemaining < 4) {
+            break;
+        }
+        samples.push(iterator.getUint32());
+    }
+    iterator.discard(size - (iterator.counter.getOffset() - offset));
+    return {
+        type: 'stsz-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        sampleCount,
+        countType: 'variable',
+        entries: samples,
+    };
+};
+exports.parseStsz = parseStsz;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface SttsBox {
+    type: 'stts-box';
+    sampleDistribution: SampleDistribution[];
+}
+type SampleDistribution = {
+    sampleCount: number;
+    sampleDelta: number;
+};
+export declare const parseStts: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => SttsBox;
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStts = void 0;
+const parseStts = ({ data, size, fileOffset, }) => {
+    const initialOffset = data.counter.getOffset();
+    const initialCounter = initialOffset - fileOffset;
+    const version = data.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STTS version ${version}`);
+    }
+    // flags, we discard them
+    data.discard(3);
+    // entry count
+    const entryCount = data.getUint32();
+    const sampleDistributions = [];
+    // entries
+    for (let i = 0; i < entryCount; i++) {
+        const sampleCount = data.getUint32();
+        const sampleDelta = data.getUint32();
+        const sampleDistribution = {
+            sampleCount,
+            sampleDelta,
+        };
+        sampleDistributions.push(sampleDistribution);
+    }
+    const bytesUsed = data.counter.getOffset() - initialOffset + initialCounter;
+    if (bytesUsed !== size) {
+        throw new Error(`Expected stts box to be ${size} bytes, but was ${bytesUsed} bytes`);
+    }
+    return {
+        type: 'stts-box',
+        sampleDistribution: sampleDistributions,
+    };
+};
+exports.parseStts = parseStts;