@remotion/media-parser 4.0.198 → 4.0.200

package/dist/boxes/iso-base-media/mdat/mdat.js

@@ -62,7 +62,6 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, }) =>
             await options.parserState.onAudioSample(sampleWithIndex.track.trackId, {
                 data: bytes,
                 timestamp: sampleWithIndex.samplePosition.offset,
-                offset: data.counter.getOffset(),
                 trackId: sampleWithIndex.track.trackId,
                 type: sampleWithIndex.samplePosition.isKeyframe ? 'key' : 'delta',
             });

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

@@ -0,0 +1,2 @@
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
+export declare const getVariableInt: (value: number, width?: number) => Uint8Array;

package/dist/boxes/webm/ebml.js

@@ -0,0 +1,72 @@
+"use strict";
+// https://github.com/Vanilagy/webm-muxer/blob/main/src/ebml.ts#L101
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariableInt = exports.measureEBMLVarInt = void 0;
+const measureEBMLVarInt = (value) => {
+    if (value < (1 << 7) - 1) {
+        /** Top bit is set, leaving 7 bits to hold the integer, but we can't store
+         * 127 because "all bits set to one" is a reserved value. Same thing for the
+         * other cases below:
+         */
+        return 1;
+    }
+    if (value < (1 << 14) - 1) {
+        return 2;
+    }
+    if (value < (1 << 21) - 1) {
+        return 3;
+    }
+    if (value < (1 << 28) - 1) {
+        return 4;
+    }
+    if (value < 2 ** 35 - 1) {
+        return 5;
+    }
+    if (value < 2 ** 42 - 1) {
+        return 6;
+    }
+    throw new Error('EBML VINT size not supported ' + value);
+};
+exports.measureEBMLVarInt = measureEBMLVarInt;
+const getVariableInt = (value, width = (0, exports.measureEBMLVarInt)(value)) => {
+    switch (width) {
+        case 1:
+            return new Uint8Array([(1 << 7) | value]);
+        case 2:
+            return new Uint8Array([(1 << 6) | (value >> 8), value]);
+        case 3:
+            return new Uint8Array([(1 << 5) | (value >> 16), value >> 8, value]);
+        case 4:
+            return new Uint8Array([
+                (1 << 4) | (value >> 24),
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 5:
+            /**
+             * JavaScript converts its doubles to 32-bit integers for bitwise
+             * operations, so we need to do a division by 2^32 instead of a
+             * right-shift of 32 to retain those top 3 bits
+             */
+            return new Uint8Array([
+                (1 << 3) | ((value / 2 ** 32) & 0x7),
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 6:
+            return new Uint8Array([
+                (1 << 2) | ((value / 2 ** 40) & 0x3),
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        default:
+            throw new Error('Bad EBML VINT size ' + width);
+    }
+};
+exports.getVariableInt = getVariableInt;

package/dist/boxes/webm/make-header.d.ts

@@ -0,0 +1,2 @@
+export declare const webmPattern: Uint8Array;
+export declare const makeMatroskaHeader: () => Uint8Array;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaHeader = exports.webmPattern = void 0;
+const ebml_1 = require("./ebml");
+const all_segments_1 = require("./segments/all-segments");
+exports.webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const matroskaToHex = (matrId) => {
+    const numbers = [];
+    for (let i = 2; i < matrId.length; i += 2) {
+        const hex = matrId.substr(i, 2);
+        numbers.push(parseInt(hex, 16));
+    }
+    return numbers;
+};
+const makeMatroskaHeader = () => {
+    const size = 0x23;
+    const array = new Uint8Array([
+        ...exports.webmPattern,
+        ...(0, ebml_1.getVariableInt)(size),
+        ...matroskaToHex(all_segments_1.matroskaElements.EBMLVersion),
+        ...(0, ebml_1.getVariableInt)(1),
+        1,
+        ...matroskaToHex(all_segments_1.matroskaElements.EBMLReadVersion),
+        ...(0, ebml_1.getVariableInt)(1),
+        1,
+        ...matroskaToHex(all_segments_1.matroskaElements.EBMLMaxIDLength),
+        ...(0, ebml_1.getVariableInt)(1),
+        4,
+        ...matroskaToHex(all_segments_1.matroskaElements.EBMLMaxSizeLength),
+        ...(0, ebml_1.getVariableInt)(1),
+        8,
+        ...matroskaToHex(all_segments_1.matroskaElements.DocType),
+        ...(0, ebml_1.getVariableInt)(8),
+        ...new TextEncoder().encode('matroska'),
+        ...matroskaToHex(all_segments_1.matroskaElements.DocTypeVersion),
+        ...(0, ebml_1.getVariableInt)(1),
+        4,
+        ...matroskaToHex(all_segments_1.matroskaElements.DocTypeReadVersion),
+        ...(0, ebml_1.getVariableInt)(1),
+        2,
+    ]);
+    return array;
+};
+exports.makeMatroskaHeader = makeMatroskaHeader;

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

@@ -1,6 +1,11 @@
 export declare const matroskaElements: {
     readonly EBMLMaxIDLength: "0x42f2";
+    readonly EBMLVersion: "0x4286";
+    readonly EBMLReadVersion: "0x42F7";
     readonly EBMLMaxSizeLength: "0x42f3";
+    readonly DocType: "0x4282";
+    readonly DocTypeVersion: "0x4287";
+    readonly DocTypeReadVersion: "0x4285";
     readonly Segment: "0x18538067";
     readonly SeekHead: "0x114d9b74";
     readonly Seek: "0x4dbb";

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

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSegmentName = exports.knownIdsWithThreeLength = exports.knownIdsWithTwoLength = exports.knownIdsWithOneLength = exports.matroskaElements = void 0;
 exports.matroskaElements = {
     EBMLMaxIDLength: '0x42f2',
+    EBMLVersion: '0x4286',
+    EBMLReadVersion: '0x42F7',
     EBMLMaxSizeLength: '0x42f3',
+    DocType: '0x4282',
+    DocTypeVersion: '0x4287',
+    DocTypeReadVersion: '0x4285',
     Segment: '0x18538067',
     SeekHead: '0x114d9b74',
     Seek: '0x4dbb',

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/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[];
@@ -135,29 +137,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];
+    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)({
@@ -299,8 +300,15 @@ 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');
+    if (length > 3) {
+        throw new Error('Expected timestamp segment to be 1 byte or 2 bytes, but is ' + length);
+    }
+    if (length === 3) {
+        const val = iterator.getUint24();
+        return {
+            type: 'timestamp-segment',
+            timestamp: val,
+        };
     }
     const value = length === 2 ? iterator.getUint16() : iterator.getUint8();
     return {
@@ -309,37 +317,46 @@ const parseTimestampSegment = (iterator, 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 timecodeRelativeToCluster = iterator.getUint16();
+    const { invisible, lacing, keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, type);
     const codec = parserContext.parserState.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(iterator.counter.getOffset());
+    if (clusterOffset === undefined) {
+        throw new Error('Could not find offset for byte offset ' + iterator.counter.getOffset());
+    }
+    const timecode = timecodeRelativeToCluster + clusterOffset;
     if (!codec) {
         throw new Error('Could not find codec for track ' + trackNumber);
     }
-    const children = [];
+    const remainingNow = length - (iterator.counter.getOffset() - start);
+    let videoSample = null;
     if (codec.codec.startsWith('V_')) {
-        const remainingNow = length - (iterator.counter.getOffset() - start);
-        await parserContext.parserState.onVideoSample(trackNumber, {
+        const partialVideoSample = {
             data: iterator.getSlice(remainingNow),
             cts: null,
             dts: null,
             duration: undefined,
-            type: keyframe ? 'key' : 'delta',
             trackId: trackNumber,
             timestamp: timecode,
-        });
+        };
+        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);
         await parserContext.parserState.onAudioSample(trackNumber, {
-            data: iterator.getSlice(vorbisRemaining),
-            offset: timecode,
+            data: iterator.getSlice(remainingNow),
             trackId: trackNumber,
             timestamp: timecode,
             type: 'key',
@@ -350,18 +367,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,
         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 +406,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

@@ -10,11 +10,11 @@ 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 | 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 | SimpleBlockOrBlockSegment | BlockGroupSegment | BlockElement | SeekIdSegment | AudioSegment | SamplingFrequencySegment | ChannelsSegment | BitDepthSegment | ReferenceBlockSegment | BlockAdditionsSegment;
 export type OnTrackEntrySegment = (trackEntry: TrackEntrySegment) => void;
 export declare const expectSegment: (iterator: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;

package/dist/boxes/webm/segments.js

@@ -168,18 +168,47 @@ 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 === '0xa3') {
-        return (0, track_entry_1.parseSimpleBlockSegment)({
+    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 === 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);

package/dist/buffer-iterator.d.ts

@@ -34,6 +34,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes?
     getEBML: () => number;
     getInt8: () => number;
     getUint16: () => number;
+    getUint24: () => number;
     getInt16: () => number;
     getUint32: () => number;
     getFixedPointUnsigned1616Number: () => number;

package/dist/buffer-iterator.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _OffsetCounter_offset, _OffsetCounter_discardedBytes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+const make_header_1 = require("./boxes/webm/make-header");
 const all_segments_1 = require("./boxes/webm/segments/all-segments");
 class OffsetCounter {
     constructor(initial) {
@@ -49,7 +50,6 @@ class OffsetCounter {
 exports.OffsetCounter = OffsetCounter;
 _OffsetCounter_offset = new WeakMap(), _OffsetCounter_discardedBytes = new WeakMap();
 const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
-const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
 const matchesPattern = (pattern) => {
     return (data) => {
@@ -129,7 +129,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
     };
     const isWebm = () => {
-        return matchesPattern(webmPattern)(data.subarray(0, 4));
+        return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
     };
     const isMp3 = () => {
         return matchesPattern(mpegPattern)(data.subarray(0, 4));
@@ -315,6 +315,13 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             counter.increment(2);
             return val;
         },
+        getUint24: () => {
+            const val1 = view.getUint8(counter.getDiscardedOffset());
+            const val2 = view.getUint8(counter.getDiscardedOffset());
+            const val3 = view.getUint8(counter.getDiscardedOffset());
+            counter.increment(3);
+            return (val1 << 16) | (val2 << 8) | val3;
+        },
         getInt16: () => {
             const val = view.getInt16(counter.getDiscardedOffset());
             counter.increment(2);

package/dist/get-audio-codec.d.ts

@@ -14,7 +14,7 @@ export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | nu
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
-export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "aac" | "mp3" | "opus" | "pcm" | "vorbis" | null;
+export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "vorbis" | "opus" | "mp3" | "aac" | "pcm" | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;
     description: Uint8Array | undefined;

package/dist/parser-state.d.ts

@@ -1,9 +1,7 @@
 import type { OnTrackEntrySegment } from './boxes/webm/segments';
 import type { CodecSegment } from './boxes/webm/segments/track-entry';
 import type { AudioSample, OnAudioSample, OnVideoSample, VideoSample } from './webcodec-sample-types';
-export type InternalStats = {
-    samplesThatHadToBeQueued: number;
-};
+export type InternalStats = {};
 export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, }: {
     hasAudioCallbacks: boolean;
     hasVideoCallbacks: boolean;
@@ -11,12 +9,12 @@ export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, }
     onTrackEntrySegment: OnTrackEntrySegment;
     getTrackInfoByNumber: (id: number) => CodecSegment;
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
+    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
     registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioSample) => Promise<void>;
     onVideoSample: (trackId: number, videoSample: VideoSample) => Promise<void>;
-    getInternalStats: () => {
-        samplesThatHadToBeQueued: number;
-    };
+    getInternalStats: () => {};
     getTimescale: () => number;
     setTimescale: (newTimescale: number) => void;
 };