@remotion/media-parser 4.0.191

package/dist/boxes/webm/segments/timestamp-scale.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTimestampScaleSegment = void 0;
+const parseTimestampScaleSegment = (iterator) => {
+    const timestampScale = iterator.getDecimalBytes(3);
+    return {
+        type: 'timestamp-scale-segment',
+        timestampScale,
+    };
+};
+exports.parseTimestampScaleSegment = parseTimestampScaleSegment;

package/dist/boxes/webm/segments/track-entry.d.ts

@@ -0,0 +1,71 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { MatroskaSegment } from '../segments';
+export type TrackEntrySegment = {
+    type: 'track-entry-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTrackEntry: (iterator: BufferIterator) => TrackEntrySegment;
+export type TrackNumberSegment = {
+    type: 'track-number-segment';
+    trackNumber: number;
+};
+export declare const parseTrackNumber: (iterator: BufferIterator) => TrackNumberSegment;
+export type TrackUIDSegment = {
+    type: 'track-uid-segment';
+    trackUid: string;
+};
+export declare const parseTrackUID: (iterator: BufferIterator) => TrackUIDSegment;
+export type FlagLacingSegment = {
+    type: 'flag-lacing-segment';
+    lacing: boolean;
+};
+export declare const parseFlagLacing: (iterator: BufferIterator) => FlagLacingSegment;
+export type LanguageSegment = {
+    type: 'language-segment';
+    language: string;
+};
+export declare const parseLanguageSegment: (iterator: BufferIterator) => LanguageSegment;
+export type CodecSegment = {
+    type: 'codec-segment';
+    codec: string;
+};
+export declare const parseCodecSegment: (iterator: BufferIterator) => CodecSegment;
+export type TrackTypeSegment = {
+    type: 'track-type-segment';
+    trackType: number;
+};
+export declare const parseTrackTypeSegment: (iterator: BufferIterator) => TrackTypeSegment;
+export type DefaultDurationSegment = {
+    type: 'default-duration-segment';
+    defaultDuration: number;
+};
+export declare const parseDefaultDurationSegment: (iterator: BufferIterator) => DefaultDurationSegment;
+export type VideoSegment = {
+    type: 'video-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseVideoSegment: (iterator: BufferIterator) => VideoSegment;
+export type WidthSegment = {
+    type: 'width-segment';
+    width: number;
+};
+export declare const parseWidthSegment: (iterator: BufferIterator) => WidthSegment;
+export type HeightSegment = {
+    type: 'height-segment';
+    height: number;
+};
+export declare const parseHeightSegment: (iterator: BufferIterator) => HeightSegment;
+export type AlphaModeSegment = {
+    type: 'alpha-mode-segment';
+    alphaMode: number;
+};
+export declare const parseAlphaModeSegment: (iterator: BufferIterator) => AlphaModeSegment;
+export type MaxBlockAdditionId = {
+    type: 'max-block-addition-id-segment';
+    maxBlockAdditionId: number;
+};
+export declare const parseMaxBlockAdditionId: (iterator: BufferIterator) => MaxBlockAdditionId;
+export type ColorSegment = {
+    type: 'color-segment';
+};
+export declare const parseColorSegment: (iterator: BufferIterator) => ColorSegment;

package/dist/boxes/webm/segments/track-entry.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackNumber = exports.parseTrackEntry = void 0;
+const parse_children_1 = require("./parse-children");
+const parseTrackEntry = (iterator) => {
+    const offset = iterator.counter.getOffset();
+    const length = iterator.getVint();
+    return {
+        type: 'track-entry-segment',
+        children: (0, parse_children_1.expectChildren)(iterator, length - (iterator.counter.getOffset() - offset)),
+    };
+};
+exports.parseTrackEntry = parseTrackEntry;
+const parseTrackNumber = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected track number to be 1 byte');
+    }
+    const trackNumber = iterator.getUint8();
+    return {
+        type: 'track-number-segment',
+        trackNumber,
+    };
+};
+exports.parseTrackNumber = parseTrackNumber;
+const parseTrackUID = (iterator) => {
+    const length = iterator.getVint();
+    // Observation: AV1 has 8 bytes, WebM has 7
+    if (length !== 8 && length !== 7) {
+        throw new Error('Expected track number to be 8 byte');
+    }
+    const bytes = iterator.getSlice(length);
+    const asString = [...bytes]
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return {
+        type: 'track-uid-segment',
+        trackUid: asString,
+    };
+};
+exports.parseTrackUID = parseTrackUID;
+const parseFlagLacing = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected flag lacing to be 1 byte');
+    }
+    const bytes = iterator.getSlice(length);
+    if (bytes[0] !== 1 && bytes[0] !== 0) {
+        throw new Error('Expected lacing to be 1 or 0');
+    }
+    return {
+        type: 'flag-lacing-segment',
+        lacing: Boolean(bytes[0]),
+    };
+};
+exports.parseFlagLacing = parseFlagLacing;
+const parseLanguageSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 3) {
+        throw new Error('Expected language segment to be 3 bytes');
+    }
+    const language = iterator.getByteString(length);
+    return {
+        type: 'language-segment',
+        language,
+    };
+};
+exports.parseLanguageSegment = parseLanguageSegment;
+const parseCodecSegment = (iterator) => {
+    const length = iterator.getVint();
+    // Could make a TypeScript enum with it
+    // https://www.matroska.org/technical/codec_specs.html
+    const codec = iterator.getByteString(length);
+    return {
+        type: 'codec-segment',
+        codec,
+    };
+};
+exports.parseCodecSegment = parseCodecSegment;
+const parseTrackTypeSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected track type segment to be 1 byte');
+    }
+    const trackType = iterator.getUint8();
+    // Could make the return type nicer
+    /* 1 - video,
+    2 - audio,
+        3 - complex,
+        16 - logo,
+        17 - subtitle,
+        18 - buttons,
+        32 - control,
+        33 - metadata;
+    */
+    return {
+        type: 'track-type-segment',
+        trackType,
+    };
+};
+exports.parseTrackTypeSegment = parseTrackTypeSegment;
+const parseDefaultDurationSegment = (iterator) => {
+    const length = iterator.getVint();
+    const defaultDuration = iterator.getDecimalBytes(length);
+    return {
+        type: 'default-duration-segment',
+        defaultDuration,
+    };
+};
+exports.parseDefaultDurationSegment = parseDefaultDurationSegment;
+const parseVideoSegment = (iterator) => {
+    const offset = iterator.counter.getOffset();
+    const length = iterator.getVint();
+    return {
+        type: 'video-segment',
+        children: (0, parse_children_1.expectChildren)(iterator, length - (iterator.counter.getOffset() - offset)),
+    };
+};
+exports.parseVideoSegment = parseVideoSegment;
+const parseWidthSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 2) {
+        throw new Error('Expected width segment to be 2 bytes');
+    }
+    const width = iterator.getUint16();
+    return {
+        type: 'width-segment',
+        width,
+    };
+};
+exports.parseWidthSegment = parseWidthSegment;
+const parseHeightSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 2) {
+        throw new Error('Expected height segment to be 2 bytes');
+    }
+    const height = iterator.getUint16();
+    return {
+        type: 'height-segment',
+        height,
+    };
+};
+exports.parseHeightSegment = parseHeightSegment;
+const parseAlphaModeSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected alpha mode segment to be 1 byte');
+    }
+    const alphaMode = iterator.getUint8();
+    return {
+        type: 'alpha-mode-segment',
+        alphaMode,
+    };
+};
+exports.parseAlphaModeSegment = parseAlphaModeSegment;
+const parseMaxBlockAdditionId = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected alpha mode segment to be 1 byte');
+    }
+    const maxBlockAdditionId = iterator.getUint8();
+    return {
+        type: 'max-block-addition-id-segment',
+        maxBlockAdditionId,
+    };
+};
+exports.parseMaxBlockAdditionId = parseMaxBlockAdditionId;
+const parseColorSegment = (iterator) => {
+    const length = iterator.getVint();
+    iterator.discard(length - 1);
+    return {
+        type: 'color-segment',
+    };
+};
+exports.parseColorSegment = parseColorSegment;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type UnknownSegment = {
+    id: string;
+    type: 'unknown-segment';
+};
+export declare const parseUnknownSegment: (iterator: BufferIterator, id: string, length: number) => UnknownSegment;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnknownSegment = void 0;
+const parseUnknownSegment = (iterator, id, length) => {
+    iterator.discard(length);
+    return {
+        id,
+        type: 'unknown-segment',
+    };
+};
+exports.parseUnknownSegment = parseUnknownSegment;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { DurationSegment } from './segments/duration';
+import type { InfoSegment } from './segments/info';
+import type { MainSegment } from './segments/main';
+import { type MuxingAppSegment } from './segments/muxing';
+import { type SeekSegment } from './segments/seek';
+import type { SeekHeadSegment } from './segments/seek-head';
+import { type SeekPositionSegment } from './segments/seek-position';
+import type { TimestampScaleSegment } from './segments/timestamp-scale';
+import type { AlphaModeSegment, CodecSegment, ColorSegment, DefaultDurationSegment, FlagLacingSegment, HeightSegment, LanguageSegment, MaxBlockAdditionId, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
+import type { TracksSegment } from './segments/tracks';
+import type { UnknownSegment } from './segments/unknown';
+import type { VoidSegment } from './segments/void';
+import type { WritingAppSegment } from './segments/writing';
+export type MatroskaSegment = MainSegment | UnknownSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment;
+export declare const expectSegment: (iterator: BufferIterator) => MatroskaSegment;

package/dist/boxes/webm/segments.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectSegment = void 0;
+const duration_1 = require("./segments/duration");
+const info_1 = require("./segments/info");
+const main_1 = require("./segments/main");
+const muxing_1 = require("./segments/muxing");
+const seek_1 = require("./segments/seek");
+const seek_head_1 = require("./segments/seek-head");
+const seek_position_1 = require("./segments/seek-position");
+const timestamp_scale_1 = require("./segments/timestamp-scale");
+const track_entry_1 = require("./segments/track-entry");
+const tracks_1 = require("./segments/tracks");
+const unknown_1 = require("./segments/unknown");
+const void_1 = require("./segments/void");
+const writing_1 = require("./segments/writing");
+const expectSegment = (iterator) => {
+    const segmentId = iterator.getMatroskaSegmentId();
+    if (segmentId === '0x') {
+        return {
+            type: 'unknown-segment',
+            id: segmentId,
+        };
+    }
+    if (segmentId === '0x18538067') {
+        return (0, main_1.parseMainSegment)(iterator);
+    }
+    if (segmentId === '0x114d9b74') {
+        return (0, seek_head_1.parseSeekHeadSegment)(iterator);
+    }
+    if (segmentId === '0x4dbb') {
+        return (0, seek_1.parseSeekSegment)(iterator);
+    }
+    if (segmentId === '0x53ac') {
+        return (0, seek_position_1.parseSeekPositionSegment)(iterator);
+    }
+    if (segmentId === '0xec') {
+        return (0, void_1.parseVoidSegment)(iterator);
+    }
+    if (segmentId === '0x1549a966') {
+        return (0, info_1.parseInfoSegment)(iterator);
+    }
+    if (segmentId === '0x2ad7b183') {
+        return (0, timestamp_scale_1.parseTimestampScaleSegment)(iterator);
+    }
+    if (segmentId === '0x4d80') {
+        return (0, muxing_1.parseMuxingSegment)(iterator);
+    }
+    if (segmentId === '0x5741') {
+        return (0, writing_1.parseWritingSegment)(iterator);
+    }
+    if (segmentId === '0x4489') {
+        return (0, duration_1.parseDurationSegment)(iterator);
+    }
+    if (segmentId === '0x1654ae6b') {
+        return (0, tracks_1.parseTracksSegment)(iterator);
+    }
+    if (segmentId === '0xae') {
+        return (0, track_entry_1.parseTrackEntry)(iterator);
+    }
+    if (segmentId === '0xd7') {
+        return (0, track_entry_1.parseTrackNumber)(iterator);
+    }
+    if (segmentId === '0x73c5') {
+        return (0, track_entry_1.parseTrackUID)(iterator);
+    }
+    if (segmentId === '0x9c') {
+        return (0, track_entry_1.parseFlagLacing)(iterator);
+    }
+    if (segmentId === '0x22b59c') {
+        return (0, track_entry_1.parseLanguageSegment)(iterator);
+    }
+    if (segmentId === '0x86') {
+        return (0, track_entry_1.parseCodecSegment)(iterator);
+    }
+    if (segmentId === '0x83') {
+        return (0, track_entry_1.parseTrackTypeSegment)(iterator);
+    }
+    if (segmentId === '0x55ee') {
+        return (0, track_entry_1.parseMaxBlockAdditionId)(iterator);
+    }
+    if (segmentId === '0x55b0') {
+        return (0, track_entry_1.parseColorSegment)(iterator);
+    }
+    if (segmentId === '0x23e383') {
+        return (0, track_entry_1.parseDefaultDurationSegment)(iterator);
+    }
+    if (segmentId === '0xe0') {
+        return (0, track_entry_1.parseVideoSegment)(iterator);
+    }
+    if (segmentId === '0xb0') {
+        return (0, track_entry_1.parseWidthSegment)(iterator);
+    }
+    if (segmentId === '0xba') {
+        return (0, track_entry_1.parseHeightSegment)(iterator);
+    }
+    if (segmentId === '0x53c0') {
+        return (0, track_entry_1.parseAlphaModeSegment)(iterator);
+    }
+    const length = iterator.getVint();
+    const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
+    const toDiscard = Math.min(bytesRemaining, length > 0 ? length : bytesRemaining);
+    const child = (0, unknown_1.parseUnknownSegment)(iterator, segmentId, toDiscard);
+    return child;
+};
+exports.expectSegment = expectSegment;

package/dist/buffer-iterator.d.ts

@@ -0,0 +1,36 @@
+export declare class OffsetCounter {
+    #private;
+    constructor(initial: number);
+    increment(amount: number): void;
+    getOffset(): number;
+    getDiscardedOffset(): number;
+    discardBytes(amount: number): void;
+    decrement(amount: number): void;
+}
+export declare const getArrayBufferIterator: (initialData: Uint8Array) => {
+    addData: (newData: Uint8Array) => void;
+    counter: OffsetCounter;
+    byteLength: () => number;
+    bytesRemaining: () => number;
+    isIsoBaseMedia: () => boolean;
+    discardFirstBytes: () => void;
+    isWebm: () => boolean;
+    discard: (length: number) => void;
+    getFourByteNumber: () => number;
+    getSlice: (amount: number) => Uint8Array;
+    getAtom: () => string;
+    getMatroskaSegmentId: () => string;
+    getVint: () => number;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getFixedPoint1616Number: () => number;
+    getPascalString: () => number[];
+    getDecimalBytes(length: number): number;
+    getByteString(length: number): string;
+    getFloat64: () => number;
+};
+export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;