@remotion/media-parser 4.0.201 → 4.0.202

package/dist/boxes/webm/segments/track-entry.js

@@ -1,71 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBitDepthSegment = exports.parseChannelsSegment = exports.parseSamplingFrequencySegment = exports.parseBlockElementSegment = exports.parseBlockAdditionsSegment = exports.parseReferenceBlockSegment = exports.parseBlockGroupSegment = exports.parseTrackNumber = exports.parseSimpleBlockOrBlockSegment = exports.parseTimestampSegment = exports.parseTagSegment = exports.parseTagsSegment = exports.parseDefaultFlagSegment = exports.parseSegmentUUIDSegment = exports.parseCrc32Segment = exports.parseCodecPrivateSegment = exports.parseInterlacedSegment = exports.parseTitleSegment = exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseDisplayHeightSegment = exports.parseDisplayWidthSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseAudioSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackEntry = void 0;
-const block_simple_block_flags_1 = require("./block-simple-block-flags");
-const parse_children_1 = require("./parse-children");
-const parseTrackEntry = 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 ' + length);
-    }
-    return {
-        type: 'track-entry-segment',
-        children: children.segments,
-    };
-};
-exports.parseTrackEntry = parseTrackEntry;
-const parseTrackUID = (iterator, length) => {
-    const bytes = iterator.getSlice(length);
-    const asString = [...bytes]
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join('');
-    return {
-        type: 'track-uid-segment',
-        trackUid: asString,
-    };
-};
-exports.parseTrackUID = parseTrackUID;
-const parseFlagLacing = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected flag lacing to be 1 byte');
-    }
-    const bytes = iterator.getSlice(length);
-    if (bytes[0] !== 1 && bytes[0] !== 0) {
-        throw new Error('Expected lacing to be 1 or 0');
-    }
-    return {
-        type: 'flag-lacing-segment',
-        lacing: Boolean(bytes[0]),
-    };
-};
-exports.parseFlagLacing = parseFlagLacing;
-const parseLanguageSegment = (iterator, length) => {
-    if (length !== 3) {
-        throw new Error('Expected language segment to be 3 bytes');
-    }
-    const language = iterator.getByteString(length);
-    return {
-        type: 'language-segment',
-        language,
-    };
-};
-exports.parseLanguageSegment = parseLanguageSegment;
-const parseCodecSegment = (iterator, length) => {
-    // Could make a TypeScript enum with it
-    // https://www.matroska.org/technical/codec_specs.html
-    const codec = iterator.getByteString(length);
-    return {
-        type: 'codec-segment',
-        codec,
-    };
-};
-exports.parseCodecSegment = parseCodecSegment;
+exports.trackTypeToString = void 0;
 const trackTypeToString = (trackType) => {
     switch (trackType) {
         case 1:
@@ -86,393 +21,4 @@ const trackTypeToString = (trackType) => {
             throw new Error(`Unknown track type: ${trackType}`);
     }
 };
-const parseTrackTypeSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected track type segment to be 1 byte');
-    }
-    const trackType = iterator.getUint8();
-    const trackTypeString = trackTypeToString(trackType);
-    // Could make the return type nicer
-    /* 1 - video,
-    2 - audio,
-        3 - complex,
-        16 - logo,
-        17 - subtitle,
-        18 - buttons,
-        32 - control,
-        33 - metadata;
-    */
-    return {
-        type: 'track-type-segment',
-        trackType: trackTypeString,
-    };
-};
-exports.parseTrackTypeSegment = parseTrackTypeSegment;
-const parseDefaultDurationSegment = (iterator, length) => {
-    const defaultDuration = iterator.getUint(length);
-    return {
-        type: 'default-duration-segment',
-        defaultDuration,
-    };
-};
-exports.parseDefaultDurationSegment = parseDefaultDurationSegment;
-const parseVideoSegment = 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: 'video-segment',
-        children: children.segments,
-    };
-};
-exports.parseVideoSegment = parseVideoSegment;
-const parseAudioSegment = 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: 'audio-segment',
-        children: children.segments,
-    };
-};
-exports.parseAudioSegment = parseAudioSegment;
-const parseWidthSegment = (iterator, length) => {
-    if (length !== 2) {
-        throw new Error('Expected width segment to be 2 bytes');
-    }
-    const width = iterator.getUint16();
-    return {
-        type: 'width-segment',
-        width,
-    };
-};
-exports.parseWidthSegment = parseWidthSegment;
-const parseHeightSegment = (iterator, length) => {
-    if (length !== 2) {
-        throw new Error('Expected height segment to be 2 bytes');
-    }
-    const height = iterator.getUint16();
-    return {
-        type: 'height-segment',
-        height,
-    };
-};
-exports.parseHeightSegment = parseHeightSegment;
-const parseDisplayWidthSegment = (iterator, length) => {
-    if (length !== 2) {
-        throw new Error(`Expected display width segment to be 2 bytes, got ${length}`);
-    }
-    const displayWidth = iterator.getUint16();
-    return {
-        type: 'display-width-segment',
-        displayWidth,
-    };
-};
-exports.parseDisplayWidthSegment = parseDisplayWidthSegment;
-const parseDisplayHeightSegment = (iterator, length) => {
-    if (length !== 2) {
-        throw new Error(`Expected display height segment to be 2 bytes, got ${length}`);
-    }
-    const displayHeight = iterator.getUint16();
-    return {
-        type: 'display-height-segment',
-        displayHeight,
-    };
-};
-exports.parseDisplayHeightSegment = parseDisplayHeightSegment;
-const parseAlphaModeSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected alpha mode segment to be 1 byte');
-    }
-    const alphaMode = iterator.getUint8();
-    return {
-        type: 'alpha-mode-segment',
-        alphaMode,
-    };
-};
-exports.parseAlphaModeSegment = parseAlphaModeSegment;
-const parseMaxBlockAdditionId = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected alpha mode segment to be 1 byte');
-    }
-    const maxBlockAdditionId = iterator.getUint8();
-    return {
-        type: 'max-block-addition-id-segment',
-        maxBlockAdditionId,
-    };
-};
-exports.parseMaxBlockAdditionId = parseMaxBlockAdditionId;
-const parseColorSegment = (iterator, length) => {
-    iterator.discard(length);
-    return {
-        type: 'color-segment',
-        length,
-    };
-};
-exports.parseColorSegment = parseColorSegment;
-const parseTitleSegment = (iterator, length) => {
-    const title = iterator.getByteString(length);
-    return {
-        type: 'title-segment',
-        title,
-    };
-};
-exports.parseTitleSegment = parseTitleSegment;
-const parseInterlacedSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected interlaced segment to be 1 byte, but is ' + length);
-    }
-    const interlaced = iterator.getUint8();
-    return {
-        type: 'interlaced-segment',
-        interlaced: Boolean(interlaced),
-    };
-};
-exports.parseInterlacedSegment = parseInterlacedSegment;
-const parseCodecPrivateSegment = (iterator, length) => {
-    return {
-        type: 'codec-private-segment',
-        codecPrivateData: iterator.getSlice(length),
-    };
-};
-exports.parseCodecPrivateSegment = parseCodecPrivateSegment;
-const parseCrc32Segment = (iterator, length) => {
-    return {
-        type: 'crc32-segment',
-        crc32: [...iterator.getSlice(length)],
-    };
-};
-exports.parseCrc32Segment = parseCrc32Segment;
-const parseSegmentUUIDSegment = (iterator, length) => {
-    return {
-        type: 'segment-uuid-segment',
-        segmentUUID: iterator.getSlice(length).toString(),
-    };
-};
-exports.parseSegmentUUIDSegment = parseSegmentUUIDSegment;
-const parseDefaultFlagSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected default flag segment to be 1 byte');
-    }
-    return {
-        type: 'default-flag-segment',
-        defaultFlag: Boolean(iterator.getUint8()),
-    };
-};
-exports.parseDefaultFlagSegment = parseDefaultFlagSegment;
-const parseTagsSegment = 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: 'tags-segment',
-        children: children.segments,
-    };
-};
-exports.parseTagsSegment = parseTagsSegment;
-const parseTagSegment = (iterator, length) => {
-    iterator.discard(length);
-    return {
-        type: 'tag-segment',
-        length,
-    };
-};
-exports.parseTagSegment = parseTagSegment;
-const parseTimestampSegment = (iterator, length) => {
-    return {
-        type: 'timestamp-segment',
-        timestamp: iterator.getUint(length),
-    };
-};
-exports.parseTimestampSegment = parseTimestampSegment;
-const parseSimpleBlockOrBlockSegment = async ({ iterator, length, parserContext, type, }) => {
-    const start = iterator.counter.getOffset();
-    const trackNumber = iterator.getVint();
-    if (trackNumber === null) {
-        throw new Error('Not enough data to get track number, should not happen');
-    }
-    const timecodeRelativeToCluster = iterator.getUint16();
-    const { invisible, lacing, keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, type);
-    const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber);
-    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(iterator.counter.getOffset());
-    const timescale = parserContext.parserState.getTimescale();
-    if (clusterOffset === undefined) {
-        throw new Error('Could not find offset for byte offset ' + iterator.counter.getOffset());
-    }
-    // https://github.com/hubblec4/Matroska-Chapters-Specs/blob/master/notes.md/#timestampscale
-    // The TimestampScale Element is used to calculate the Raw Timestamp of a Block. The timestamp is obtained by adding the Block's timestamp to the Cluster's Timestamp Element, and then multiplying that result by the TimestampScale. The result will be the Block's Raw Timestamp in nanoseconds.
-    const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) *
-        timescale *
-        (trackTimescale !== null && trackTimescale !== void 0 ? trackTimescale : 1);
-    // Timecode should be in microseconds
-    const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
-    if (!codec) {
-        throw new Error('Could not find codec for track ' + trackNumber);
-    }
-    const remainingNow = length - (iterator.counter.getOffset() - start);
-    let videoSample = null;
-    if (codec.startsWith('V_')) {
-        const partialVideoSample = {
-            data: iterator.getSlice(remainingNow),
-            cts: null,
-            dts: null,
-            duration: undefined,
-            trackId: trackNumber,
-            timestamp: timecodeInMicroseconds,
-        };
-        if (keyframe === null) {
-            // If we don't know if this is a keyframe, we know after we emit the BlockGroup
-            videoSample = partialVideoSample;
-        }
-        else {
-            const sample = {
-                ...partialVideoSample,
-                type: keyframe ? 'key' : 'delta',
-            };
-            await parserContext.parserState.onVideoSample(trackNumber, sample);
-        }
-    }
-    if (codec.startsWith('A_')) {
-        await parserContext.parserState.onAudioSample(trackNumber, {
-            data: iterator.getSlice(remainingNow),
-            trackId: trackNumber,
-            timestamp: timecodeInMicroseconds,
-            type: 'key',
-        });
-    }
-    const remainingNowAfter = length - (iterator.counter.getOffset() - start);
-    if (remainingNowAfter > 0) {
-        iterator.discard(remainingNowAfter);
-    }
-    return {
-        type: 'simple-block-or-block-segment',
-        length,
-        trackNumber,
-        timecodeInMicroseconds,
-        keyframe,
-        lacing,
-        invisible,
-        videoSample,
-    };
-};
-exports.parseSimpleBlockOrBlockSegment = parseSimpleBlockOrBlockSegment;
-const parseTrackNumber = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error('Expected track number to be 1 byte');
-    }
-    const trackNumber = iterator.getUint8();
-    return {
-        type: 'track-number-segment',
-        trackNumber,
-    };
-};
-exports.parseTrackNumber = parseTrackNumber;
-const parseBlockGroupSegment = 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 boxes are not allowed');
-    }
-    return {
-        type: 'block-group-segment',
-        children: children.segments,
-    };
-};
-exports.parseBlockGroupSegment = parseBlockGroupSegment;
-const parseReferenceBlockSegment = (iterator, length) => {
-    if (length > 4) {
-        throw new Error(`Expected reference block segment to be 4 bytes, but got ${length}`);
-    }
-    const referenceBlock = length === 4
-        ? iterator.getUint32()
-        : length === 3
-            ? iterator.getUint24()
-            : length === 2
-                ? iterator.getUint16()
-                : iterator.getUint8();
-    return {
-        type: 'reference-block-segment',
-        referenceBlock,
-    };
-};
-exports.parseReferenceBlockSegment = parseReferenceBlockSegment;
-const parseBlockAdditionsSegment = (iterator, length) => {
-    const blockAdditions = iterator.getSlice(length);
-    return {
-        type: 'block-additions-segment',
-        blockAdditions,
-    };
-};
-exports.parseBlockAdditionsSegment = parseBlockAdditionsSegment;
-const parseBlockElementSegment = (iterator, length) => {
-    iterator.discard(length);
-    return {
-        type: 'block-element-segment',
-        length,
-    };
-};
-exports.parseBlockElementSegment = parseBlockElementSegment;
-const parseSamplingFrequencySegment = (iterator, length) => {
-    if (length === 4) {
-        return {
-            type: 'sampling-frequency-segment',
-            samplingFrequency: iterator.getFloat32(),
-        };
-    }
-    if (length === 8) {
-        return {
-            type: 'sampling-frequency-segment',
-            samplingFrequency: iterator.getFloat64(),
-        };
-    }
-    throw new Error(`Expected length of sampling frequency segment to be 4 or 8, got ${length}`);
-};
-exports.parseSamplingFrequencySegment = parseSamplingFrequencySegment;
-const parseChannelsSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error(`Expected length of channels segment to be 1, got ${length}`);
-    }
-    const channels = iterator.getUint8();
-    return {
-        type: 'channels-segment',
-        channels,
-    };
-};
-exports.parseChannelsSegment = parseChannelsSegment;
-const parseBitDepthSegment = (iterator, length) => {
-    if (length !== 1) {
-        throw new Error(`Expected length of bit depth segment to be 1, got ${length}`);
-    }
-    const bitDepth = iterator.getUint8();
-    return {
-        type: 'bit-depth-segment',
-        bitDepth,
-    };
-};
-exports.parseBitDepthSegment = parseBitDepthSegment;
+exports.trackTypeToString = trackTypeToString;

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

@@ -1,20 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { ParseResult } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
-import type { PossibleEbml } from './segments/all-segments';
-import type { DurationSegment } from './segments/duration';
-import type { InfoSegment } from './segments/info';
-import { type MainSegment } from './segments/main';
-import { type MuxingAppSegment } from './segments/muxing';
-import type { SeekIdSegment } from './segments/seek';
-import { type SeekSegment } from './segments/seek';
-import type { SeekHeadSegment } from './segments/seek-head';
-import { type SeekPositionSegment } from './segments/seek-position';
-import type { TimestampScaleSegment } from './segments/timestamp-scale';
-import type { AlphaModeSegment, AudioSegment, BitDepthSegment, BlockAdditionsSegment, BlockElement, BlockGroupSegment, ChannelsSegment, ClusterSegment, CodecPrivateSegment, CodecSegment, ColorSegment, Crc32Segment, DefaultDurationSegment, DefaultFlagSegment, DisplayHeightSegment, DisplayWidthSegment, FlagLacingSegment, HeightSegment, InterlacedSegment, LanguageSegment, MaxBlockAdditionId, ReferenceBlockSegment, SamplingFrequencySegment, SegmentUUIDSegment, SimpleBlockOrBlockSegment, TagSegment, TagsSegment, TimestampSegment, TitleSegment, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
-import type { TracksSegment } from './segments/tracks';
-import type { VoidSegment } from './segments/void';
-import type { WritingAppSegment } from './segments/writing';
-export type MatroskaSegment = MainSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | DisplayWidthSegment | DisplayHeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment | TitleSegment | InterlacedSegment | CodecPrivateSegment | Crc32Segment | SegmentUUIDSegment | DefaultFlagSegment | TagsSegment | TagSegment | ClusterSegment | TimestampSegment | SimpleBlockOrBlockSegment | BlockGroupSegment | BlockElement | SeekIdSegment | AudioSegment | SamplingFrequencySegment | ChannelsSegment | BitDepthSegment | ReferenceBlockSegment | BlockAdditionsSegment | PossibleEbml;
-export type OnTrackEntrySegment = (trackEntry: TrackEntrySegment) => void;
+import type { PossibleEbml, 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>;