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

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -1,13 +1,18 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { ParseResult } from '../../../parse-result';
+import type { ExpectSegmentParseResult, MatroskaParseResult } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { MatroskaSegment } from '../segments';
-type WrapChildren = (segments: MatroskaSegment[]) => MatroskaSegment;
-export declare const expectChildren: ({ iterator, length, initialChildren, wrap, parserContext, }: {
+import type { PossibleEbml } from './all-segments';
+export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;
+export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, }: {
     iterator: BufferIterator;
     length: number;
-    initialChildren: MatroskaSegment[];
-    wrap: WrapChildren | null;
+    children: MatroskaSegment[];
     parserContext: ParserContext;
-}) => Promise<ParseResult>;
-export {};
+    startOffset: number;
+}) => Promise<MatroskaParseResult>;

package/dist/boxes/webm/segments/parse-children.js

@@ -1,100 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = void 0;
+exports.expectChildren = exports.expectAndProcessSegment = void 0;
 const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, wrap, }) => {
+const processParseResult = ({ parseResult, children, }) => {
+    if (parseResult.segment && !children.includes(parseResult.segment)) {
+        children.push(parseResult.segment);
+    }
     if (parseResult.status === 'incomplete') {
         // No need to decrement because expectSegment already does it
         return {
             status: 'incomplete',
-            segments: [],
+            segment: parseResult.segment,
             continueParsing: async () => {
                 const newParseResult = await parseResult.continueParsing();
                 return processParseResult({
                     children,
                     parseResult: newParseResult,
-                    wrap,
                 });
             },
-            skipTo: null,
         };
     }
-    for (const segment of parseResult.segments) {
-        children.push(segment);
-    }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
+        segment: parseResult.segment,
     };
 };
-const continueParsingfunction = ({ result, iterator, children, wrap, parserContext, length, }) => async () => {
-    if (result.status !== 'incomplete') {
-        throw new Error('expected incomplete');
+const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, }) => {
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        parserContext,
+        offset,
+        children,
+    });
+    return processParseResult({
+        children,
+        parseResult: segment,
+    });
+};
+exports.expectAndProcessSegment = expectAndProcessSegment;
+const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, }) => {
+    if (result.status === 'done') {
+        throw new Error('Should not continue after done');
     }
-    const offset = iterator.counter.getOffset();
-    const continued = await result.continueParsing();
-    if (continued.status === 'incomplete') {
-        if (!parserContext.supportsContentRange) {
-            throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-        }
+    const segmentResult = await result.continueParsing();
+    if (segmentResult.status === 'done') {
         return {
             status: 'incomplete',
-            continueParsing: continueParsingfunction({
-                result: continued,
-                iterator,
-                children,
-                wrap,
-                parserContext,
-                length: length - (iterator.counter.getOffset() - offset),
-            }),
-            skipTo: continued.skipTo,
-            segments: wrap ? [wrap(children)] : children,
+            continueParsing: () => {
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                return (0, exports.expectChildren)({
+                    children,
+                    iterator,
+                    length,
+                    parserContext,
+                    startOffset,
+                });
+            },
+            skipTo: null,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return (0, exports.expectChildren)({
-        iterator,
-        length: length - (iterator.counter.getOffset() - offset),
-        initialChildren: children,
-        wrap,
-        parserContext,
-    });
+    return {
+        status: 'incomplete',
+        continueParsing: () => {
+            return continueAfterSegmentResult({
+                result: segmentResult,
+                children,
+                iterator,
+                length,
+                parserContext,
+                startOffset,
+            });
+        },
+        skipTo: null,
+    };
 };
-const expectChildren = async ({ iterator, length, initialChildren, wrap, parserContext, }) => {
-    const children = [...initialChildren];
-    const startOffset = iterator.counter.getOffset();
+const expectChildren = async ({ iterator, length, children, parserContext, startOffset, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
         }
-        const parseResult = await (0, segments_1.expectSegment)(iterator, parserContext);
-        const child = processParseResult({
+        const currentOffset = iterator.counter.getOffset();
+        const child = await (0, exports.expectAndProcessSegment)({
+            iterator,
+            parserContext,
+            offset: currentOffset,
             children,
-            parseResult,
-            wrap,
         });
         if (child.status === 'incomplete') {
-            if (!parserContext.supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
             return {
                 status: 'incomplete',
-                continueParsing: continueParsingfunction({
-                    result: child,
-                    iterator,
-                    children,
-                    wrap,
-                    parserContext,
-                    length: length - (iterator.counter.getOffset() - startOffset),
-                }),
-                skipTo: child.skipTo,
-                segments: wrap ? [wrap(children)] : children,
+                continueParsing: () => {
+                    return continueAfterSegmentResult({
+                        result: child,
+                        children,
+                        iterator,
+                        length: length - (currentOffset - startOffset),
+                        parserContext,
+                        startOffset: currentOffset,
+                    });
+                },
+                skipTo: null,
             };
         }
     }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
     };
 };
 exports.expectChildren = expectChildren;

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

@@ -1,7 +1,12 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ParseResult } from '../../parse-result';
+import type { ExpectSegmentParseResult } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
-import type { PossibleEbml, TrackEntry } from './segments/all-segments';
+import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: (iterator: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;
+export declare const expectSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;