@remotion/media-parser 4.0.249 → 4.0.251

package/dist/boxes/webm/segments.js

@@ -1,161 +0,0 @@
-"use strict";
-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 continueAfterMatroskaParseResult = async ({ result, iterator, state, segment, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const proceeded = await result.continueParsing();
-    if (proceeded.status === 'done') {
-        return {
-            status: 'done',
-            segment,
-        };
-    }
-    return {
-        continueParsing() {
-            return continueAfterMatroskaParseResult({
-                result: proceeded,
-                iterator,
-                state,
-                segment,
-            });
-        },
-        segment: null,
-        status: 'incomplete',
-    };
-};
-const expectSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
-    iterator.counter.decrement(iterator.counter.getOffset() - offset);
-    if (iterator.bytesRemaining() === 0) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
-    }
-    const segmentId = iterator.getMatroskaSegmentId();
-    if (segmentId === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
-    }
-    const offsetBeforeVInt = iterator.counter.getOffset();
-    const length = iterator.getVint();
-    const offsetAfterVInt = iterator.counter.getOffset();
-    if (length === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            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,
-            children: newSegment.value,
-            state,
-            startOffset: iterator.counter.getOffset(),
-            fields,
-            topLevelStructure,
-        });
-        if (main.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterMatroskaParseResult({
-                        iterator,
-                        state,
-                        result: main,
-                        segment: newSegment,
-                    });
-                },
-                segment: newSegment,
-            };
-        }
-        return {
-            status: 'done',
-            segment: newSegment,
-        };
-    }
-    if (bytesRemainingNow < length) {
-        const bytesRead = iterator.counter.getOffset() - offset;
-        iterator.counter.decrement(bytesRead);
-        return {
-            status: 'incomplete',
-            segment: null,
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
-    }
-    const segment = await parseSegment({
-        segmentId,
-        iterator,
-        length,
-        state,
-        headerReadSoFar: iterator.counter.getOffset() - offset,
-    });
-    return {
-        status: 'done',
-        segment,
-    };
-};
-exports.expectSegment = expectSegment;
-const parseSegment = async ({ segmentId, iterator, length, state, 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, state);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, state });
-    return remapped;
-};

package/dist/continue-mdat-routine.d.ts

@@ -1,17 +0,0 @@
-import type { BufferIterator } from './buffer-iterator';
-import type { LogLevel } from './log';
-import type { Options, ParseMediaFields } from './options';
-import type { IsoBaseMediaBox, ParseResult } from './parse-result';
-import type { PartialMdatBox } from './parse-video';
-import type { ParserState } from './state/parser-state';
-export declare const continueMdatRoutine: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }: {
-    iterator: BufferIterator;
-    maxBytes: number;
-    allowIncompleteBoxes: boolean;
-    initialBoxes: IsoBaseMediaBox[];
-    state: ParserState;
-    continueMdat: PartialMdatBox;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult>;

package/dist/continue-mdat-routine.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.continueMdatRoutine = void 0;
-const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
-const parse_mdat_partially_1 = require("./boxes/iso-base-media/parse-mdat-partially");
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const has_all_info_1 = require("./has-all-info");
-const may_skip_video_data_1 = require("./may-skip-video-data/may-skip-video-data");
-const continueMdatRoutine = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }) => {
-    var _a;
-    const initialOffset = iterator.counter.getOffset();
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() - initialOffset < maxBytes) {
-        const result = await (0, parse_mdat_partially_1.parseMdatPartially)({
-            iterator,
-            boxSize: continueMdat.boxSize,
-            fileOffset: continueMdat.fileOffset,
-            parsedBoxes: initialBoxes,
-            state,
-            signal,
-        });
-        if (result.type === 'incomplete') {
-            throw new Error('Incomplete boxes are not allowed in this routine');
-        }
-        if (result.type === 'partial-mdat-box') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.continueMdatRoutine)({
-                        iterator,
-                        maxBytes,
-                        allowIncompleteBoxes,
-                        initialBoxes,
-                        state,
-                        continueMdat: result,
-                        signal,
-                        logLevel,
-                        fields,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        const alreadyHasMdat = (_a = state.structure
-            .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
-        if (result.box.type === 'mdat-box' && alreadyHasMdat) {
-            initialBoxes = initialBoxes.filter((b) => b.type !== 'mdat-box');
-            initialBoxes.push(result.box);
-            iterator.allowDiscard();
-            break;
-        }
-        else {
-            initialBoxes.push(result.box);
-            if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
-                return {
-                    status: 'done',
-                };
-            }
-        }
-        iterator.removeBytesRead();
-    }
-    const mdatState = (0, traversal_1.getMdatBox)(initialBoxes);
-    const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
-        !(0, may_skip_video_data_1.maySkipVideoData)({ state }) &&
-        state.supportsContentRange;
-    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !(0, may_skip_video_data_1.maySkipVideoData)({ state });
-    if (skipped || buffered) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                if (buffered) {
-                    iterator.skipTo(mdatState.fileOffset, false);
-                }
-                return (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
-                    iterator,
-                    maxBytes,
-                    allowIncompleteBoxes: false,
-                    initialBoxes,
-                    state,
-                    signal,
-                    logLevel,
-                    fields,
-                });
-            },
-            skipTo: skipped ? mdatState.fileOffset : null,
-        };
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.continueMdatRoutine = continueMdatRoutine;

package/dist/parse-video.d.ts

@@ -1,28 +0,0 @@
-import type { BufferIterator } from './buffer-iterator';
-import { type LogLevel } from './log';
-import type { Options, ParseMediaFields } from './options';
-import type { IsoBaseMediaBox, ParseResult } from './parse-result';
-import type { ParserState } from './state/parser-state';
-export type PartialMdatBox = {
-    type: 'partial-mdat-box';
-    boxSize: number;
-    fileOffset: number;
-};
-export type BoxAndNext = {
-    type: 'complete';
-    box: IsoBaseMediaBox;
-    size: number;
-    skipTo: number | null;
-} | {
-    type: 'incomplete';
-} | PartialMdatBox;
-export declare const parseVideo: ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
-    mimeType: string | null;
-    contentLength: number | null;
-    name: string | null;
-}) => Promise<ParseResult>;

package/dist/parse-video.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVideo = void 0;
-const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
-const parse_mp3_1 = require("./boxes/mp3/parse-mp3");
-const parse_box_1 = require("./boxes/riff/parse-box");
-const next_pes_header_store_1 = require("./boxes/transport-stream/next-pes-header-store");
-const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transport-stream");
-const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
-const errors_1 = require("./errors");
-const log_1 = require("./log");
-const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }) => {
-    if (iterator.bytesRemaining() === 0) {
-        return Promise.reject(new Error('no bytes'));
-    }
-    const fileType = iterator.detectFileType();
-    if (fileType.type === 'riff') {
-        log_1.Log.verbose(logLevel, 'Detected RIFF container');
-        state.structure.setStructure({
-            type: 'riff',
-            boxes: [],
-        });
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, state, fields }));
-    }
-    if (fileType.type === 'iso-base-media') {
-        log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
-        const initialBoxes = [];
-        state.structure.setStructure({
-            type: 'iso-base-media',
-            boxes: initialBoxes,
-        });
-        return (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
-            iterator,
-            maxBytes: Infinity,
-            allowIncompleteBoxes: true,
-            initialBoxes,
-            state,
-            signal,
-            logLevel,
-            fields,
-        });
-    }
-    if (fileType.type === 'webm') {
-        log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        state.structure.setStructure({
-            boxes: [],
-            type: 'matroska',
-        });
-        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, state, fields });
-    }
-    if (fileType.type === 'transport-stream') {
-        log_1.Log.verbose(logLevel, 'Detected MPEG-2 Transport Stream');
-        state.structure.setStructure({
-            boxes: [],
-            type: 'transport-stream',
-        });
-        return (0, parse_transport_stream_1.parseTransportStream)({
-            iterator,
-            state,
-            streamBuffers: new Map(),
-            fields,
-            nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
-        });
-    }
-    if (fileType.type === 'mp3') {
-        const structure = {
-            boxes: [],
-            type: 'mp3',
-        };
-        state.structure.setStructure(structure);
-        return (0, parse_mp3_1.parseMp3)({ iterator, structure, state });
-    }
-    if (fileType.type === 'wav') {
-        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
-            message: 'WAV files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-            audioType: 'wav',
-        }));
-    }
-    if (fileType.type === 'aac') {
-        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
-            message: 'AAC files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-            audioType: 'aac',
-        }));
-    }
-    if (fileType.type === 'gif') {
-        return Promise.reject(new errors_1.IsAGifError({
-            message: 'GIF files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-        }));
-    }
-    if (fileType.type === 'pdf') {
-        return Promise.reject(new errors_1.IsAPdfError({
-            message: 'GIF files are not supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-        }));
-    }
-    if (fileType.type === 'bmp' ||
-        fileType.type === 'jpeg' ||
-        fileType.type === 'png' ||
-        fileType.type === 'webp') {
-        return Promise.reject(new errors_1.IsAnImageError({
-            message: 'Image files are not supported',
-            imageType: fileType.type,
-            dimensions: fileType.dimensions,
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-        }));
-    }
-    if (fileType.type === 'unknown') {
-        return Promise.reject(new errors_1.IsAnUnsupportedFileTypeError({
-            message: 'Unknown file format',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-        }));
-    }
-    return Promise.reject(new Error('Unknown video format ' + fileType));
-};
-exports.parseVideo = parseVideo;