@remotion/media-parser 4.0.254 → 4.0.256

package/dist/boxes/webm/ebml.js

@@ -0,0 +1,94 @@
+"use strict";
+// https://github.com/Vanilagy/webm-muxer/blob/main/src/ebml.ts#L101
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariableInt = exports.measureEBMLVarInt = void 0;
+const measureEBMLVarInt = (value) => {
+    if (value < (1 << 7) - 1) {
+        /** Top bit is set, leaving 7 bits to hold the integer, but we can't store
+         * 127 because "all bits set to one" is a reserved value. Same thing for the
+         * other cases below:
+         */
+        return 1;
+    }
+    if (value < (1 << 14) - 1) {
+        return 2;
+    }
+    if (value < (1 << 21) - 1) {
+        return 3;
+    }
+    if (value < (1 << 28) - 1) {
+        return 4;
+    }
+    if (value < 2 ** 35 - 1) {
+        return 5;
+    }
+    if (value < 2 ** 42 - 1) {
+        return 6;
+    }
+    throw new Error('EBML VINT size not supported ' + value);
+};
+exports.measureEBMLVarInt = measureEBMLVarInt;
+const getVariableInt = (value, minWidth) => {
+    const width = Math.max((0, exports.measureEBMLVarInt)(value), minWidth !== null && minWidth !== void 0 ? minWidth : 0);
+    switch (width) {
+        case 1:
+            return new Uint8Array([(1 << 7) | value]);
+        case 2:
+            return new Uint8Array([(1 << 6) | (value >> 8), value]);
+        case 3:
+            return new Uint8Array([(1 << 5) | (value >> 16), value >> 8, value]);
+        case 4:
+            return new Uint8Array([
+                (1 << 4) | (value >> 24),
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 5:
+            /**
+             * JavaScript converts its doubles to 32-bit integers for bitwise
+             * operations, so we need to do a division by 2^32 instead of a
+             * right-shift of 32 to retain those top 3 bits
+             */
+            return new Uint8Array([
+                (1 << 3) | ((value / 2 ** 32) & 0x7),
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 6:
+            return new Uint8Array([
+                (1 << 2) | ((value / 2 ** 40) & 0x3),
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 7:
+            return new Uint8Array([
+                (1 << 1) | ((value / 2 ** 48) & 0x1),
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 8:
+            return new Uint8Array([
+                (1 << 0) | ((value / 2 ** 56) & 0x1),
+                (value / 2 ** 48) | 0,
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        default:
+            throw new Error('Bad EBML VINT size ' + width);
+    }
+};
+exports.getVariableInt = getVariableInt;

package/dist/boxes/webm/get-ready-tracks.d.ts

@@ -0,0 +1,3 @@
+import type { Track } from '../../get-tracks';
+import type { MainSegment } from './segments/all-segments';
+export declare const getTracksFromMatroska: (segment: MainSegment, timescale: number) => Track[];

package/dist/boxes/webm/get-ready-tracks.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTracksFromMatroska = void 0;
+const make_track_1 = require("./make-track");
+const traversal_1 = require("./traversal");
+const getTracksFromMatroska = (segment, timescale) => {
+    const tracksSegment = (0, traversal_1.getTracksSegment)(segment);
+    if (!tracksSegment) {
+        throw new Error('No tracks segment');
+    }
+    const tracks = [];
+    for (const trackEntrySegment of tracksSegment.value) {
+        if (trackEntrySegment.type === 'Crc32') {
+            continue;
+        }
+        if (trackEntrySegment.type !== 'TrackEntry') {
+            throw new Error('Expected track entry segment');
+        }
+        const track = (0, make_track_1.getTrack)({
+            track: trackEntrySegment,
+            timescale,
+        });
+        if (track) {
+            tracks.push(track);
+        }
+    }
+    return tracks;
+};
+exports.getTracksFromMatroska = getTracksFromMatroska;

package/dist/boxes/webm/get-sample-from-block.d.ts

@@ -0,0 +1,17 @@
+import type { ParserContext } from '../../parser-context';
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
+type SampleResult = {
+    type: 'video-sample';
+    videoSample: AudioOrVideoSample;
+} | {
+    type: 'audio-sample';
+    audioSample: AudioOrVideoSample;
+} | {
+    type: 'partial-video-sample';
+    partialVideoSample: Omit<AudioOrVideoSample, 'type'>;
+} | {
+    type: 'no-sample';
+};
+export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, parserContext: ParserContext, offset: number) => SampleResult;
+export {};

package/dist/boxes/webm/get-sample-from-block.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSampleFromBlock = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const all_segments_1 = require("./segments/all-segments");
+const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
+const getSampleFromBlock = (ebml, parserContext, offset) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
+    const trackNumber = iterator.getVint();
+    if (trackNumber === null) {
+        throw new Error('Not enough data to get track number, should not happen');
+    }
+    const timecodeRelativeToCluster = iterator.getInt16();
+    const { keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, ebml.type === 'SimpleBlock'
+        ? all_segments_1.matroskaElements.SimpleBlock
+        : all_segments_1.matroskaElements.Block);
+    const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
+    const timescale = parserContext.parserState.getTimescale();
+    if (clusterOffset === undefined) {
+        throw new Error('Could not find offset for byte offset ' + offset);
+    }
+    // https://github.com/hubblec4/Matroska-Chapters-Specs/blob/master/notes.md/#timestampscale
+    // The TimestampScale Element is used to calculate the Raw Timestamp of a Block. The timestamp is obtained by adding the Block's timestamp to the Cluster's Timestamp Element, and then multiplying that result by the TimestampScale. The result will be the Block's Raw Timestamp in nanoseconds.
+    const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) *
+        timescale *
+        (trackTimescale !== null && trackTimescale !== void 0 ? trackTimescale : 1);
+    // Timecode should be in microseconds
+    const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
+    if (!codec) {
+        throw new Error(`Could not find codec for track ${trackNumber}`);
+    }
+    const remainingNow = ebml.value.length - iterator.counter.getOffset();
+    if (codec.startsWith('V_')) {
+        const partialVideoSample = {
+            data: iterator.getSlice(remainingNow),
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
+            duration: undefined,
+            trackId: trackNumber,
+            timestamp: timecodeInMicroseconds,
+        };
+        if (keyframe === null) {
+            iterator.destroy();
+            return {
+                type: 'partial-video-sample',
+                partialVideoSample,
+            };
+        }
+        const sample = {
+            ...partialVideoSample,
+            type: keyframe ? 'key' : 'delta',
+        };
+        iterator.destroy();
+        return {
+            type: 'video-sample',
+            videoSample: sample,
+        };
+    }
+    if (codec.startsWith('A_')) {
+        const audioSample = {
+            data: iterator.getSlice(remainingNow),
+            trackId: trackNumber,
+            timestamp: timecodeInMicroseconds,
+            type: 'key',
+            duration: undefined,
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
+        };
+        iterator.destroy();
+        return {
+            type: 'audio-sample',
+            audioSample,
+        };
+    }
+    iterator.destroy();
+    return {
+        type: 'no-sample',
+    };
+};
+exports.getSampleFromBlock = getSampleFromBlock;

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

@@ -0,0 +1,8 @@
+import type { BytesAndOffset, PossibleEbmlOrUint8Array } from './segments/all-segments';
+import { matroskaElements } from './segments/all-segments';
+export declare const webmPattern: Uint8Array;
+export declare const matroskaToHex: (matrId: (typeof matroskaElements)[keyof typeof matroskaElements]) => Uint8Array;
+export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
+export declare const padMatroskaBytes: (fields: PossibleEbmlOrUint8Array, totalLength: number) => BytesAndOffset[];
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export declare function serializeUint16(value: number): Uint8Array;

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

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineUint8Arrays = exports.padMatroskaBytes = exports.makeMatroskaBytes = exports.matroskaToHex = exports.webmPattern = void 0;
+exports.serializeUint16 = serializeUint16;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const ebml_1 = require("./ebml");
+const all_segments_1 = require("./segments/all-segments");
+exports.webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const matroskaToHex = (matrId) => {
+    const numbers = new Uint8Array((matrId.length - 2) / 2);
+    for (let i = 2; i < matrId.length; i += 2) {
+        const hex = matrId.substring(i, i + 2);
+        numbers[(i - 2) / 2] = parseInt(hex, 16);
+    }
+    return numbers;
+};
+exports.matroskaToHex = matroskaToHex;
+function putUintDynamic(number, minimumLength) {
+    if (number < 0) {
+        throw new Error('This function is designed for non-negative integers only.');
+    }
+    // Calculate the minimum number of bytes needed to store the integer
+    const length = Math.max(minimumLength !== null && minimumLength !== void 0 ? minimumLength : 0, Math.ceil(Math.log2(number + 1) / 8));
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        // Extract each byte from the number
+        bytes[length - 1 - i] = (number >> (8 * i)) & 0xff;
+    }
+    return bytes;
+}
+const makeFromStructure = (fields) => {
+    if ('bytes' in fields) {
+        return fields;
+    }
+    const arrays = [];
+    const struct = all_segments_1.ebmlMap[(0, all_segments_1.getIdForName)(fields.type)];
+    if (struct.type === 'uint8array') {
+        return {
+            bytes: fields.value,
+            offsets: { offset: 0, children: [], field: fields.type },
+        };
+    }
+    if (struct.type === 'children') {
+        const children = [];
+        let bytesWritten = 0;
+        for (const item of fields.value) {
+            const { bytes, offsets } = (0, exports.makeMatroskaBytes)(item);
+            arrays.push(bytes);
+            children.push((0, all_segments_1.incrementOffsetAndChildren)(offsets, bytesWritten));
+            bytesWritten += bytes.byteLength;
+        }
+        return {
+            bytes: (0, exports.combineUint8Arrays)(arrays),
+            offsets: { offset: 0, children, field: fields.type },
+        };
+    }
+    if (struct.type === 'string') {
+        return {
+            bytes: new TextEncoder().encode(fields.value),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'uint') {
+        return {
+            bytes: putUintDynamic(fields.value.value, fields.value.byteLength),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'hex-string') {
+        const hex = fields.value.substring(2);
+        const arr = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+            const byte = parseInt(hex.substring(i, i + 2), 16);
+            arr[i / 2] = byte;
+        }
+        return {
+            bytes: arr,
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    if (struct.type === 'float') {
+        const value = fields.value;
+        if (value.size === '32') {
+            const dataView = new DataView(new ArrayBuffer(4));
+            dataView.setFloat32(0, value.value);
+            return {
+                bytes: new Uint8Array(dataView.buffer),
+                offsets: {
+                    children: [],
+                    offset: 0,
+                    field: fields.type,
+                },
+            };
+        }
+        const dataView2 = new DataView(new ArrayBuffer(8));
+        dataView2.setFloat64(0, value.value);
+        return {
+            bytes: new Uint8Array(dataView2.buffer),
+            offsets: {
+                children: [],
+                offset: 0,
+                field: fields.type,
+            },
+        };
+    }
+    throw new Error('Unexpected type');
+};
+const makeMatroskaBytes = (fields) => {
+    if ('bytes' in fields) {
+        return fields;
+    }
+    const value = makeFromStructure(fields);
+    const header = (0, exports.matroskaToHex)((0, all_segments_1.getIdForName)(fields.type));
+    const size = (0, ebml_1.getVariableInt)(value.bytes.length, fields.minVintWidth);
+    const bytes = (0, exports.combineUint8Arrays)([header, size, value.bytes]);
+    return {
+        bytes,
+        offsets: {
+            offset: value.offsets.offset,
+            field: value.offsets.field,
+            children: value.offsets.children.map((c) => {
+                return (0, all_segments_1.incrementOffsetAndChildren)(c, header.byteLength + size.byteLength);
+            }),
+        },
+    };
+};
+exports.makeMatroskaBytes = makeMatroskaBytes;
+const padMatroskaBytes = (fields, totalLength) => {
+    const regular = (0, exports.makeMatroskaBytes)(fields);
+    const paddingLength = totalLength -
+        regular.bytes.byteLength -
+        (0, exports.matroskaToHex)(all_segments_1.matroskaElements.Void).byteLength;
+    if (paddingLength < 0) {
+        throw new Error('ooops');
+    }
+    const padding = (0, exports.makeMatroskaBytes)({
+        type: 'Void',
+        value: new Uint8Array(paddingLength).fill(0),
+        minVintWidth: null,
+    });
+    return [
+        regular,
+        {
+            bytes: padding.bytes,
+            offsets: (0, all_segments_1.incrementOffsetAndChildren)(padding.offsets, regular.bytes.length),
+        },
+    ];
+};
+exports.padMatroskaBytes = padMatroskaBytes;
+const combineUint8Arrays = (arrays) => {
+    if (arrays.length === 0) {
+        return new Uint8Array([]);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    let totalLength = 0;
+    for (const array of arrays) {
+        totalLength += array.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+};
+exports.combineUint8Arrays = combineUint8Arrays;
+function serializeUint16(value) {
+    const buffer = new ArrayBuffer(2);
+    const view = new DataView(buffer);
+    view.setUint16(0, value);
+    return new Uint8Array(buffer);
+}

package/dist/boxes/webm/make-track.d.ts

@@ -0,0 +1,9 @@
+import type { AudioTrack, MediaParserAudioCodec, VideoTrack } from '../../get-tracks';
+import type { TrackEntry } from './segments/all-segments';
+export declare const getMatroskaAudioCodecWithoutConfigString: ({ track, }: {
+    track: TrackEntry;
+}) => MediaParserAudioCodec;
+export declare const getTrack: ({ timescale, track, }: {
+    timescale: number;
+    track: TrackEntry;
+}) => VideoTrack | AudioTrack | null;