music-metadata 12.0.0 → 12.1.1

package/README.md

@@ -606,7 +606,21 @@ Returns a list of supported MIME-types. This may include some MIME-types which a
   only that the parser will attempt to calculate it when possible, even if it requires reading the full file.
 
 - `includeChapters`: `boolean` (default: `false`)
-  When `true`, the MP4 parser scans the `mdat` atom for chapters.
+  When `true`, the MP4 parser reads QuickTime chapter tracks and Nero `chpl` chapter lists.
+  A usable QuickTime chapter track takes precedence over a Nero list.
+  Files, buffers, and Blobs support chapters whether `moov` appears before or after `mdat`.
+  For forward-only streams, `moov` must appear before the chapter data.
+
+- `maxMemoryAllocation`: `number` (default: `67108864`, 64 MiB)
+
+  Maximum bytes buffered for a single metadata payload, accumulated Ogg packet, or tokenizer stream lookahead.
+  Must be a positive safe integer. Parsing rejects payloads above this limit before allocating them.
+  The parser configures this limit once on its `strtok3` tokenizers, including tokenizers for embedded tags.
+  Oversized tokenizer allocations or stream lookahead reject with `strtok3.BufferSizeError`.
+  When using `parseFromTokenizer()`, also configure `maxBufferSize` on the supplied tokenizer at creation.
+  Increase it for files with unusually large metadata or cover art, or lower it for constrained environments.
+  Audio/video data that is skipped does not count toward this limit. This does not cap total process memory:
+  decoded metadata, multiple retained tags, and temporary copies can require additional memory.
 
 - `mkvUseIndex`: `boolean` (default: `false`)
 
@@ -665,45 +679,84 @@ Audio format information. Defined in the TypeScript `IFormat` interface:
 
 #### `metadata.format.trackInfo`
 
-Containers such as Matroska and MPEG-4 can contain multiple audio and video tracks.
-The experimental `metadata.format.trackInfo` property describes these individual tracks.
+`metadata.format.trackInfo` provides the same track abstraction for single-stream audio files and
+multi-track containers (MPEG-4, Matroska, ASF, and Ogg). Tracks can carry audio, video, subtitles, or
+metadata. Import `TrackType` from `music-metadata` to select tracks without knowing the container:
+
+```js
+import { parseFile, TrackType } from 'music-metadata';
+
+const { format } = await parseFile('movie.mp4');
+const audioTracks = format.trackInfo.filter(track => track.type === TrackType.audio);
+const videoTracks = format.trackInfo.filter(track => track.type === TrackType.video);
+```
+
+Each entry describes one discovered track. The order follows container discovery and does not identify
+a preferred track; use `type`, container flags, and language to choose one. In MPEG-4, the codec and
+media properties describe the first sample description, even when the track has multiple sample descriptions. In Ogg, entries describe
+logical media streams; Skeleton headers do not create media tracks. Single-stream audio parsers map
+their format properties to one audio track after parsing.
+
+Properties are optional when unavailable and are not copied between tracks. In particular, a container
+or summary bitrate is not a per-track bitrate. MPEG-4 track timing comes from media headers (or parsed
+audio fragments), and track bitrates from sample sizes and duration. ASF supplies audio/video stream
+properties and stream bitrates from both standalone and nested Stream Properties Objects. Codec List
+entries supply names for matching streams; unused codecs do not create tracks. Matroska applies
+specified defaults for flags, language, channels, and sample rate, and prefers IETF language tags when present. Video duration/bitrate coverage and overall
+video statistics remain incomplete. The existing `format` fields retain their summary semantics.
+
+For Ogg/Opus, the per-track average bitrate uses the logical stream's payload bytes, including codec
+headers and excluding Ogg framing and other streams. It requires the logical stream's end-of-stream
+(EOS) page and a known duration; reaching input EOF alone is insufficient. Set `duration: true` to
+allow scanning when needed. The summary `format.bitrate` retains
+its existing file-size estimate and can differ from the per-track bitrate. Vorbis and Speex use nominal
+bitrates when their headers provide them.
 
 `metadata.format.trackInfo` is an array of [trackInfo](#trackinfo) objects, empty when no track information is available.
 
 ##### trackInfo
 
 Individual track information. Defined in the TypeScript `ITrackInfo` interface:
-- `trackInfo.type?: TrackType` Track type
+- `trackInfo.id?: number` Container track ID/number, or Ogg stream serial number; only meaningful within the file
+- `trackInfo.type?: TrackType` Track type (`audio`, `video`, `subtitle`, `metadata`, or other known types)
+- `trackInfo.codecId?: string` Container-specific codec identifier, such as `mp4a`, `A_AAC`, or ASF audio format tag `0x0161`
 - `trackInfo.codecName?: string` Codec name
+- `trackInfo.codecProfile?: string` Codec profile
+- `trackInfo.duration?: number` Track duration in seconds
+- `trackInfo.bitrate?: number` Encoded track bitrate in bits per second
+- `trackInfo.lossless?: boolean` Whether the track uses lossless compression
 - `trackInfo.codecSettings?: string` Codec settings
-- `trackInfo.flagEnabled?: boolean` Set if the track is usable, default: `true`
-- `trackInfo.flagDefault?: boolean` Set if that track (audio, video or subs) SHOULD be active if no language found matches the user preference.
-- `trackInfo.flagLacing?: boolean` Set if the track **may** contain blocks using lacing
+- `trackInfo.flagEnabled?: boolean` Whether the track is enabled; Matroska defaults to `true`, MPEG-4 uses the track header flag
+- `trackInfo.flagDefault?: boolean` Whether the container marks the track as a default selection; Matroska defaults to `true`
+- `trackInfo.flagForced?: boolean` Whether a subtitle track should be displayed without explicit selection
+- `trackInfo.flagLacing?: boolean` Whether a Matroska track may contain blocks using lacing; defaults to `true`
 - `trackInfo.name?: string` A human-readable track name.
 - `trackInfo.language?: string` Specifies the language of the track
-- `trackInfo.audio?: IAudioTrack`, see [`trackInfo.audioTrack`](#trackinfoaudiotrack)
-- `trackInfo.video?: IVideoTrack`, see [`trackInfo.videoTrack`](#trackinfovideotrack)
-
-##### `trackInfo.audioTrack`
-
-- `audioTrack.samplingFrequency?: number`
-- `audioTrack.outputSamplingFrequency?: number`
-- `audioTrack.channels?: number`
-- `audioTrack.channelPositions?: Uint8Array`
-- `audioTrack.bitDepth?: number`
-
-##### `trackInfo.videoTrack`
-
-- `videoTrack.flagInterlaced?: boolean`
-- `videoTrack.stereoMode?: number`
-- `videoTrack.pixelWidth?: number`
-- `videoTrack.pixelHeight?: number`
-- `videoTrack.displayWidth?: number`
-- `videoTrack.displayHeight?: number`
-- `videoTrack.displayUnit?: number`
-- `videoTrack.aspectRatioType?: number`
-- `videoTrack.colourSpace?: Uint8Array`
-- `videoTrack.gammaValue?: number`
+- `trackInfo.audio?: IAudioTrack`, see [`trackInfo.audio`](#trackinfoaudio)
+- `trackInfo.video?: IVideoTrack`, see [`trackInfo.video`](#trackinfovideo)
+
+##### `trackInfo.audio`
+
+- `trackInfo.audio.numberOfSamples?: number` Number of decoded sample frames (one sample per channel), when known
+- `trackInfo.audio.samplingFrequency?: number` Sample rate in hertz; for Opus, the informational original input rate
+- `trackInfo.audio.outputSamplingFrequency?: number` Output sample rate in hertz; Opus granules and sample counts use 48000 Hz
+- `trackInfo.audio.channels?: number`
+- `trackInfo.audio.channelPositions?: Uint8Array`
+- `trackInfo.audio.bitDepth?: number`
+
+##### `trackInfo.video`
+
+- `trackInfo.video.frameRate?: number` Frames per second, when known
+- `trackInfo.video.flagInterlaced?: boolean`
+- `trackInfo.video.stereoMode?: number`
+- `trackInfo.video.pixelWidth?: number`
+- `trackInfo.video.pixelHeight?: number`
+- `trackInfo.video.displayWidth?: number`
+- `trackInfo.video.displayHeight?: number`
+- `trackInfo.video.displayUnit?: number`
+- `trackInfo.video.aspectRatioType?: number`
+- `trackInfo.video.colourSpace?: Uint8Array`
+- `trackInfo.video.gammaValue?: number`
 
 #### `metadata.common`
 

package/lib/ParserFactory.js

@@ -5,7 +5,9 @@ import { parse as mimeTypeParse } from 'media-typer';
 import { aiffParserLoader } from './aiff/AiffLoader.js';
 import { apeParserLoader } from './apev2/Apev2Loader.js';
 import { asfParserLoader } from './asf/AsfLoader.js';
+import { getMaxMemoryAllocation } from './common/Allocation.js';
 import { MetadataCollector } from './common/MetadataCollector.js';
+import { createAudioTrackInfo } from './common/TrackInfo.js';
 import { scanAppendingHeaders } from './core.js';
 import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
 import { dsfParserLoader } from './dsf/DsfLoader.js';
@@ -55,6 +57,7 @@ export class ParserFactory {
         this.parsers.push(parser);
     }
     async parse(tokenizer, parserLoader, opts = {}) {
+        getMaxMemoryAllocation(opts);
         if (tokenizer.supportsRandomAccess()) {
             debug('tokenizer supports random-access, scanning for appending headers');
             await scanAppendingHeaders(tokenizer, opts);
@@ -89,9 +92,14 @@ export class ParserFactory {
         debug(`Loading ${parserLoader.parserType} parser...`);
         const metadata = new MetadataCollector(opts);
         const ParserImpl = await parserLoader.load();
-        const parser = new ParserImpl(metadata, tokenizer, opts ?? {});
+        const parser = new ParserImpl(metadata, tokenizer, opts);
         debug(`Parser ${parserLoader.parserType} loaded`);
         await parser.parse();
+        // Audio-only parsers describe their single stream through the format fields.
+        // Container parsers supply their own tracks; never copy aggregate fields to them.
+        if (metadata.format.trackInfo.length === 0 && metadata.format.hasAudio === true) {
+            metadata.addStreamInfo(createAudioTrackInfo(metadata.format));
+        }
         if (metadata.format.trackInfo) {
             if (metadata.format.hasAudio === undefined) {
                 metadata.setFormat('hasAudio', !!metadata.format.trackInfo.find(track => track.type === TrackType.audio));

package/lib/aiff/AiffParser.js

@@ -1,6 +1,7 @@
 import initDebug from 'debug';
 import * as strtok3 from 'strtok3';
 import * as Token from 'token-types';
+import { getTokenizerOptions } from '../common/Allocation.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
@@ -18,11 +19,11 @@ const debug = initDebug('music-metadata:parser:aiff');
 export class AIFFParser extends BasicParser {
     isCompressed = null;
     async parse() {
-        const header = await this.tokenizer.readToken(iff.Header);
+        const header = await this.readToken(iff.Header);
         if (header.chunkID !== 'FORM') {
             throw new AiffContentError("Invalid Chunk-ID, expected 'FORM'"); // Not AIFF format
         }
-        const type = await this.tokenizer.readToken(FourCcToken);
+        const type = await this.readToken(FourCcToken);
         switch (type) {
             case 'AIFF':
                 this.metadata.setFormat('container', type);
@@ -41,7 +42,7 @@ export class AIFFParser extends BasicParser {
             while (!this.tokenizer.fileInfo.size ||
                 this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
                 debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
-                const chunkHeader = await this.tokenizer.readToken(iff.Header);
+                const chunkHeader = await this.readToken(iff.Header);
                 const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
                 const bytesRead = await this.readData(chunkHeader);
                 await this.tokenizer.ignore(nextChunk - bytesRead);
@@ -63,7 +64,7 @@ export class AIFFParser extends BasicParser {
                 if (this.isCompressed === null) {
                     throw new AiffContentError('Failed to parse AIFF.COMM chunk when compression type is unknown');
                 }
-                const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
+                const common = await this.readToken(new AiffToken.Common(header, this.isCompressed));
                 this.metadata.setFormat('bitsPerSample', common.sampleSize);
                 this.metadata.setFormat('sampleRate', common.sampleRate);
                 this.metadata.setFormat('numberOfChannels', common.numChannels);
@@ -76,8 +77,8 @@ export class AIFFParser extends BasicParser {
             }
             case 'ID3 ': {
                 // ID3-meta-data
-                const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
-                const rst = strtok3.fromBuffer(id3_data);
+                const id3_data = await this.readToken(new Token.Uint8ArrayType(header.chunkSize));
+                const rst = strtok3.fromBuffer(id3_data, getTokenizerOptions(this.options));
                 await new ID3v2Parser().parse(this.metadata, rst, this.options);
                 return header.chunkSize;
             }
@@ -97,7 +98,7 @@ export class AIFFParser extends BasicParser {
         }
     }
     async readTextChunk(header) {
-        const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
+        const value = await this.readToken(new Token.StringType(header.chunkSize, 'ascii'));
         const values = value
             .split('\0')
             .map(v => v.trim())

package/lib/apev2/APEv2Parser.js

@@ -2,6 +2,7 @@ import { textDecode } from '@borewit/text-codec';
 import initDebug from 'debug';
 import * as strtok3 from 'strtok3';
 import { StringType } from 'token-types';
+import { getTokenizerOptions, readBuffer } from '../common/Allocation.js';
 import { BasicParser } from '../common/BasicParser.js';
 import * as util from '../common/Util.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
@@ -60,8 +61,7 @@ export class APEv2Parser extends BasicParser {
         if (footer.ID !== preamble) {
             throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
         }
-        strtok3.fromBuffer(buffer);
-        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer), options);
+        const apeParser = new APEv2Parser(metadata, strtok3.fromBuffer(buffer, getTokenizerOptions(options)), options);
         return apeParser.parseTags(footer);
     }
     ape = {};
@@ -82,8 +82,7 @@ export class APEv2Parser extends BasicParser {
         if (this.tokenizer.fileInfo.size) {
             // Try to read the APEv2 header using just the footer-header
             const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position; // ToDo: take ID3v1 into account
-            const buffer = new Uint8Array(remaining);
-            await this.tokenizer.readBuffer(buffer);
+            const buffer = await this.readTagValue(remaining);
             return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
         }
     }
@@ -167,28 +166,7 @@ export class APEv2Parser extends BasicParser {
         }
     }
     async readTagValue(size) {
-        const chunkSize = 64 * 1024;
-        if ((!this.tokenizer.supportsRandomAccess() || this.tokenizer.fileInfo.size === undefined) && size > chunkSize) {
-            // Stream sizes may be unknown or untrustworthy. Only allocate the full
-            // value after all of its bytes have actually been read.
-            const chunks = [];
-            for (let remaining = size; remaining > 0;) {
-                const chunk = new Uint8Array(Math.min(remaining, chunkSize));
-                await this.tokenizer.readBuffer(chunk);
-                chunks.push(chunk);
-                remaining -= chunk.length;
-            }
-            const value = new Uint8Array(size);
-            let offset = 0;
-            for (const chunk of chunks) {
-                value.set(chunk, offset);
-                offset += chunk.length;
-            }
-            return value;
-        }
-        const value = new Uint8Array(size);
-        await this.tokenizer.readBuffer(value);
-        return value;
+        return readBuffer(this.tokenizer, size, this.options, undefined, message => new ApeContentError(message));
     }
     async parseDescriptorExpansion(lenExp) {
         await this.tokenizer.ignore(lenExp);
@@ -199,6 +177,7 @@ export class APEv2Parser extends BasicParser {
         // ToDo before
         this.metadata.setFormat('lossless', true);
         this.metadata.setFormat('container', "Monkey's Audio");
+        this.metadata.setFormat('codec', "Monkey's Audio");
         this.metadata.setFormat('bitsPerSample', header.bitsPerSample);
         this.metadata.setFormat('sampleRate', header.sampleRate);
         this.metadata.setFormat('numberOfChannels', header.channel);

package/lib/asf/AsfObject.d.ts

@@ -1,5 +1,5 @@
 import type { IGetToken, ITokenizer } from 'strtok3';
-import type { AnyTagValue, IPicture, ITag } from '../type.js';
+import type { AnyTagValue, IAudioTrack, IPicture, ITag, IVideoTrack } from '../type.js';
 import AsfGuid from './AsfGuid.js';
 declare const AsfContentParseError_base: {
     new (message: string): {
@@ -199,6 +199,11 @@ export interface IStreamPropertiesObject {
      * Error Correction Type
      */
     errorCorrectionType: AsfGuid;
+    streamNumber: number;
+    codecId?: string;
+    audio?: IAudioTrack;
+    video?: IVideoTrack;
+    bitrate?: number;
 }
 /**
  * Token for: 3.3 Stream Properties Object (mandatory, one per stream)
@@ -283,7 +288,7 @@ export interface IExtendedStreamPropertiesObject {
     streamNameCount: number;
     payloadExtensionSystems: number;
     streamNames: IStreamName[];
-    streamPropertiesObject: number | null;
+    streamPropertiesObject: IStreamPropertiesObject | null;
 }
 /**
  * 4.1 Extended Stream Properties Object (optional, 1 per media stream)

package/lib/asf/AsfObject.js

@@ -1,6 +1,5 @@
 // ASF Objects
 import * as Token from 'token-types';
-import * as util from '../common/Util.js';
 import { AttachedPictureType } from '../id3v2/ID3v2Token.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
 import AsfGuid from './AsfGuid.js';
@@ -97,6 +96,7 @@ export class State {
 export class FilePropertiesObject extends State {
     static guid = AsfGuid.FilePropertiesObject;
     get(buf, off) {
+        const flags = Token.UINT32_LE.get(buf, off + 64);
         return {
             fileId: AsfGuid.fromBin(buf, off),
             fileSize: Token.UINT64_LE.get(buf, off + 16),
@@ -106,8 +106,8 @@ export class FilePropertiesObject extends State {
             sendDuration: Token.UINT64_LE.get(buf, off + 48),
             preroll: Token.UINT64_LE.get(buf, off + 56),
             flags: {
-                broadcast: util.getBit(buf, off + 64, 24),
-                seekable: util.getBit(buf, off + 64, 25)
+                broadcast: (flags & 1) !== 0,
+                seekable: (flags & 2) !== 0
             },
             // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
             minimumDataPacketSize: Token.UINT32_LE.get(buf, off + 68),
@@ -123,11 +123,52 @@ export class FilePropertiesObject extends State {
 export class StreamPropertiesObject extends State {
     static guid = AsfGuid.StreamPropertiesObject;
     get(buf, off) {
-        return {
+        const available = Math.min(this.len, buf.length - off);
+        if (available < 54) {
+            throw new AsfContentParseError('Truncated Stream Properties Object');
+        }
+        const typeSpecificSize = Token.UINT32_LE.get(buf, off + 40);
+        const correctionSize = Token.UINT32_LE.get(buf, off + 44);
+        if (typeSpecificSize + correctionSize > available - 54) {
+            throw new AsfContentParseError('ASF stream data exceeds Stream Properties Object payload');
+        }
+        const result = {
             streamType: AsfGuid.decodeMediaType(AsfGuid.fromBin(buf, off)),
-            errorCorrectionType: AsfGuid.fromBin(buf, off + 8)
-            // ToDo
+            errorCorrectionType: AsfGuid.fromBin(buf, off + 16),
+            streamNumber: Token.UINT16_LE.get(buf, off + 48) & 0x7f
         };
+        const data = off + 54;
+        if (result.streamType === 'audio' && typeSpecificSize >= 16) {
+            result.codecId = `0x${Token.UINT16_LE.get(buf, data).toString(16).padStart(4, '0')}`;
+            result.audio = {
+                channels: Token.UINT16_LE.get(buf, data + 2),
+                samplingFrequency: Token.UINT32_LE.get(buf, data + 4)
+            };
+            const bitDepth = Token.UINT16_LE.get(buf, data + 14);
+            if (bitDepth > 0) {
+                result.audio.bitDepth = bitDepth;
+            }
+            const bytesPerSecond = Token.UINT32_LE.get(buf, data + 8);
+            if (bytesPerSecond > 0) {
+                result.bitrate = bytesPerSecond * 8;
+            }
+        }
+        else if (result.streamType === 'video' && typeSpecificSize >= 11) {
+            result.video = {
+                pixelWidth: Token.UINT32_LE.get(buf, data),
+                pixelHeight: Token.UINT32_LE.get(buf, data + 4)
+            };
+            // ASF specification 9.2: DWORD width, DWORD height, BYTE flags, WORD format size.
+            // The packed BITMAPINFOHEADER follows at +11; its compression DWORD is at +16.
+            const formatSize = Token.UINT16_LE.get(buf, data + 9);
+            if (formatSize > typeSpecificSize - 11) {
+                throw new AsfContentParseError('ASF video format data exceeds stream data');
+            }
+            if (formatSize >= 20) {
+                result.codecId = new Token.StringType(4, 'ascii').get(buf, data + 27);
+            }
+        }
+        return result;
     }
 }
 /**
@@ -293,32 +334,68 @@ export class ExtendedContentDescriptionObjectState extends State {
 export class ExtendedStreamPropertiesObjectState extends State {
     static guid = AsfGuid.ExtendedStreamPropertiesObject;
     get(buf, off) {
-        const view = new DataView(buf.buffer, off);
-        return {
+        const end = off + Math.min(this.len, buf.length - off);
+        if (end - off < 64) {
+            throw new AsfContentParseError('Truncated Extended Stream Properties Object');
+        }
+        const flags = Token.UINT32_LE.get(buf, off + 44);
+        const result = {
             startTime: Token.UINT64_LE.get(buf, off),
             endTime: Token.UINT64_LE.get(buf, off + 8),
-            dataBitrate: view.getInt32(12, true),
-            bufferSize: view.getInt32(16, true),
-            initialBufferFullness: view.getInt32(20, true),
-            alternateDataBitrate: view.getInt32(24, true),
-            alternateBufferSize: view.getInt32(28, true),
-            alternateInitialBufferFullness: view.getInt32(32, true),
-            maximumObjectSize: view.getInt32(36, true),
+            dataBitrate: Token.UINT32_LE.get(buf, off + 16),
+            bufferSize: Token.UINT32_LE.get(buf, off + 20),
+            initialBufferFullness: Token.UINT32_LE.get(buf, off + 24),
+            alternateDataBitrate: Token.UINT32_LE.get(buf, off + 28),
+            alternateBufferSize: Token.UINT32_LE.get(buf, off + 32),
+            alternateInitialBufferFullness: Token.UINT32_LE.get(buf, off + 36),
+            maximumObjectSize: Token.UINT32_LE.get(buf, off + 40),
             flags: {
-                // ToDo, check flag positions
-                reliableFlag: util.getBit(buf, off + 40, 0),
-                seekableFlag: util.getBit(buf, off + 40, 1),
-                resendLiveCleanpointsFlag: util.getBit(buf, off + 40, 2)
+                reliableFlag: (flags & 1) !== 0,
+                seekableFlag: (flags & 2) !== 0,
+                resendLiveCleanpointsFlag: (flags & 8) !== 0
             },
-            // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
-            streamNumber: view.getInt16(42, true),
-            streamLanguageId: view.getInt16(44, true),
-            averageTimePerFrame: view.getInt32(52, true),
-            streamNameCount: view.getInt32(54, true),
-            payloadExtensionSystems: view.getInt32(56, true),
-            streamNames: [], // ToDo
+            streamNumber: Token.UINT16_LE.get(buf, off + 48) & 0x7f,
+            streamLanguageId: Token.UINT16_LE.get(buf, off + 50),
+            averageTimePerFrame: Number(Token.UINT64_LE.get(buf, off + 52)),
+            streamNameCount: Token.UINT16_LE.get(buf, off + 60),
+            payloadExtensionSystems: Token.UINT16_LE.get(buf, off + 62),
+            streamNames: [],
             streamPropertiesObject: null
         };
+        let cursor = off + 64;
+        const requireBytes = (length) => {
+            if (length > end - cursor) {
+                throw new AsfContentParseError('ASF extended stream data exceeds object payload');
+            }
+        };
+        for (let index = 0; index < result.streamNameCount; ++index) {
+            requireBytes(4);
+            const language = Token.UINT16_LE.get(buf, cursor);
+            const length = Token.UINT16_LE.get(buf, cursor + 2);
+            cursor += 4;
+            requireBytes(length);
+            result.streamNames.push({
+                streamLanguageId: language,
+                streamName: parseUnicodeAttr(buf.subarray(cursor, cursor + length))
+            });
+            cursor += length;
+        }
+        for (let index = 0; index < result.payloadExtensionSystems; ++index) {
+            requireBytes(22);
+            const length = Token.UINT32_LE.get(buf, cursor + 18);
+            cursor += 22;
+            requireBytes(length);
+            cursor += length;
+        }
+        if (cursor < end) {
+            requireBytes(HeaderObjectToken.len);
+            const header = HeaderObjectToken.get(buf, cursor);
+            if (!header.objectId.equals(AsfGuid.StreamPropertiesObject) || header.objectSize !== end - cursor) {
+                throw new AsfContentParseError('Invalid embedded ASF Stream Properties Object');
+            }
+            result.streamPropertiesObject = new StreamPropertiesObject(header).get(buf, cursor + HeaderObjectToken.len);
+        }
+        return result;
     }
 }
 /**

package/lib/asf/AsfParser.d.ts

@@ -10,6 +10,9 @@ import { BasicParser } from '../common/BasicParser.js';
  * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
  */
 export declare class AsfParser extends BasicParser {
+    private streams;
+    private codecs;
+    private streamBitrates;
     parse(): Promise<void>;
     private parseObjectHeaders;
     private addTags;