@remotion/media-parser 4.0.194 → 4.0.196

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

@@ -2,16 +2,92 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectChildren = void 0;
 const segments_1 = require("../segments");
-const expectChildren = (iterator, length) => {
-    const children = [];
+const processParseResult = ({ parseResult, children, wrap, }) => {
+    if (parseResult.status === 'incomplete') {
+        // No need to decrement because expectSegment already does it
+        return {
+            status: 'incomplete',
+            segments: [],
+            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,
+    };
+};
+const continueParsingfunction = ({ result, iterator, children, wrap, parserContext, length, }) => async () => {
+    if (result.status !== 'incomplete') {
+        throw new Error('expected incomplete');
+    }
+    const offset = iterator.counter.getOffset();
+    const continued = await result.continueParsing();
+    if (continued.status === 'incomplete') {
+        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,
+        };
+    }
+    return (0, exports.expectChildren)({
+        iterator,
+        length: length - (iterator.counter.getOffset() - offset),
+        initialChildren: children,
+        wrap,
+        parserContext,
+    });
+};
+const expectChildren = async ({ iterator, length, initialChildren, wrap, parserContext, }) => {
+    const children = [...initialChildren];
     const startOffset = iterator.counter.getOffset();
     while (iterator.counter.getOffset() < startOffset + length) {
-        const child = (0, segments_1.expectSegment)(iterator);
-        children.push(child);
-        if (child.type === 'unknown-segment') {
+        if (iterator.bytesRemaining() === 0) {
             break;
         }
+        const parseResult = await (0, segments_1.expectSegment)(iterator, parserContext);
+        const child = processParseResult({
+            children,
+            parseResult,
+            wrap,
+        });
+        if (child.status === 'incomplete') {
+            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,
+            };
+        }
     }
-    return children;
+    return {
+        status: 'done',
+        segments: wrap ? [wrap(children)] : children,
+    };
 };
 exports.expectChildren = expectChildren;

package/dist/boxes/webm/segments/seek-head.d.ts

@@ -1,8 +1,9 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
 import { type MatroskaSegment } from '../segments';
 export type SeekHeadSegment = {
     type: 'seek-head-segment';
     children: MatroskaSegment[];
     length: number;
 };
-export declare const parseSeekHeadSegment: (iterator: BufferIterator) => SeekHeadSegment;
+export declare const parseSeekHeadSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<SeekHeadSegment>;

package/dist/boxes/webm/segments/seek-head.js

@@ -2,12 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSeekHeadSegment = void 0;
 const parse_children_1 = require("./parse-children");
-const parseSeekHeadSegment = (iterator) => {
-    const length = iterator.getVint();
+const parseSeekHeadSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
     return {
         type: 'seek-head-segment',
         length,
-        children: (0, parse_children_1.expectChildren)(iterator, length),
+        children: children.segments,
     };
 };
 exports.parseSeekHeadSegment = parseSeekHeadSegment;

package/dist/boxes/webm/segments/seek-position.d.ts

@@ -3,4 +3,4 @@ export type SeekPositionSegment = {
     type: 'seek-position-segment';
     seekPosition: number;
 };
-export declare const parseSeekPositionSegment: (iterator: BufferIterator) => SeekPositionSegment;
+export declare const parseSeekPositionSegment: (iterator: BufferIterator, length: number) => SeekPositionSegment;

package/dist/boxes/webm/segments/seek-position.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSeekPositionSegment = void 0;
-const parseSeekPositionSegment = (iterator) => {
-    const length = iterator.getVint();
+const parseSeekPositionSegment = (iterator, length) => {
     const seekPosition = iterator.getDecimalBytes(length);
     return {
         type: 'seek-position-segment',

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

@@ -1,8 +1,13 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
 import type { MatroskaSegment } from '../segments';
 export type SeekSegment = {
     type: 'seek-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseSeekSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<SeekSegment>;
+export type SeekIdSegment = {
+    type: 'seek-id-segment';
     seekId: string;
-    child: MatroskaSegment;
 };
-export declare const parseSeekSegment: (iterator: BufferIterator) => SeekSegment;
+export declare const parseSeekIdSegment: (iterator: BufferIterator) => SeekIdSegment;

package/dist/boxes/webm/segments/seek.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSeekSegment = void 0;
-const segments_1 = require("../segments");
-const parseSeekSegment = (iterator) => {
-    // length
-    iterator.discard(4);
-    const seekId = iterator.getMatroskaSegmentId();
-    const child = (0, segments_1.expectSegment)(iterator);
+exports.parseSeekIdSegment = exports.parseSeekSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseSeekSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
     return {
         type: 'seek-segment',
-        seekId,
-        child,
+        children: children.segments,
     };
 };
 exports.parseSeekSegment = parseSeekSegment;
+const parseSeekIdSegment = (iterator) => {
+    const seekId = iterator.getMatroskaSegmentId();
+    return {
+        type: 'seek-id-segment',
+        seekId,
+    };
+};
+exports.parseSeekIdSegment = parseSeekIdSegment;

package/dist/boxes/webm/segments/track-entry.d.ts

@@ -1,101 +1,181 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
 import type { MatroskaSegment } from '../segments';
 export type TrackEntrySegment = {
     type: 'track-entry-segment';
     children: MatroskaSegment[];
 };
-export declare const parseTrackEntry: (iterator: BufferIterator) => TrackEntrySegment;
+export declare const parseTrackEntry: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TrackEntrySegment>;
 export type TrackNumberSegment = {
     type: 'track-number-segment';
     trackNumber: number;
 };
-export declare const parseTrackNumber: (iterator: BufferIterator) => TrackNumberSegment;
 export type TrackUIDSegment = {
     type: 'track-uid-segment';
     trackUid: string;
 };
-export declare const parseTrackUID: (iterator: BufferIterator) => TrackUIDSegment;
+export declare const parseTrackUID: (iterator: BufferIterator, length: number) => TrackUIDSegment;
 export type FlagLacingSegment = {
     type: 'flag-lacing-segment';
     lacing: boolean;
 };
-export declare const parseFlagLacing: (iterator: BufferIterator) => FlagLacingSegment;
+export declare const parseFlagLacing: (iterator: BufferIterator, length: number) => FlagLacingSegment;
 export type LanguageSegment = {
     type: 'language-segment';
     language: string;
 };
-export declare const parseLanguageSegment: (iterator: BufferIterator) => LanguageSegment;
+export declare const parseLanguageSegment: (iterator: BufferIterator, length: number) => LanguageSegment;
 export type CodecSegment = {
     type: 'codec-segment';
     codec: string;
 };
-export declare const parseCodecSegment: (iterator: BufferIterator) => CodecSegment;
+export declare const parseCodecSegment: (iterator: BufferIterator, length: number) => CodecSegment;
+type TrackType = 'video' | 'audio' | 'complex' | 'subtitle' | 'button' | 'control' | 'metadata';
 export type TrackTypeSegment = {
     type: 'track-type-segment';
-    trackType: number;
+    trackType: TrackType;
 };
-export declare const parseTrackTypeSegment: (iterator: BufferIterator) => TrackTypeSegment;
+export declare const parseTrackTypeSegment: (iterator: BufferIterator, length: number) => TrackTypeSegment;
 export type DefaultDurationSegment = {
     type: 'default-duration-segment';
     defaultDuration: number;
 };
-export declare const parseDefaultDurationSegment: (iterator: BufferIterator) => DefaultDurationSegment;
+export declare const parseDefaultDurationSegment: (iterator: BufferIterator, length: number) => DefaultDurationSegment;
 export type VideoSegment = {
     type: 'video-segment';
     children: MatroskaSegment[];
 };
-export declare const parseVideoSegment: (iterator: BufferIterator) => VideoSegment;
+export declare const parseVideoSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<VideoSegment>;
+export type AudioSegment = {
+    type: 'audio-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseAudioSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<AudioSegment>;
 export type WidthSegment = {
     type: 'width-segment';
     width: number;
 };
-export declare const parseWidthSegment: (iterator: BufferIterator) => WidthSegment;
+export declare const parseWidthSegment: (iterator: BufferIterator, length: number) => WidthSegment;
 export type HeightSegment = {
     type: 'height-segment';
     height: number;
 };
-export declare const parseHeightSegment: (iterator: BufferIterator) => HeightSegment;
+export declare const parseHeightSegment: (iterator: BufferIterator, length: number) => HeightSegment;
+export type DisplayWidthSegment = {
+    type: 'display-width-segment';
+    displayWidth: number;
+};
+export declare const parseDisplayWidthSegment: (iterator: BufferIterator, length: number) => DisplayWidthSegment;
+export type DisplayHeightSegment = {
+    type: 'display-height-segment';
+    displayHeight: number;
+};
+export declare const parseDisplayHeightSegment: (iterator: BufferIterator, length: number) => DisplayHeightSegment;
 export type AlphaModeSegment = {
     type: 'alpha-mode-segment';
     alphaMode: number;
 };
-export declare const parseAlphaModeSegment: (iterator: BufferIterator) => AlphaModeSegment;
+export declare const parseAlphaModeSegment: (iterator: BufferIterator, length: number) => AlphaModeSegment;
 export type MaxBlockAdditionId = {
     type: 'max-block-addition-id-segment';
     maxBlockAdditionId: number;
 };
-export declare const parseMaxBlockAdditionId: (iterator: BufferIterator) => MaxBlockAdditionId;
+export declare const parseMaxBlockAdditionId: (iterator: BufferIterator, length: number) => MaxBlockAdditionId;
 export type ColorSegment = {
     type: 'color-segment';
+    length: number;
 };
-export declare const parseColorSegment: (iterator: BufferIterator) => ColorSegment;
+export declare const parseColorSegment: (iterator: BufferIterator, length: number) => ColorSegment;
 export type TitleSegment = {
     type: 'title-segment';
     title: string;
 };
-export declare const parseTitleSegment: (iterator: BufferIterator) => TitleSegment;
+export declare const parseTitleSegment: (iterator: BufferIterator, length: number) => TitleSegment;
 export type InterlacedSegment = {
     type: 'interlaced-segment';
     interlaced: boolean;
 };
-export declare const parseInterlacedSegment: (iterator: BufferIterator) => InterlacedSegment;
+export declare const parseInterlacedSegment: (iterator: BufferIterator, length: number) => InterlacedSegment;
 export type CodecPrivateSegment = {
     type: 'codec-private-segment';
-    codecPrivateData: number[];
+    codecPrivateData: Uint8Array;
 };
-export declare const parseCodecPrivateSegment: (iterator: BufferIterator) => CodecPrivateSegment;
+export declare const parseCodecPrivateSegment: (iterator: BufferIterator, length: number) => CodecPrivateSegment;
 export type Crc32Segment = {
     type: 'crc32-segment';
     crc32: number[];
 };
-export declare const parseCrc32Segment: (iterator: BufferIterator) => Crc32Segment;
+export declare const parseCrc32Segment: (iterator: BufferIterator, length: number) => Crc32Segment;
 export type SegmentUUIDSegment = {
     type: 'segment-uuid-segment';
     segmentUUID: string;
 };
-export declare const parseSegmentUUIDSegment: (iterator: BufferIterator) => SegmentUUIDSegment;
+export declare const parseSegmentUUIDSegment: (iterator: BufferIterator, length: number) => SegmentUUIDSegment;
 export type DefaultFlagSegment = {
     type: 'default-flag-segment';
     defaultFlag: boolean;
 };
-export declare const parseDefaultFlagSegment: (iterator: BufferIterator) => DefaultFlagSegment;
+export declare const parseDefaultFlagSegment: (iterator: BufferIterator, length: number) => DefaultFlagSegment;
+export type TagsSegment = {
+    type: 'tags-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTagsSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TagsSegment>;
+export type TagSegment = {
+    type: 'tag-segment';
+    length: number;
+};
+export declare const parseTagSegment: (iterator: BufferIterator, length: number) => TagSegment;
+export type ClusterSegment = {
+    type: 'cluster-segment';
+    children: MatroskaSegment[];
+};
+export type TimestampSegment = {
+    type: 'timestamp-segment';
+    timestamp: number;
+};
+export declare const parseTimestampSegment: (iterator: BufferIterator, length: number) => TimestampSegment;
+export type SimpleBlockSegment = {
+    type: 'simple-block-segment';
+    length: number;
+    trackNumber: number;
+    timecode: number;
+    headerFlags: number;
+    keyframe: boolean;
+    lacing: [number, number];
+    invisible: boolean;
+    children: MatroskaSegment[];
+};
+export type GetTracks = () => TrackEntrySegment[];
+export declare const parseSimpleBlockSegment: ({ iterator, length, parserContext, }: {
+    iterator: BufferIterator;
+    length: number;
+    parserContext: ParserContext;
+}) => Promise<SimpleBlockSegment>;
+export declare const parseTrackNumber: (iterator: BufferIterator, length: number) => TrackNumberSegment;
+export type BlockGroupSegment = {
+    type: 'block-group-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseBlockGroupSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<BlockGroupSegment>;
+export type BlockElement = {
+    type: 'block-element-segment';
+    length: number;
+};
+export declare const parseBlockElementSegment: (iterator: BufferIterator, length: number) => BlockElement;
+export type SamplingFrequencySegment = {
+    type: 'sampling-frequency-segment';
+    samplingFrequency: number;
+};
+export declare const parseSamplingFrequencySegment: (iterator: BufferIterator, length: number) => SamplingFrequencySegment;
+export type ChannelsSegment = {
+    type: 'channels-segment';
+    channels: number;
+};
+export declare const parseChannelsSegment: (iterator: BufferIterator, length: number) => ChannelsSegment;
+export type BitDepthSegment = {
+    type: 'bit-depth-segment';
+    bitDepth: number;
+};
+export declare const parseBitDepthSegment: (iterator: BufferIterator, length: number) => BitDepthSegment;
+export {};