@remotion/webcodecs 4.0.245 → 4.0.247

package/dist/audio-decoder.d.ts

@@ -1,4 +1,5 @@
-import type { AudioOrVideoSample, AudioTrack, LogLevel, ProgressTracker } from '@remotion/media-parser';
+import type { AudioOrVideoSample, AudioTrack, LogLevel } from '@remotion/media-parser';
+import type { ProgressTracker } from './create/progress-tracker';
 export type WebCodecsAudioDecoder = {
     processSample: (audioSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;

package/dist/audio-encoder.d.ts

@@ -1,4 +1,5 @@
-import type { LogLevel, ProgressTracker } from '@remotion/media-parser';
+import type { LogLevel } from '@remotion/media-parser';
+import type { ProgressTracker } from './create/progress-tracker';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 export type WebCodecsAudioEncoder = {
     encodeFrame: (audioData: AudioData) => Promise<void>;

package/dist/auto-select-writer.d.ts

@@ -1,3 +1,3 @@
-import { type WriterInterface } from '@remotion/media-parser';
 import type { LogLevel } from './log';
+import type { WriterInterface } from './writers/writer';
 export declare const autoSelectWriter: (writer: WriterInterface | undefined, logLevel: LogLevel) => Promise<WriterInterface>;

package/dist/auto-select-writer.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autoSelectWriter = void 0;
-const web_fs_1 = require("@remotion/media-parser/web-fs");
-const media_parser_1 = require("@remotion/media-parser");
-const buffer_1 = require("@remotion/media-parser/buffer");
+const web_fs_1 = require("./writers/web-fs");
+const with_resolvers_1 = require("./create/with-resolvers");
 const log_1 = require("./log");
+const buffer_1 = require("./writers/buffer");
 const autoSelectWriter = async (writer, logLevel) => {
     if (writer) {
         log_1.Log.verbose(logLevel, 'Using writer provided by user');
@@ -18,7 +18,7 @@ const autoSelectWriter = async (writer, logLevel) => {
         return buffer_1.bufferWriter;
     }
     try {
-        const { promise: timeout, reject, resolve, } = media_parser_1.MediaParserInternals.withResolvers();
+        const { promise: timeout, reject, resolve } = (0, with_resolvers_1.withResolvers)();
         const time = setTimeout(() => reject(new Error('WebFS check timeout')), 2000);
         const webFsSupported = await Promise.race([(0, web_fs_1.canUseWebFsWriter)(), timeout]);
         resolve();

package/dist/convert-encoded-chunk.d.ts

@@ -1,3 +1,2 @@
 import type { AudioOrVideoSample } from '@remotion/media-parser';
-export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
 export declare const convertEncodedChunk: (chunk: EncodedAudioChunk | EncodedVideoChunk, trackId: number) => AudioOrVideoSample;

package/dist/convert-encoded-chunk.js

@@ -1,26 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertEncodedChunk = exports.combineUint8Arrays = void 0;
-const combineUint8Arrays = (arrays) => {
-    if (arrays.length === 0) {
-        return new Uint8Array([]);
-    }
-    if (arrays.length === 1) {
-        return arrays[0];
-    }
-    let totalLength = 0;
-    for (const array of arrays) {
-        totalLength += array.length;
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const array of arrays) {
-        result.set(array, offset);
-        offset += array.length;
-    }
-    return result;
-};
-exports.combineUint8Arrays = combineUint8Arrays;
+exports.convertEncodedChunk = void 0;
 const convertEncodedChunk = (chunk, trackId) => {
     var _a;
     const arr = new Uint8Array(chunk.byteLength);

package/dist/convert-media.d.ts

@@ -2,13 +2,14 @@
  * Copyright (c) 2025 Remotion AG
  * For licensing, see: https://remotion.dev/docs/webcodecs#license
  */
-import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
+import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import { type ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import { type ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 import type { ResizeOperation } from './resizing/mode';
+import type { WriterInterface } from './writers/writer';
 export type ConvertMediaProgress = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;

package/dist/convert-media.js

@@ -11,6 +11,8 @@ exports.convertMedia = void 0;
 const media_parser_1 = require("@remotion/media-parser");
 const auto_select_writer_1 = require("./auto-select-writer");
 const calculate_progress_1 = require("./calculate-progress");
+const progress_tracker_1 = require("./create/progress-tracker");
+const with_resolvers_1 = require("./create/with-resolvers");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const generate_output_filename_1 = require("./generate-output-filename");
 const log_1 = require("./log");
@@ -30,7 +32,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
     if (videoCodec && videoCodec !== 'vp8' && videoCodec !== 'vp9') {
         return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
     }
-    const { resolve, reject, getPromiseToImmediatelyReturn } = media_parser_1.MediaParserInternals.withResolversAndWaitForReturn();
+    const { resolve, reject, getPromiseToImmediatelyReturn } = (0, with_resolvers_1.withResolversAndWaitForReturn)();
     const controller = new AbortController();
     const abortConversion = (errCause) => {
         reject(errCause);
@@ -48,7 +50,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         everyMilliseconds: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : 100,
         signal: controller.signal,
     });
-    const progressTracker = media_parser_1.MediaParserInternals.makeProgressTracker();
+    const progressTracker = (0, progress_tracker_1.makeProgressTracker)();
     const state = await creator({
         filename: (0, generate_output_filename_1.generateOutputFilename)(src, container),
         writer: await (0, auto_select_writer_1.autoSelectWriter)(writer, logLevel),

package/dist/create/event-emitter.d.ts

@@ -0,0 +1,31 @@
+type Input = {
+    timestamp: number;
+    keyFrame: boolean;
+};
+type Output = {
+    timestamp: number;
+};
+type Processed = {};
+type Progress = {
+    smallestProgress: number;
+};
+type IoEventMap = {
+    input: Input;
+    output: Output;
+    processed: Processed;
+    progress: Progress;
+};
+export type IoEventTypes = keyof IoEventMap;
+export type CallbackListener<T extends IoEventTypes> = (data: {
+    detail: IoEventMap[T];
+}) => void;
+type IoListeners = {
+    [EventType in IoEventTypes]: CallbackListener<EventType>[];
+};
+export declare class IoEventEmitter {
+    listeners: IoListeners;
+    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
+}
+export {};

package/dist/create/event-emitter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoEventEmitter = void 0;
+class IoEventEmitter {
+    constructor() {
+        this.listeners = {
+            input: [],
+            output: [],
+            processed: [],
+            progress: [],
+        };
+    }
+    addEventListener(name, callback) {
+        this.listeners[name].push(callback);
+    }
+    removeEventListener(name, callback) {
+        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+    }
+    dispatchEvent(dispatchName, context) {
+        this.listeners[dispatchName].forEach((callback) => {
+            callback({ detail: context });
+        });
+    }
+}
+exports.IoEventEmitter = IoEventEmitter;

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 matroska_utils_1 = require("../../matroska/matroska-utils");
+const primitives_1 = require("../primitives");
+const createAvc1Data = ({ avccBox, pasp, width, height, horizontalResolution, verticalResolution, compressorName, depth, }) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_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,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMp4a = void 0;
+const matroska_utils_1 = require("../../matroska/matroska-utils");
+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, matroska_utils_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, matroska_utils_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, matroska_utils_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]),
+                // see create-aac-codecprivate.ts
+                (0, primitives_1.addLeading128Size)(codecPrivate),
+            ])),
+            // SLConfigDescrTag
+            new Uint8Array([6]),
+            (0, primitives_1.addLeading128Size)(new Uint8Array([2])),
+        ])),
+    ]));
+    return (0, primitives_1.addSize)((0, matroska_utils_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 matroska_utils_1 = require("../matroska/matroska-utils");
+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, matroska_utils_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 matroska_utils_1 = require("../matroska/matroska-utils");
+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, matroska_utils_1.combineUint8Arrays)(compatibleBrands.map((b) => (0, primitives_1.stringsToUint8Array)(b)));
+    return (0, primitives_1.addSize)((0, matroska_utils_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 matroska_utils_1 = require("../matroska/matroska-utils");
+const primitives_1 = require("./primitives");
+const createIlst = (items) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_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, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsoBaseMedia = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const matroska_utils_1 = require("../matroska/matroska-utils");
+const create_ftyp_1 = require("./create-ftyp");
+const mp4_header_1 = require("./mp4-header");
+const primitives_1 = require("./primitives");
+const CONTAINER_TIMESCALE = 1000;
+const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }) => {
+    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 globalDurationInUnits = 0;
+    const lowestTrackTimestamps = {};
+    const trackDurations = {};
+    const currentTracks = [];
+    const samplePositions = [];
+    const sampleChunkIndices = [];
+    const moovOffset = w.getWrittenByteCount();
+    const getPaddedMoovAtom = () => {
+        return (0, mp4_header_1.createPaddedMoovAtom)({
+            durationInUnits: globalDurationInUnits,
+            trackInfo: currentTracks.map((track) => {
+                var _a, _b;
+                return {
+                    track,
+                    durationInUnits: (_a = trackDurations[track.trackNumber]) !== null && _a !== void 0 ? _a : 0,
+                    samplePositions: (_b = samplePositions[track.trackNumber]) !== null && _b !== void 0 ? _b : [],
+                    timescale: track.timescale,
+                };
+            }),
+            timescale: CONTAINER_TIMESCALE,
+        });
+    };
+    await w.write(getPaddedMoovAtom());
+    let mdatSize = 8;
+    const mdatSizeOffset = w.getWrittenByteCount();
+    await w.write((0, matroska_utils_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 addCodecPrivateToTrack = ({ trackNumber, codecPrivate, }) => {
+        currentTracks.forEach((track) => {
+            if (track.trackNumber === trackNumber) {
+                track.codecPrivate = codecPrivate;
+            }
+        });
+    };
+    let lastChunkWasVideo = false;
+    const addSample = async ({ chunk, trackNumber, isVideo, codecPrivate, }) => {
+        var _a, _b, _c, _d;
+        const position = w.getWrittenByteCount();
+        await w.write(chunk.data);
+        mdatSize += chunk.data.length;
+        onBytesProgress(w.getWrittenByteCount());
+        progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, (_a = chunk.cts) !== null && _a !== void 0 ? _a : Infinity, (_b = chunk.dts) !== null && _b !== void 0 ? _b : Infinity));
+        progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+        if (codecPrivate) {
+            addCodecPrivateToTrack({ trackNumber, codecPrivate });
+        }
+        const currentTrack = currentTracks.find((t) => t.trackNumber === trackNumber);
+        if (!currentTrack) {
+            throw new Error(`Tried to add sample to track ${trackNumber}, but it doesn't exist`);
+        }
+        if (!lowestTrackTimestamps[trackNumber] ||
+            chunk.timestamp < lowestTrackTimestamps[trackNumber]) {
+            lowestTrackTimestamps[trackNumber] = chunk.timestamp;
+        }
+        if (typeof lowestTrackTimestamps[trackNumber] !== 'number') {
+            throw new Error(`Tried to add sample to track ${trackNumber}, but it has no timestamp`);
+        }
+        const newDurationInMicroSeconds = chunk.timestamp +
+            ((_c = chunk.duration) !== null && _c !== void 0 ? _c : 0) -
+            lowestTrackTimestamps[trackNumber];
+        const newDurationInTrackTimeUnits = Math.round(newDurationInMicroSeconds / (1000000 / currentTrack.timescale));
+        trackDurations[trackNumber] = newDurationInTrackTimeUnits;
+        // webcodecs returns frame duration in microseconds
+        const newDurationInMilliseconds = Math.round((newDurationInMicroSeconds / 1000000) * CONTAINER_TIMESCALE);
+        if (newDurationInMilliseconds > globalDurationInUnits) {
+            globalDurationInUnits = newDurationInMilliseconds;
+            onMillisecondsProgress(newDurationInMilliseconds);
+        }
+        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) * currentTrack.timescale),
+            dts: Math.round((chunk.dts / 1000000) * currentTrack.timescale),
+            duration: Math.round((((_d = chunk.duration) !== null && _d !== void 0 ? _d : 0) / 1000000) * currentTrack.timescale),
+            size: chunk.data.length,
+        };
+        lastChunkWasVideo = isVideo;
+        samplePositions[trackNumber].push(samplePositionToAdd);
+    };
+    const addTrack = (track) => {
+        const trackNumber = currentTracks.length + 1;
+        currentTracks.push({ ...track, trackNumber });
+        progressTracker.registerTrack(trackNumber);
+        return Promise.resolve({ trackNumber });
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: () => {
+            return w.save();
+        },
+        remove: async () => {
+            await w.remove();
+        },
+        addSample: ({ chunk, trackNumber, isVideo, codecPrivate }) => {
+            operationProm.current = operationProm.current.then(() => {
+                return addSample({
+                    chunk,
+                    trackNumber,
+                    isVideo,
+                    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() {
+            media_parser_1.MediaParserInternals.Log.verbose(logLevel, 'All write operations queued. Waiting for finish...');
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+            media_parser_1.MediaParserInternals.Log.verbose(logLevel, 'Cleanup tasks executed');
+            await operationProm.current;
+            await updateMoov();
+            await updateMdatSize();
+            media_parser_1.MediaParserInternals.Log.verbose(logLevel, 'All write operations done. Waiting for finish...');
+            await w.waitForFinish();
+        },
+    };
+};
+exports.createIsoBaseMedia = createIsoBaseMedia;

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

@@ -0,0 +1,5 @@
+export declare const createMdia: ({ mdhd, hdlr, minf, }: {
+    mdhd: Uint8Array;
+    hdlr: Uint8Array;
+    minf: Uint8Array;
+}) => Uint8Array;