@remotion/media-parser 4.0.199 → 4.0.201

package/dist/boxes/webm/segments/all-segments.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSegmentName = exports.knownIdsWithThreeLength = exports.knownIdsWithTwoLength = exports.knownIdsWithOneLength = exports.matroskaElements = void 0;
+exports.ebmlMap = exports.voidHeader = exports.seek = exports.seekPosition = exports.seekId = exports.matroskaHeader = exports.matroskaHeaderStructure = exports.voidEbml = exports.docTypeReadVersion = exports.docTypeVersion = exports.docType = exports.ebmlMaxSizeLength = exports.ebmlMaxIdLength = exports.ebmlReadVersion = exports.ebmlVersion = exports.getIdForName = exports.getSegmentName = exports.knownIdsWithThreeLength = exports.knownIdsWithTwoLength = exports.knownIdsWithOneLength = exports.matroskaElements = void 0;
 exports.matroskaElements = {
+    Header: '0x1a45dfa3',
     EBMLMaxIDLength: '0x42f2',
+    EBMLVersion: '0x4286',
+    EBMLReadVersion: '0x42f7',
     EBMLMaxSizeLength: '0x42f3',
+    DocType: '0x4282',
+    DocTypeVersion: '0x4287',
+    DocTypeReadVersion: '0x4285',
     Segment: '0x18538067',
     SeekHead: '0x114d9b74',
     Seek: '0x4dbb',
@@ -275,3 +281,126 @@ const getSegmentName = (id) => {
     return (_a = Object.entries(exports.matroskaElements).find(([, value]) => value === id)) === null || _a === void 0 ? void 0 : _a[0];
 };
 exports.getSegmentName = getSegmentName;
+const getIdForName = (name) => {
+    var _a;
+    const value = (_a = Object.entries(exports.matroskaElements).find(([key]) => key === name)) === null || _a === void 0 ? void 0 : _a[1];
+    if (!value) {
+        throw new Error(`Could not find id for name ${name}`);
+    }
+    return value;
+};
+exports.getIdForName = getIdForName;
+exports.ebmlVersion = {
+    name: 'EBMLVersion',
+    type: 'uint',
+};
+exports.ebmlReadVersion = {
+    name: 'EBMLReadVersion',
+    type: 'uint',
+};
+exports.ebmlMaxIdLength = {
+    name: 'EBMLMaxIDLength',
+    type: 'uint',
+};
+exports.ebmlMaxSizeLength = {
+    name: 'EBMLMaxSizeLength',
+    type: 'uint',
+};
+exports.docType = {
+    name: 'DocType',
+    type: 'string',
+};
+exports.docTypeVersion = {
+    name: 'DocTypeVersion',
+    type: 'uint',
+};
+exports.docTypeReadVersion = {
+    name: 'DocTypeReadVersion',
+    type: 'uint',
+};
+exports.voidEbml = {
+    name: 'Void',
+    type: 'void',
+};
+exports.matroskaHeaderStructure = [
+    exports.ebmlVersion,
+    exports.ebmlReadVersion,
+    exports.ebmlMaxIdLength,
+    exports.ebmlMaxSizeLength,
+    exports.docType,
+    exports.docTypeVersion,
+    exports.docTypeReadVersion,
+];
+exports.matroskaHeader = {
+    name: 'Header',
+    type: 'children',
+    children: exports.matroskaHeaderStructure,
+};
+exports.seekId = {
+    name: 'SeekID',
+    type: 'hex-string',
+};
+exports.seekPosition = {
+    name: 'SeekPosition',
+    type: 'uint',
+};
+exports.seek = {
+    name: 'Seek',
+    type: 'children',
+    children: [exports.seekId, exports.seekPosition],
+};
+exports.voidHeader = {
+    name: 'Void',
+    type: 'void',
+};
+exports.ebmlMap = {
+    [exports.matroskaElements.Header]: exports.matroskaHeader,
+    [exports.matroskaElements.DocType]: exports.docType,
+    [exports.matroskaElements.DocTypeVersion]: exports.docTypeVersion,
+    [exports.matroskaElements.DocTypeReadVersion]: exports.docTypeReadVersion,
+    [exports.matroskaElements.EBMLVersion]: exports.ebmlVersion,
+    [exports.matroskaElements.EBMLReadVersion]: exports.ebmlReadVersion,
+    [exports.matroskaElements.EBMLMaxIDLength]: exports.ebmlMaxIdLength,
+    [exports.matroskaElements.EBMLMaxSizeLength]: exports.ebmlMaxSizeLength,
+    [exports.matroskaElements.Void]: exports.voidEbml,
+    [exports.matroskaElements.Cues]: {
+        name: 'Cues',
+        type: 'void',
+    },
+    [exports.matroskaElements.DateUTC]: {
+        name: 'DateUTC',
+        type: 'void',
+    },
+    [exports.matroskaElements.TrackTimestampScale]: {
+        name: 'TrackTimestampScale',
+        type: 'float',
+    },
+    [exports.matroskaElements.CodecDelay]: {
+        name: 'CodecDelay',
+        type: 'void',
+    },
+    [exports.matroskaElements.SeekPreRoll]: {
+        name: 'SeekPreRoll',
+        type: 'void',
+    },
+    [exports.matroskaElements.DiscardPadding]: {
+        name: 'DiscardPadding',
+        type: 'void',
+    },
+    [exports.matroskaElements.OutputSamplingFrequency]: {
+        name: 'OutputSamplingFrequency',
+        type: 'void',
+    },
+    [exports.matroskaElements.CodecName]: {
+        name: 'CodecName',
+        type: 'void',
+    },
+    [exports.matroskaElements.Position]: {
+        name: 'Position',
+        type: 'void',
+    },
+    [exports.matroskaElements.SliceDuration]: {
+        name: 'SliceDuration',
+        type: 'void',
+    },
+};

package/dist/boxes/webm/segments/block-simple-block-flags.d.ts

@@ -0,0 +1,9 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import { matroskaElements } from './all-segments';
+type BlockFlags = {
+    invisible: boolean;
+    lacing: number;
+    keyframe: boolean | null;
+};
+export declare const parseBlockFlags: (iterator: BufferIterator, type: (typeof matroskaElements)['Block'] | (typeof matroskaElements)['SimpleBlock']) => BlockFlags;
+export {};

package/dist/boxes/webm/segments/block-simple-block-flags.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBlockFlags = void 0;
+const all_segments_1 = require("./all-segments");
+const parseBlockFlags = (iterator, type) => {
+    if (type === all_segments_1.matroskaElements.Block) {
+        iterator.startReadingBits();
+        // Reserved
+        iterator.getBits(4);
+        const invisible = Boolean(iterator.getBits(1));
+        const lacing = iterator.getBits(2);
+        // unused
+        iterator.getBits(1);
+        iterator.stopReadingBits();
+        return {
+            invisible,
+            lacing,
+            keyframe: null,
+        };
+    }
+    if (type === all_segments_1.matroskaElements.SimpleBlock) {
+        iterator.startReadingBits();
+        const keyframe = Boolean(iterator.getBits(1));
+        // Reserved
+        iterator.getBits(3);
+        const invisible = Boolean(iterator.getBits(1));
+        const lacing = iterator.getBits(2);
+        iterator.getBits(1);
+        iterator.stopReadingBits();
+        return {
+            invisible,
+            lacing,
+            keyframe,
+        };
+    }
+    throw new Error('Unexpected type');
+};
+exports.parseBlockFlags = parseBlockFlags;

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

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

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

@@ -10,4 +10,4 @@ export type SeekIdSegment = {
     type: 'seek-id-segment';
     seekId: string;
 };
-export declare const parseSeekIdSegment: (iterator: BufferIterator) => SeekIdSegment;
+export declare const parseSeekIdSegment: (iterator: BufferIterator, length: number) => SeekIdSegment;

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

@@ -19,8 +19,14 @@ const parseSeekSegment = async (iterator, length, parserContext) => {
     };
 };
 exports.parseSeekSegment = parseSeekSegment;
-const parseSeekIdSegment = (iterator) => {
-    const seekId = iterator.getMatroskaSegmentId();
+const parseSeekIdSegment = (iterator, length) => {
+    const seekId = '0x' +
+        [...iterator.getSlice(length)]
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    if (seekId === null) {
+        throw new Error('Not enough bytes to parse seek id');
+    }
     return {
         type: 'seek-id-segment',
         seekId,

package/dist/boxes/webm/segments/timestamp-scale.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTimestampScaleSegment = void 0;
 const parseTimestampScaleSegment = (iterator) => {
-    const timestampScale = iterator.getDecimalBytes(3);
+    const timestampScale = iterator.getUint(3);
     return {
         type: 'timestamp-scale-segment',
         timestampScale,

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

@@ -1,6 +1,8 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { ParserContext } from '../../../parser-context';
+import type { VideoSample } from '../../../webcodec-sample-types';
 import type { MatroskaSegment } from '../segments';
+import type { matroskaElements } from './all-segments';
 export type TrackEntrySegment = {
     type: 'track-entry-segment';
     children: MatroskaSegment[];
@@ -29,6 +31,10 @@ export type CodecSegment = {
     type: 'codec-segment';
     codec: string;
 };
+export type TrackInfo = {
+    codec: string;
+    trackTimescale: number | null;
+};
 export declare const parseCodecSegment: (iterator: BufferIterator, length: number) => CodecSegment;
 type TrackType = 'video' | 'audio' | 'complex' | 'subtitle' | 'button' | 'control' | 'metadata';
 export type TrackTypeSegment = {
@@ -135,29 +141,39 @@ export type TimestampSegment = {
     timestamp: number;
 };
 export declare const parseTimestampSegment: (iterator: BufferIterator, length: number) => TimestampSegment;
-export type SimpleBlockSegment = {
-    type: 'simple-block-segment';
+export type SimpleBlockOrBlockSegment = {
+    type: 'simple-block-or-block-segment';
     length: number;
     trackNumber: number;
-    timecode: number;
-    headerFlags: number;
-    keyframe: boolean;
-    lacing: [number, number];
+    timecodeInMicroseconds: number;
+    keyframe: boolean | null;
+    lacing: number;
     invisible: boolean;
-    children: MatroskaSegment[];
+    videoSample: Omit<VideoSample, 'type'> | null;
 };
 export type GetTracks = () => TrackEntrySegment[];
-export declare const parseSimpleBlockSegment: ({ iterator, length, parserContext, }: {
+export declare const parseSimpleBlockOrBlockSegment: ({ iterator, length, parserContext, type, }: {
     iterator: BufferIterator;
     length: number;
     parserContext: ParserContext;
-}) => Promise<SimpleBlockSegment>;
+    type: (typeof matroskaElements)['Block'] | (typeof matroskaElements)['SimpleBlock'];
+}) => Promise<SimpleBlockOrBlockSegment>;
 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 ReferenceBlockSegment = {
+    type: 'reference-block-segment';
+    referenceBlock: number;
+};
+export declare const parseReferenceBlockSegment: (iterator: BufferIterator, length: number) => ReferenceBlockSegment;
+export type BlockAdditionsSegment = {
+    type: 'block-additions-segment';
+    blockAdditions: Uint8Array;
+};
+export declare const parseBlockAdditionsSegment: (iterator: BufferIterator, length: number) => BlockAdditionsSegment;
 export type BlockElement = {
     type: 'block-element-segment';
     length: number;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBitDepthSegment = exports.parseChannelsSegment = exports.parseSamplingFrequencySegment = exports.parseBlockElementSegment = exports.parseBlockGroupSegment = exports.parseTrackNumber = exports.parseSimpleBlockSegment = 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;
+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)({
@@ -108,7 +109,7 @@ const parseTrackTypeSegment = (iterator, length) => {
 };
 exports.parseTrackTypeSegment = parseTrackTypeSegment;
 const parseDefaultDurationSegment = (iterator, length) => {
-    const defaultDuration = iterator.getDecimalBytes(length);
+    const defaultDuration = iterator.getUint(length);
     return {
         type: 'default-duration-segment',
         defaultDuration,
@@ -299,49 +300,64 @@ const parseTagSegment = (iterator, length) => {
 };
 exports.parseTagSegment = parseTagSegment;
 const parseTimestampSegment = (iterator, length) => {
-    if (length > 2) {
-        throw new Error('Expected timestamp segment to be 1 byte or 2 bytes');
-    }
-    const value = length === 2 ? iterator.getUint16() : iterator.getUint8();
     return {
         type: 'timestamp-segment',
-        timestamp: value,
+        timestamp: iterator.getUint(length),
     };
 };
 exports.parseTimestampSegment = parseTimestampSegment;
-const parseSimpleBlockSegment = async ({ iterator, length, parserContext, }) => {
+const parseSimpleBlockOrBlockSegment = async ({ iterator, length, parserContext, type, }) => {
     const start = iterator.counter.getOffset();
     const trackNumber = iterator.getVint();
-    const timecode = iterator.getUint16();
-    const headerFlags = iterator.getUint8();
-    const invisible = Boolean((headerFlags >> 5) & 1);
-    const pos6 = (headerFlags >> 6) & 1;
-    const pos7 = (headerFlags >> 6) & 1;
-    const keyframe = Boolean((headerFlags >> 7) & 1);
-    const codec = parserContext.parserState.getTrackInfoByNumber(trackNumber);
+    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 children = [];
-    if (codec.codec.startsWith('V_')) {
-        const remainingNow = length - (iterator.counter.getOffset() - start);
-        await parserContext.parserState.onVideoSample(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,
-            type: keyframe ? 'key' : 'delta',
             trackId: trackNumber,
-            timestamp: timecode,
-        });
+            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.codec.startsWith('A_')) {
-        const vorbisRemaining = length - (iterator.counter.getOffset() - start);
+    if (codec.startsWith('A_')) {
         await parserContext.parserState.onAudioSample(trackNumber, {
-            data: iterator.getSlice(vorbisRemaining),
-            offset: timecode,
+            data: iterator.getSlice(remainingNow),
             trackId: trackNumber,
-            timestamp: timecode,
+            timestamp: timecodeInMicroseconds,
             type: 'key',
         });
     }
@@ -350,18 +366,17 @@ const parseSimpleBlockSegment = async ({ iterator, length, parserContext, }) =>
         iterator.discard(remainingNowAfter);
     }
     return {
-        type: 'simple-block-segment',
+        type: 'simple-block-or-block-segment',
         length,
         trackNumber,
-        timecode,
-        headerFlags,
+        timecodeInMicroseconds,
         keyframe,
-        lacing: [pos6, pos7],
+        lacing,
         invisible,
-        children,
+        videoSample,
     };
 };
-exports.parseSimpleBlockSegment = parseSimpleBlockSegment;
+exports.parseSimpleBlockOrBlockSegment = parseSimpleBlockOrBlockSegment;
 const parseTrackNumber = (iterator, length) => {
     if (length !== 1) {
         throw new Error('Expected track number to be 1 byte');
@@ -390,6 +405,31 @@ const parseBlockGroupSegment = async (iterator, length, parserContext) => {
     };
 };
 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 {

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

@@ -1,6 +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';
@@ -10,11 +11,10 @@ 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, BlockElement, BlockGroupSegment, ChannelsSegment, ClusterSegment, CodecPrivateSegment, CodecSegment, ColorSegment, Crc32Segment, DefaultDurationSegment, DefaultFlagSegment, DisplayHeightSegment, DisplayWidthSegment, FlagLacingSegment, HeightSegment, InterlacedSegment, LanguageSegment, MaxBlockAdditionId, SamplingFrequencySegment, SegmentUUIDSegment, SimpleBlockSegment, TagSegment, TagsSegment, TimestampSegment, TitleSegment, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
+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 { UnknownSegment } from './segments/unknown';
 import type { VoidSegment } from './segments/void';
 import type { WritingAppSegment } from './segments/writing';
-export type MatroskaSegment = MainSegment | UnknownSegment | 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 | SimpleBlockSegment | BlockGroupSegment | BlockElement | SeekIdSegment | AudioSegment | SamplingFrequencySegment | ChannelsSegment | BitDepthSegment;
+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;
 export declare const expectSegment: (iterator: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;

package/dist/boxes/webm/segments.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
 const add_new_matroska_tracks_1 = require("../../add-new-matroska-tracks");
 const get_track_1 = require("./get-track");
+const parse_ebml_1 = require("./parse-ebml");
 const all_segments_1 = require("./segments/all-segments");
 const duration_1 = require("./segments/duration");
 const info_1 = require("./segments/info");
@@ -14,33 +15,17 @@ const seek_position_1 = require("./segments/seek-position");
 const timestamp_scale_1 = require("./segments/timestamp-scale");
 const track_entry_1 = require("./segments/track-entry");
 const tracks_1 = require("./segments/tracks");
-const unknown_1 = require("./segments/unknown");
 const void_1 = require("./segments/void");
 const writing_1 = require("./segments/writing");
-const parseSegment = async ({ segmentId, iterator, length, parserContext, }) => {
+const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
     if (length === 0) {
         throw new Error(`Expected length of ${segmentId} to be greater than 0`);
     }
-    if (segmentId === '0x') {
-        return {
-            type: 'unknown-segment',
-            id: segmentId,
-        };
-    }
-    // Log this to debug
-    /*
-    console.log(
-        'segmentId',
-        segmentId,
-        getSegmentName(segmentId),
-        iterator.counter.getOffset(),
-    );
-    */
     if (segmentId === '0x114d9b74') {
         return (0, seek_head_1.parseSeekHeadSegment)(iterator, length, parserContext);
     }
     if (segmentId === '0x53ab') {
-        return (0, seek_1.parseSeekIdSegment)(iterator);
+        return (0, seek_1.parseSeekIdSegment)(iterator, length);
     }
     if (segmentId === '0x4dbb') {
         return (0, seek_1.parseSeekSegment)(iterator, length, parserContext);
@@ -168,30 +153,57 @@ const parseSegment = async ({ segmentId, iterator, length, parserContext, }) =>
     if (segmentId === all_segments_1.matroskaElements.BitDepth) {
         return (0, track_entry_1.parseBitDepthSegment)(iterator, length);
     }
-    if (segmentId === '0xe7') {
-        return (0, track_entry_1.parseTimestampSegment)(iterator, length);
+    if (segmentId === all_segments_1.matroskaElements.Timestamp) {
+        const offset = iterator.counter.getOffset();
+        const timestampSegment = (0, track_entry_1.parseTimestampSegment)(iterator, length);
+        parserContext.parserState.setTimestampOffset(offset, timestampSegment.timestamp);
+        return timestampSegment;
     }
-    if (segmentId === '0xa3') {
-        return (0, track_entry_1.parseSimpleBlockSegment)({
+    if (segmentId === all_segments_1.matroskaElements.SimpleBlock ||
+        segmentId === all_segments_1.matroskaElements.Block) {
+        return (0, track_entry_1.parseSimpleBlockOrBlockSegment)({
             iterator,
             length,
             parserContext,
+            type: segmentId,
         });
     }
+    if (segmentId === all_segments_1.matroskaElements.ReferenceBlock) {
+        return (0, track_entry_1.parseReferenceBlockSegment)(iterator, length);
+    }
+    if (segmentId === all_segments_1.matroskaElements.BlockAdditions) {
+        return (0, track_entry_1.parseBlockAdditionsSegment)(iterator, length);
+    }
     if (segmentId === '0xa0') {
-        return (0, track_entry_1.parseBlockGroupSegment)(iterator, length, parserContext);
+        const blockGroup = await (0, track_entry_1.parseBlockGroupSegment)(iterator, length, parserContext);
+        // Blocks don't have information about keyframes.
+        // https://ffmpeg.org/pipermail/ffmpeg-devel/2015-June/173825.html
+        // "For Blocks, keyframes is
+        // inferred by the absence of ReferenceBlock element (as done by matroskadec).""
+        const block = blockGroup.children.find((c) => c.type === 'simple-block-or-block-segment');
+        if (!block || block.type !== 'simple-block-or-block-segment') {
+            throw new Error('Expected block segment');
+        }
+        const hasReferenceBlock = blockGroup.children.find((c) => c.type === 'reference-block-segment');
+        const partialVideoSample = block.videoSample;
+        if (partialVideoSample) {
+            const completeFrame = {
+                ...partialVideoSample,
+                type: hasReferenceBlock ? 'delta' : 'key',
+            };
+            await parserContext.parserState.onVideoSample(partialVideoSample.trackId, completeFrame);
+        }
+        return blockGroup;
     }
     if (segmentId === '0xa1') {
         return (0, track_entry_1.parseBlockElementSegment)(iterator, length);
     }
-    const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
-    const toDiscard = Math.min(bytesRemaining, length > 0 ? length : bytesRemaining);
-    const child = (0, unknown_1.parseUnknownSegment)(iterator, segmentId, toDiscard);
-    return child;
+    iterator.counter.decrement(headerReadSoFar);
+    return (0, parse_ebml_1.parseEbml)(iterator);
 };
 const expectSegment = async (iterator, parserContext) => {
-    const bytesRemaining_ = iterator.bytesRemaining();
-    if (bytesRemaining_ === 0) {
+    const offset = iterator.counter.getOffset();
+    if (iterator.bytesRemaining() === 0) {
         return {
             status: 'incomplete',
             segments: [],
@@ -201,9 +213,30 @@ const expectSegment = async (iterator, parserContext) => {
             skipTo: null,
         };
     }
-    const offset = iterator.counter.getOffset();
     const segmentId = iterator.getMatroskaSegmentId();
+    if (segmentId === null) {
+        iterator.counter.decrement(iterator.counter.getOffset() - offset);
+        return {
+            status: 'incomplete',
+            segments: [],
+            continueParsing: () => {
+                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+            },
+            skipTo: null,
+        };
+    }
     const length = iterator.getVint();
+    if (length === null) {
+        iterator.counter.decrement(iterator.counter.getOffset() - offset);
+        return {
+            status: 'incomplete',
+            segments: [],
+            continueParsing: () => {
+                return Promise.resolve((0, exports.expectSegment)(iterator, parserContext));
+            },
+            skipTo: null,
+        };
+    }
     const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
     if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
         const main = await (0, parse_children_1.expectChildren)({
@@ -251,6 +284,7 @@ const expectSegment = async (iterator, parserContext) => {
         iterator,
         length,
         parserContext,
+        headerReadSoFar: iterator.counter.getOffset() - offset,
     });
     return {
         status: 'done',

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

@@ -4,4 +4,5 @@ import type { CodecSegment, TrackEntrySegment } from './segments/track-entry';
 export declare const getMainSegment: (segments: AnySegment[]) => MainSegment | null;
 export declare const getTrackNumber: (track: TrackEntrySegment) => number | null;
 export declare const getTrackCodec: (track: TrackEntrySegment) => CodecSegment | null;
+export declare const getTrackTimestampScale: (track: TrackEntrySegment) => number | null;
 export declare const getTrackByNumber: (tracks: TrackEntrySegment[], id: number) => TrackEntrySegment | undefined;