@remotion/media-parser 4.0.194 → 4.0.196

package/dist/boxes/webm/bitstream/av1/matrix-coefficients.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matrixCoefficients = void 0;
+exports.matrixCoefficients = {
+    MC_IDENTITY: 0,
+    MC_BT_709: 1,
+    MC_UNSPECIFIED: 2,
+    MC_RESERVED_3: 3,
+    MC_FCC: 4,
+    MC_BT_470_B_G: 5,
+    MC_BT_601: 6,
+    MC_SMPTE_240: 7,
+    MC_SMPTE_YCGCO: 8,
+    MC_BT_2020_NCL: 9,
+    MC_BT_2020_CL: 10,
+    MC_SMPTE_2085: 11,
+    MC_CHROMAT_NCL: 12,
+    MC_CHROMAT_CL: 13,
+    MC_ICTCP: 14,
+};

package/dist/boxes/webm/bitstream/av1/operating-parameters-info.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type OperatingParametersInfo = {
+    decoder_buffer_delay: number;
+    encoder_buffer_delay: number;
+    low_delay_mode_flag: boolean;
+};
+export declare const parseOperatingParametersInfo: ({ stream, buffer_delay_length_minus_1, }: {
+    stream: BufferIterator;
+    buffer_delay_length_minus_1: number;
+}) => OperatingParametersInfo;

package/dist/boxes/webm/bitstream/av1/operating-parameters-info.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOperatingParametersInfo = void 0;
+const parseOperatingParametersInfo = ({ stream, buffer_delay_length_minus_1, }) => {
+    const n = buffer_delay_length_minus_1 + 1;
+    const decoder_buffer_delay = stream.getBits(n);
+    const encoder_buffer_delay = stream.getBits(n);
+    const low_delay_mode_flag = Boolean(stream.getBits(1));
+    return {
+        decoder_buffer_delay,
+        encoder_buffer_delay,
+        low_delay_mode_flag,
+    };
+};
+exports.parseOperatingParametersInfo = parseOperatingParametersInfo;

package/dist/boxes/webm/bitstream/av1/temporal-point-info.d.ts

@@ -0,0 +1,5 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export declare const getTemporalPointInfo: ({ stream, frame_presentation_time_length_minus_1, }: {
+    stream: BufferIterator;
+    frame_presentation_time_length_minus_1: number;
+}) => number;

package/dist/boxes/webm/bitstream/av1/temporal-point-info.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemporalPointInfo = void 0;
+const getTemporalPointInfo = ({ stream, frame_presentation_time_length_minus_1, }) => {
+    const n = frame_presentation_time_length_minus_1 + 1;
+    return stream.getBits(n);
+};
+exports.getTemporalPointInfo = getTemporalPointInfo;

package/dist/boxes/webm/bitstream/av1/timing-info.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type TimingInfo = {
+    num_units_in_display_tick: number;
+    time_scale: number;
+    equal_picture_interval: boolean;
+    num_ticks_per_picture_minus_1: number;
+};
+export declare const getTimingInfo: (stream: BufferIterator) => TimingInfo;

package/dist/boxes/webm/bitstream/av1/timing-info.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimingInfo = void 0;
+const uvlc_1 = require("./uvlc");
+const getTimingInfo = (stream) => {
+    const num_units_in_display_tick = stream.getBits(32);
+    const time_scale = stream.getBits(32);
+    const equal_picture_interval = Boolean(stream.getBits(1));
+    let num_ticks_per_picture_minus_1 = 0;
+    if (equal_picture_interval) {
+        num_ticks_per_picture_minus_1 = (0, uvlc_1.uvlc)(stream);
+    }
+    return {
+        num_units_in_display_tick,
+        time_scale,
+        equal_picture_interval,
+        num_ticks_per_picture_minus_1,
+    };
+};
+exports.getTimingInfo = getTimingInfo;

package/dist/boxes/webm/bitstream/av1/transfer-characteristics.d.ts

@@ -0,0 +1,21 @@
+export declare const transferCharacteristics: {
+    TC_RESERVED_0: number;
+    TC_BT_709: number;
+    TC_UNSPECIFIED: number;
+    TC_RESERVED_3: number;
+    TC_BT_470_M: number;
+    TC_BT_470_B_G: number;
+    TC_BT_601: number;
+    TC_SMPTE_240: number;
+    TC_LINEAR: number;
+    TC_LOG_100: number;
+    TC_LOG_100_SQRT10: number;
+    TC_IEC_61966: number;
+    TC_BT_1361: number;
+    TC_SRGB: number;
+    TC_BT_2020_10_BIT: number;
+    TC_BT_2020_12_BIT: number;
+    TC_SMPTE_2084: number;
+    TC_SMPTE_428: number;
+    TC_HLG: number;
+};

package/dist/boxes/webm/bitstream/av1/transfer-characteristics.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferCharacteristics = void 0;
+exports.transferCharacteristics = {
+    TC_RESERVED_0: 0,
+    TC_BT_709: 1,
+    TC_UNSPECIFIED: 2,
+    TC_RESERVED_3: 3,
+    TC_BT_470_M: 4,
+    TC_BT_470_B_G: 5,
+    TC_BT_601: 6,
+    TC_SMPTE_240: 7,
+    TC_LINEAR: 8,
+    TC_LOG_100: 9,
+    TC_LOG_100_SQRT10: 10,
+    TC_IEC_61966: 11,
+    TC_BT_1361: 12,
+    TC_SRGB: 13,
+    TC_BT_2020_10_BIT: 14,
+    TC_BT_2020_12_BIT: 15,
+    TC_SMPTE_2084: 16,
+    TC_SMPTE_428: 17,
+    TC_HLG: 18,
+};

package/dist/boxes/webm/bitstream/av1/uvlc.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export declare const uvlc: (stream: BufferIterator) => number;

package/dist/boxes/webm/bitstream/av1/uvlc.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uvlc = void 0;
+const uvlc = (stream) => {
+    let leadingZeroBits = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const done = stream.getBits(1);
+        if (done) {
+            break;
+        }
+        leadingZeroBits++;
+    }
+    if (leadingZeroBits >= 32) {
+        return (1 << 32) - 1;
+    }
+    const value = stream.getBits(leadingZeroBits);
+    return value + (1 << leadingZeroBits) - 1;
+};
+exports.uvlc = uvlc;

package/dist/boxes/webm/bitstream/av1.d.ts

@@ -0,0 +1,20 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
+import type { VideoSample } from '../../../webcodec-sample-types';
+import { type Av1BitstreamHeaderSegment } from './av1/header-segment';
+type Av1BitstreamUimplementedSegment = {
+    type: 'av1-bitstream-unimplemented';
+};
+export type Av1BitstreamSegment = Av1BitstreamHeaderSegment | Av1BitstreamUimplementedSegment;
+export declare const av1Bitstream: ({ stream, length, onVideoSample, trackNumber, context, timecode, }: {
+    stream: BufferIterator;
+    length: number;
+    onVideoSample: (trackId: number, sample: VideoSample) => void;
+    trackNumber: number;
+    context: ParserContext;
+    timecode: number;
+}) => {
+    discarded: boolean;
+    segment: Av1BitstreamSegment;
+};
+export {};

package/dist/boxes/webm/bitstream/av1.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.av1Bitstream = void 0;
+const combine_uint8array_1 = require("../../../combine-uint8array");
+const bitstream_frame_1 = require("./av1/bitstream-frame");
+const header_segment_1 = require("./av1/header-segment");
+const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, timecode, }) => {
+    var _a, _b;
+    const address = stream.counter.getOffset();
+    stream.startReadingBits();
+    // log this to understand:
+    // (firstByte.toString(2).padStart(8, '0'));
+    // get bit 0
+    const obuForbiddenBit = stream.getBits(1);
+    if (obuForbiddenBit) {
+        throw new Error('obuForbiddenBit is not 0');
+    }
+    // get bits 1-3
+    const obuType = stream.getBits(4);
+    // get bit 4
+    const obuExtensionFlag = stream.getBits(1);
+    // get bit 5
+    const obuHasSizeField = stream.getBits(1);
+    // reserved bit
+    stream.getBits(1);
+    let size = null;
+    if (obuExtensionFlag) {
+        // extension
+        stream.getBits(6);
+    }
+    if (obuHasSizeField) {
+        // size
+        size = stream.leb128();
+    }
+    /*
+    console.log(
+        address.toString(16),
+        firstByte.toString(2).padStart(8, '0'),
+        obuForbiddenBit,
+        obuType,
+        obuExtensionFlag,
+        obuHasSizeField,
+        reservedBit,
+        size,
+    );
+    */
+    const bytesReadSoFar = stream.counter.getOffset() - address;
+    const segment = obuType === 1
+        ? (0, header_segment_1.parseAv1BitstreamHeaderSegment)(stream)
+        : {
+            type: 'av1-bitstream-unimplemented',
+        };
+    if (obuType === 6) {
+        const head = context.parserState.getAv1BitstreamHeaderSegment();
+        if (!head) {
+            throw new Error('Expected header segment');
+        }
+        const header = (0, bitstream_frame_1.parseAv1Frame)({
+            stream,
+            headerSegment: head.segment,
+        });
+        const bytesAdvanced = stream.counter.getOffset() - address;
+        stream.counter.decrement(bytesAdvanced);
+        if (size === null) {
+            throw new Error('Expected size in OBU');
+        }
+        const clusterTimestamp = context.parserState.getClusterTimestamp();
+        if (clusterTimestamp === null) {
+            throw new Error('Expected cluster timestamp');
+        }
+        const toSlice = size + bytesReadSoFar;
+        const frame = stream.getSlice(toSlice);
+        let extraBytes = null;
+        if (!context.parserState.getIsFirstAv1FrameRead()) {
+            context.parserState.setIsFirstAv1FrameRead();
+            extraBytes =
+                (_b = (_a = context.parserState.getAv1BitstreamHeaderSegment()) === null || _a === void 0 ? void 0 : _a.header) !== null && _b !== void 0 ? _b : null;
+            if (!extraBytes) {
+                throw new Error('Expected extra bytes');
+            }
+        }
+        onVideoSample(trackNumber, {
+            data: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
+            timestamp: timecode + clusterTimestamp,
+            duration: undefined,
+            trackId: trackNumber,
+            cts: null,
+            dts: null,
+            type: header.header.frameType === 'key' ? 'key' : 'delta',
+        });
+        stream.stopReadingBits();
+        return {
+            discarded: true,
+            segment,
+        };
+    }
+    stream.stopReadingBits();
+    if (size === null) {
+        return {
+            discarded: false,
+            segment,
+        };
+    }
+    const end = stream.counter.getOffset();
+    const remaining = (size === null ? length : size + bytesReadSoFar) - (end - address);
+    if (remaining > 0) {
+        stream.discard(remaining);
+    }
+    const remainingNow = length - (stream.counter.getOffset() - address);
+    if (remainingNow > 0 && remainingNow <= 2) {
+        throw new Error('remainingNow > 0 && remainingNow <= 2');
+    }
+    return {
+        discarded: Boolean(size),
+        segment,
+    };
+};
+exports.av1Bitstream = av1Bitstream;

package/dist/boxes/webm/bitstream/h264/get-h264-descriptor.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,2 @@
+import type { TrackEntrySegment } from './segments/track-entry';
+export declare const getAudioDescription: (track: TrackEntrySegment) => undefined | Uint8Array;

package/dist/boxes/webm/description.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioDescription = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const traversal_1 = require("../../traversal");
+const getAudioDescription = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec || codec.codec !== 'A_VORBIS') {
+        return undefined;
+    }
+    // how to parse vorbis private
+    // https://github.com/google/ExoPlayer/blob/dd430f7053a1a3958deea3ead6a0565150c06bfc/library/extractor/src/main/java/com/google/android/exoplayer2/extractor/mkv/MatroskaExtractor.java#L2466
+    const privateData = (0, traversal_1.getPrivateData)(track);
+    if (!privateData) {
+        return undefined;
+    }
+    if (privateData[0] !== 2) {
+        throw new Error('Expected vorbis private data version 2');
+    }
+    let offset = 1;
+    let vorbisInfoLength = 0;
+    let vorbisSkipLength = 0;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisInfoLength += 0xff;
+        offset++;
+    }
+    vorbisInfoLength += privateData[offset++] & 0xff;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisSkipLength += 0xff;
+        offset++;
+    }
+    vorbisSkipLength += privateData[offset++] & 0xff;
+    if (privateData[offset] !== 0x01) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisInfo = privateData.slice(offset, offset + vorbisInfoLength);
+    offset += vorbisInfoLength;
+    if (privateData[offset] !== 0x03) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisComments = privateData.slice(offset, offset + vorbisSkipLength);
+    offset += vorbisSkipLength;
+    if (privateData[offset] !== 0x05) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisBooks = privateData.slice(offset);
+    const bufferIterator = (0, buffer_iterator_1.getArrayBufferIterator)(vorbisInfo.slice(0));
+    // type
+    bufferIterator.getUint8();
+    // vorbis
+    const vorbis = bufferIterator.getByteString(6);
+    if (vorbis !== 'vorbis') {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisVersion = bufferIterator.getUint32Le();
+    if (vorbisVersion !== 0) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisDescription = new Uint8Array([
+        // constructing the vorbis description
+        // This format consists in the page_segments field
+        /**
+         * The number of segment entries to appear in the segment table.
+         * The maximum number of 255 segments (255 bytes each) sets the maximum possible physical page size at 65307 bytes or just under 64kB (thus we know that a header corrupted so as destroy sizing/alignment information will not cause a runaway bitstream.
+         * We'll read in the page according to the corrupted size information that's guaranteed to be a reasonable size regardless, notice the checksum mismatch, drop sync and then look for recapture).
+         */
+        2,
+        // followed by the segment_table field
+        // offset of the comments table
+        vorbisInfo.length,
+        // offset of the codebooks table
+        vorbisComments.length,
+        // followed by the three Vorbis header packets,
+        // respectively the identification header,
+        ...vorbisInfo,
+        // the comments header,
+        ...vorbisComments,
+        // and the setup header, in this order, as described in section 4.2 of [VORBIS].
+        ...vorbisBooks,
+    ]);
+    return vorbisDescription;
+};
+exports.getAudioDescription = getAudioDescription;

package/dist/boxes/webm/get-ready-tracks.d.ts

@@ -0,0 +1,3 @@
+import type { Track } from '../../get-tracks';
+import type { MainSegment } from './segments/main';
+export declare const getTracksFromMatroska: (segment: MainSegment, timescale: number) => Track[];

package/dist/boxes/webm/get-ready-tracks.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTracksFromMatroska = void 0;
+const traversal_1 = require("../../traversal");
+const get_track_1 = require("./get-track");
+const getTracksFromMatroska = (segment, timescale) => {
+    const tracksSegment = (0, traversal_1.getTracksSegment)(segment);
+    if (!tracksSegment) {
+        throw new Error('No tracks segment');
+    }
+    const tracks = [];
+    for (const trackEntrySegment of tracksSegment.children) {
+        if (trackEntrySegment.type === 'crc32-segment') {
+            continue;
+        }
+        if (trackEntrySegment.type !== 'track-entry-segment') {
+            throw new Error('Expected track entry segment');
+        }
+        const track = (0, get_track_1.getTrack)({
+            track: trackEntrySegment,
+            timescale,
+        });
+        if (track) {
+            tracks.push(track);
+        }
+    }
+    return tracks;
+};
+exports.getTracksFromMatroska = getTracksFromMatroska;

package/dist/boxes/webm/get-track.d.ts

@@ -0,0 +1,6 @@
+import type { AudioTrack, VideoTrack } from '../../get-tracks';
+import type { TrackEntrySegment } from './segments/track-entry';
+export declare const getTrack: ({ timescale, track, }: {
+    timescale: number;
+    track: TrackEntrySegment;
+}) => VideoTrack | AudioTrack | null;

package/dist/boxes/webm/get-track.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrack = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
+const traversal_1 = require("../../traversal");
+const av1_codec_private_1 = require("./av1-codec-private");
+const description_1 = require("./description");
+const getDescription = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec) {
+        return undefined;
+    }
+    if (codec.codec === 'V_MPEG4/ISO/AVC' || codec.codec === 'V_MPEGH/ISO/HEVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            return priv;
+        }
+    }
+    return undefined;
+};
+const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
+    if (codec.codec === 'V_VP8') {
+        return 'vp8';
+    }
+    if (codec.codec === 'V_VP9') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            throw new Error('@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it?');
+        }
+        return 'vp09.00.10.08';
+    }
+    if (codec.codec === 'V_MPEG4/ISO/AVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            return `avc1.${priv[1].toString(16).padStart(2, '0')}${priv[2].toString(16).padStart(2, '0')}${priv[3].toString(16).padStart(2, '0')}`;
+        }
+        throw new Error('Could not find a CodecPrivate field in TrackEntry');
+    }
+    if (codec.codec === 'V_AV1') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (!priv) {
+            throw new Error('Expected private data in AV1 track');
+        }
+        return (0, av1_codec_private_1.parseAv1PrivateData)(priv, null);
+    }
+    if (codec.codec === 'V_MPEGH/ISO/HEVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        return 'hvc1.' + (0, make_hvc1_codec_strings_1.getHvc1CodecString)(iterator);
+    }
+    throw new Error(`Unknown codec: ${codec.codec}`);
+};
+const getMatroskaAudioCodecString = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec) {
+        throw new Error('Expected codec segment');
+    }
+    if (codec.codec === 'A_OPUS') {
+        return 'opus';
+    }
+    if (codec.codec === 'A_VORBIS') {
+        return 'vorbis';
+    }
+    if (codec.codec === 'A_PCM/INT/LIT') {
+        // https://github.com/ietf-wg-cellar/matroska-specification/issues/142#issuecomment-330004950
+        // Audio samples MUST be considered as signed values, except if the audio bit depth is 8 which MUST be interpreted as unsigned values.
+        const bitDepth = (0, traversal_1.getBitDepth)(track);
+        if (bitDepth === null) {
+            throw new Error('Expected bit depth');
+        }
+        if (bitDepth === 8) {
+            return 'pcm-u8';
+        }
+        return 'pcm-s' + bitDepth;
+    }
+    if (codec.codec === 'A_AAC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        iterator.startReadingBits();
+        /**
+         * ChatGPT
+         * 	▪	The first 5 bits represent the AOT.
+                ▪	Common values:
+                ◦	1 for AAC Main
+                ◦	2 for AAC LC (Low Complexity)
+                ◦	3 for AAC SSR (Scalable Sample Rate)
+                ◦	4 for AAC LTP (Long Term Prediction)
+                ◦	5 for SBR (Spectral Band Replication)
+                ◦	29 for HE-AAC (which uses SBR with AAC LC)
+         */
+        /**
+         * Fully qualified codec:
+         * This codec has multiple possible codec strings:
+            "mp4a.40.2" — MPEG-4 AAC LC
+            "mp4a.40.02" — MPEG-4 AAC LC, leading 0 for Aud-OTI compatibility
+            "mp4a.40.5" — MPEG-4 HE-AAC v1 (AAC LC + SBR)
+            "mp4a.40.05" — MPEG-4 HE-AAC v1 (AAC LC + SBR), leading 0 for Aud-OTI compatibility
+            "mp4a.40.29" — MPEG-4 HE-AAC v2 (AAC LC + SBR + PS)
+            "mp4a.67" — MPEG-2 AAC LC
+        */
+        const profile = iterator.getBits(5);
+        iterator.stopReadingBits();
+        iterator.destroy();
+        return `mp4a.40.${profile.toString().padStart(2, '0')}`;
+    }
+    if (codec.codec === 'A_MPEG/L3') {
+        return 'mp3';
+    }
+    throw new Error(`Unknown codec: ${codec.codec}`);
+};
+const getTrack = ({ timescale, track, }) => {
+    const trackType = (0, traversal_1.getTrackTypeSegment)(track);
+    if (!trackType) {
+        throw new Error('Expected track type segment');
+    }
+    const trackId = (0, traversal_1.getTrackId)(track);
+    if (trackType.trackType === 'video') {
+        const width = (0, traversal_1.getWidthSegment)(track);
+        if (width === null) {
+            throw new Error('Expected width segment');
+        }
+        const height = (0, traversal_1.getHeightSegment)(track);
+        if (height === null) {
+            throw new Error('Expected height segment');
+        }
+        const displayHeight = (0, traversal_1.getDisplayHeightSegment)(track);
+        const displayWidth = (0, traversal_1.getDisplayWidthSegment)(track);
+        const codec = (0, traversal_1.getCodecSegment)(track);
+        if (!codec) {
+            return null;
+        }
+        const codecString = getMatroskaVideoCodecString({
+            track,
+            codecSegment: codec,
+        });
+        if (!codecString) {
+            return null;
+        }
+        return {
+            type: 'video',
+            trackId,
+            codec: codecString,
+            description: getDescription(track),
+            height: displayHeight ? displayHeight.displayHeight : height.height,
+            width: displayWidth ? displayWidth.displayWidth : width.width,
+            sampleAspectRatio: {
+                numerator: 1,
+                denominator: 1,
+            },
+            timescale,
+            samplePositions: [],
+            codedHeight: height.height,
+            codedWidth: width.width,
+            displayAspectHeight: displayHeight
+                ? displayHeight.displayHeight
+                : height.height,
+            displayAspectWidth: displayWidth
+                ? displayWidth.displayWidth
+                : width.width,
+            rotation: 0,
+        };
+    }
+    if (trackType.trackType === 'audio') {
+        const sampleRate = (0, traversal_1.getSampleRate)(track);
+        const numberOfChannels = (0, traversal_1.getNumberOfChannels)(track);
+        if (sampleRate === null) {
+            throw new Error('Could not find sample rate or number of channels');
+        }
+        return {
+            type: 'audio',
+            trackId,
+            codec: getMatroskaAudioCodecString(track),
+            samplePositions: null,
+            timescale,
+            numberOfChannels,
+            sampleRate,
+            description: (0, description_1.getAudioDescription)(track),
+        };
+    }
+    return null;
+};
+exports.getTrack = getTrack;

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

@@ -1,3 +1,4 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { ParseResult } from '../../parse-result';
-export declare const parseWebm: (counter: BufferIterator) => ParseResult;
+import type { ParserContext } from '../../parser-context';
+export declare const parseWebm: (counter: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
 const segments_1 = require("./segments");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = (counter) => {
+const parseWebm = (counter, parserContext) => {
     counter.discard(4);
     const length = counter.getVint();
     if (length !== 31 && length !== 35) {
@@ -11,6 +11,6 @@ const parseWebm = (counter) => {
     }
     // Discard header for now
     counter.discard(length);
-    return { status: 'done', segments: [(0, segments_1.expectSegment)(counter)] };
+    return (0, segments_1.expectSegment)(counter, parserContext);
 };
 exports.parseWebm = parseWebm;