@remotion/media-parser 4.0.208 → 4.0.210

package/dist/buffer-iterator.js

@@ -370,6 +370,12 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             for (let i = 1; i < actualLength; i++) {
                 value = (value << 8) | d[i];
             }
+            // Livestreamed segments sometimes have a Cluster length of 0xFFFFFFFFFFFFFF
+            // which we parse as -1
+            // this should be treated as Infinity
+            if (value === -1) {
+                return Infinity;
+            }
             return value;
         },
         getUint8,

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

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

package/dist/create/cluster-segment.js

@@ -4,15 +4,15 @@ exports.makeSimpleBlock = exports.createClusterSegment = exports.CLUSTER_MIN_VIN
 const ebml_1 = require("../boxes/webm/ebml");
 const make_header_1 = require("../boxes/webm/make-header");
 exports.CLUSTER_MIN_VINT_WIDTH = 8;
-const createClusterSegment = () => {
+const createClusterSegment = (timestamp) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Cluster',
         value: [
             {
                 type: 'Timestamp',
-                minVintWidth: 4,
+                minVintWidth: null,
                 value: {
-                    value: 0,
+                    value: timestamp,
                     byteLength: null,
                 },
             },
@@ -26,8 +26,6 @@ const makeSimpleBlock = ({ bytes, trackNumber, timecodeRelativeToCluster, keyfra
     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,

package/dist/create/cluster.d.ts

@@ -0,0 +1,13 @@
+import type { Writer } from '../writers/writer';
+export type AudioOrVideoSample = {
+    timestamp: number;
+    type: 'key' | 'delta';
+    copyTo(destination: AllowSharedBufferSource): void;
+    byteLength: number;
+    duration: number | null;
+};
+export declare const timestampToClusterTimestamp: (timestamp: number) => number;
+export declare const makeCluster: (w: Writer, timestamp: number) => Promise<{
+    addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<void>;
+    shouldMakeNewCluster: (newT: number, keyframe: boolean) => boolean;
+}>;

package/dist/create/cluster.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCluster = exports.timestampToClusterTimestamp = 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 timescale_1 = require("./timescale");
+const maxClusterTimestamp = 2 ** 15;
+const timestampToClusterTimestamp = (timestamp) => {
+    return Math.round((timestamp / timescale_1.CREATE_TIME_SCALE) * 1000);
+};
+exports.timestampToClusterTimestamp = timestampToClusterTimestamp;
+const makeCluster = async (w, timestamp) => {
+    const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(timestamp));
+    const clusterVIntPosition = w.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength -
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength -
+        cluster_segment_1.CLUSTER_MIN_VINT_WIDTH;
+    await w.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const arr = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(arr);
+        const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp) -
+            (0, exports.timestampToClusterTimestamp)(timestamp);
+        if (timecodeRelativeToCluster < 0) {
+            throw new Error(`timecodeRelativeToCluster is negative (track ${trackNumber})`);
+        }
+        if (timecodeRelativeToCluster > maxClusterTimestamp) {
+            throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
+        }
+        const keyframe = chunk.type === 'key';
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: arr,
+            invisible: false,
+            keyframe,
+            lacing: 0,
+            trackNumber,
+            timecodeRelativeToCluster,
+        });
+        clusterSize += simpleBlock.byteLength;
+        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await w.write(simpleBlock);
+    };
+    const shouldMakeNewCluster = (newT, keyframe) => {
+        const newTimestamp = (0, exports.timestampToClusterTimestamp)(newT);
+        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(timestamp);
+        return newTimestamp - oldTimestamp >= 2000 && keyframe;
+    };
+    return { addSample, shouldMakeNewCluster };
+};
+exports.makeCluster = makeCluster;

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

@@ -1,8 +1,10 @@
 import type { WriterInterface } from '../writers/writer';
+import type { AudioOrVideoSample } from './cluster';
 import type { MakeTrackAudio, MakeTrackVideo } from './matroska-trackentry';
 export type MediaFn = {
-    save: () => Promise<void>;
-    addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+    save: () => Promise<File>;
+    remove: () => Promise<void>;
+    addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<void>;
     updateDuration: (duration: number) => Promise<void>;
     addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{
         trackNumber: number;

package/dist/create/create-media.js

@@ -4,104 +4,144 @@ 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 cluster_1 = require("./cluster");
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
+const matroska_cues_1 = require("./matroska-cues");
 const matroska_header_1 = require("./matroska-header");
 const matroska_info_1 = require("./matroska-info");
+const matroska_seek_1 = require("./matroska-seek");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
+const timescale_1 = require("./timescale");
 const createMedia = async (writer) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     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,
+        timescale: timescale_1.CREATE_TIME_SCALE,
     });
     const currentTracks = [];
-    const matroskaTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+    const seeks = [];
+    const cues = [];
+    const trackNumbers = [];
     const matroskaSegment = (0, matroska_segment_1.createMatroskaSegment)([
         matroskaInfo,
-        ...matroskaTracks,
+        ...(0, matroska_seek_1.createMatroskaSeekHead)(seeks),
+        ...(0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks),
     ]);
     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();
+    const seekHeadOffset = ((_f = (_e = matroskaSegment.offsets.children.find((o) => o.field === 'SeekHead')) === null || _e === void 0 ? void 0 : _e.offset) !== null && _f !== void 0 ? _f : 0) + w.getWrittenByteCount();
+    if (!seekHeadOffset) {
+        throw new Error('could not get seek offset');
+    }
     if (!durationOffset) {
         throw new Error('could not get duration offset');
     }
     if (!tracksOffset) {
         throw new Error('could not get tracks offset');
     }
+    seeks.push({
+        hexString: all_segments_1.matroskaElements.Tracks,
+        byte: tracksOffset - seekHeadOffset,
+    });
+    const updateSeekWrite = async () => {
+        const updatedSeek = (0, matroska_seek_1.createMatroskaSeekHead)(seeks);
+        await w.updateDataAt(seekHeadOffset, (0, make_header_1.combineUint8Arrays)(updatedSeek.map((b) => b.bytes)));
+    };
+    const segmentOffset = w.getWrittenByteCount() +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Segment).byteLength;
+    const updateSegmentSize = async (size) => {
+        const data = (0, ebml_1.getVariableInt)(size, matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH);
+        await w.updateDataAt(segmentOffset, data);
+    };
     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),
+    const clusterOffset = w.getWrittenByteCount();
+    let currentCluster = await (0, cluster_1.makeCluster)(w, 0);
+    seeks.push({
+        hexString: all_segments_1.matroskaElements.Cluster,
+        byte: clusterOffset - seekHeadOffset,
+    });
+    cues.push({
+        time: 0,
+        clusterPosition: clusterOffset - seekHeadOffset,
+        trackNumbers,
+    });
+    const trackNumberProgresses = {};
+    const getClusterOrMakeNew = async (chunk) => {
+        const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+        if (!currentCluster.shouldMakeNewCluster(smallestProgress, chunk.type === 'key')) {
+            return currentCluster;
+        }
+        const newCluster = w.getWrittenByteCount();
+        cues.push({
+            time: smallestProgress,
+            clusterPosition: newCluster - seekHeadOffset,
+            trackNumbers,
         });
-        clusterSize += simpleBlock.byteLength;
-        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
-        await w.write(simpleBlock);
+        currentCluster = await (0, cluster_1.makeCluster)(w, smallestProgress);
+        return currentCluster;
+    };
+    const addSample = async (chunk, trackNumber) => {
+        var _a;
+        trackNumberProgresses[trackNumber] = chunk.timestamp;
+        const cluster = await getClusterOrMakeNew(chunk);
+        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        await updateDuration(newDuration);
+        return cluster.addSample(chunk, trackNumber);
     };
     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 blocks = (0, make_duration_with_padding_1.makeDurationWithPadding)(newDuration);
+        await w.updateDataAt(durationOffset, blocks.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 operationProm = { current: Promise.resolve() };
     const waitForFinishPromises = [];
     return {
         save: async () => {
-            await w.save();
+            const file = await w.save();
+            return file;
+        },
+        remove: async () => {
+            await w.remove();
         },
         addSample: (chunk, trackNumber) => {
-            operationProm = operationProm.then(() => addSample(chunk, trackNumber));
-            return operationProm;
+            operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber));
+            return operationProm.current;
         },
         updateDuration: (duration) => {
-            operationProm = operationProm.then(() => updateDuration(duration));
-            return operationProm;
+            operationProm.current = operationProm.current.then(() => updateDuration(duration));
+            return operationProm.current;
         },
         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 }));
+            operationProm.current = operationProm.current.then(() => addTrack(bytes));
+            trackNumbers.push(trackNumber);
+            return operationProm.current.then(() => ({ trackNumber }));
         },
         addWaitForFinishPromise: (promise) => {
             waitForFinishPromises.push(promise);
         },
         async waitForFinish() {
             await Promise.all(waitForFinishPromises.map((p) => p()));
+            await operationProm.current;
+            seeks.push({
+                hexString: all_segments_1.matroskaElements.Cues,
+                byte: w.getWrittenByteCount() - seekHeadOffset,
+            });
+            await updateSeekWrite();
+            await w.write((0, matroska_cues_1.createMatroskaCues)(cues).bytes);
+            const segmentSize = w.getWrittenByteCount() - segmentOffset;
+            await w.waitForFinish();
+            await updateSegmentSize(segmentSize);
         },
     };
 };

package/dist/create/cues.js

@@ -0,0 +1 @@
+"use strict";

package/dist/create/make-duration-with-padding.d.ts

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

package/dist/create/make-duration-with-padding.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDurationWithPadding = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeDurationWithPadding = (newDuration) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Duration',
+        value: {
+            value: newDuration,
+            size: '64',
+        },
+        minVintWidth: 8,
+    });
+};
+exports.makeDurationWithPadding = makeDurationWithPadding;

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

@@ -0,0 +1,6 @@
+export type Cue = {
+    time: number;
+    clusterPosition: number;
+    trackNumbers: number[];
+};
+export declare const createMatroskaCues: (cues: Cue[]) => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-cues.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaCues = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const cluster_1 = require("./cluster");
+const createMatroskaCues = (cues) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Cues',
+        minVintWidth: null,
+        value: cues.map((cue) => {
+            return {
+                type: 'CuePoint',
+                value: [
+                    {
+                        type: 'CueTime',
+                        minVintWidth: null,
+                        value: {
+                            value: (0, cluster_1.timestampToClusterTimestamp)(cue.time),
+                            byteLength: null,
+                        },
+                    },
+                    ...cue.trackNumbers.map((trackNumber) => ({
+                        type: 'CueTrackPositions',
+                        value: [
+                            {
+                                type: 'CueTrack',
+                                minVintWidth: null,
+                                value: {
+                                    value: trackNumber,
+                                    byteLength: null,
+                                },
+                            },
+                            {
+                                type: 'CueClusterPosition',
+                                minVintWidth: null,
+                                value: {
+                                    value: cue.clusterPosition,
+                                    byteLength: null,
+                                },
+                            },
+                        ],
+                        minVintWidth: null,
+                    })),
+                ],
+                minVintWidth: null,
+            };
+        }),
+    });
+};
+exports.createMatroskaCues = createMatroskaCues;

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

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

package/dist/create/matroska-info.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMatroskaInfo = void 0;
 const make_header_1 = require("../boxes/webm/make-header");
-const makeMatroskaInfo = ({ timescale, duration, }) => {
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
+const makeMatroskaInfo = ({ timescale }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Info',
         value: [
@@ -24,16 +25,7 @@ const makeMatroskaInfo = ({ timescale, duration, }) => {
                 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),
+            (0, make_duration_with_padding_1.makeDurationWithPadding)(0),
         ],
         minVintWidth: null,
     });

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

@@ -0,0 +1,6 @@
+import type { MatroskaElement } from '../boxes/webm/segments/all-segments';
+export type Seek = {
+    hexString: MatroskaElement;
+    byte: number;
+};
+export declare const createMatroskaSeekHead: (seeks: Seek[]) => import("../boxes/webm/segments/all-segments").BytesAndOffset[];

package/dist/create/matroska-seek.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSeekHead = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaSeekHead = (seeks) => {
+    return (0, make_header_1.padMatroskaBytes)((0, make_header_1.makeMatroskaBytes)({
+        type: 'SeekHead',
+        minVintWidth: null,
+        value: seeks.map((seek) => {
+            return {
+                type: 'Seek',
+                minVintWidth: null,
+                value: [
+                    {
+                        type: 'SeekID',
+                        minVintWidth: null,
+                        value: seek.hexString,
+                    },
+                    {
+                        type: 'SeekPosition',
+                        minVintWidth: null,
+                        value: {
+                            value: seek.byte,
+                            byteLength: null,
+                        },
+                    },
+                ],
+            };
+        }),
+    }), 200);
+};
+exports.createMatroskaSeekHead = createMatroskaSeekHead;

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

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

package/dist/create/matroska-segment.js

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

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

@@ -1,32 +1,27 @@
 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;
+import type { MediaParserAudioCodec, MediaParserVideoCodec, VideoTrackColorParams } from '../get-tracks';
 export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
-    color: MatroskaColorParams;
+    color: VideoTrackColorParams;
     width: number;
     height: number;
 }) => BytesAndOffset;
 export type MakeTrackAudio = {
     trackNumber: number;
-    codecId: string;
+    codec: MediaParserAudioCodec;
     numberOfChannels: number;
     sampleRate: number;
     type: 'audio';
+    codecPrivate: Uint8Array | null;
 };
 export type MakeTrackVideo = {
-    color: MatroskaColorParams;
+    color: VideoTrackColorParams;
     width: number;
     height: number;
-    defaultDuration: number;
     trackNumber: number;
-    codecId: string;
+    codec: MediaParserVideoCodec;
     type: 'video';
+    codecPrivate: Uint8Array | null;
 };
-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 makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }: MakeTrackAudio) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, trackNumber, codec, codecPrivate, }: MakeTrackVideo) => BytesAndOffset;
 export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset[];