@remotion/media-parser 4.0.191

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

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSamples = exports.processSample = void 0;
+// https://developer.apple.com/documentation/quicktime-file-format/video_sample_description
+const videoTags = [
+    'cvid',
+    'jpeg',
+    'smc ',
+    'rle ',
+    'rpza',
+    'kpcd',
+    'png ',
+    'mjpa',
+    'mjpb',
+    'SVQ1',
+    'SVQ3',
+    'mp4v',
+    'avc1',
+    'dvc ',
+    'dvcp',
+    'gif ',
+    'h263',
+    'tiff',
+    'raw ',
+    '2vuY',
+    'yuv2',
+    'v308',
+    'v408',
+    'v216',
+    'v410',
+    'v210',
+    'hvc1',
+];
+// https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
+const audioTags = [
+    0x00000000,
+    'NONE',
+    'raw ',
+    'twos',
+    'sowt',
+    'MAC3 ',
+    'MAC6 ',
+    'ima4',
+    'fl32',
+    'fl64',
+    'in24',
+    'in32',
+    'ulaw',
+    'alaw',
+    0x6d730002,
+    0x6d730011,
+    'dvca',
+    'QDMC',
+    'QDM2',
+    'Qclp',
+    0x6d730055,
+    '.mp3',
+    'mp4a',
+    'ac-3',
+];
+const processSample = ({ iterator, }) => {
+    const fileOffset = iterator.counter.getOffset();
+    const bytesRemaining = iterator.bytesRemaining();
+    const boxSize = iterator.getUint32();
+    if (bytesRemaining < boxSize) {
+        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}`);
+    }
+    const boxFormat = iterator.getAtom();
+    const isVideo = videoTags.includes(boxFormat);
+    const isAudio = audioTags.includes(boxFormat) || audioTags.includes(Number(boxFormat));
+    // 6 reserved bytes
+    iterator.discard(6);
+    const dataReferenceIndex = iterator.getUint16();
+    const version = iterator.getUint16();
+    const revisionLevel = iterator.getUint16();
+    const vendor = iterator.getSlice(4);
+    if (!isVideo && !isAudio) {
+        const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+        iterator.discard(bytesRemainingInBox);
+        return {
+            sample: {
+                type: 'unknown',
+                offset: fileOffset,
+                dataReferenceIndex,
+                version,
+                revisionLevel,
+                vendor: [...Array.from(new Uint8Array(vendor))],
+                size: boxSize,
+                format: boxFormat,
+            },
+        };
+    }
+    if (isAudio) {
+        if (version === 0) {
+            const numberOfChannels = iterator.getUint16();
+            const sampleSize = iterator.getUint16();
+            const compressionId = iterator.getUint16();
+            const packetSize = iterator.getUint16();
+            const sampleRate = iterator.getFixedPoint1616Number();
+            const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+            iterator.discard(bytesRemainingInBox);
+            return {
+                sample: {
+                    format: boxFormat,
+                    offset: fileOffset,
+                    dataReferenceIndex,
+                    version,
+                    revisionLevel,
+                    vendor: [...Array.from(new Uint8Array(vendor))],
+                    size: boxSize,
+                    type: 'audio',
+                    numberOfChannels,
+                    sampleSize,
+                    compressionId,
+                    packetSize,
+                    sampleRate,
+                    samplesPerPacket: null,
+                    bytesPerPacket: null,
+                    bytesPerFrame: null,
+                    bitsPerSample: null,
+                },
+            };
+        }
+        if (version === 1) {
+            const numberOfChannels = iterator.getUint16();
+            const sampleSize = iterator.getUint16();
+            const compressionId = iterator.getUint16();
+            const packetSize = iterator.getUint16();
+            const sampleRate = iterator.getFixedPoint1616Number();
+            const samplesPerPacket = iterator.getUint16();
+            const bytesPerPacket = iterator.getUint16();
+            const bytesPerFrame = iterator.getUint16();
+            const bitsPerSample = iterator.getUint16();
+            const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+            iterator.discard(bytesRemainingInBox);
+            return {
+                sample: {
+                    format: boxFormat,
+                    offset: fileOffset,
+                    dataReferenceIndex,
+                    version,
+                    revisionLevel,
+                    vendor: [...Array.from(new Uint8Array(vendor))],
+                    size: boxSize,
+                    type: 'audio',
+                    numberOfChannels,
+                    sampleSize,
+                    compressionId,
+                    packetSize,
+                    sampleRate,
+                    samplesPerPacket,
+                    bytesPerPacket,
+                    bytesPerFrame,
+                    bitsPerSample,
+                },
+            };
+        }
+        throw new Error(`Unsupported version ${version}`);
+    }
+    if (isVideo) {
+        const temporalQuality = iterator.getUint32();
+        const spacialQuality = iterator.getUint32();
+        const width = iterator.getUint16();
+        const height = iterator.getUint16();
+        const horizontalResolution = iterator.getFixedPoint1616Number();
+        const verticalResolution = iterator.getFixedPoint1616Number();
+        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);
+        return {
+            sample: {
+                format: boxFormat,
+                offset: fileOffset,
+                dataReferenceIndex,
+                version,
+                revisionLevel,
+                vendor: [...Array.from(new Uint8Array(vendor))],
+                size: boxSize,
+                type: 'video',
+                width,
+                height,
+                horizontalResolutionPpi: horizontalResolution,
+                verticalResolutionPpi: verticalResolution,
+                spacialQuality,
+                temporalQuality,
+                dataSize,
+                frameCountPerSample,
+                compressorName,
+                depth,
+                colorTableId,
+            },
+        };
+    }
+    throw new Error(`Unknown sample format ${boxFormat}`);
+};
+exports.processSample = processSample;
+const parseSamples = (iterator, maxBytes) => {
+    const samples = [];
+    const initialOffset = iterator.counter.getOffset();
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const { sample } = (0, exports.processSample)({
+            iterator,
+        });
+        if (sample) {
+            samples.push(sample);
+        }
+    }
+    return samples;
+};
+exports.parseSamples = parseSamples;

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+import type { Sample } from './samples';
+export interface StsdBox extends BaseBox {
+    type: 'stsd-box';
+    numberOfEntries: number;
+    samples: Sample[];
+}
+export declare const parseStsd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StsdBox;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsd = void 0;
+const samples_1 = require("./samples");
+const parseStsd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    // flags, we discard them
+    iterator.discard(3);
+    const numberOfEntries = iterator.getUint32();
+    const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
+    const boxes = (0, samples_1.parseSamples)(iterator, bytesRemainingInBox);
+    if (boxes.length !== numberOfEntries) {
+        throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
+    }
+    return {
+        type: 'stsd-box',
+        boxSize: size,
+        offset,
+        numberOfEntries,
+        samples: boxes,
+    };
+};
+exports.parseStsd = parseStsd;

package/dist/boxes/iso-base-media/stts/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/stts/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;

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

@@ -0,0 +1,22 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { BaseBox } from './base-type';
+import type { ThreeDMatrix } from './mvhd';
+export interface TkhdBox extends BaseBox {
+    type: 'tkhd-box';
+    alternateGroup: number;
+    creationTime: number | null;
+    duration: number;
+    modificationTime: number | null;
+    trackId: number;
+    version: number;
+    layer: number;
+    volume: number;
+    matrix: ThreeDMatrix;
+    width: number;
+    height: number;
+}
+export declare const parseTkhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => TkhdBox;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTkhd = void 0;
+const to_date_1 = require("./to-date");
+const parseTkhd = ({ iterator, offset, size, }) => {
+    if (size !== 92) {
+        throw new Error(`Expected tkhd size of version 0 to be 92, got ${size}`);
+    }
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported TKHD version ${version}`);
+    }
+    // Flags, we discard them
+    iterator.discard(3);
+    const creationTime = iterator.getUint32();
+    const modificationTime = iterator.getUint32();
+    const trackId = iterator.getUint32();
+    // reserved
+    iterator.discard(4);
+    const duration = iterator.getUint32();
+    // reserved 2
+    iterator.discard(4);
+    // reserved 3
+    iterator.discard(4);
+    const layer = iterator.getUint16();
+    const alternateGroup = iterator.getUint16();
+    const volume = iterator.getUint16();
+    // reserved 4
+    iterator.discard(2);
+    const matrix = [
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+        iterator.getUint32(),
+    ];
+    const widthWithoutRotationApplied = iterator.getUint32() / (matrix[0] === 0 ? 1 : matrix[0]);
+    const heightWithoutRotationApplied = iterator.getUint32() / (matrix[4] === 0 ? 1 : matrix[4]);
+    // TODO: This is not correct, HEVC videos with matrix is wrong
+    const width = widthWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+    const height = heightWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+    return {
+        offset,
+        boxSize: size,
+        type: 'tkhd-box',
+        creationTime: (0, to_date_1.toUnixTimestamp)(creationTime),
+        modificationTime: (0, to_date_1.toUnixTimestamp)(modificationTime),
+        trackId,
+        duration,
+        layer,
+        alternateGroup,
+        volume,
+        matrix: matrix,
+        width,
+        height,
+        version,
+    };
+};
+exports.parseTkhd = parseTkhd;

package/dist/boxes/iso-base-media/to-date.d.ts

@@ -0,0 +1 @@
+export declare const toUnixTimestamp: (value: number) => number | null;

package/dist/boxes/iso-base-media/to-date.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUnixTimestamp = void 0;
+const toUnixTimestamp = (value) => {
+    if (value === 0) {
+        return null;
+    }
+    const baseDate = new Date('1904-01-01T00:00:00Z');
+    return Math.floor(value + baseDate.getTime() / 1000) * 1000;
+};
+exports.toUnixTimestamp = toUnixTimestamp;

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { AnySegment } from '../../../parse-result';
+import type { BaseBox } from '../base-type';
+export interface TrakBox extends BaseBox {
+    type: 'trak-box';
+    children: AnySegment[];
+}
+export declare const parseTrak: ({ data, size, offsetAtStart, }: {
+    data: BufferIterator;
+    size: number;
+    offsetAtStart: number;
+}) => TrakBox;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrak = void 0;
+const process_box_1 = require("../process-box");
+const parseTrak = ({ data, size, offsetAtStart, }) => {
+    const children = (0, process_box_1.parseBoxes)({
+        iterator: data,
+        maxBytes: size - (data.counter.getOffset() - offsetAtStart),
+        allowIncompleteBoxes: false,
+        initialBoxes: [],
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete boxes are not allowed');
+    }
+    return {
+        offset: offsetAtStart,
+        boxSize: size,
+        type: 'trak-box',
+        children: children.segments,
+    };
+};
+exports.parseTrak = parseTrak;

package/dist/boxes/webm/parse-webm-header.d.ts

@@ -0,0 +1,3 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+export declare const parseWebm: (counter: BufferIterator) => ParseResult;

package/dist/boxes/webm/parse-webm-header.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWebm = void 0;
+const segments_1 = require("./segments");
+// Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
+const parseWebm = (counter) => {
+    counter.discard(4);
+    const length = counter.getEBML();
+    if (length !== 31) {
+        throw new Error(`Expected header length 31, got ${length}`);
+    }
+    // Discard header for now
+    counter.discard(31);
+    return { status: 'done', segments: [(0, segments_1.expectSegment)(counter)] };
+};
+exports.parseWebm = parseWebm;

package/dist/boxes/webm/segments/duration.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type DurationSegment = {
+    type: 'duration-segment';
+    duration: number;
+};
+export declare const parseDurationSegment: (iterator: BufferIterator) => DurationSegment;

package/dist/boxes/webm/segments/duration.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDurationSegment = void 0;
+const parseDurationSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 8) {
+        throw new Error('Expected duration segment to be 8 bytes');
+    }
+    const duration = iterator.getFloat64();
+    return {
+        type: 'duration-segment',
+        duration,
+    };
+};
+exports.parseDurationSegment = parseDurationSegment;

package/dist/boxes/webm/segments/info.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { MatroskaSegment } from '../segments';
+export type InfoSegment = {
+    type: 'info-segment';
+    length: number;
+    children: MatroskaSegment[];
+};
+export declare const parseInfoSegment: (iterator: BufferIterator) => InfoSegment;

package/dist/boxes/webm/segments/info.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInfoSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseInfoSegment = (iterator) => {
+    const length = iterator.getVint();
+    const children = (0, parse_children_1.expectChildren)(iterator, length);
+    return {
+        type: 'info-segment',
+        length,
+        children,
+    };
+};
+exports.parseInfoSegment = parseInfoSegment;

package/dist/boxes/webm/segments/main.d.ts

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import { type MatroskaSegment } from '../segments';
+export type MainSegment = {
+    type: 'main-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseMainSegment: (iterator: BufferIterator) => MainSegment;

package/dist/boxes/webm/segments/main.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMainSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseMainSegment = (iterator) => {
+    const length = iterator.getVint();
+    const children = (0, parse_children_1.expectChildren)(iterator, length);
+    return {
+        type: 'main-segment',
+        children,
+    };
+};
+exports.parseMainSegment = parseMainSegment;

package/dist/boxes/webm/segments/muxing.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type MuxingAppSegment = {
+    type: 'muxing-app-segment';
+    value: string;
+};
+export declare const parseMuxingSegment: (iterator: BufferIterator) => MuxingAppSegment;

package/dist/boxes/webm/segments/muxing.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMuxingSegment = void 0;
+const parseMuxingSegment = (iterator) => {
+    const length = iterator.getVint();
+    const value = iterator.getByteString(length);
+    return {
+        type: 'muxing-app-segment',
+        value,
+    };
+};
+exports.parseMuxingSegment = parseMuxingSegment;

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -0,0 +1,3 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { MatroskaSegment } from '../segments';
+export declare const expectChildren: (iterator: BufferIterator, length: number) => MatroskaSegment[];

package/dist/boxes/webm/segments/parse-children.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectChildren = void 0;
+const segments_1 = require("../segments");
+const expectChildren = (iterator, length) => {
+    const children = [];
+    const startOffset = iterator.counter.getOffset();
+    while (iterator.counter.getOffset() < startOffset + length) {
+        const child = (0, segments_1.expectSegment)(iterator);
+        children.push(child);
+        if (child.type === 'unknown-segment') {
+            break;
+        }
+    }
+    return children;
+};
+exports.expectChildren = expectChildren;

package/dist/boxes/webm/segments/seek-head.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import { type MatroskaSegment } from '../segments';
+export type SeekHeadSegment = {
+    type: 'seek-head-segment';
+    children: MatroskaSegment[];
+    length: number;
+};
+export declare const parseSeekHeadSegment: (iterator: BufferIterator) => SeekHeadSegment;

package/dist/boxes/webm/segments/seek-head.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeekHeadSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseSeekHeadSegment = (iterator) => {
+    const length = iterator.getVint();
+    return {
+        type: 'seek-head-segment',
+        length,
+        children: (0, parse_children_1.expectChildren)(iterator, length),
+    };
+};
+exports.parseSeekHeadSegment = parseSeekHeadSegment;

package/dist/boxes/webm/segments/seek-position.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type SeekPositionSegment = {
+    type: 'seek-position-segment';
+    seekPosition: number;
+};
+export declare const parseSeekPositionSegment: (iterator: BufferIterator) => SeekPositionSegment;

package/dist/boxes/webm/segments/seek-position.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeekPositionSegment = void 0;
+const parseSeekPositionSegment = (iterator) => {
+    const length = iterator.getVint();
+    const seekPosition = iterator.getDecimalBytes(length);
+    return {
+        type: 'seek-position-segment',
+        seekPosition,
+    };
+};
+exports.parseSeekPositionSegment = parseSeekPositionSegment;

package/dist/boxes/webm/segments/seek.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { MatroskaSegment } from '../segments';
+export type SeekSegment = {
+    type: 'seek-segment';
+    seekId: string;
+    child: MatroskaSegment;
+};
+export declare const parseSeekSegment: (iterator: BufferIterator) => SeekSegment;

package/dist/boxes/webm/segments/seek.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeekSegment = void 0;
+const segments_1 = require("../segments");
+const parseSeekSegment = (iterator) => {
+    // length
+    iterator.discard(4);
+    const seekId = iterator.getMatroskaSegmentId();
+    const child = (0, segments_1.expectSegment)(iterator);
+    return {
+        type: 'seek-segment',
+        seekId,
+        child,
+    };
+};
+exports.parseSeekSegment = parseSeekSegment;

package/dist/boxes/webm/segments/timestamp-scale.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type TimestampScaleSegment = {
+    type: 'timestamp-scale-segment';
+    timestampScale: number;
+};
+export declare const parseTimestampScaleSegment: (iterator: BufferIterator) => TimestampScaleSegment;