@remotion/media-parser 4.0.249 → 4.0.251

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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectRiffBox = void 0;
-const is_movi_1 = require("./is-movi");
-const parse_movi_1 = require("./parse-movi");
-const parse_riff_box_1 = require("./parse-riff-box");
-const expectRiffBox = async ({ iterator, state, structure, fields, }) => {
-    // Need at least 16 bytes to read LIST,size,movi,size
-    if (iterator.bytesRemaining() < 16) {
-        return {
-            type: 'incomplete',
-            continueParsing() {
-                return (0, exports.expectRiffBox)({ structure, iterator, state, fields });
-            },
-        };
-    }
-    const ckId = iterator.getByteString(4, false);
-    const ckSize = iterator.getUint32Le();
-    if ((0, is_movi_1.isMoviAtom)(iterator, ckId)) {
-        iterator.discard(4);
-        return (0, parse_movi_1.parseMovi)({
-            iterator,
-            maxOffset: ckSize + iterator.counter.getOffset() - 4,
-            state,
-            structure,
-        });
-    }
-    if (iterator.bytesRemaining() < ckSize) {
-        iterator.counter.decrement(8);
-        return {
-            type: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectRiffBox)({ structure, iterator, state, fields });
-            },
-        };
-    }
-    return {
-        type: 'complete',
-        box: await (0, parse_riff_box_1.parseRiffBox)({
-            id: ckId,
-            iterator,
-            size: ckSize,
-            boxes: structure.boxes,
-            state,
-            fields,
-        }),
-        skipTo: null,
-    };
-};
-exports.expectRiffBox = expectRiffBox;

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRiff = void 0;
-const has_all_info_1 = require("../../has-all-info");
-const parse_riff_body_1 = require("./parse-riff-body");
-const parseRiff = ({ iterator, state, fields, }) => {
-    const riff = iterator.getByteString(4, false);
-    if (riff !== 'RIFF') {
-        throw new Error('Not a RIFF file');
-    }
-    const structure = state.structure.getStructure();
-    if (structure.type !== 'riff') {
-        throw new Error('Structure is not a RIFF structure');
-    }
-    const size = iterator.getUint32Le();
-    const fileType = iterator.getByteString(4, false);
-    if (fileType !== 'WAVE' && fileType !== 'AVI') {
-        throw new Error(`File type ${fileType} not supported`);
-    }
-    structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
-    if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
-        return Promise.resolve({
-            status: 'done',
-            segments: structure,
-        });
-    }
-    return (0, parse_riff_body_1.parseRiffBody)({
-        iterator,
-        maxOffset: Infinity,
-        state,
-        structure,
-        fields,
-    });
-};
-exports.parseRiff = parseRiff;

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

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

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFmtBox = void 0;
-const parseFmtBox = ({ iterator, boxes, size, }) => {
-    const box = iterator.startBox(size);
-    const header = boxes.find((b) => b.type === 'riff-header');
-    if (!header) {
-        throw new Error('Expected RIFF header');
-    }
-    if (header.fileType !== 'WAVE') {
-        throw new Error('Only supporting WAVE type');
-    }
-    const wFormatTag = iterator.getUint16Le();
-    if (wFormatTag !== 1) {
-        throw new Error('Expected wFormatTag to be 1, only supporting this');
-    }
-    const numberOfChannels = iterator.getUint16Le();
-    const sampleRate = iterator.getUint32Le();
-    const byteRate = iterator.getUint32Le();
-    const blockAlign = iterator.getUint16Le();
-    const bitsPerSample = iterator.getUint16Le();
-    box.expectNoMoreBytes();
-    return {
-        type: 'wave-format-box',
-        formatTag: wFormatTag,
-        numberOfChannels,
-        sampleRate,
-        blockAlign,
-        byteRate,
-        bitsPerSample,
-    };
-};
-exports.parseFmtBox = parseFmtBox;

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

@@ -1,10 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ParserState } from '../../state/parser-state';
-import type { RiffBox } from './riff-box';
-export declare const parseListBox: ({ iterator, size, state, fields, }: {
-    iterator: BufferIterator;
-    size: number;
-    state: ParserState;
-    fields: Options<ParseMediaFields>;
-}) => Promise<RiffBox>;

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseListBox = void 0;
-const parse_riff_body_1 = require("./parse-riff-body");
-const parseListBox = async ({ iterator, size, state, fields, }) => {
-    const counter = iterator.counter.getOffset();
-    const listType = iterator.getByteString(4, false);
-    if (listType === 'movi') {
-        throw new Error('should not be handled here');
-    }
-    const structure = {
-        type: 'riff',
-        boxes: [],
-    };
-    const result = await (0, parse_riff_body_1.parseRiffBody)({
-        structure,
-        iterator,
-        maxOffset: counter + size,
-        state,
-        fields,
-    });
-    if (result.status === 'incomplete') {
-        throw new Error(`Should only parse complete boxes (${listType})`);
-    }
-    return {
-        type: 'list-box',
-        listType,
-        children: structure.boxes,
-    };
-};
-exports.parseListBox = parseListBox;

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

@@ -1,17 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import type { RiffResult } from './expect-riff-box';
-export declare const handleChunk: ({ iterator, state, structure, ckId, ckSize, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    structure: RiffStructure;
-    ckId: string;
-    ckSize: number;
-}) => Promise<void>;
-export declare const parseMovi: ({ iterator, maxOffset, state, structure, }: {
-    iterator: BufferIterator;
-    maxOffset: number;
-    state: ParserState;
-    structure: RiffStructure;
-}) => Promise<RiffResult>;

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

@@ -1,11 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ParseResult, RiffStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-export declare const parseRiffBody: ({ iterator, structure, maxOffset, state, fields, }: {
-    iterator: BufferIterator;
-    structure: RiffStructure;
-    maxOffset: number;
-    state: ParserState;
-    fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult>;

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

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRiffBody = void 0;
-const get_tracks_1 = require("../../get-tracks");
-const has_all_info_1 = require("../../has-all-info");
-const register_track_1 = require("../../register-track");
-const continue_after_riff_result_1 = require("./continue-after-riff-result");
-const expect_riff_box_1 = require("./expect-riff-box");
-const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
-const traversal_1 = require("./traversal");
-const parseRiffBody = async ({ iterator, structure, maxOffset, state, fields, }) => {
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() < maxOffset &&
-        !(0, has_all_info_1.hasAllInfo)({ fields, state })) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)({
-            iterator,
-            state,
-            structure,
-            fields,
-        });
-        if (result.type === 'complete' && result.skipTo !== null) {
-            return {
-                status: 'incomplete',
-                skipTo: result.skipTo,
-                continueParsing() {
-                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result,
-                        structure,
-                        fields,
-                    }));
-                },
-            };
-        }
-        if (result.type === 'incomplete') {
-            return {
-                status: 'incomplete',
-                async continueParsing() {
-                    return Promise.resolve((0, continue_after_riff_result_1.continueAfterRiffBoxResult)({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result: await result.continueParsing(),
-                        structure,
-                        fields,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        if (result.box === null) {
-            continue;
-        }
-        structure.boxes.push(result.box);
-        // When parsing an AVI
-        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
-            const tracks = (0, get_tracks_1.getTracks)(structure, state);
-            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
-                state.callbacks.tracks.setIsDone();
-            }
-        }
-        // When parsing a WAV
-        if (result.box.type === 'wave-format-box') {
-            state.callbacks.tracks.setIsDone();
-        }
-        if (result.box.type === 'strf-box-video' ||
-            result.box.type === 'strf-box-audio') {
-            const strh = (0, traversal_1.getStrhBox)(structure.boxes);
-            const strf = (0, traversal_1.getStrfBox)(structure.boxes);
-            if (!strh || !strf) {
-                throw new Error('strh or strf box missing');
-            }
-            if (strf.type === 'strf-box-audio' && state.onAudioTrack) {
-                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                await (0, register_track_1.registerTrack)({
-                    state,
-                    track: audioTrack,
-                    container: 'avi',
-                });
-            }
-            if (state.onVideoTrack && strf.type === 'strf-box-video') {
-                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
-                    strh,
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
-                    state,
-                    track: videoTrack,
-                    container: 'avi',
-                });
-            }
-            state.riff.incrementNextTrackIndex();
-        }
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.parseRiffBody = parseRiffBody;

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

@@ -1,12 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ParserState } from '../../state/parser-state';
-import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ iterator, size, id, boxes, state, fields, }: {
-    iterator: BufferIterator;
-    size: number;
-    id: string;
-    boxes: RiffBox[];
-    state: ParserState;
-    fields: Options<ParseMediaFields>;
-}) => Promise<RiffBox>;

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

@@ -1,7 +0,0 @@
-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/transport-stream/get-tracks.d.ts

@@ -1,5 +0,0 @@
-import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import type { AllTracks } from '../riff/get-tracks-from-avi';
-export declare const getTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => AllTracks;
-export declare const hasAllTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => boolean;

package/dist/boxes/transport-stream/parse-packet.d.ts

@@ -1,13 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import type { TransportStreamBox } from './boxes';
-import type { NextPesHeaderStore } from './next-pes-header-store';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parsePacket: ({ iterator, structure, streamBuffers, parserState, nextPesHeaderStore, }: {
-    iterator: BufferIterator;
-    structure: TransportStreamStructure;
-    streamBuffers: StreamBufferMap;
-    parserState: ParserState;
-    nextPesHeaderStore: NextPesHeaderStore;
-}) => Promise<TransportStreamBox | null>;

package/dist/boxes/transport-stream/parse-stream-packet.d.ts

@@ -1,15 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import type { PacketPes } from './parse-pes';
-import type { TransportStreamEntry } from './parse-pmt';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseStream: ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }: {
-    iterator: BufferIterator;
-    transportStreamEntry: TransportStreamEntry;
-    streamBuffers: StreamBufferMap;
-    state: ParserState;
-    programId: number;
-    structure: TransportStreamStructure;
-    nextPesHeader: PacketPes;
-}) => Promise<void>;

package/dist/boxes/transport-stream/parse-transport-stream.d.ts

@@ -1,13 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ParseResult } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import type { NextPesHeaderStore } from './next-pes-header-store';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseTransportStream: ({ iterator, state, streamBuffers, fields, nextPesHeaderStore, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    streamBuffers: StreamBufferMap;
-    fields: Options<ParseMediaFields>;
-    nextPesHeaderStore: NextPesHeaderStore;
-}) => Promise<ParseResult>;

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

@@ -1,37 +0,0 @@
-"use strict";
-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',
-        };
-    }
-    return {
-        status: 'incomplete',
-        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 = async ({ counter, state, fields, }) => {
-    const structure = state.structure.getStructure();
-    if (structure.type !== 'matroska') {
-        throw new Error('Invalid structure type');
-    }
-    const results = await (0, parse_children_1.expectChildren)({
-        iterator: counter,
-        length: Infinity,
-        children: structure.boxes,
-        state,
-        startOffset: counter.counter.getOffset(),
-        fields,
-        topLevelStructure: structure,
-    });
-    return continueAfterMatroskaResult(results, structure);
-};
-exports.parseWebm = parseWebm;

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

@@ -1,23 +0,0 @@
-import type { BufferIterator } from '../../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../../options';
-import type { ExpectSegmentParseResult, MatroskaParseResult, MatroskaStructure } from '../../../parse-result';
-import type { ParserState } from '../../../state/parser-state';
-import type { MatroskaSegment } from '../segments';
-import type { PossibleEbml } from './all-segments';
-export declare const expectAndProcessSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;
-export declare const expectChildren: ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    length: number;
-    children: MatroskaSegment[];
-    state: ParserState;
-    startOffset: number;
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<MatroskaParseResult>;

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

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = exports.expectAndProcessSegment = void 0;
-const has_all_info_1 = require("../../../has-all-info");
-const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, state, fields, topLevelStructure, }) => {
-    if (parseResult.segment && !children.includes(parseResult.segment)) {
-        children.push(parseResult.segment);
-        if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
-            return {
-                status: 'done',
-                segment: parseResult.segment,
-            };
-        }
-        if (parseResult.segment.type === 'Tracks') {
-            state.callbacks.tracks.setIsDone();
-        }
-    }
-    if (parseResult.status === 'incomplete') {
-        // No need to decrement because expectSegment already does it
-        return {
-            status: 'incomplete',
-            segment: parseResult.segment,
-            continueParsing: async () => {
-                const newParseResult = await parseResult.continueParsing();
-                return processParseResult({
-                    children,
-                    parseResult: newParseResult,
-                    state,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
-    }
-    return {
-        status: 'done',
-        segment: parseResult.segment,
-    };
-};
-const expectAndProcessSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
-    const segment = await (0, segments_1.expectSegment)({
-        iterator,
-        state,
-        offset,
-        children,
-        fields,
-        topLevelStructure,
-    });
-    return processParseResult({
-        children,
-        parseResult: segment,
-        state,
-        fields,
-        topLevelStructure,
-    });
-};
-exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, state, iterator, startOffset, fields, topLevelStructure, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const segmentResult = await result.continueParsing();
-    if (segmentResult.status === 'done') {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                return (0, exports.expectChildren)({
-                    children,
-                    iterator,
-                    length,
-                    state,
-                    startOffset,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            skipTo: null,
-        };
-    }
-    return {
-        status: 'incomplete',
-        continueParsing: () => {
-            return continueAfterSegmentResult({
-                result: segmentResult,
-                children,
-                iterator,
-                length,
-                state,
-                startOffset,
-                fields,
-                topLevelStructure,
-            });
-        },
-        skipTo: null,
-    };
-};
-const expectChildren = async ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }) => {
-    while (iterator.counter.getOffset() < startOffset + length) {
-        if (iterator.bytesRemaining() === 0) {
-            break;
-        }
-        const currentOffset = iterator.counter.getOffset();
-        const child = await (0, exports.expectAndProcessSegment)({
-            iterator,
-            state,
-            offset: currentOffset,
-            children,
-            fields,
-            topLevelStructure,
-        });
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
-            state,
-        })) {
-            return {
-                status: 'done',
-            };
-        }
-        if (child.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterSegmentResult({
-                        result: child,
-                        children,
-                        iterator,
-                        length: length - (currentOffset - startOffset),
-                        state,
-                        startOffset: currentOffset,
-                        fields,
-                        topLevelStructure,
-                    });
-                },
-                skipTo: null,
-            };
-        }
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.expectChildren = expectChildren;

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

@@ -1,15 +0,0 @@
-import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ExpectSegmentParseResult, MatroskaStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
-import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
-export type MatroskaSegment = PossibleEbml;
-export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;