@remotion/media-parser 4.0.229 → 4.0.231

package/dist/boxes/webm/segments.js

@@ -3,26 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
 const parse_ebml_1 = require("./parse-ebml");
 const parse_children_1 = require("./segments/parse-children");
-const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
-    if (length < 0) {
-        throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+const continueAfterMatroskaParseResult = async ({ result, iterator, parserContext, segment, }) => {
+    if (result.status === 'done') {
+        throw new Error('Should not continue after done');
     }
-    iterator.counter.decrement(headerReadSoFar);
-    const offset = iterator.counter.getOffset();
-    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
-    return remapped;
+    const proceeded = await result.continueParsing();
+    if (proceeded.status === 'done') {
+        return {
+            status: 'done',
+            segment,
+        };
+    }
+    return {
+        continueParsing() {
+            return continueAfterMatroskaParseResult({
+                result: proceeded,
+                iterator,
+                parserContext,
+                segment,
+            });
+        },
+        segment: null,
+        status: 'incomplete',
+    };
 };
-const expectSegment = async (iterator, parserContext) => {
-    const offset = iterator.counter.getOffset();
+const expectSegment = async ({ iterator, parserContext, offset, children, }) => {
+    iterator.counter.decrement(iterator.counter.getOffset() - offset);
     if (iterator.bytesRemaining() === 0) {
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, parse_children_1.expectAndProcessSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const segmentId = iterator.getMatroskaSegmentId();
@@ -30,11 +48,15 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(iterator.counter.getOffset() - offset);
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, parse_children_1.expectAndProcessSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const offsetBeforeVInt = iterator.counter.getOffset();
@@ -44,43 +66,43 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(iterator.counter.getOffset() - offset);
         return {
             status: 'incomplete',
-            segments: [],
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
             },
-            skipTo: null,
+            segment: null,
         };
     }
     const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
     if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+        const newSegment = {
+            type: segmentId === '0x18538067' ? 'Segment' : 'Cluster',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
+        };
         const main = await (0, parse_children_1.expectChildren)({
             iterator,
             length,
-            initialChildren: [],
-            wrap: segmentId === '0x18538067'
-                ? (s) => ({
-                    type: 'Segment',
-                    value: s,
-                    minVintWidth: offsetAfterVInt - offsetBeforeVInt,
-                })
-                : (s) => ({
-                    type: 'Cluster',
-                    value: s,
-                    minVintWidth: offsetAfterVInt - offsetBeforeVInt,
-                }),
+            children: newSegment.value,
             parserContext,
+            startOffset: iterator.counter.getOffset(),
         });
         if (main.status === 'incomplete') {
             return {
                 status: 'incomplete',
-                segments: main.segments,
-                skipTo: null,
-                continueParsing: main.continueParsing,
+                continueParsing: () => {
+                    return continueAfterMatroskaParseResult({
+                        iterator,
+                        parserContext,
+                        result: main,
+                        segment: newSegment,
+                    });
+                },
+                segment: newSegment,
             };
         }
         return {
             status: 'done',
-            segments: main.segments,
+            segment: newSegment,
         };
     }
     if (bytesRemainingNow < length) {
@@ -88,11 +110,10 @@ const expectSegment = async (iterator, parserContext) => {
         iterator.counter.decrement(bytesRead);
         return {
             status: 'incomplete',
-            segments: [],
+            segment: null,
             continueParsing: () => {
-                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
             },
-            skipTo: null,
         };
     }
     const segment = await parseSegment({
@@ -104,7 +125,17 @@ const expectSegment = async (iterator, parserContext) => {
     });
     return {
         status: 'done',
-        segments: [segment],
+        segment,
     };
 };
 exports.expectSegment = expectSegment;
+const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
+    if (length < 0) {
+        throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+    }
+    iterator.counter.decrement(headerReadSoFar);
+    const offset = iterator.counter.getOffset();
+    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
+    return remapped;
+};

package/dist/buffer-iterator.d.ts

@@ -26,7 +26,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     isWebm: () => boolean;
     discard: (length: number) => void;
     getEightByteNumber: (littleEndian?: boolean) => number;
-    getFourByteNumber: (littleEndian?: boolean) => number;
+    getFourByteNumber: () => number;
     getSlice: (amount: number) => Uint8Array;
     getAtom: () => string;
     isRiff: () => boolean;

package/dist/buffer-iterator.js

@@ -132,14 +132,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         ]);
         return Number(bigInt);
     };
-    const getFourByteNumber = (littleEndian = false) => {
-        if (littleEndian) {
-            const one = getUint8();
-            const two = getUint8();
-            const three = getUint8();
-            const four = getUint8();
-            return (four << 24) | (three << 16) | (two << 8) | one;
-        }
+    const getFourByteNumber = () => {
         return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
     };
     const getPaddedFourByteNumber = () => {

package/dist/create/iso-base-media/codec-specific/avc1.d.ts

@@ -0,0 +1,2 @@
+import type { Avc1Data } from './create-codec-specific-data';
+export declare const createAvc1Data: ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }: Avc1Data) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/avc1.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAvc1Data = void 0;
+const make_header_1 = require("../../../boxes/webm/make-header");
+const primitives_1 = require("../primitives");
+const createAvc1Data = ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('avc1'),
+        // reserved
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+        // data_reference_index
+        new Uint8Array([0, 1]),
+        // version
+        new Uint8Array([0, 0]),
+        // revisionLevel
+        new Uint8Array([0, 0]),
+        // vendor
+        new Uint8Array([0, 0, 0, 0]),
+        // temporalQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // spatialQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // width
+        (0, primitives_1.numberTo16BitUIntOrInt)(width),
+        // height
+        (0, primitives_1.numberTo16BitUIntOrInt)(height),
+        // horizontalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(horizontalResolution),
+        // verticalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(verticalResolution),
+        // dataSize
+        new Uint8Array([0, 0, 0, 0]),
+        // frame count per sample
+        (0, primitives_1.numberTo16BitUIntOrInt)(1),
+        // compressor name
+        (0, primitives_1.stringToPascalString)(compressorName),
+        // depth
+        (0, primitives_1.numberTo16BitUIntOrInt)(depth),
+        // colorTableId
+        (0, primitives_1.numberTo16BitUIntOrInt)(-1),
+        // avcc box
+        avccBox,
+        // pasp
+        pasp,
+    ]));
+};
+exports.createAvc1Data = createAvc1Data;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.d.ts

@@ -0,0 +1,22 @@
+import type { MakeTrackAudio, MakeTrackVideo } from '../../make-track-info';
+export type Avc1Data = {
+    pasp: Uint8Array;
+    avccBox: Uint8Array;
+    width: number;
+    height: number;
+    horizontalResolution: number;
+    verticalResolution: number;
+    compressorName: string;
+    depth: number;
+    type: 'avc1-data';
+};
+export type Mp4aData = {
+    type: 'mp4a-data';
+    sampleRate: number;
+    channelCount: number;
+    maxBitrate: number;
+    avgBitrate: number;
+    codecPrivate: Uint8Array | null;
+};
+export type CodecSpecificData = Avc1Data | Mp4aData;
+export declare const createCodecSpecificData: (track: MakeTrackAudio | MakeTrackVideo) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodecSpecificData = void 0;
+const create_avcc_1 = require("../trak/mdia/minf/stbl/stsd/create-avcc");
+const create_pasp_1 = require("../trak/mdia/minf/stbl/stsd/create-pasp");
+const avc1_1 = require("./avc1");
+const mp4a_1 = require("./mp4a");
+const createCodecSpecificData = (track) => {
+    if (track.type === 'video') {
+        return (0, avc1_1.createAvc1Data)({
+            avccBox: (0, create_avcc_1.createAvccBox)(track.codecPrivate),
+            compressorName: 'WebCodecs',
+            depth: 24,
+            horizontalResolution: 72,
+            verticalResolution: 72,
+            height: track.height,
+            width: track.width,
+            pasp: (0, create_pasp_1.createPasp)(1, 1),
+            type: 'avc1-data',
+        });
+    }
+    if (track.type === 'audio') {
+        return (0, mp4a_1.createMp4a)({
+            type: 'mp4a-data',
+            // TODO: Put in values based on real data,
+            // this seems to work though
+            avgBitrate: 128 * 1024,
+            maxBitrate: 128 * 1024,
+            channelCount: track.numberOfChannels,
+            sampleRate: track.sampleRate,
+            codecPrivate: track.codecPrivate,
+        });
+    }
+    throw new Error('Unsupported codec specific data ' + track);
+};
+exports.createCodecSpecificData = createCodecSpecificData;

package/dist/create/iso-base-media/codec-specific/mp4a.d.ts

@@ -0,0 +1,2 @@
+import type { Mp4aData } from './create-codec-specific-data';
+export declare const createMp4a: ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }: Mp4aData) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/mp4a.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMp4a = void 0;
+const make_header_1 = require("../../../boxes/webm/make-header");
+const primitives_1 = require("../primitives");
+const createMp4a = ({ sampleRate, channelCount, avgBitrate, maxBitrate, codecPrivate, }) => {
+    if (!codecPrivate) {
+        throw new Error('Need codecPrivate for mp4a');
+    }
+    const esdsAtom = (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('esds'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // tag = 'ES_DescrTag'
+        new Uint8Array([3]),
+        (0, primitives_1.addLeading128Size)((0, make_header_1.combineUint8Arrays)([
+            // ES_ID
+            (0, primitives_1.numberTo16BitUIntOrInt)(2),
+            // streamDependenceFlag, URL_Flag, OCRstreamFlag
+            new Uint8Array([0]),
+            // DecoderConfigDescrTag
+            new Uint8Array([4]),
+            (0, primitives_1.addLeading128Size)((0, make_header_1.combineUint8Arrays)([
+                // objectTypeIndication
+                new Uint8Array([0x40]),
+                // streamType, upStream
+                new Uint8Array([21]),
+                // reserved
+                new Uint8Array([0, 0, 0]),
+                // maxBitrate
+                (0, primitives_1.numberTo32BitUIntOrInt)(maxBitrate),
+                // avgBitrate
+                (0, primitives_1.numberTo32BitUIntOrInt)(avgBitrate),
+                // DecoderSpecificInfoTag
+                new Uint8Array([5]),
+                // codec private, for example [17, 144]
+                // audioObjectType = 2 = 'AAC LC'
+                // samplingFrequencyIndex = 3 = '48000 Hz'
+                // channelConfiguration = 2 = '2 channels'
+                /**
+                 * Byte 1 (17):  0001 0001
+                                                ^^^^^ ^^^^
+                                                |     |
+                                                |     +-- Start of samplingFrequencyIndex (3)
+                                                +-- audioConfigType (2)
+
+                    Byte 2 (144): 1001 0000
+                                                ^^^^ ^^^^
+                                                |    |
+                                                |    +-- Remaining bits/padding
+                                                +-- channelConfiguration (2)
+                    */
+                (0, primitives_1.addLeading128Size)(codecPrivate),
+            ])),
+            // SLConfigDescrTag
+            new Uint8Array([6]),
+            (0, primitives_1.addLeading128Size)(new Uint8Array([2])),
+        ])),
+    ]));
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('mp4a'),
+        // reserved
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+        // data_reference_index
+        (0, primitives_1.numberTo16BitUIntOrInt)(1),
+        // version
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // revision level
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // vendor
+        new Uint8Array([0, 0, 0, 0]),
+        // channelCount
+        (0, primitives_1.numberTo16BitUIntOrInt)(channelCount),
+        // sampleSize
+        (0, primitives_1.numberTo16BitUIntOrInt)(16),
+        // compressionId
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // packet size
+        (0, primitives_1.numberTo16BitUIntOrInt)(0),
+        // sample rate
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(sampleRate),
+        // esds atom
+        esdsAtom,
+    ]));
+};
+exports.createMp4a = createMp4a;

package/dist/create/iso-base-media/create-colr.d.ts

@@ -0,0 +1,6 @@
+export declare const createColr: ({ fullRange, matrixIndex, primaries, transferFunction, }: {
+    fullRange: boolean;
+    matrixIndex: number;
+    primaries: number;
+    transferFunction: number;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-colr.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createColr = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+// TODO: Not used in creation of MP4 yet
+const createColr = ({ fullRange, matrixIndex, primaries, transferFunction, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('colr'),
+        // colour_type
+        (0, primitives_1.stringsToUint8Array)('nclx'),
+        // primaries
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, primaries]),
+        // transfer_function
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, transferFunction]),
+        // matrix_index
+        // 1 = 'ITU-R BT.7090
+        new Uint8Array([0, matrixIndex]),
+        // full_range_flag
+        new Uint8Array([fullRange ? 1 : 0]),
+    ]));
+};
+exports.createColr = createColr;

package/dist/create/iso-base-media/create-ftyp.d.ts

@@ -0,0 +1,10 @@
+export declare const createFtyp: ({ majorBrand, minorBrand, compatibleBrands, }: {
+    majorBrand: string;
+    minorBrand: number;
+    compatibleBrands: string[];
+}) => Uint8Array;
+export declare const createIsoBaseMediaFtyp: ({ majorBrand, minorBrand, compatibleBrands, }: {
+    majorBrand: string;
+    minorBrand: number;
+    compatibleBrands: string[];
+}) => Uint8Array;

package/dist/create/iso-base-media/create-ftyp.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsoBaseMediaFtyp = exports.createFtyp = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createFtyp = ({ majorBrand, minorBrand, compatibleBrands, }) => {
+    const type = (0, primitives_1.stringsToUint8Array)('ftyp');
+    const majorBrandArr = (0, primitives_1.stringsToUint8Array)(majorBrand);
+    const minorBrandArr = (0, primitives_1.numberTo32BitUIntOrInt)(minorBrand);
+    const compatibleBrandsArr = (0, make_header_1.combineUint8Arrays)(compatibleBrands.map((b) => (0, primitives_1.stringsToUint8Array)(b)));
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        type,
+        majorBrandArr,
+        minorBrandArr,
+        compatibleBrandsArr,
+    ]));
+};
+exports.createFtyp = createFtyp;
+const createIsoBaseMediaFtyp = ({ majorBrand, minorBrand, compatibleBrands, }) => {
+    return (0, exports.createFtyp)({ compatibleBrands, majorBrand, minorBrand });
+};
+exports.createIsoBaseMediaFtyp = createIsoBaseMediaFtyp;

package/dist/create/iso-base-media/create-ilst.d.ts

@@ -0,0 +1 @@
+export declare const createIlst: (items: Uint8Array[]) => Uint8Array;

package/dist/create/iso-base-media/create-ilst.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIlst = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createIlst = (items) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // name
+        (0, primitives_1.stringsToUint8Array)('ilst'),
+        // items
+        ...items,
+    ]));
+};
+exports.createIlst = createIlst;

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

@@ -0,0 +1,2 @@
+import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
+export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsoBaseMedia = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const log_1 = require("../../log");
+const create_ftyp_1 = require("./create-ftyp");
+const mp4_header_1 = require("./mp4-header");
+const primitives_1 = require("./primitives");
+const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }) => {
+    const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
+        compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
+        majorBrand: 'isom',
+        minorBrand: 512,
+    });
+    const w = await writer.createContent({ filename, mimeType: 'video/mp4' });
+    await w.write(header);
+    let durationInUnits = 0;
+    const currentTracks = [];
+    const samplePositions = [];
+    const sampleChunkIndices = [];
+    const moovOffset = w.getWrittenByteCount();
+    const getPaddedMoovAtom = () => {
+        return (0, mp4_header_1.createPaddedMoovAtom)({
+            durationInUnits,
+            trackInfo: currentTracks.map((track) => {
+                var _a;
+                return {
+                    track,
+                    durationInUnits,
+                    samplePositions: (_a = samplePositions[track.trackNumber]) !== null && _a !== void 0 ? _a : [],
+                    timescale: track.timescale,
+                };
+            }),
+            timescale: 1000,
+        });
+    };
+    await w.write(getPaddedMoovAtom());
+    let mdatSize = 8;
+    const mdatSizeOffset = w.getWrittenByteCount();
+    await w.write((0, make_header_1.combineUint8Arrays)([
+        // size
+        (0, primitives_1.numberTo32BitUIntOrInt)(mdatSize),
+        // type
+        (0, primitives_1.stringsToUint8Array)('mdat'),
+    ]));
+    const updateMdatSize = async () => {
+        await w.updateDataAt(mdatSizeOffset, (0, primitives_1.numberTo32BitUIntOrInt)(mdatSize));
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const operationProm = { current: Promise.resolve() };
+    const updateMoov = async () => {
+        await w.updateDataAt(moovOffset, getPaddedMoovAtom());
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const updateDuration = (newDuration) => {
+        durationInUnits = newDuration;
+        onMillisecondsProgress(newDuration);
+    };
+    const addCodecPrivateToTrack = ({ trackNumber, codecPrivate, }) => {
+        currentTracks.forEach((track) => {
+            if (track.trackNumber === trackNumber) {
+                track.codecPrivate = codecPrivate;
+            }
+        });
+    };
+    let lastChunkWasVideo = false;
+    const addSample = async ({ chunk, trackNumber, isVideo, timescale, codecPrivate, }) => {
+        var _a, _b;
+        const position = w.getWrittenByteCount();
+        await w.write(chunk.data);
+        mdatSize += chunk.data.length;
+        onBytesProgress(w.getWrittenByteCount());
+        if (codecPrivate) {
+            addCodecPrivateToTrack({ trackNumber, codecPrivate });
+        }
+        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        updateDuration(newDuration);
+        if (!samplePositions[trackNumber]) {
+            samplePositions[trackNumber] = [];
+        }
+        if (typeof sampleChunkIndices[trackNumber] === 'undefined') {
+            sampleChunkIndices[trackNumber] = 0;
+        }
+        // For video, make a new chunk if it's a keyframe
+        if (isVideo && chunk.type === 'key') {
+            sampleChunkIndices[trackNumber]++;
+        } // For audio, make a new chunk every 22 samples, that's how bbb.mp4 is encoded
+        else if (!isVideo && samplePositions[trackNumber].length % 22 === 0) {
+            sampleChunkIndices[trackNumber]++;
+        }
+        // Need to create a new chunk if the last chunk was a different type
+        else if (lastChunkWasVideo !== isVideo) {
+            sampleChunkIndices[trackNumber]++;
+        }
+        // media parser and EncodedVideoChunk returns timestamps in microseconds
+        // need to normalize the timestamps to milliseconds
+        const samplePositionToAdd = {
+            isKeyframe: chunk.type === 'key',
+            offset: position,
+            chunk: sampleChunkIndices[trackNumber],
+            cts: Math.round(chunk.cts / (1000000 / timescale)),
+            dts: Math.round(chunk.dts / (1000000 / timescale)),
+            duration: Math.round(((_b = chunk.duration) !== null && _b !== void 0 ? _b : 0) / (1000000 / timescale)),
+            size: chunk.data.length,
+        };
+        lastChunkWasVideo = isVideo;
+        samplePositions[trackNumber].push(samplePositionToAdd);
+    };
+    const addTrack = (track) => {
+        const trackNumber = currentTracks.length + 1;
+        currentTracks.push({ ...track, trackNumber });
+        return Promise.resolve({ trackNumber });
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: () => {
+            return w.save();
+        },
+        remove: async () => {
+            await w.remove();
+        },
+        addSample: ({ chunk, trackNumber, isVideo, timescale, codecPrivate }) => {
+            operationProm.current = operationProm.current.then(() => {
+                return addSample({
+                    chunk,
+                    trackNumber,
+                    isVideo,
+                    timescale,
+                    codecPrivate,
+                });
+            });
+            return operationProm.current;
+        },
+        addTrack: (track) => {
+            operationProm.current = operationProm.current.then(() => addTrack(track));
+            return operationProm.current;
+        },
+        updateTrackSampleRate: ({ sampleRate, trackNumber }) => {
+            currentTracks.forEach((track) => {
+                if (track.trackNumber === trackNumber) {
+                    if (track.type !== 'audio') {
+                        throw new Error(`Tried to update sample rate of track ${trackNumber}, but it's not an audio track`);
+                    }
+                    track.sampleRate = sampleRate;
+                }
+            });
+        },
+        addWaitForFinishPromise: (promise) => {
+            waitForFinishPromises.push(promise);
+        },
+        async waitForFinish() {
+            log_1.Log.verbose(logLevel, 'All write operations queued. Waiting for finish...');
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+            log_1.Log.verbose(logLevel, 'Cleanup tasks executed');
+            await operationProm.current;
+            await updateMoov();
+            await updateMdatSize();
+            log_1.Log.verbose(logLevel, 'All write operations done. Waiting for finish...');
+            await w.waitForFinish();
+        },
+        updateDuration: (duration) => {
+            operationProm.current = operationProm.current.then(() => updateDuration(duration));
+            return operationProm.current;
+        },
+    };
+};
+exports.createIsoBaseMedia = createIsoBaseMedia;