@remotion/media-parser 4.0.206 → 4.0.208

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, length: number) => VoidSegment;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVoidSegment = void 0;
+const parseVoidSegment = (iterator, length) => {
+    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, length: number) => WritingAppSegment;

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

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

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserContext } from '../../parser-context';
+import type { MatroskaSegment } from './segments';
+export type TracksSegment = {
+    type: 'tracks-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTracksSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TracksSegment>;

package/dist/boxes/webm/tracks.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTracksSegment = void 0;
+const parse_children_1 = require("./segments/parse-children");
+const parseTracksSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
+    return {
+        type: 'tracks-segment',
+        children: children.segments,
+    };
+};
+exports.parseTracksSegment = parseTracksSegment;

package/dist/combine-uint8array.d.ts

@@ -0,0 +1 @@
+export declare const combineUint8Arrays: (array1: Uint8Array | null, array2: Uint8Array) => Uint8Array;

package/dist/combine-uint8array.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineUint8Arrays = void 0;
+const combineUint8Arrays = (array1, array2) => {
+    if (!array1) {
+        return array2;
+    }
+    const combined = new Uint8Array(array1.length + array2.length);
+    combined.set(array1);
+    combined.set(array2, array1.length);
+    return combined;
+};
+exports.combineUint8Arrays = combineUint8Arrays;

package/dist/create/cluster-segment.d.ts

@@ -0,0 +1,10 @@
+export declare const CLUSTER_MIN_VINT_WIDTH = 8;
+export declare const createClusterSegment: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;
+export declare const makeSimpleBlock: ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }: {
+    bytes: Uint8Array;
+    trackNumber: number;
+    timecodeRelativeToCluster: number;
+    keyframe: boolean;
+    invisible: boolean;
+    lacing: number;
+}) => Uint8Array;

package/dist/create/cluster-segment.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSimpleBlock = exports.createClusterSegment = exports.CLUSTER_MIN_VINT_WIDTH = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+exports.CLUSTER_MIN_VINT_WIDTH = 8;
+const createClusterSegment = () => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Cluster',
+        value: [
+            {
+                type: 'Timestamp',
+                minVintWidth: 4,
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+            },
+        ],
+        minVintWidth: exports.CLUSTER_MIN_VINT_WIDTH,
+    });
+};
+exports.createClusterSegment = createClusterSegment;
+const makeSimpleBlock = ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }) => {
+    const simpleBlockHeader = (0, make_header_1.matroskaToHex)('0xa3');
+    const headerByte = (Number(keyframe) << 7) | (Number(invisible) << 3) | (lacing << 1);
+    const body = (0, make_header_1.combineUint8Arrays)([
+        (0, ebml_1.getVariableInt)(trackNumber, null),
+        // TODO: Cannot encode long videos because of uint16 overflow
+        // need to make new cluster
+        (0, make_header_1.serializeUint16)(timecodeRelativeToCluster),
+        new Uint8Array([headerByte]),
+        bytes,
+    ]);
+    return (0, make_header_1.combineUint8Arrays)([
+        simpleBlockHeader,
+        (0, ebml_1.getVariableInt)(body.length, null),
+        body,
+    ]);
+};
+exports.makeSimpleBlock = makeSimpleBlock;

package/dist/create/create-media.d.ts

@@ -0,0 +1,13 @@
+import type { WriterInterface } from '../writers/writer';
+import type { MakeTrackAudio, MakeTrackVideo } from './matroska-trackentry';
+export type MediaFn = {
+    save: () => Promise<void>;
+    addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+    updateDuration: (duration: number) => Promise<void>;
+    addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{
+        trackNumber: number;
+    }>;
+    addWaitForFinishPromise: (promise: () => Promise<void>) => void;
+    waitForFinish: () => Promise<void>;
+};
+export declare const createMedia: (writer: WriterInterface) => Promise<MediaFn>;

package/dist/create/create-media.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMedia = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+const all_segments_1 = require("../boxes/webm/segments/all-segments");
+const cluster_segment_1 = require("./cluster-segment");
+const matroska_header_1 = require("./matroska-header");
+const matroska_info_1 = require("./matroska-info");
+const matroska_segment_1 = require("./matroska-segment");
+const matroska_trackentry_1 = require("./matroska-trackentry");
+const createMedia = async (writer) => {
+    var _a, _b, _c, _d;
+    const header = (0, matroska_header_1.makeMatroskaHeader)();
+    const w = await writer.createContent();
+    await w.write(header.bytes);
+    const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
+        timescale: 1000000,
+        // TODO: Hardcoded
+        duration: 2658,
+    });
+    const currentTracks = [];
+    const matroskaTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+    const matroskaSegment = (0, matroska_segment_1.createMatroskaSegment)([
+        matroskaInfo,
+        ...matroskaTracks,
+    ]);
+    const durationOffset = ((_b = (_a = matroskaSegment.offsets.children[0].children.find((c) => c.field === 'Duration')) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0) + w.getWrittenByteCount();
+    const tracksOffset = ((_d = (_c = matroskaSegment.offsets.children.find((o) => o.field === 'Tracks')) === null || _c === void 0 ? void 0 : _c.offset) !== null && _d !== void 0 ? _d : 0) + w.getWrittenByteCount();
+    if (!durationOffset) {
+        throw new Error('could not get duration offset');
+    }
+    if (!tracksOffset) {
+        throw new Error('could not get tracks offset');
+    }
+    await w.write(matroskaSegment.bytes);
+    const cluster = (0, cluster_segment_1.createClusterSegment)();
+    const clusterVIntPosition = w.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength;
+    await w.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const arr = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(arr);
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: arr,
+            invisible: false,
+            keyframe: chunk.type === 'key',
+            lacing: 0,
+            trackNumber,
+            // TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
+            // Maybe it only works by coincidence
+            timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
+        });
+        clusterSize += simpleBlock.byteLength;
+        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await w.write(simpleBlock);
+    };
+    const updateDuration = async (newDuration) => {
+        const blocks = (0, make_header_1.padMatroskaBytes)({
+            type: 'Duration',
+            value: {
+                value: newDuration,
+                size: '64',
+            },
+            minVintWidth: null,
+        }, 
+        // TODO: That's too much padding
+        1000);
+        await w.updateDataAt(durationOffset, (0, make_header_1.combineUint8Arrays)(blocks.map((b) => b.bytes)));
+    };
+    const addTrack = async (track) => {
+        currentTracks.push(track);
+        const newTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+        await w.updateDataAt(tracksOffset, (0, make_header_1.combineUint8Arrays)(newTracks.map((b) => b.bytes)));
+    };
+    let operationProm = Promise.resolve();
+    const waitForFinishPromises = [];
+    return {
+        save: async () => {
+            await w.save();
+        },
+        addSample: (chunk, trackNumber) => {
+            operationProm = operationProm.then(() => addSample(chunk, trackNumber));
+            return operationProm;
+        },
+        updateDuration: (duration) => {
+            operationProm = operationProm.then(() => updateDuration(duration));
+            return operationProm;
+        },
+        addTrack: (track) => {
+            const trackNumber = currentTracks.length + 1;
+            const bytes = track.type === 'video'
+                ? (0, matroska_trackentry_1.makeMatroskaVideoTrackEntryBytes)({ ...track, trackNumber })
+                : (0, matroska_trackentry_1.makeMatroskaAudioTrackEntryBytes)({ ...track, trackNumber });
+            operationProm = operationProm.then(() => addTrack(bytes));
+            return operationProm.then(() => ({ trackNumber }));
+        },
+        addWaitForFinishPromise: (promise) => {
+            waitForFinishPromises.push(promise);
+        },
+        async waitForFinish() {
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+        },
+    };
+};
+exports.createMedia = createMedia;

package/dist/create/matroska-header.d.ts

@@ -0,0 +1 @@
+export declare const makeMatroskaHeader: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-header.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaHeader = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaHeader = () => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Header',
+        value: [
+            {
+                minVintWidth: null,
+                type: 'EBMLVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                minVintWidth: null,
+                type: 'EBMLReadVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                type: 'EBMLMaxIDLength',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'EBMLMaxSizeLength',
+                value: {
+                    byteLength: null,
+                    value: 8,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocType',
+                value: 'webm',
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeVersion',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeReadVersion',
+                value: {
+                    byteLength: null,
+                    value: 2,
+                },
+                minVintWidth: null,
+            },
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaHeader = makeMatroskaHeader;

package/dist/create/matroska-info.d.ts

@@ -0,0 +1,4 @@
+export declare const makeMatroskaInfo: ({ timescale, duration, }: {
+    timescale: number;
+    duration: number;
+}) => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-info.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaInfo = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaInfo = ({ timescale, duration, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Info',
+        value: [
+            {
+                type: 'TimestampScale',
+                value: {
+                    value: timescale,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'MuxingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            {
+                type: 'WritingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            ...(0, make_header_1.padMatroskaBytes)({
+                type: 'Duration',
+                value: {
+                    value: duration,
+                    size: '64',
+                },
+                minVintWidth: null,
+            }, 
+            // TODO: That's too much padding
+            1000),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaInfo = makeMatroskaInfo;

package/dist/create/matroska-segment.d.ts

@@ -0,0 +1,2 @@
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export declare const createMatroskaSegment: (children: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska-segment.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSegment = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaSegment = (children) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Segment',
+        value: children,
+        minVintWidth: 8,
+    });
+};
+exports.createMatroskaSegment = createMatroskaSegment;

package/dist/create/matroska-trackentry.d.ts

@@ -0,0 +1,32 @@
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export type MatroskaColorParams = {
+    transferChracteristics: 'bt709' | 'smpte170m' | 'iec61966-2-1' | null;
+    matrixCoefficients: 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | null;
+    primaries: 'bt709' | 'smpte170m' | 'bt470bg' | null;
+    fullRange: boolean | null;
+};
+export declare const makeMatroskaColorBytes: ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }: MatroskaColorParams) => BytesAndOffset;
+export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+}) => BytesAndOffset;
+export type MakeTrackAudio = {
+    trackNumber: number;
+    codecId: string;
+    numberOfChannels: number;
+    sampleRate: number;
+    type: 'audio';
+};
+export type MakeTrackVideo = {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+    defaultDuration: number;
+    trackNumber: number;
+    codecId: string;
+    type: 'video';
+};
+export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }: MakeTrackAudio) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: MakeTrackVideo) => BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset[];