@remotion/media-parser 4.0.209 → 4.0.211

package/dist/boxes/webm/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrackByNumber = exports.getTrackTimestampScale = exports.getTrackCodec = exports.getTrackNumber = exports.getMainSegment = void 0;
+exports.getClusterSegment = exports.getPrivateData = exports.getBitDepth = exports.getNumberOfChannels = exports.getSampleRate = exports.getAudioSegment = exports.getVideoSegment = exports.getTimescaleSegment = exports.getTracksSegment = exports.getDisplayWidthSegment = exports.getHeightSegment = exports.getWidthSegment = exports.getTrackTypeSegment = exports.getDisplayHeightSegment = exports.getRangeSegment = exports.getPrimariesSegment = exports.getMatrixCoefficientsSegment = exports.getTransferCharacteristicsSegment = exports.getColourSegment = exports.getCodecSegment = exports.getTrackId = exports.getTrackByNumber = exports.getTrackTimestampScale = exports.getTrackCodec = exports.getTrackNumber = exports.getMainSegment = void 0;
 const getMainSegment = (segments) => {
     return segments.find((s) => s.type === 'Segment');
 };
@@ -34,3 +34,216 @@ const getTrackByNumber = (tracks, id) => {
     });
 };
 exports.getTrackByNumber = getTrackByNumber;
+const getTrackId = (track) => {
+    const trackId = track.value.find((b) => b.type === 'TrackNumber');
+    if (!trackId || trackId.type !== 'TrackNumber') {
+        throw new Error('Expected track number segment');
+    }
+    return trackId.value.value;
+};
+exports.getTrackId = getTrackId;
+const getCodecSegment = (track) => {
+    const codec = track.value.find((b) => b.type === 'CodecID');
+    if (!codec || codec.type !== 'CodecID') {
+        return null;
+    }
+    return codec;
+};
+exports.getCodecSegment = getCodecSegment;
+const getColourSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const colour = videoSegment.value.find((b) => b.type === 'Colour');
+    if (!colour || colour.type !== 'Colour') {
+        return null;
+    }
+    return colour;
+};
+exports.getColourSegment = getColourSegment;
+const getTransferCharacteristicsSegment = (color) => {
+    if (!color || color.type !== 'Colour') {
+        return null;
+    }
+    const box = color.value.find((b) => b.type === 'TransferCharacteristics');
+    if (!box || box.type !== 'TransferCharacteristics') {
+        return null;
+    }
+    return box;
+};
+exports.getTransferCharacteristicsSegment = getTransferCharacteristicsSegment;
+const getMatrixCoefficientsSegment = (color) => {
+    if (!color || color.type !== 'Colour') {
+        return null;
+    }
+    const box = color.value.find((b) => b.type === 'MatrixCoefficients');
+    if (!box || box.type !== 'MatrixCoefficients') {
+        return null;
+    }
+    return box;
+};
+exports.getMatrixCoefficientsSegment = getMatrixCoefficientsSegment;
+const getPrimariesSegment = (color) => {
+    if (!color || color.type !== 'Colour') {
+        return null;
+    }
+    const box = color.value.find((b) => b.type === 'Primaries');
+    if (!box || box.type !== 'Primaries') {
+        return null;
+    }
+    return box;
+};
+exports.getPrimariesSegment = getPrimariesSegment;
+const getRangeSegment = (color) => {
+    if (!color || color.type !== 'Colour') {
+        return null;
+    }
+    const box = color.value.find((b) => b.type === 'Range');
+    if (!box || box.type !== 'Range') {
+        return null;
+    }
+    return box;
+};
+exports.getRangeSegment = getRangeSegment;
+const getDisplayHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayHeight = videoSegment.value.find((b) => b.type === 'DisplayHeight');
+    if (!displayHeight || displayHeight.type !== 'DisplayHeight') {
+        return null;
+    }
+    return displayHeight;
+};
+exports.getDisplayHeightSegment = getDisplayHeightSegment;
+const getTrackTypeSegment = (track) => {
+    const trackType = track.value.find((b) => b.type === 'TrackType');
+    if (!trackType || trackType.type !== 'TrackType') {
+        return null;
+    }
+    return trackType;
+};
+exports.getTrackTypeSegment = getTrackTypeSegment;
+const getWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const width = videoSegment.value.find((b) => b.type === 'PixelWidth');
+    if (!width || width.type !== 'PixelWidth') {
+        return null;
+    }
+    return width;
+};
+exports.getWidthSegment = getWidthSegment;
+const getHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const height = videoSegment.value.find((b) => b.type === 'PixelHeight');
+    if (!height || height.type !== 'PixelHeight') {
+        return null;
+    }
+    return height;
+};
+exports.getHeightSegment = getHeightSegment;
+const getDisplayWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayWidth = videoSegment.value.find((b) => b.type === 'DisplayWidth');
+    if (!displayWidth || displayWidth.type !== 'DisplayWidth') {
+        return null;
+    }
+    return displayWidth;
+};
+exports.getDisplayWidthSegment = getDisplayWidthSegment;
+const getTracksSegment = (segment) => {
+    const tracksSegment = segment.value.find((b) => b.type === 'Tracks');
+    if (!tracksSegment || tracksSegment.type !== 'Tracks') {
+        return null;
+    }
+    return tracksSegment;
+};
+exports.getTracksSegment = getTracksSegment;
+const getTimescaleSegment = (segment) => {
+    const infoSegment = segment.value.find((b) => b.type === 'Info');
+    if (!infoSegment || infoSegment.type !== 'Info') {
+        return null;
+    }
+    const timescale = infoSegment.value.find((b) => b.type === 'TimestampScale');
+    if (!timescale || timescale.type !== 'TimestampScale') {
+        return null;
+    }
+    return timescale;
+};
+exports.getTimescaleSegment = getTimescaleSegment;
+const getVideoSegment = (track) => {
+    const videoSegment = track.value.find((b) => b.type === 'Video');
+    if (!videoSegment || videoSegment.type !== 'Video') {
+        return null;
+    }
+    return videoSegment !== null && videoSegment !== void 0 ? videoSegment : null;
+};
+exports.getVideoSegment = getVideoSegment;
+const getAudioSegment = (track) => {
+    const audioSegment = track.value.find((b) => b.type === 'Audio');
+    if (!audioSegment || audioSegment.type !== 'Audio') {
+        return null;
+    }
+    return audioSegment !== null && audioSegment !== void 0 ? audioSegment : null;
+};
+exports.getAudioSegment = getAudioSegment;
+const getSampleRate = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const samplingFrequency = audioSegment.value.find((b) => b.type === 'SamplingFrequency');
+    if (!samplingFrequency || samplingFrequency.type !== 'SamplingFrequency') {
+        return null;
+    }
+    return samplingFrequency.value.value;
+};
+exports.getSampleRate = getSampleRate;
+const getNumberOfChannels = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        throw new Error('Could not find audio segment');
+    }
+    const channels = audioSegment.value.find((b) => b.type === 'Channels');
+    if (!channels || channels.type !== 'Channels') {
+        return 1;
+    }
+    return channels.value.value;
+};
+exports.getNumberOfChannels = getNumberOfChannels;
+const getBitDepth = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const bitDepth = audioSegment.value.find((b) => b.type === 'BitDepth');
+    if (!bitDepth || bitDepth.type !== 'BitDepth') {
+        return null;
+    }
+    return bitDepth.value.value;
+};
+exports.getBitDepth = getBitDepth;
+const getPrivateData = (track) => {
+    const privateData = track.value.find((b) => b.type === 'CodecPrivate');
+    if (!privateData || privateData.type !== 'CodecPrivate') {
+        return null;
+    }
+    return privateData.value;
+};
+exports.getPrivateData = getPrivateData;
+const getClusterSegment = (segment) => {
+    const clusterSegment = segment.value.find((b) => b.type === 'Cluster');
+    return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;
+};
+exports.getClusterSegment = getClusterSegment;

package/dist/buffer-iterator.d.ts

@@ -5,13 +5,14 @@ export declare class OffsetCounter {
     getOffset(): number;
     getDiscardedOffset(): number;
     setDiscardedOffset(offset: number): void;
+    getDiscardedBytes(): number;
     discardBytes(amount: number): void;
     decrement(amount: number): void;
 }
 export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes: number | null) => {
     startReadingBits: () => void;
     stopReadingBits: () => void;
-    skipTo: (offset: number) => void;
+    skipTo: (offset: number, reset: boolean) => void;
     addData: (newData: Uint8Array) => void;
     counter: OffsetCounter;
     peekB: (length: number) => void;
@@ -53,5 +54,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getInt32: () => number;
     destroy: () => void;
     isMp3: () => boolean;
+    disallowDiscard: () => void;
+    allowDiscard: () => void;
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -37,6 +37,9 @@ class OffsetCounter {
     setDiscardedOffset(offset) {
         __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, offset, "f");
     }
+    getDiscardedBytes() {
+        return __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f");
+    }
     discardBytes(amount) {
         __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f") + amount, "f");
     }
@@ -73,11 +76,18 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     data.set(initialData);
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
+    let discardAllowed = true;
     const getSlice = (amount) => {
         const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
         counter.increment(amount);
         return value;
     };
+    const disallowDiscard = () => {
+        discardAllowed = false;
+    };
+    const allowDiscard = () => {
+        discardAllowed = true;
+    };
     const getUint8 = () => {
         const val = view.getUint8(counter.getDiscardedOffset());
         counter.increment(1);
@@ -191,8 +201,11 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return matchesPattern(mpegPattern)(data.subarray(0, 4));
     };
     const removeBytesRead = () => {
+        if (!discardAllowed) {
+            return;
+        }
         const bytesToRemove = counter.getDiscardedOffset();
-        // Only to this operation if it is really worth it 😇
+        // Only do this operation if it is really worth it 😇
         if (bytesToRemove < 100000) {
             return;
         }
@@ -202,12 +215,23 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         buf.resize(newData.byteLength);
         view = new DataView(data.buffer);
     };
-    const skipTo = (offset) => {
+    const skipTo = (offset, reset) => {
         const becomesSmaller = offset < counter.getOffset();
         if (becomesSmaller) {
-            buf.resize(0);
-            counter.decrement(counter.getOffset() - offset);
-            counter.setDiscardedOffset(offset);
+            if (reset) {
+                buf.resize(0);
+                counter.decrement(counter.getOffset() - offset);
+                counter.setDiscardedOffset(offset);
+            }
+            else {
+                const toDecrement = counter.getOffset() - offset;
+                const newOffset = counter.getOffset() - toDecrement;
+                counter.decrement(toDecrement);
+                const c = counter.getDiscardedBytes();
+                if (c > newOffset) {
+                    throw new Error('already discarded too many bytes');
+                }
+            }
         }
         else {
             const currentOffset = counter.getOffset();
@@ -452,6 +476,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getInt32,
         destroy,
         isMp3,
+        disallowDiscard,
+        allowDiscard,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/create/cluster-segment.js

@@ -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

@@ -1,5 +1,19 @@
 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<{
+        timecodeRelativeToCluster: number;
+    }>;
+    shouldMakeNewCluster: ({ isVideo, keyframe, newT, }: {
+        newT: number;
+        keyframe: boolean;
+        isVideo: 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)({
@@ -37,11 +43,12 @@ const makeCluster = async (w, timestamp) => {
         clusterSize += simpleBlock.byteLength;
         await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
         await w.write(simpleBlock);
+        return { timecodeRelativeToCluster };
     };
-    const shouldMakeNewCluster = (chunk) => {
-        const newTimestamp = timestampToClusterTimestamp(chunk.timestamp);
-        const oldTimestamp = timestampToClusterTimestamp(timestamp);
-        return newTimestamp - oldTimestamp >= 2000 && chunk.type === 'key';
+    const shouldMakeNewCluster = ({ isVideo, keyframe, newT, }) => {
+        const newTimestamp = (0, exports.timestampToClusterTimestamp)(newT);
+        const oldTimestamp = (0, exports.timestampToClusterTimestamp)(timestamp);
+        return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
     };
     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, isVideo: boolean) => 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, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent();
     await w.write(header.bytes);
@@ -18,68 +22,143 @@ 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)([
+        ...(0, matroska_seek_1.createMatroskaSeekHead)(seeks),
         matroskaInfo,
-        ...matroskaTracks,
+        ...(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 infoSegment = matroskaSegment.offsets.children.find((o) => o.field === 'Info');
+    const durationOffset = ((_b = (_a = infoSegment === null || infoSegment === void 0 ? void 0 : infoSegment.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();
+    const infoOffset = ((_g = infoSegment === null || infoSegment === void 0 ? void 0 : infoSegment.offset) !== null && _g !== void 0 ? _g : 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');
     }
+    if (!infoOffset) {
+        throw new Error('could not get tracks offset');
+    }
+    seeks.push({
+        hexString: all_segments_1.matroskaElements.Info,
+        byte: infoOffset - seekHeadOffset,
+    });
+    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();
+    const updateSegmentSize = async (size) => {
+        const data = (0, ebml_1.getVariableInt)(size, matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH);
+        await w.updateDataAt(segmentOffset + (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Segment).byteLength, data);
+    };
     await w.write(matroskaSegment.bytes);
+    const clusterOffset = w.getWrittenByteCount();
     let currentCluster = await (0, cluster_1.makeCluster)(w, 0);
-    const getClusterOrMakeNew = async (chunk) => {
-        if (!currentCluster.shouldMakeNewCluster(chunk)) {
-            return currentCluster;
+    seeks.push({
+        hexString: all_segments_1.matroskaElements.Cluster,
+        byte: clusterOffset - seekHeadOffset,
+    });
+    const trackNumberProgresses = {};
+    const getClusterOrMakeNew = async ({ chunk, isVideo, }) => {
+        const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+        if (!currentCluster.shouldMakeNewCluster({
+            newT: smallestProgress,
+            keyframe: chunk.type === 'key',
+            isVideo,
+        })) {
+            return { cluster: currentCluster, isNew: false, smallestProgress };
         }
-        currentCluster = await (0, cluster_1.makeCluster)(w, chunk.timestamp);
-        return currentCluster;
+        currentCluster = await (0, cluster_1.makeCluster)(w, smallestProgress);
+        return { cluster: currentCluster, isNew: true, smallestProgress };
     };
-    const addSample = async (chunk, trackNumber) => {
-        const cluster = await getClusterOrMakeNew(chunk);
-        return cluster.addSample(chunk, trackNumber);
+    const addSample = async (chunk, trackNumber, isVideo) => {
+        var _a;
+        trackNumberProgresses[trackNumber] = chunk.timestamp;
+        const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
+            chunk,
+            isVideo,
+        });
+        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        await updateDuration(newDuration);
+        const { timecodeRelativeToCluster } = await cluster.addSample(chunk, trackNumber);
+        if (isNew) {
+            const newCluster = w.getWrittenByteCount();
+            cues.push({
+                time: (0, cluster_1.timestampToClusterTimestamp)(smallestProgress) +
+                    timecodeRelativeToCluster,
+                clusterPosition: newCluster - seekHeadOffset,
+                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;
+        addSample: (chunk, trackNumber, isVideo) => {
+            operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber, isVideo));
+            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);
+            await w.waitForFinish();
+            const segmentSize = w.getWrittenByteCount() -
+                segmentOffset -
+                (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Segment).byteLength -
+                matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH;
+            await updateSegmentSize(segmentSize);
         },
     };
 };

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;
+    trackNumber: number;
+};
+export declare const createMatroskaCues: (cues: Cue[]) => import("../boxes/webm/segments/all-segments").BytesAndOffset;