@remotion/media-parser 4.0.254 → 4.0.256

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.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    privateData: 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 privateData = data.getSlice(size - 8);
+    return {
+        type: 'avcc-box',
+        privateData,
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;

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

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { IccProfile } from '../parse-icc-profile';
+type ExtraData = {
+    colorType: 'transfer-characteristics';
+    primaries: number;
+    transfer: number;
+    matrixIndex: number;
+    fullRangeFlag: boolean;
+} | {
+    colorType: 'icc-profile';
+    profile: Uint8Array;
+    parsed: IccProfile;
+};
+export type ColorParameterBox = {
+    type: 'colr-box';
+} & ExtraData;
+export declare const parseColorParameterBox: ({ iterator, size, }: {
+    iterator: BufferIterator;
+    size: number;
+}) => ColorParameterBox;
+export {};

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseColorParameterBox = void 0;
+const parse_icc_profile_1 = require("../parse-icc-profile");
+const parseColorParameterBox = ({ iterator, size, }) => {
+    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',
+            colorType: 'transfer-characteristics',
+            fullRangeFlag,
+            matrixIndex,
+            primaries,
+            transfer,
+        };
+    }
+    if (byteString === 'nclc') {
+        const primaries = iterator.getUint16();
+        const transfer = iterator.getUint16();
+        const matrixIndex = iterator.getUint16();
+        return {
+            type: 'colr-box',
+            colorType: 'transfer-characteristics',
+            fullRangeFlag: false,
+            matrixIndex,
+            primaries,
+            transfer,
+        };
+    }
+    if (byteString === 'prof') {
+        const profile = iterator.getSlice(size - 12);
+        return {
+            type: 'colr-box',
+            colorType: 'icc-profile',
+            profile,
+            parsed: (0, parse_icc_profile_1.parseIccProfile)(profile),
+        };
+    }
+    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,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCtts = void 0;
+const parseCtts = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0 && version !== 1) {
+        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();
+        // V1 = signed, V0 = unsigned
+        // however some files are buggy
+        // Let's do the same thing as mp4box
+        // https://github.com/gpac/mp4box.js/blob/c6cc468145bc5b031b866446111f29c8b620dbe6/src/parsing/ctts.js#L2
+        const sampleOffset = iterator.getInt32();
+        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';
+    privateData: 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 privateData = 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',
+        privateData,
+        configurationString: constraintString,
+    };
+};
+exports.parseHvcc = parseHvcc;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type KeysEntry = {
+    keySize: number;
+    namespace: string;
+    value: string;
+};
+export interface KeysBox extends BaseBox {
+    type: 'keys-box';
+    version: number;
+    entryCount: number;
+    entries: KeysEntry[];
+}
+export declare const parseKeys: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => KeysBox;
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKeys = void 0;
+const parseKeys = ({ iterator, offset, size, }) => {
+    const box = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    // flags
+    iterator.discard(3);
+    // entry_count
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        // key_size
+        const keySize = iterator.getUint32();
+        const namespace = iterator.getAtom();
+        const value = iterator.getByteString(keySize - 8);
+        // data
+        const entry = {
+            keySize,
+            namespace,
+            value,
+        };
+        entries.push(entry);
+    }
+    box.discardRest();
+    return {
+        type: 'keys-box',
+        boxSize: size,
+        offset,
+        version,
+        entryCount,
+        entries,
+    };
+};
+exports.parseKeys = parseKeys;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { Options, ParseMediaFields } from '../../../options';
+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';
+    dataReferenceIndex: number;
+    format: string;
+    children: AnySegment[];
+}
+export declare const parseMebx: ({ iterator, offset, size, options, signal, fields, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+    options: ParserContext;
+    signal: AbortSignal | null;
+    fields: Options<ParseMediaFields>;
+}) => Promise<MebxBox>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMebx = void 0;
+const process_box_1 = require("../process-box");
+const parseMebx = async ({ iterator, offset, size, options, signal, fields, }) => {
+    // reserved, 6 bit
+    iterator.discard(6);
+    const dataReferenceIndex = iterator.getUint16();
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+        iterator,
+        maxBytes: iterator.counter.getOffset() - offset,
+        allowIncompleteBoxes: false,
+        initialBoxes: [],
+        options,
+        continueMdat: false,
+        signal,
+        logLevel: 'info',
+        fields,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete boxes are not allowed');
+    }
+    return {
+        type: 'mebx-box',
+        boxSize: size,
+        offset,
+        dataReferenceIndex,
+        format: 'mebx',
+        children: children.segments.boxes,
+    };
+};
+exports.parseMebx = parseMebx;

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

@@ -0,0 +1,68 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
+import type { Options, ParseMediaFields } from '../../../options';
+import type { AnySegment, IsoBaseMediaBox } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
+type SampleBase = {
+    format: string;
+    offset: number;
+    dataReferenceIndex: number;
+    size: number;
+};
+export type AudioSample = SampleBase & {
+    type: 'audio';
+    numberOfChannels: number;
+    sampleSize: number;
+    compressionId: number;
+    packetSize: number;
+    sampleRate: number;
+    samplesPerPacket: number | null;
+    bytesPerPacket: number | null;
+    bytesPerFrame: number | null;
+    bitsPerSample: number | null;
+    children: AnySegment[];
+    version: number;
+    revisionLevel: number;
+    vendor: number[];
+};
+export type VideoSample = SampleBase & {
+    type: 'video';
+    temporalQuality: number;
+    spacialQuality: number;
+    width: number;
+    height: number;
+    compressorName: number[];
+    horizontalResolutionPpi: number;
+    verticalResolutionPpi: number;
+    dataSize: number;
+    frameCountPerSample: number;
+    depth: number;
+    colorTableId: number;
+    descriptors: IsoBaseMediaBox[];
+    version: number;
+    revisionLevel: number;
+    vendor: number[];
+};
+type UnknownSample = SampleBase & {
+    type: 'unknown';
+};
+export type Sample = AudioSample | VideoSample | UnknownSample;
+type SampleAndNext = {
+    sample: Sample | null;
+};
+export declare const processSample: ({ iterator, options, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    options: ParserContext;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<SampleAndNext>;
+export declare const parseSamples: ({ iterator, maxBytes, options, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    options: ParserContext;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<Sample[]>;
+export {};