@remotion/media-parser 4.0.231 → 4.0.232

package/dist/boxes/riff/parse-strf.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrf = void 0;
+const parseStrfAudio = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const formatTag = iterator.getUint16Le();
+    const numberOfChannels = iterator.getUint16Le();
+    const samplesPerSec = iterator.getUint32Le();
+    const avgBytesPerSec = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const cbSize = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-audio',
+        avgBytesPerSecond: avgBytesPerSec,
+        bitsPerSample,
+        blockAlign,
+        cbSize,
+        formatTag,
+        numberOfChannels,
+        sampleRate: samplesPerSec,
+    };
+};
+const parseStrfVideo = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const biSize = iterator.getUint32Le();
+    const width = iterator.getInt32Le();
+    const height = iterator.getInt32Le();
+    const planes = iterator.getUint16Le();
+    const bitCount = iterator.getUint16Le();
+    const compression = iterator.getByteString(4);
+    const sizeImage = iterator.getUint32Le();
+    const xPelsPerMeter = iterator.getInt32Le();
+    const yPelsPerMeter = iterator.getInt32Le();
+    const clrUsed = iterator.getUint32Le();
+    const clrImportant = iterator.getUint32Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-video',
+        biSize,
+        bitCount,
+        clrImportant,
+        clrUsed,
+        compression,
+        height,
+        planes,
+        sizeImage,
+        width,
+        xPelsPerMeter,
+        yPelsPerMeter,
+    };
+};
+const parseStrf = ({ iterator, size, boxes, }) => {
+    const strh = boxes.find((b) => b.type === 'strh-box');
+    if (!strh) {
+        throw new Error('strh box not found');
+    }
+    if (strh.fccType === 'vids') {
+        return parseStrfVideo({ iterator, size });
+    }
+    if (strh.fccType === 'auds') {
+        return parseStrfAudio({ iterator, size });
+    }
+    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+exports.parseStrf = parseStrf;

package/dist/boxes/riff/parse-strh.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { RiffBox } from './riff-box';
+export declare const parseStrh: ({ iterator, size, }: {
+    iterator: BufferIterator;
+    size: number;
+}) => RiffBox;

package/dist/boxes/riff/parse-strh.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrh = void 0;
+const parseStrh = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const fccType = iterator.getByteString(4);
+    if (fccType !== 'vids' && fccType !== 'auds') {
+        throw new Error('Expected AVI handler to be vids / auds');
+    }
+    const handler = fccType === 'vids' ? iterator.getByteString(4) : iterator.getUint32Le();
+    if (typeof handler === 'string' && handler !== 'H264') {
+        throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
+    }
+    if (fccType === 'auds' && handler !== 1) {
+        throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
+    }
+    const flags = iterator.getUint32Le();
+    const priority = iterator.getUint16Le();
+    const language = iterator.getUint16Le();
+    const initialFrames = iterator.getUint32Le();
+    const scale = iterator.getUint32Le();
+    const rate = iterator.getUint32Le();
+    const start = iterator.getUint32Le();
+    const length = iterator.getUint32Le();
+    const suggestedBufferSize = iterator.getUint32Le();
+    const quality = iterator.getUint32Le();
+    const sampleSize = iterator.getUint32Le();
+    box.discardRest();
+    return {
+        type: 'strh-box',
+        fccType,
+        handler,
+        flags,
+        priority,
+        initialFrames,
+        length,
+        quality,
+        rate,
+        sampleSize,
+        scale,
+        start,
+        suggestedBufferSize,
+        language,
+    };
+};
+exports.parseStrh = parseStrh;

package/dist/boxes/riff/riff-box.d.ts

@@ -0,0 +1,81 @@
+export type WaveFormatBox = {
+    type: 'wave-format-box';
+    formatTag: 1;
+    numberOfChannels: number;
+    sampleRate: number;
+    blockAlign: number;
+    byteRate: number;
+    bitsPerSample: number;
+};
+export type ListBox = {
+    type: 'list-box';
+    listType: string;
+    children: RiffBox[];
+};
+export type RiffRegularBox = {
+    type: 'riff-box';
+    size: number;
+    id: string;
+};
+export type AvihBox = {
+    type: 'avih-box';
+    microSecPerFrame: number;
+    maxBytesPerSecond: number;
+    paddingGranularity: number;
+    flags: number;
+    totalFrames: number;
+    initialFrames: number;
+    streams: number;
+    suggestedBufferSize: number;
+    width: number;
+    height: number;
+};
+export type StrhBox = {
+    type: 'strh-box';
+    fccType: 'vids' | 'auds';
+    handler: 'H264' | number;
+    flags: number;
+    priority: number;
+    initialFrames: number;
+    scale: number;
+    rate: number;
+    start: number;
+    length: number;
+    suggestedBufferSize: number;
+    quality: number;
+    sampleSize: number;
+    language: number;
+};
+export type StrfBoxVideo = {
+    type: 'strf-box-video';
+    biSize: number;
+    width: number;
+    height: number;
+    planes: number;
+    bitCount: number;
+    compression: string;
+    sizeImage: number;
+    xPelsPerMeter: number;
+    yPelsPerMeter: number;
+    clrUsed: number;
+    clrImportant: number;
+};
+export type StrfBoxAudio = {
+    type: 'strf-box-audio';
+    formatTag: number;
+    numberOfChannels: number;
+    sampleRate: number;
+    avgBytesPerSecond: number;
+    blockAlign: number;
+    bitsPerSample: number;
+    cbSize: number;
+};
+export type RiffHeader = {
+    type: 'riff-header';
+    fileSize: number;
+    fileType: string;
+};
+export type MoviBox = {
+    type: 'movi-box';
+};
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox;

package/dist/boxes/riff/riff-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { RiffBox } from './riff-box';
+export declare const parseStrf: ({ iterator, size, boxes, }: {
+    iterator: BufferIterator;
+    size: number;
+    boxes: RiffBox[];
+}) => RiffBox;

package/dist/boxes/riff/strf.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrf = void 0;
+const parseStrfAudio = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const formatTag = iterator.getUint16Le();
+    const numberOfChannels = iterator.getUint16Le();
+    const samplesPerSec = iterator.getUint32Le();
+    const avgBytesPerSec = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const cbSize = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-audio',
+        avgBytesPerSecond: avgBytesPerSec,
+        bitsPerSample,
+        blockAlign,
+        cbSize,
+        formatTag,
+        numberOfChannels,
+        sampleRate: samplesPerSec,
+    };
+};
+const parseStrfVideo = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const biSize = iterator.getUint32Le();
+    const width = iterator.getInt32Le();
+    const height = iterator.getInt32Le();
+    const planes = iterator.getUint16Le();
+    const bitCount = iterator.getUint16Le();
+    const compression = iterator.getByteString(4);
+    const sizeImage = iterator.getUint32Le();
+    const xPelsPerMeter = iterator.getInt32Le();
+    const yPelsPerMeter = iterator.getInt32Le();
+    const clrUsed = iterator.getUint32Le();
+    const clrImportant = iterator.getUint32Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-video',
+        biSize,
+        bitCount,
+        clrImportant,
+        clrUsed,
+        compression,
+        height,
+        planes,
+        sizeImage,
+        width,
+        xPelsPerMeter,
+        yPelsPerMeter,
+    };
+};
+const parseStrf = ({ iterator, size, boxes, }) => {
+    const strh = boxes.find((b) => b.type === 'strh-box');
+    if (!strh) {
+        throw new Error('strh box not found');
+    }
+    if (strh.fccType === 'vids') {
+        return parseStrfVideo({ iterator, size });
+    }
+    if (strh.fccType === 'auds') {
+        return parseStrfAudio({ iterator, size });
+    }
+    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+exports.parseStrf = parseStrf;

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

@@ -0,0 +1 @@
+export declare const MEDIA_PARSER_RIFF_TIMESCALE = 1000000;

package/dist/boxes/riff/timescale.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_PARSER_RIFF_TIMESCALE = void 0;
+exports.MEDIA_PARSER_RIFF_TIMESCALE = 1000000;

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

@@ -158,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/create-matroska-media.js

@@ -160,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;
     }>;

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