@remotion/webcodecs 4.0.245 → 4.0.247

package/dist/create/iso-base-media/trak/mdia/minf/create-vmhd.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVmhd = void 0;
+const matroska_utils_1 = require("../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../primitives");
+const createVmhd = () => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('vmhd'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 1]),
+        // graphics mode, 0 = copy
+        new Uint8Array([0, 0]),
+        // opcolor
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+    ]));
+};
+exports.createVmhd = createVmhd;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-ctts.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createCttsBox: (samplePositions: SamplePosition[]) => Uint8Array | null;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-ctts.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCttsBox = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const makeEntry = (entry) => {
+    return (0, matroska_utils_1.combineUint8Arrays)([
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleCount),
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleOffset),
+    ]);
+};
+const createCttsBox = (samplePositions) => {
+    const offsets = samplePositions.map((s) => s.cts - s.dts);
+    const entries = [];
+    let lastOffset = null;
+    for (const offset of offsets) {
+        if (lastOffset === offset) {
+            entries[entries.length - 1].sampleCount++;
+        }
+        else {
+            entries.push({
+                sampleCount: 1,
+                sampleOffset: offset,
+            });
+        }
+        lastOffset = offset;
+    }
+    const needsCtts = entries.length > 0 && entries.some((e) => e.sampleOffset !== 0);
+    if (!needsCtts) {
+        return null;
+    }
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('ctts'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // entry count
+        (0, primitives_1.numberTo32BitUIntOrInt)(entries.length),
+        // entries
+        ...entries.map((e) => makeEntry(e)),
+    ]));
+};
+exports.createCttsBox = createCttsBox;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stco.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createStcoAtom: (samplePositions: SamplePosition[]) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stco.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStcoAtom = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const createStcoAtom = (samplePositions) => {
+    const chunkOffsets = [];
+    let lastChunk;
+    for (const sample of samplePositions) {
+        if (lastChunk !== sample.chunk) {
+            chunkOffsets.push(sample.offset);
+        }
+        lastChunk = sample.chunk;
+    }
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stco'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // number of entries
+        (0, primitives_1.numberTo32BitUIntOrInt)(chunkOffsets.length),
+        // chunk offsets
+        ...chunkOffsets.map((offset) => (0, primitives_1.numberTo32BitUIntOrInt)(offset)),
+    ]));
+};
+exports.createStcoAtom = createStcoAtom;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsc.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createStsc: (samplePositions: SamplePosition[]) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsc.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStsc = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const createEntry = (entry) => {
+    return (0, matroska_utils_1.combineUint8Arrays)([
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.firstChunk),
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.samplesPerChunk),
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleDescriptionIndex),
+    ]);
+};
+const createStsc = (samplePositions) => {
+    const entries = [];
+    const deduplicateLastEntry = () => {
+        const lastEntry = entries[entries.length - 1];
+        const secondToLastEntry = entries[entries.length - 2];
+        if (lastEntry &&
+            secondToLastEntry &&
+            lastEntry.samplesPerChunk === secondToLastEntry.samplesPerChunk &&
+            lastEntry.sampleDescriptionIndex ===
+                secondToLastEntry.sampleDescriptionIndex) {
+            const lastIndex = entries.length - 1;
+            entries.length = lastIndex;
+        }
+    };
+    let lastChunk;
+    for (const samplePosition of samplePositions) {
+        if (samplePosition.chunk === lastChunk) {
+            entries[entries.length - 1].samplesPerChunk++;
+        }
+        else {
+            deduplicateLastEntry();
+            entries.push({
+                firstChunk: samplePosition.chunk,
+                samplesPerChunk: 1,
+                sampleDescriptionIndex: 1,
+            });
+            lastChunk = samplePosition.chunk;
+        }
+    }
+    deduplicateLastEntry();
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stsc'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // entry count
+        (0, primitives_1.numberTo32BitUIntOrInt)(entries.length),
+        // entries
+        ...entries.map((e) => createEntry(e)),
+    ]));
+};
+exports.createStsc = createStsc;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stss.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createStss: (samplePositions: SamplePosition[]) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stss.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStss = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const createStss = (samplePositions) => {
+    const samples = samplePositions
+        .map((sample, i) => [sample.isKeyframe, i])
+        .filter((s) => s[0])
+        .map((s) => s[1] + 1);
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stss'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // entry count
+        (0, primitives_1.numberTo32BitUIntOrInt)(samples.length),
+        ...samples.map((sample) => (0, primitives_1.numberTo32BitUIntOrInt)(sample)),
+    ]));
+};
+exports.createStss = createStss;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsz.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createStsz: (samplePositions: SamplePosition[]) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsz.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStsz = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const createStsz = (samplePositions) => {
+    const sampleSizes = samplePositions.map((samplePosition) => samplePosition.size);
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stsz'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // sample size
+        // Possible optimization for the future: If all sizes are the same, we don't have to list them all out
+        // https://developer.apple.com/documentation/quicktime-file-format/sample_size_atom
+        (0, primitives_1.numberTo32BitUIntOrInt)(0),
+        // number of entries
+        (0, primitives_1.numberTo32BitUIntOrInt)(sampleSizes.length),
+        // sample sizes
+        ...sampleSizes.map((size) => (0, primitives_1.numberTo32BitUIntOrInt)(size)),
+    ]));
+};
+exports.createStsz = createStsz;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stts.d.ts

@@ -0,0 +1,2 @@
+import type { SamplePosition } from '@remotion/media-parser';
+export declare const createSttsAtom: (samplePositions: SamplePosition[]) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stts.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSttsAtom = void 0;
+const matroska_utils_1 = require("../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../primitives");
+const makeEntry = (entry) => {
+    if (entry.sampleOffset < 0) {
+        throw new Error('negative sample offset in stts ' + entry.sampleOffset);
+    }
+    return (0, matroska_utils_1.combineUint8Arrays)([
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleCount),
+        (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleOffset),
+    ]);
+};
+const createSttsAtom = (samplePositions) => {
+    let lastDuration = null;
+    const durations = samplePositions.map((_, i, a) => {
+        var _a, _b;
+        // TODO: Why does 0 appear here?
+        if (a[i].duration === undefined || a[i].duration === 0) {
+            return ((_b = (_a = a[i + 1]) === null || _a === void 0 ? void 0 : _a.dts) !== null && _b !== void 0 ? _b : a[i].dts) - a[i].dts;
+        }
+        return a[i].duration;
+    });
+    const entries = [];
+    for (const duration of durations) {
+        if (duration === lastDuration) {
+            entries[entries.length - 1].sampleCount++;
+        }
+        else {
+            entries.push({
+                sampleCount: 1,
+                sampleOffset: duration,
+            });
+        }
+        lastDuration = duration;
+    }
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stts'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // entry count
+        (0, primitives_1.numberTo32BitUIntOrInt)(entries.length),
+        // entries
+        ...entries.map((e) => makeEntry(e)),
+    ]));
+};
+exports.createSttsAtom = createSttsAtom;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avc1.d.ts

@@ -0,0 +1 @@
+export declare const createStsdData: (codecSpecificData: Uint8Array) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avc1.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStsdData = void 0;
+const matroska_utils_1 = require("../../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../../primitives");
+const createStsdData = (codecSpecificData) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('stsd'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // entry count
+        new Uint8Array([0, 0, 0, 1]),
+        // entry
+        codecSpecificData,
+    ]));
+};
+exports.createStsdData = createStsdData;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avcc.d.ts

@@ -0,0 +1 @@
+export declare const createAvccBox: (privateData: Uint8Array | null) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avcc.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAvccBox = void 0;
+const matroska_utils_1 = require("../../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../../primitives");
+const createAvccBox = (privateData) => {
+    if (!privateData) {
+        throw new Error('privateData is required');
+    }
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('avcC'),
+        privateData,
+    ]));
+};
+exports.createAvccBox = createAvccBox;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.d.ts

@@ -0,0 +1 @@
+export declare const createPasp: (x: number, y: number) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPasp = void 0;
+const matroska_utils_1 = require("../../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../../primitives");
+const createPasp = (x, y) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        (0, primitives_1.stringsToUint8Array)('pasp'),
+        (0, primitives_1.numberTo32BitUIntOrInt)(x),
+        (0, primitives_1.numberTo32BitUIntOrInt)(y),
+    ]));
+};
+exports.createPasp = createPasp;

package/dist/create/iso-base-media/udta/create-meta.d.ts

@@ -0,0 +1,4 @@
+export declare const createMeta: ({ hdlr, ilst, }: {
+    hdlr: Uint8Array;
+    ilst: Uint8Array;
+}) => Uint8Array;

package/dist/create/iso-base-media/udta/create-meta.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMeta = void 0;
+const matroska_utils_1 = require("../../matroska/matroska-utils");
+const primitives_1 = require("../primitives");
+const createMeta = ({ hdlr, ilst, }) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('meta'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // hdlr
+        hdlr,
+        // ilst
+        ilst,
+    ]));
+};
+exports.createMeta = createMeta;

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

@@ -0,0 +1 @@
+export declare const createHdlr: (type: "video" | "audio" | "mdir") => Uint8Array;

package/dist/create/iso-base-media/udta/meta/create-hdlr.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHdlr = void 0;
+const matroska_utils_1 = require("../../../matroska/matroska-utils");
+const primitives_1 = require("../../primitives");
+const createHdlr = (type) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('hdlr'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // pre_defined
+        new Uint8Array([0, 0, 0, 0]),
+        // handler_type
+        (0, primitives_1.stringsToUint8Array)(type === 'mdir' ? 'mdir' : type === 'video' ? 'vide' : 'soun'),
+        // reserved
+        type === 'mdir'
+            ? (0, primitives_1.numberTo32BitUIntOrInt)(1634758764)
+            : new Uint8Array([0, 0, 0, 0]),
+        new Uint8Array([0, 0, 0, 0]),
+        new Uint8Array([0, 0, 0, 0]),
+        // name
+        (0, primitives_1.stringsToUint8Array)(type === 'mdir'
+            ? '\0'
+            : type === 'video'
+                ? 'VideoHandler\0'
+                : 'SoundHandler\0'),
+    ]));
+};
+exports.createHdlr = createHdlr;

package/dist/create/make-track-info.d.ts

@@ -0,0 +1,20 @@
+import type { MediaParserAudioCodec, MediaParserVideoCodec, VideoTrackColorParams } from '@remotion/media-parser';
+export type MakeTrackAudio = {
+    trackNumber: number;
+    codec: MediaParserAudioCodec;
+    numberOfChannels: number;
+    sampleRate: number;
+    type: 'audio';
+    codecPrivate: Uint8Array | null;
+    timescale: number;
+};
+export type MakeTrackVideo = {
+    color: VideoTrackColorParams;
+    width: number;
+    height: number;
+    trackNumber: number;
+    codec: MediaParserVideoCodec;
+    type: 'video';
+    codecPrivate: Uint8Array | null;
+    timescale: number;
+};

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

@@ -0,0 +1,10 @@
+export declare const CLUSTER_MIN_VINT_WIDTH = 8;
+export declare const createClusterSegment: (timestamp: number) => import("./matroska-utils").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/matroska/cluster-segment.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSimpleBlock = exports.createClusterSegment = exports.CLUSTER_MIN_VINT_WIDTH = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+exports.CLUSTER_MIN_VINT_WIDTH = 8;
+const createClusterSegment = (timestamp) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Cluster',
+        value: [
+            {
+                type: 'Timestamp',
+                minVintWidth: null,
+                value: {
+                    value: timestamp,
+                    byteLength: null,
+                },
+            },
+        ],
+        minVintWidth: exports.CLUSTER_MIN_VINT_WIDTH,
+    });
+};
+exports.createClusterSegment = createClusterSegment;
+const makeSimpleBlock = ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }) => {
+    const simpleBlockHeader = (0, matroska_utils_1.matroskaToHex)('0xa3');
+    const headerByte = (Number(keyframe) << 7) | (Number(invisible) << 3) | (lacing << 1);
+    const body = (0, matroska_utils_1.combineUint8Arrays)([
+        (0, matroska_utils_1.getVariableInt)(trackNumber, null),
+        (0, matroska_utils_1.serializeUint16)(timecodeRelativeToCluster),
+        new Uint8Array([headerByte]),
+        bytes,
+    ]);
+    return (0, matroska_utils_1.combineUint8Arrays)([
+        simpleBlockHeader,
+        (0, matroska_utils_1.getVariableInt)(body.length, null),
+        body,
+    ]);
+};
+exports.makeSimpleBlock = makeSimpleBlock;

package/dist/create/matroska/cluster.d.ts

@@ -0,0 +1,25 @@
+import { type AudioOrVideoSample } from '@remotion/media-parser';
+import type { LogLevel } from '../../log';
+import type { Writer } from '../../writers/writer';
+export declare const timestampToClusterTimestamp: (timestamp: number, timescale: number) => number;
+export declare const canFitInCluster: ({ clusterStartTimestamp, chunk, timescale, }: {
+    clusterStartTimestamp: number;
+    chunk: AudioOrVideoSample;
+    timescale: number;
+}) => boolean;
+export declare const makeCluster: ({ writer, clusterStartTimestamp, timescale, logLevel, }: {
+    writer: Writer;
+    clusterStartTimestamp: number;
+    timescale: number;
+    logLevel: LogLevel;
+}) => Promise<{
+    addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<{
+        timecodeRelativeToCluster: number;
+    }>;
+    shouldMakeNewCluster: ({ isVideo, chunk, newT, }: {
+        newT: number;
+        chunk: AudioOrVideoSample;
+        isVideo: boolean;
+    }) => boolean;
+    startTimestamp: number;
+}>;

package/dist/create/matroska/cluster.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCluster = exports.canFitInCluster = exports.timestampToClusterTimestamp = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const log_1 = require("../../log");
+const cluster_segment_1 = require("./cluster-segment");
+const matroska_utils_1 = require("./matroska-utils");
+const maxClusterTimestamp = 2 ** 15;
+const timestampToClusterTimestamp = (timestamp, timescale) => {
+    return Math.round((timestamp / timescale) * 1000);
+};
+exports.timestampToClusterTimestamp = timestampToClusterTimestamp;
+const canFitInCluster = ({ clusterStartTimestamp, chunk, timescale, }) => {
+    const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
+        (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
+    if (timecodeRelativeToCluster < 0) {
+        throw new Error(`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`);
+    }
+    return timecodeRelativeToCluster <= maxClusterTimestamp;
+};
+exports.canFitInCluster = canFitInCluster;
+const makeCluster = async ({ writer, clusterStartTimestamp, timescale, logLevel, }) => {
+    log_1.Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
+    const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale));
+    const clusterVIntPosition = writer.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, matroska_utils_1.matroskaToHex)(media_parser_1.MediaParserInternals.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength -
+        (0, matroska_utils_1.matroskaToHex)(media_parser_1.MediaParserInternals.matroskaElements.Cluster).byteLength -
+        cluster_segment_1.CLUSTER_MIN_VINT_WIDTH;
+    await writer.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
+            (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
+        if (!(0, exports.canFitInCluster)({ clusterStartTimestamp, chunk, timescale })) {
+            throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
+        }
+        const keyframe = chunk.type === 'key';
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: chunk.data,
+            invisible: false,
+            keyframe,
+            lacing: 0,
+            trackNumber,
+            timecodeRelativeToCluster,
+        });
+        clusterSize += simpleBlock.byteLength;
+        await writer.updateDataAt(clusterVIntPosition, (0, matroska_utils_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await writer.write(simpleBlock);
+        return { timecodeRelativeToCluster };
+    };
+    const shouldMakeNewCluster = ({ isVideo, chunk, newT, }) => {
+        const newTimestamp = (0, exports.timestampToClusterTimestamp)(newT, timescale);
+        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
+        const canFit = (0, exports.canFitInCluster)({
+            chunk,
+            clusterStartTimestamp,
+            timescale,
+        });
+        if (!canFit) {
+            // We must create a new cluster
+            // This is for example if we have an audio-only file
+            log_1.Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
+            return true;
+        }
+        const keyframe = chunk.type === 'key';
+        // TODO: Timestamp falls apart when video only
+        return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
+    };
+    return {
+        addSample,
+        shouldMakeNewCluster,
+        startTimestamp: clusterStartTimestamp,
+    };
+};
+exports.makeCluster = makeCluster;

package/dist/create/matroska/color.d.ts

@@ -0,0 +1,2 @@
+import type { VideoTrackColorParams } from '@remotion/media-parser';
+export declare const makeMatroskaColorBytes: ({ transferCharacteristics, matrixCoefficients, primaries, fullRange, }: VideoTrackColorParams) => import("./matroska-utils").BytesAndOffset;