@remotion/media-parser 4.0.231 → 4.0.233

package/dist/boxes/riff/traversal.d.ts

@@ -0,0 +1,8 @@
+import type { RiffStructure } from '../../parse-result';
+import type { AvihBox, ListBox, RiffBox, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+export declare const isRiffAvi: (structure: RiffStructure) => boolean;
+export declare const getHdlrBox: (structure: RiffStructure) => ListBox | null;
+export declare const getAvihBox: (structure: RiffStructure) => AvihBox | null;
+export declare const getStrlBoxes: (structure: RiffStructure) => ListBox[];
+export declare const getStrhBox: (strlBoxChildren: RiffBox[]) => StrhBox | null;
+export declare const getStrfBox: (strlBoxChildren: RiffBox[]) => StrfBoxAudio | StrfBoxVideo | null;

package/dist/boxes/riff/traversal.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrfBox = exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
+const isRiffAvi = (structure) => {
+    return structure.boxes.some((box) => box.type === 'riff-header' && box.fileType === 'AVI');
+};
+exports.isRiffAvi = isRiffAvi;
+const getHdlrBox = (structure) => {
+    return structure.boxes.find((box) => box.type === 'list-box' && box.listType === 'hdrl');
+};
+exports.getHdlrBox = getHdlrBox;
+const getAvihBox = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
+    if (!hdlrBox) {
+        return null;
+    }
+    return hdlrBox.children.find((box) => box.type === 'avih-box');
+};
+exports.getAvihBox = getAvihBox;
+const getStrlBoxes = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
+    if (!hdlrBox) {
+        return [];
+    }
+    return hdlrBox.children.filter((box) => box.type === 'list-box' && box.listType === 'strl');
+};
+exports.getStrlBoxes = getStrlBoxes;
+const getStrhBox = (strlBoxChildren) => {
+    return strlBoxChildren.find((box) => box.type === 'strh-box');
+};
+exports.getStrhBox = getStrhBox;
+const getStrfBox = (strlBoxChildren) => {
+    var _a;
+    return ((_a = strlBoxChildren.find((box) => box.type === 'strf-box-audio' || box.type === 'strf-box-video')) !== null && _a !== void 0 ? _a : null);
+};
+exports.getStrfBox = getStrfBox;

package/dist/boxes/webm/parse-ebml.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postprocessEbml = exports.parseEbml = void 0;
-const add_new_matroska_tracks_1 = require("../../add-new-matroska-tracks");
+const register_track_1 = require("../../register-track");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
 const all_segments_1 = require("./segments/all-segments");
@@ -115,7 +115,7 @@ const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
             timescale: parserContext.parserState.getTimescale(),
         });
         if (track) {
-            await (0, add_new_matroska_tracks_1.registerTrack)({
+            await (0, register_track_1.registerTrack)({
                 state: parserContext.parserState,
                 options: parserContext,
                 track,

package/dist/boxes/webm/parse-webm-header.d.ts

@@ -1,4 +1,4 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ParseResult } from '../../parse-result';
+import type { MatroskaStructure, ParseResult } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
-export declare const parseWebm: (counter: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;
+export declare const parseWebm: (counter: BufferIterator, parserContext: ParserContext) => Promise<ParseResult<MatroskaStructure>>;

package/dist/boxes/webm/parse-webm-header.js

@@ -2,33 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
 const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaResult = (result, children) => {
+const continueAfterMatroskaResult = (result, structure) => {
     if (result.status === 'done') {
         return {
             status: 'done',
-            segments: children,
+            segments: structure,
         };
     }
     return {
         status: 'incomplete',
-        segments: children,
+        segments: structure,
         continueParsing: async () => {
             const newResult = await result.continueParsing();
-            return continueAfterMatroskaResult(newResult, children);
+            return continueAfterMatroskaResult(newResult, structure);
         },
         skipTo: null,
     };
 };
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 const parseWebm = async (counter, parserContext) => {
-    const children = [];
+    const structure = { type: 'matroska', boxes: [] };
     const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
         length: Infinity,
-        children,
+        children: structure.boxes,
         parserContext,
         startOffset: counter.counter.getOffset(),
     });
-    return continueAfterMatroskaResult(results, children);
+    return continueAfterMatroskaResult(results, structure);
 };
 exports.parseWebm = parseWebm;

package/dist/boxes/webm/traversal.d.ts

@@ -1,6 +1,6 @@
-import type { AnySegment } from '../../parse-result';
+import type { MatroskaSegment } from './segments';
 import type { AudioSegment, ClusterSegment, CodecIdSegment, ColourSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, MatrixCoefficientsSegment, PrimariesSegment, RangeSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, TransferCharacteristicsSegment, VideoSegment, WidthSegment } from './segments/all-segments';
-export declare const getMainSegment: (segments: AnySegment[]) => MainSegment | null;
+export declare const getMainSegment: (segments: MatroskaSegment[]) => MainSegment | null;
 export declare const getTrackNumber: (track: TrackEntry) => import("./segments/all-segments").UintWithSize | null;
 export declare const getTrackCodec: (track: TrackEntry) => CodecIdSegment | null;
 export declare const getTrackTimestampScale: (track: TrackEntry) => import("./segments/all-segments").FloatWithSize | null;

package/dist/buffer-iterator.d.ts

@@ -37,9 +37,10 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getEBML: () => number;
     getInt8: () => number;
     getUint16: () => number;
+    getUint16Le: () => number;
     getUint24: () => number;
     getInt16: () => number;
-    getUint32: (littleEndian?: boolean) => number;
+    getUint32: () => number;
     getUint64: (littleEndian?: boolean) => bigint;
     getFixedPointUnsigned1616Number: () => number;
     getFixedPointSigned1616Number: () => number;
@@ -56,5 +57,9 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     isMp3: () => boolean;
     disallowDiscard: () => void;
     allowDiscard: () => void;
+    startBox: (size: number) => {
+        discardRest: () => void;
+        expectNoMoreBytes: () => void;
+    };
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -89,6 +89,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const allowDiscard = () => {
         discardAllowed = true;
     };
+    const discard = (length) => {
+        counter.increment(length);
+    };
     const getUint8 = () => {
         const val = view.getUint8(counter.getDiscardedOffset());
         counter.increment(1);
@@ -142,8 +145,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         }
         return lastInt;
     };
-    const getUint32 = (littleEndian = false) => {
-        const val = view.getUint32(counter.getDiscardedOffset(), littleEndian);
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getDiscardedOffset());
         counter.increment(4);
         return val;
     };
@@ -152,6 +155,18 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         counter.increment(8);
         return val;
     };
+    const startBox = (size) => {
+        const startOffset = counter.getOffset();
+        return {
+            discardRest: () => discard(size - (counter.getOffset() - startOffset)),
+            expectNoMoreBytes: () => {
+                const remaining = size - (counter.getOffset() - startOffset);
+                if (remaining !== 0) {
+                    throw new Error('expected 0 bytes, got ' + remaining);
+                }
+            },
+        };
+    };
     const getUint32Le = () => {
         const val = view.getUint32(counter.getDiscardedOffset(), true);
         counter.increment(4);
@@ -300,9 +315,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         leb128,
         removeBytesRead,
         isWebm,
-        discard: (length) => {
-            counter.increment(length);
-        },
+        discard,
         getEightByteNumber,
         getFourByteNumber,
         getSlice,
@@ -414,6 +427,11 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             counter.increment(2);
             return val;
         },
+        getUint16Le: () => {
+            const val = view.getUint16(counter.getDiscardedOffset(), true);
+            counter.increment(2);
+            return val;
+        },
         getUint24: () => {
             const val1 = view.getUint8(counter.getDiscardedOffset());
             const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
@@ -472,6 +490,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         isMp3,
         disallowDiscard,
         allowDiscard,
+        startBox,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

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/create-iso-base-media.d.ts

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

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

@@ -6,7 +6,7 @@ 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 createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }) => {
     const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
         compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
         majorBrand: 'isom',
@@ -70,6 +70,7 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         await w.write(chunk.data);
         mdatSize += chunk.data.length;
         onBytesProgress(w.getWrittenByteCount());
+        progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
         if (codecPrivate) {
             addCodecPrivateToTrack({ trackNumber, codecPrivate });
         }
@@ -109,6 +110,7 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     const addTrack = (track) => {
         const trackNumber = currentTracks.length + 1;
         currentTracks.push({ ...track, trackNumber });
+        progressTracker.registerTrack(trackNumber);
         return Promise.resolve({ trackNumber });
     };
     const waitForFinishPromises = [];
@@ -158,10 +160,6 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
             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;

package/dist/create/matroska/cluster.js

@@ -15,7 +15,7 @@ const canFitInCluster = ({ clusterStartTimestamp, chunk, timescale, }) => {
     const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
         (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
     if (timecodeRelativeToCluster < 0) {
-        throw new Error(`timecodeRelativeToCluster is negative`);
+        throw new Error(`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`);
     }
     return timecodeRelativeToCluster <= maxClusterTimestamp;
 };

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

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

package/dist/create/matroska/create-matroska-media.js

@@ -13,7 +13,7 @@ const matroska_seek_1 = require("./matroska-seek");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
 const timescale = 1000000;
-const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }) => {
+const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent({ filename, mimeType: 'video/webm' });
@@ -79,17 +79,11 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         hexString: all_segments_1.matroskaElements.Cluster,
         byte: clusterOffset - seekHeadOffset,
     });
-    const trackNumberProgresses = {};
-    const getClusterOrMakeNew = async ({ chunk, isVideo, trackNumber, }) => {
-        const trackProgressValues = Object.values(trackNumberProgresses);
-        const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+    const getClusterOrMakeNew = async ({ chunk, isVideo, }) => {
         // In Safari, samples can arrive out of order, e.g public/bigbuckbunny.mp4
         // Therefore, only updating track number progress if it is a keyframe
         // to allow for timestamps to be lower than the previous one
-        // Also doing this AFTER smallestProgress is calculated
-        if (chunk.type === 'key') {
-            trackNumberProgresses[trackNumber] = chunk.timestamp;
-        }
+        const smallestProgress = progressTracker.getSmallestProgress();
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
             isVideo,
@@ -115,7 +109,6 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
             chunk,
             isVideo,
-            trackNumber,
         });
         const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
         await updateDuration(newDuration);
@@ -129,12 +122,16 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
                 trackNumber,
             });
         }
+        if (chunk.type === 'key') {
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+        }
         onBytesProgress(w.getWrittenByteCount());
         onMillisecondsProgress(newDuration);
     };
     const addTrack = async (track) => {
         currentTracks.push(track);
         const newTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+        progressTracker.registerTrack(track.trackNumber);
         await w.updateDataAt(tracksOffset, (0, make_header_1.combineUint8Arrays)(newTracks.map((b) => b.bytes)));
     };
     const operationProm = { current: Promise.resolve() };
@@ -160,10 +157,6 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
             operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber, isVideo }));
             return operationProm.current;
         },
-        updateDuration: (duration) => {
-            operationProm.current = operationProm.current.then(() => updateDuration(duration));
-            return operationProm.current;
-        },
         addTrack: (track) => {
             const trackNumber = currentTracks.length + 1;
             operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber }));

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

@@ -2,6 +2,7 @@ import type { LogLevel } from '../log';
 import type { AudioOrVideoSample } from '../webcodec-sample-types';
 import type { WriterInterface } from '../writers/writer';
 import type { MakeTrackAudio, MakeTrackVideo } from './make-track-info';
+import type { ProgressTracker } from './progress-tracker';
 export type MediaFn = {
     save: () => Promise<Blob>;
     remove: () => Promise<void>;
@@ -12,7 +13,6 @@ export type MediaFn = {
         timescale: number;
         codecPrivate: Uint8Array | null;
     }) => Promise<void>;
-    updateDuration: (duration: number) => Promise<void>;
     addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{
         trackNumber: number;
     }>;
@@ -29,4 +29,5 @@ export type MediaFnGeneratorInput = {
     onMillisecondsProgress: (totalMilliseconds: number) => void;
     logLevel: LogLevel;
     filename: string;
+    progressTracker: ProgressTracker;
 };

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

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

package/dist/create/mp3/create-mp3.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMp3 = void 0;
+const log_1 = require("../../log");
+const createMp3 = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, }) => {
+    const w = await writer.createContent({ filename, mimeType: 'audio/mpeg' });
+    const operationProm = { current: Promise.resolve() };
+    const addSample = async (chunk) => {
+        var _a;
+        await w.write(chunk.data);
+        onMillisecondsProgress(chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0));
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: () => {
+            return w.save();
+        },
+        remove: () => {
+            return w.remove();
+        },
+        addSample: ({ chunk, trackNumber }) => {
+            if (trackNumber !== 1) {
+                throw new Error('Only one track supported for WAV');
+            }
+            operationProm.current = operationProm.current.then(() => addSample(chunk));
+            return operationProm.current;
+        },
+        updateTrackSampleRate: () => {
+            throw new Error('updateTrackSampleRate() not implemented for WAV encoder');
+        },
+        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()));
+            await operationProm.current;
+            await w.waitForFinish();
+        },
+        addTrack: (track) => {
+            if (track.type !== 'audio') {
+                throw new Error('Only audio tracks supported for WAV');
+            }
+            return Promise.resolve({ trackNumber: 1 });
+        },
+    };
+};
+exports.createMp3 = createMp3;

package/dist/create/progress-tracker.d.ts

@@ -0,0 +1,7 @@
+export declare const makeProgressTracker: () => {
+    registerTrack: (trackNumber: number) => void;
+    getSmallestProgress: () => number;
+    updateTrackProgress: (trackNumber: number, progress: number) => void;
+    waitForProgress: () => Promise<void>;
+};
+export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeProgressTracker = void 0;
+const event_emitter_1 = require("./event-emitter");
+const with_resolvers_1 = require("./with-resolvers");
+const makeProgressTracker = () => {
+    const trackNumberProgresses = {};
+    const eventEmitter = new event_emitter_1.IoEventEmitter();
+    const calculateSmallestProgress = () => {
+        const progressValues = Object.values(trackNumberProgresses);
+        if (progressValues.length === 0) {
+            return 0;
+        }
+        return Math.min(...progressValues);
+    };
+    return {
+        registerTrack: (trackNumber) => {
+            trackNumberProgresses[trackNumber] = 0;
+        },
+        getSmallestProgress: () => {
+            return calculateSmallestProgress();
+        },
+        updateTrackProgress: (trackNumber, progress) => {
+            if (trackNumberProgresses[trackNumber] === undefined) {
+                throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
+            }
+            trackNumberProgresses[trackNumber] = progress;
+            eventEmitter.dispatchEvent('progress', {
+                smallestProgress: calculateSmallestProgress(),
+            });
+        },
+        waitForProgress: () => {
+            const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+            const on = () => {
+                eventEmitter.removeEventListener('processed', on);
+                resolve();
+            };
+            eventEmitter.addEventListener('processed', on);
+            return promise;
+        },
+    };
+};
+exports.makeProgressTracker = makeProgressTracker;

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

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

package/dist/create/wav/create-wav.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWav = void 0;
+const log_1 = require("../../log");
+const numberTo32BiIntLittleEndian = (num) => {
+    return new Uint8Array([
+        num & 0xff,
+        (num >> 8) & 0xff,
+        (num >> 16) & 0xff,
+        (num >> 24) & 0xff,
+    ]);
+};
+const numberTo16BitLittleEndian = (num) => {
+    return new Uint8Array([num & 0xff, (num >> 8) & 0xff]);
+};
+const BIT_DEPTH = 16;
+const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }) => {
+    const w = await writer.createContent({ filename, mimeType: 'audio/wav' });
+    await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
+    const sizePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
+    await w.write(new Uint8Array([0x57, 0x41, 0x56, 0x45])); // "WAVE"
+    await w.write(new Uint8Array([0x66, 0x6d, 0x74, 0x20])); // "fmt "
+    await w.write(new Uint8Array([0x10, 0x00, 0x00, 0x00])); // fmt chunk size = 16
+    await w.write(new Uint8Array([0x01, 0x00])); // Audio format (PCM) = 1, set 3 if float32 would be true
+    const channelNumPosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x01, 0x00])); // Number of channels = 1
+    const sampleRatePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Sample rate
+    const byteRatePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Byte rate
+    const blockAlignPosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00])); // Block align
+    await w.write(numberTo16BitLittleEndian(BIT_DEPTH)); // Bits per sample
+    await w.write(new Uint8Array([0x64, 0x61, 0x74, 0x61])); // "data"
+    const dataSizePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
+    const operationProm = { current: Promise.resolve() };
+    const updateSize = async () => {
+        const size = w.getWrittenByteCount() - sizePosition - 4;
+        await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
+        const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
+        await w.updateDataAt(dataSizePosition, numberTo32BiIntLittleEndian(dataSize));
+    };
+    const updateChannelNum = async (numberOfChannels) => {
+        await w.updateDataAt(channelNumPosition, new Uint8Array([numberOfChannels, 0x00]));
+    };
+    const updateSampleRate = async (sampleRate) => {
+        await w.updateDataAt(sampleRatePosition, numberTo32BiIntLittleEndian(sampleRate));
+    };
+    const updateByteRate = async ({ sampleRate, numberOfChannels, }) => {
+        await w.updateDataAt(byteRatePosition, numberTo32BiIntLittleEndian(sampleRate * numberOfChannels + BYTES_PER_SAMPLE));
+    };
+    const updateBlockAlign = async (numberOfChannels) => {
+        await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
+    };
+    const addSample = async (chunk) => {
+        var _a;
+        log_1.Log.verbose(logLevel, 'Adding sample', chunk);
+        await w.write(chunk.data);
+        onMillisecondsProgress((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: () => {
+            return w.save();
+        },
+        remove: () => {
+            return w.remove();
+        },
+        addSample: ({ chunk, trackNumber }) => {
+            if (trackNumber !== 1) {
+                throw new Error('Only one track supported for WAV');
+            }
+            operationProm.current = operationProm.current.then(() => addSample(chunk));
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+            return operationProm.current;
+        },
+        updateTrackSampleRate: () => {
+            throw new Error('updateTrackSampleRate() not implemented for WAV encoder');
+        },
+        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()));
+            await operationProm.current;
+            await updateSize();
+            await w.waitForFinish();
+        },
+        addTrack: async (track) => {
+            if (track.type !== 'audio') {
+                throw new Error('Only audio tracks supported for WAV');
+            }
+            await updateChannelNum(track.numberOfChannels);
+            await updateSampleRate(track.sampleRate);
+            await updateByteRate({
+                sampleRate: track.sampleRate,
+                numberOfChannels: track.numberOfChannels,
+            });
+            await updateBlockAlign(track.numberOfChannels);
+            progressTracker.registerTrack(1);
+            return Promise.resolve({ trackNumber: 1 });
+        },
+    };
+};
+exports.createWav = createWav;

package/dist/create/with-resolvers.d.ts

@@ -0,0 +1,10 @@
+export declare const withResolvers: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare const withResolversAndWaitForReturn: <T>() => {
+    getPromiseToImmediatelyReturn: () => Promise<T>;
+    reject: (reason: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};