@remotion/media-parser 4.0.209 → 4.0.210

package/dist/create/cluster.d.ts

@@ -1,5 +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: EncodedVideoChunk, trackNumber: number) => Promise<void>;
-    shouldMakeNewCluster: (chunk: EncodedVideoChunk) => boolean;
+    addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<void>;
+    shouldMakeNewCluster: (newT: number, keyframe: boolean) => boolean;
 }>;

package/dist/create/cluster.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCluster = void 0;
+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");
@@ -10,20 +10,26 @@ 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)(timestampToClusterTimestamp(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;
+    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 = timestampToClusterTimestamp(chunk.timestamp) -
-            timestampToClusterTimestamp(timestamp);
+        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');
+            throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
         }
         const keyframe = chunk.type === 'key';
         const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
@@ -38,10 +44,10 @@ const makeCluster = async (w, timestamp) => {
         await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
         await w.write(simpleBlock);
     };
-    const shouldMakeNewCluster = (chunk) => {
-        const newTimestamp = timestampToClusterTimestamp(chunk.timestamp);
-        const oldTimestamp = timestampToClusterTimestamp(timestamp);
-        return newTimestamp - oldTimestamp >= 2000 && chunk.type === 'key';
+    const shouldMakeNewCluster = (newT, keyframe) => {
+        const newTimestamp = (0, exports.timestampToClusterTimestamp)(newT);
+        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(timestamp);
+        return newTimestamp - oldTimestamp >= 2000 && keyframe;
     };
     return { addSample, shouldMakeNewCluster };
 };

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

@@ -1,16 +1,20 @@
 "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_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);
@@ -18,68 +22,126 @@ const createMedia = async (writer) => {
         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 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) => {
-        if (!currentCluster.shouldMakeNewCluster(chunk)) {
+        const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+        if (!currentCluster.shouldMakeNewCluster(smallestProgress, chunk.type === 'key')) {
             return currentCluster;
         }
-        currentCluster = await (0, cluster_1.makeCluster)(w, chunk.timestamp);
+        const newCluster = w.getWrittenByteCount();
+        cues.push({
+            time: smallestProgress,
+            clusterPosition: newCluster - seekHeadOffset,
+            trackNumbers,
+        });
+        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_duration_with_padding_1.makeDurationWithPadding)(newDuration);
-        await w.updateDataAt(durationOffset, (0, make_header_1.combineUint8Arrays)(blocks.map((b) => b.bytes)));
+        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

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

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

@@ -3,13 +3,13 @@ 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.padMatroskaBytes)({
+    return (0, make_header_1.makeMatroskaBytes)({
         type: 'Duration',
         value: {
             value: newDuration,
             size: '64',
         },
-        minVintWidth: null,
-    }, 100);
+        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.js

@@ -25,7 +25,7 @@ const makeMatroskaInfo = ({ timescale }) => {
                 value: '@remotion/media-parser',
                 minVintWidth: null,
             },
-            ...(0, make_duration_with_padding_1.makeDurationWithPadding)(0),
+            (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[];