@remotion/media-parser 4.0.254 → 4.0.256

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdat = void 0;
+const get_tracks_1 = require("../../../get-tracks");
+const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
+const traversal_1 = require("../traversal");
+const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }) => {
+    const alreadyHas = (0, get_tracks_1.hasTracks)({
+        type: 'iso-base-media',
+        boxes: existingBoxes,
+    }, options.parserState);
+    if (!alreadyHas) {
+        if (maySkipSampleProcessing) {
+            data.discard(size - (data.counter.getOffset() - fileOffset));
+            return Promise.resolve({
+                type: 'mdat-box',
+                boxSize: size,
+                status: 'samples-skipped',
+                fileOffset,
+            });
+        }
+        data.discard(size - (data.counter.getOffset() - fileOffset));
+        data.disallowDiscard();
+        return Promise.resolve({
+            type: 'mdat-box',
+            boxSize: size,
+            status: 'samples-buffered',
+            fileOffset,
+        });
+    }
+    const tracks = (0, get_tracks_1.getTracks)({ type: 'iso-base-media', boxes: existingBoxes }, options.parserState);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const flatSamples = allTracks
+        .map((track) => {
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(track.trakBox, (0, traversal_1.getMoofBox)(existingBoxes));
+        if (!samplePositions) {
+            throw new Error('No sample positions');
+        }
+        return samplePositions.map((samplePosition) => {
+            return {
+                track: { ...track },
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    while (true) {
+        if (signal && signal.aborted) {
+            break;
+        }
+        const samplesWithIndex = flatSamples.find((sample) => {
+            return sample.samplePosition.offset === data.counter.getOffset();
+        });
+        if (!samplesWithIndex) {
+            // There are various reasons why in mdat we find weird stuff:
+            // - iphonevideo.hevc has a fake hoov atom which is not mapped
+            // - corrupted.mp4 has a corrupt table
+            const nextSample_ = flatSamples
+                .filter((s) => s.samplePosition.offset > data.counter.getOffset())
+                .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+            if (nextSample_) {
+                data.discard(nextSample_.samplePosition.offset - data.counter.getOffset());
+                continue;
+            }
+            else {
+                const bytesRemaining = size + fileOffset - data.counter.getOffset();
+                data.discard(bytesRemaining);
+                break;
+            }
+        }
+        if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
+            break;
+        }
+        const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
+        const timestamp = (samplesWithIndex.samplePosition.cts * 1000000) /
+            samplesWithIndex.track.timescale;
+        const duration = (samplesWithIndex.samplePosition.duration * 1000000) /
+            samplesWithIndex.track.timescale;
+        const cts = (samplesWithIndex.samplePosition.cts * 1000000) /
+            samplesWithIndex.track.timescale;
+        const dts = (samplesWithIndex.samplePosition.dts * 1000000) /
+            samplesWithIndex.track.timescale;
+        if (samplesWithIndex.track.type === 'audio') {
+            await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
+                data: bytes,
+                timestamp,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+            });
+        }
+        if (samplesWithIndex.track.type === 'video') {
+            await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
+                data: bytes,
+                timestamp,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: samplesWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
+            });
+        }
+        const remaining = size - (data.counter.getOffset() - fileOffset);
+        data.removeBytesRead();
+        if (remaining === 0) {
+            break;
+        }
+    }
+    return Promise.resolve({
+        type: 'mdat-box',
+        boxSize: size,
+        status: 'samples-processed',
+        fileOffset,
+    });
+};
+exports.parseMdat = parseMdat;

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

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface MdhdBox {
+    type: 'mdhd-box';
+    version: number;
+    timescale: number;
+    duration: number;
+    language: number;
+    quality: number;
+    creationTime: number | null;
+    modificationTime: number | null;
+}
+export declare const parseMdhd: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => MdhdBox;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdhd = void 0;
+const parseMdhd = ({ data, size, fileOffset, }) => {
+    const version = data.getUint8();
+    // flags, we discard them
+    data.discard(3);
+    // creation time
+    const creationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
+    // modification time
+    const modificationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
+    const timescale = data.getUint32();
+    const duration = version === 1 ? data.getUint64() : data.getUint32();
+    const language = data.getUint16();
+    // quality
+    const quality = data.getUint16();
+    const remaining = size - (data.counter.getOffset() - fileOffset);
+    if (remaining !== 0) {
+        throw new Error(`Expected remaining bytes to be 0, got ${remaining}`);
+    }
+    return {
+        type: 'mdhd-box',
+        duration: Number(duration),
+        timescale,
+        version,
+        language,
+        quality,
+        creationTime,
+        modificationTime,
+    };
+};
+exports.parseMdhd = parseMdhd;

package/dist/boxes/iso-base-media/meta/hdlr.d.ts

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface HdlrBox extends BaseBox {
+    type: 'hdlr-box';
+    hdlrType: string;
+    componentName: string;
+}
+export declare const parseHdlr: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => Promise<HdlrBox>;

package/dist/boxes/iso-base-media/meta/hdlr.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHdlr = void 0;
+const parseHdlr = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported hdlr version: ${version}`);
+    }
+    // version
+    iterator.discard(3);
+    // predefined
+    iterator.discard(4);
+    // type
+    const hdlrType = iterator.getByteString(4);
+    // component manufactor
+    iterator.discard(4);
+    // component flags
+    iterator.discard(4);
+    // component flags mask
+    iterator.discard(4);
+    // component name
+    const componentName = iterator.readUntilNullTerminator();
+    box.discardRest();
+    return Promise.resolve({
+        type: 'hdlr-box',
+        boxSize: size,
+        offset,
+        hdlrType,
+        componentName,
+    });
+};
+exports.parseHdlr = parseHdlr;

package/dist/boxes/iso-base-media/meta/ilst.d.ts

@@ -0,0 +1,28 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type IlstEntry = {
+    index: number;
+    wellKnownType: number;
+    type: string;
+    value: Value;
+};
+export type Value = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'unknown';
+    value: unknown;
+};
+export interface IlstBox extends BaseBox {
+    type: 'ilst-box';
+    entries: IlstEntry[];
+}
+export declare const parseIlstBox: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => IlstBox;
+export {};

package/dist/boxes/iso-base-media/meta/ilst.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIlstBox = void 0;
+// https://developer.apple.com/documentation/quicktime-file-format/well-known_types
+const parseFromWellKnownType = (wellKnownType, iterator, size) => {
+    if (wellKnownType === 1) {
+        const value = iterator.getByteString(size);
+        return { type: 'text', value };
+    }
+    if (wellKnownType === 21) {
+        if (size === 1) {
+            return { type: 'number', value: iterator.getInt8() };
+        }
+        if (size === 2) {
+            return { type: 'number', value: iterator.getInt16() };
+        }
+        if (size === 3) {
+            return { type: 'number', value: iterator.getInt24() };
+        }
+        if (size === 4) {
+            return { type: 'number', value: iterator.getInt32() };
+        }
+        if (size === 8) {
+            return { type: 'number', value: Number(iterator.getInt64()) };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    if (wellKnownType === 22) {
+        if (size === 1) {
+            return { type: 'number', value: iterator.getUint8() };
+        }
+        if (size === 2) {
+            return { type: 'number', value: iterator.getUint16() };
+        }
+        if (size === 3) {
+            return { type: 'number', value: iterator.getUint24() };
+        }
+        if (size === 4) {
+            return { type: 'number', value: iterator.getUint32() };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    if (wellKnownType === 23) {
+        if (size === 4) {
+            return { type: 'number', value: iterator.getFloat32() };
+        }
+        if (size === 8) {
+            return { type: 'number', value: iterator.getFloat64() };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    iterator.discard(size);
+    return { type: 'unknown', value: null };
+};
+const parseIlstBox = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const entries = [];
+    while (iterator.counter.getOffset() < size + offset) {
+        // metadata size
+        const metadataSize = iterator.getUint32();
+        const index = iterator.getUint32();
+        // "skip" as a number
+        if (index === 1936419184) {
+            iterator.discard(metadataSize - 8);
+            continue;
+        }
+        const innerSize = iterator.getUint32();
+        const type = iterator.getAtom();
+        const typeIndicator = iterator.getUint8();
+        if (typeIndicator !== 0) {
+            throw new Error('Expected type indicator to be 0');
+        }
+        const wellKnownType = iterator.getUint24();
+        iterator.discard(4);
+        const value = parseFromWellKnownType(wellKnownType, iterator, innerSize - 16);
+        entries.push({ index, type, wellKnownType, value });
+    }
+    box.discardRest();
+    return {
+        type: 'ilst-box',
+        boxSize: size,
+        offset,
+        entries,
+    };
+};
+exports.parseIlstBox = parseIlstBox;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
+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 MoovBox extends BaseBox {
+    type: 'moov-box';
+    children: AnySegment[];
+}
+export declare const parseMoov: ({ iterator, offset, size, options, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+    options: ParserContext;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<MoovBox>;

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

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

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

@@ -0,0 +1,30 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { BaseBox } from './base-type';
+export type ThreeDMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export interface MvhdBox extends BaseBox {
+    durationInUnits: number;
+    durationInSeconds: number;
+    creationTime: number | null;
+    modificationTime: number | null;
+    timeScale: number;
+    rate: number;
+    volume: number;
+    matrix: ThreeDMatrix;
+    nextTrackId: number;
+    type: 'mvhd-box';
+}
+export declare const parseMvhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => MvhdBox;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMvhd = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const to_date_1 = require("./to-date");
+const parseMvhd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    // Flags, we discard them
+    iterator.discard(3);
+    const creationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const modificationTime = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const timeScale = iterator.getUint32();
+    const durationInUnits = version === 1 ? iterator.getUint64() : iterator.getUint32();
+    const durationInSeconds = Number(durationInUnits) / timeScale;
+    const rateArray = iterator.getSlice(4);
+    const rateView = (0, buffer_iterator_1.getArrayBufferIterator)(rateArray, rateArray.length);
+    const rate = rateView.getInt8() * 10 +
+        rateView.getInt8() +
+        rateView.getInt8() * 0.1 +
+        rateView.getInt8() * 0.01;
+    const volumeArray = iterator.getSlice(2);
+    const volumeView = (0, buffer_iterator_1.getArrayBufferIterator)(volumeArray, volumeArray.length);
+    const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
+    // reserved 16bit
+    iterator.discard(2);
+    // reserved 32bit x2
+    iterator.discard(4);
+    iterator.discard(4);
+    // matrix
+    const matrix = [
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+    ];
+    // pre-defined
+    iterator.discard(4 * 6);
+    // next track id
+    const nextTrackId = iterator.getUint32();
+    volumeView.destroy();
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        creationTime: (0, to_date_1.toUnixTimestamp)(Number(creationTime)),
+        modificationTime: (0, to_date_1.toUnixTimestamp)(Number(modificationTime)),
+        timeScale,
+        durationInUnits: Number(durationInUnits),
+        durationInSeconds,
+        rate,
+        volume,
+        matrix: matrix,
+        nextTrackId,
+        type: 'mvhd-box',
+        boxSize: size,
+        offset,
+    };
+};
+exports.parseMvhd = parseMvhd;

package/dist/boxes/iso-base-media/parse-icc-profile.d.ts

@@ -0,0 +1,36 @@
+type Point = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type IccProfile = {
+    size: number;
+    preferredCMMType: string;
+    profileVersion: string;
+    profileDeviceClass: string;
+    colorSpace: string;
+    pcs: string;
+    dateTime: Uint8Array;
+    signature: string;
+    primaryPlatform: string;
+    profileFlags: number;
+    deviceManufacturer: string;
+    deviceModel: string;
+    deviceAttributes: bigint;
+    renderingIntent: number;
+    pcsIlluminant: [number, number, number];
+    profileCreator: string;
+    profileId: string;
+    entries: Entry[];
+    rXYZ: Point | null;
+    gXYZ: Point | null;
+    bXYZ: Point | null;
+    whitePoint: Point | null;
+};
+type Entry = {
+    tag: string;
+    size: number;
+    offset: number;
+};
+export declare const parseIccProfile: (data: Uint8Array) => IccProfile;
+export {};

package/dist/boxes/iso-base-media/parse-icc-profile.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIccProfile = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const parseIccProfile = (data) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, Infinity);
+    const size = iterator.getUint32();
+    if (size !== data.length) {
+        throw new Error('Invalid ICC profile size');
+    }
+    const preferredCMMType = iterator.getByteString(4);
+    const profileVersion = iterator.getByteString(4);
+    const profileDeviceClass = iterator.getByteString(4);
+    const colorSpace = iterator.getByteString(4);
+    const pcs = iterator.getByteString(4);
+    const dateTime = iterator.getSlice(12);
+    const signature = iterator.getByteString(4);
+    if (signature !== 'acsp') {
+        throw new Error('Invalid ICC profile signature');
+    }
+    const primaryPlatform = iterator.getByteString(4);
+    const profileFlags = iterator.getUint32();
+    const deviceManufacturer = iterator.getByteString(4);
+    const deviceModel = iterator.getByteString(4);
+    const deviceAttributes = iterator.getUint64();
+    const renderingIntent = iterator.getUint32();
+    const pcsIlluminant1 = iterator.getUint32();
+    const pcsIlluminant2 = iterator.getUint32();
+    const pcsIlluminant3 = iterator.getUint32();
+    const profileCreator = iterator.getByteString(4);
+    const profileId = iterator.getByteString(16);
+    // reserved
+    iterator.discard(28);
+    const tagCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < tagCount; i++) {
+        const entry = {
+            tag: iterator.getByteString(4),
+            offset: iterator.getUint32(),
+            size: iterator.getUint32(),
+        };
+        entries.push(entry);
+    }
+    let lastOffset = -1;
+    let rXYZ = null;
+    let gXYZ = null;
+    let bXYZ = null;
+    let whitePoint = null;
+    for (const entry of entries) {
+        const found = data.slice(entry.offset, entry.offset + entry.size);
+        if (entry.tag === 'rXYZ' ||
+            entry.tag === 'gXYZ' ||
+            entry.tag === 'bXYZ' ||
+            entry.tag === 'wtpt') {
+            const it = (0, buffer_iterator_1.getArrayBufferIterator)(found, Infinity);
+            it.discard(4);
+            const x = it.getInt32() / 65536;
+            const y = it.getInt32() / 65536;
+            const z = it.getInt32() / 65536;
+            it.destroy();
+            const point = { x, y, z };
+            if (entry.tag === 'rXYZ') {
+                rXYZ = point;
+            }
+            else if (entry.tag === 'gXYZ') {
+                gXYZ = point;
+            }
+            else if (entry.tag === 'bXYZ') {
+                bXYZ = point;
+            }
+            else if (entry.tag === 'wtpt') {
+                whitePoint = point;
+            }
+        }
+        if (lastOffset !== -1) {
+            const bytesToAdvance = entry.offset - lastOffset;
+            const bytesToGoBackwards = entry.size - bytesToAdvance;
+            if (bytesToGoBackwards > 0) {
+                iterator.counter.decrement(bytesToGoBackwards);
+            }
+        }
+        lastOffset = entry.offset;
+    }
+    const profile = {
+        size,
+        preferredCMMType,
+        profileVersion,
+        profileDeviceClass,
+        colorSpace,
+        pcs,
+        dateTime,
+        signature,
+        primaryPlatform,
+        profileFlags,
+        deviceManufacturer,
+        deviceModel,
+        deviceAttributes,
+        renderingIntent,
+        pcsIlluminant: [
+            pcsIlluminant1 / 65536,
+            pcsIlluminant2 / 65536,
+            pcsIlluminant3 / 65536,
+        ],
+        profileCreator,
+        profileId,
+        entries,
+        bXYZ,
+        gXYZ,
+        rXYZ,
+        whitePoint,
+    };
+    iterator.destroy();
+    return profile;
+};
+exports.parseIccProfile = parseIccProfile;

package/dist/boxes/iso-base-media/process-box.d.ts

@@ -0,0 +1,34 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { LogLevel } from '../../log';
+import type { Options, ParseMediaFields } from '../../options';
+import type { IsoBaseMediaBox, IsoBaseMediaStructure, ParseResult } from '../../parse-result';
+import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
+import type { ParserContext } from '../../parser-context';
+export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }: {
+    iterator: BufferIterator;
+    boxSize: number;
+    fileOffset: number;
+    parsedBoxes: IsoBaseMediaBox[];
+    options: ParserContext;
+    signal: AbortSignal | null;
+}) => Promise<BoxAndNext>;
+export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    allowIncompleteBoxes: boolean;
+    parsedBoxes: IsoBaseMediaBox[];
+    options: ParserContext;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<BoxAndNext>;
+export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    allowIncompleteBoxes: boolean;
+    initialBoxes: IsoBaseMediaBox[];
+    options: ParserContext;
+    continueMdat: false | PartialMdatBox;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult<IsoBaseMediaStructure>>;