@remotion/media-parser 4.0.230 → 4.0.232

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/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/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, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -6,13 +6,13 @@ 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, }) => {
+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();
+    const w = await writer.createContent({ filename, mimeType: 'video/mp4' });
     await w.write(header);
     let durationInUnits = 0;
     const currentTracks = [];
@@ -113,9 +113,8 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     };
     const waitForFinishPromises = [];
     return {
-        save: async () => {
-            const file = await w.save();
-            return file;
+        save: () => {
+            return w.save();
         },
         remove: async () => {
             await w.remove();
@@ -159,10 +158,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.d.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from '../../log';
 import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { Writer } from '../../writers/writer';
 export declare const timestampToClusterTimestamp: (timestamp: number, timescale: number) => number;
@@ -6,7 +7,12 @@ export declare const canFitInCluster: ({ clusterStartTimestamp, chunk, timescale
     chunk: AudioOrVideoSample;
     timescale: number;
 }) => boolean;
-export declare const makeCluster: (w: Writer, clusterStartTimestamp: number, timescale: number) => Promise<{
+export declare const makeCluster: ({ writer, clusterStartTimestamp, timescale, logLevel, }: {
+    writer: Writer;
+    clusterStartTimestamp: number;
+    timescale: number;
+    logLevel: LogLevel;
+}) => Promise<{
     addSample: (chunk: AudioOrVideoSample, trackNumber: number) => Promise<{
         timecodeRelativeToCluster: number;
     }>;

package/dist/create/matroska/cluster.js

@@ -4,6 +4,7 @@ exports.makeCluster = exports.canFitInCluster = exports.timestampToClusterTimest
 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 log_1 = require("../../log");
 const cluster_segment_1 = require("./cluster-segment");
 const maxClusterTimestamp = 2 ** 15;
 const timestampToClusterTimestamp = (timestamp, timescale) => {
@@ -19,15 +20,16 @@ const canFitInCluster = ({ clusterStartTimestamp, chunk, timescale, }) => {
     return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
 exports.canFitInCluster = canFitInCluster;
-const makeCluster = async (w, clusterStartTimestamp, timescale) => {
+const makeCluster = async ({ writer, clusterStartTimestamp, timescale, logLevel, }) => {
+    log_1.Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
     const cluster = (0, cluster_segment_1.createClusterSegment)((0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale));
-    const clusterVIntPosition = w.getWrittenByteCount() +
+    const clusterVIntPosition = writer.getWrittenByteCount() +
         cluster.offsets.offset +
         (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).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);
+    await writer.write(cluster.bytes);
     const addSample = async (chunk, trackNumber) => {
         const timecodeRelativeToCluster = (0, exports.timestampToClusterTimestamp)(chunk.timestamp, timescale) -
             (0, exports.timestampToClusterTimestamp)(clusterStartTimestamp, timescale);
@@ -44,8 +46,8 @@ const makeCluster = async (w, clusterStartTimestamp, timescale) => {
             timecodeRelativeToCluster,
         });
         clusterSize += simpleBlock.byteLength;
-        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
-        await w.write(simpleBlock);
+        await writer.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await writer.write(simpleBlock);
         return { timecodeRelativeToCluster };
     };
     const shouldMakeNewCluster = ({ isVideo, chunk, newT, }) => {
@@ -59,6 +61,7 @@ const makeCluster = async (w, clusterStartTimestamp, timescale) => {
         if (!canFit) {
             // We must create a new cluster
             // This is for example if we have an audio-only file
+            log_1.Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
             return true;
         }
         const keyframe = chunk.type === 'key';

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, }: MediaFnGeneratorInput) => Promise<MediaFn>;
+export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -13,10 +13,10 @@ 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, }) => {
+const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
-    const w = await writer.createContent();
+    const w = await writer.createContent({ filename, mimeType: 'video/webm' });
     await w.write(header.bytes);
     const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
         timescale,
@@ -69,14 +69,27 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
     };
     await w.write(matroskaSegment.bytes);
     const clusterOffset = w.getWrittenByteCount();
-    let currentCluster = await (0, cluster_1.makeCluster)(w, 0, timescale);
+    let currentCluster = await (0, cluster_1.makeCluster)({
+        writer: w,
+        clusterStartTimestamp: 0,
+        timescale,
+        logLevel,
+    });
     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));
+    const getClusterOrMakeNew = async ({ chunk, isVideo, trackNumber, }) => {
+        const trackProgressValues = Object.values(trackNumberProgresses);
+        const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+        // 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;
+        }
         if (!currentCluster.shouldMakeNewCluster({
             newT: smallestProgress,
             isVideo,
@@ -84,7 +97,12 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
         })) {
             return { cluster: currentCluster, isNew: false, smallestProgress };
         }
-        currentCluster = await (0, cluster_1.makeCluster)(w, smallestProgress, timescale);
+        currentCluster = await (0, cluster_1.makeCluster)({
+            writer: w,
+            clusterStartTimestamp: smallestProgress,
+            timescale,
+            logLevel,
+        });
         return { cluster: currentCluster, isNew: true, smallestProgress };
     };
     const updateDuration = async (newDuration) => {
@@ -94,10 +112,10 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
     };
     const addSample = async ({ chunk, trackNumber, isVideo, }) => {
         var _a;
-        trackNumberProgresses[trackNumber] = chunk.timestamp;
         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);
@@ -132,9 +150,8 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
                 }
             });
         },
-        save: async () => {
-            const file = await w.save();
-            return file;
+        save: () => {
+            return w.save();
         },
         remove: async () => {
             await w.remove();
@@ -143,10 +160,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

@@ -12,7 +12,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;
     }>;
@@ -28,4 +27,5 @@ export type MediaFnGeneratorInput = {
     onBytesProgress: (totalBytes: number) => void;
     onMillisecondsProgress: (totalMilliseconds: number) => void;
     logLevel: LogLevel;
+    filename: string;
 };

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/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, }: MediaFnGeneratorInput) => Promise<MediaFn>;

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

@@ -0,0 +1,108 @@
+"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, }) => {
+    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));
+            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);
+            return Promise.resolve({ trackNumber: 1 });
+        },
+    };
+};
+exports.createWav = createWav;