music-metadata 12.0.0 → 12.1.0

package/README.md

@@ -606,7 +606,10 @@ 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.
 
 - `mkvUseIndex`: `boolean` (default: `false`)
 
@@ -665,45 +668,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

@@ -6,6 +6,7 @@ import { aiffParserLoader } from './aiff/AiffLoader.js';
 import { apeParserLoader } from './apev2/Apev2Loader.js';
 import { asfParserLoader } from './asf/AsfLoader.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';
@@ -92,6 +93,11 @@ export class ParserFactory {
         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/apev2/APEv2Parser.js

@@ -199,6 +199,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;

package/lib/asf/AsfParser.js

@@ -1,5 +1,6 @@
 import initDebug from 'debug';
 import { EndOfStreamError } from 'strtok3';
+import * as Token from 'token-types';
 import { BasicParser } from '../common/BasicParser.js';
 import { TrackType } from '../type.js';
 import AsfGuid from './AsfGuid.js';
@@ -19,6 +20,9 @@ const maxAsfMetadataObjectSize = 16 * 1024 * 1024;
  * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
  */
 export class AsfParser extends BasicParser {
+    streams = new Map();
+    codecs = [];
+    streamBitrates = new Map();
     async parse() {
         const header = await this.tokenizer.readToken(AsfObject.TopLevelHeaderObjectToken);
         if (!header.objectId.equals(AsfGuid.HeaderObject)) {
@@ -28,6 +32,52 @@ export class AsfParser extends BasicParser {
             throw new AsfContentParseError(`Unrealistic number of ASF header objects: ${header.numberOfHeaderObjects}`);
         }
         await this.parseObjectHeaders(header.numberOfHeaderObjects, header.objectSize - AsfObject.TopLevelHeaderObjectToken.len);
+        for (const stream of this.streams.values()) {
+            const type = stream.streamType === 'audio'
+                ? TrackType.audio
+                : stream.streamType === 'video'
+                    ? TrackType.video
+                    : stream.streamType === 'command'
+                        ? TrackType.control
+                        : stream.streamType === 'binary'
+                            ? TrackType.metadata
+                            : undefined;
+            const codec = this.codecs.find(codec => {
+                if (type === TrackType.audio && codec.type.audioCodec && codec.information.length >= 2) {
+                    return stream.codecId === `0x${Token.UINT16_LE.get(codec.information, 0).toString(16).padStart(4, '0')}`;
+                }
+                return (type === TrackType.video &&
+                    codec.type.videoCodec &&
+                    codec.information.length >= 4 &&
+                    stream.codecId === new Token.StringType(4, 'ascii').get(codec.information, 0));
+            });
+            const track = { id: stream.streamNumber, type };
+            if (stream.codecId !== undefined) {
+                track.codecId = stream.codecId;
+            }
+            if (codec) {
+                track.codecName = codec.codecName;
+            }
+            if (stream.audio) {
+                track.audio = stream.audio;
+            }
+            if (stream.video) {
+                track.video = stream.video;
+            }
+            const bitrate = this.streamBitrates.get(stream.streamNumber) ?? stream.bitrate;
+            if (bitrate !== undefined) {
+                track.bitrate = bitrate;
+            }
+            this.metadata.addStreamInfo(track);
+        }
+        const audio = [...this.streams.values()].find(stream => stream.audio)?.audio;
+        if (audio) {
+            this.metadata.setFormat('sampleRate', audio.samplingFrequency);
+            this.metadata.setFormat('numberOfChannels', audio.channels);
+            if (audio.bitDepth !== undefined) {
+                this.metadata.setFormat('bitsPerSample', audio.bitDepth);
+            }
+        }
     }
     async parseObjectHeaders(numberOfObjectHeaders, remainingHeaderSize) {
         let tags;
@@ -49,6 +99,13 @@ export class AsfParser extends BasicParser {
                     this.validateAllocationSize(payloadSize, 'Stream Properties Object');
                     const spo = await this.tokenizer.readToken(new AsfObject.StreamPropertiesObject(header));
                     this.metadata.setFormat('container', `ASF/${spo.streamType}`);
+                    if (spo.streamType === 'audio') {
+                        this.metadata.setFormat('hasAudio', true);
+                    }
+                    else if (spo.streamType === 'video') {
+                        this.metadata.setFormat('hasVideo', true);
+                    }
+                    this.streams.set(spo.streamNumber, spo);
                     break;
                 }
                 case AsfObject.HeaderExtensionObject.guid.str: {
@@ -85,12 +142,7 @@ export class AsfParser extends BasicParser {
                         const message = error instanceof Error ? error.message : String(error);
                         throw new AsfContentParseError(`Invalid ASF Codec List Object: ${message}`);
                     }
-                    codecs.forEach(codec => {
-                        this.metadata.addStreamInfo({
-                            type: codec.type.videoCodec ? TrackType.video : TrackType.audio,
-                            codecName: codec.codecName
-                        });
-                    });
+                    this.codecs.push(...codecs);
                     const audioCodecs = codecs
                         .filter(codec => codec.type.audioCodec)
                         .map(codec => codec.codecName)
@@ -98,10 +150,21 @@ export class AsfParser extends BasicParser {
                     this.metadata.setFormat('codec', audioCodecs);
                     break;
                 }
-                case AsfGuid.StreamBitratePropertiesObject.str:
-                    // ToDo?
-                    await this.ignorePayload(payloadSize, 'Stream Bitrate Properties Object');
+                case AsfGuid.StreamBitratePropertiesObject.str: {
+                    if (payloadSize < 2) {
+                        throw new AsfContentParseError('Truncated Stream Bitrate Properties Object');
+                    }
+                    const count = await this.tokenizer.readToken(Token.UINT16_LE);
+                    if (count * 6 > payloadSize - 2) {
+                        throw new AsfContentParseError('ASF stream bitrate records exceed object payload');
+                    }
+                    for (let index = 0; index < count; ++index) {
+                        const streamNumber = (await this.tokenizer.readToken(Token.UINT16_LE)) & 0x7f;
+                        this.streamBitrates.set(streamNumber, await this.tokenizer.readToken(Token.UINT32_LE));
+                    }
+                    await this.ignorePayload(payloadSize - 2 - count * 6, 'Stream Bitrate Properties Object');
                     break;
+                }
                 case AsfGuid.PaddingObject.str:
                     // ToDo: register bytes pad
                     debug('Padding: %s bytes', payloadSize);
@@ -170,11 +233,17 @@ export class AsfParser extends BasicParser {
             const { header, payloadSize } = await this.readObjectHeader(extensionSize, 'extension');
             // Parse data part of the ASF Object
             switch (header.objectId.str) {
-                case AsfObject.ExtendedStreamPropertiesObjectState.guid.str: // 4.1
-                    // ToDo: extended stream header properties are ignored
+                case AsfObject.ExtendedStreamPropertiesObjectState.guid.str: {
+                    // 4.1
                     this.validateAllocationSize(payloadSize, 'Extended Stream Properties Object');
-                    await this.tokenizer.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
+                    const extended = await this.tokenizer.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
+                    if (extended.streamPropertiesObject) {
+                        const stream = extended.streamPropertiesObject;
+                        this.streams.set(stream.streamNumber, stream);
+                        this.metadata.setFormat('container', `ASF/${stream.streamType}`);
+                    }
                     break;
+                }
                 case AsfObject.MetadataObjectState.guid.str: {
                     // 4.7
                     this.validateAllocationSize(payloadSize, 'Metadata Object');

package/lib/common/MetadataCollector.js

@@ -5,6 +5,7 @@ import { TrackTypeValueToKeyMap } from '../type.js';
 import { CombinedTagMapper } from './CombinedTagMapper.js';
 import { CommonTagMapper } from './GenericTagMapper.js';
 import { isSingleton, isUnique } from './GenericTagTypes.js';
+import { normalizeBitrate } from './TrackInfo.js';
 import { toRatio } from './Util.js';
 const debug = initDebug('music-metadata:collector');
 const TagPriority = [
@@ -65,6 +66,9 @@ export class MetadataCollector {
     }
     addStreamInfo(streamInfo) {
         debug(`streamInfo: type=${streamInfo.type ? TrackTypeValueToKeyMap[streamInfo.type] : '?'}, codec=${streamInfo.codecName}`);
+        if (normalizeBitrate(streamInfo.bitrate) === undefined) {
+            delete streamInfo.bitrate;
+        }
         this.format.trackInfo.push(streamInfo);
     }
     setFormat(key, value) {

package/lib/common/TrackInfo.d.ts

@@ -0,0 +1,5 @@
+import { type IFormat, type ITrackInfo } from '../type.js';
+/** Return a bitrate only when it conveys a finite, positive value. */
+export declare function normalizeBitrate(bitrate: number | undefined): number | undefined;
+/** Map the format of a single audio stream to the shared track abstraction. */
+export declare function createAudioTrackInfo(format: IFormat): ITrackInfo;

package/lib/common/TrackInfo.js

@@ -0,0 +1,39 @@
+import { TrackType } from '../type.js';
+/** Return a bitrate only when it conveys a finite, positive value. */
+export function normalizeBitrate(bitrate) {
+    return bitrate !== undefined && Number.isFinite(bitrate) && bitrate > 0 ? bitrate : undefined;
+}
+/** Map the format of a single audio stream to the shared track abstraction. */
+export function createAudioTrackInfo(format) {
+    const audio = {};
+    const track = { type: TrackType.audio, audio };
+    if (format.codec !== undefined) {
+        track.codecName = format.codec;
+    }
+    if (format.codecProfile !== undefined) {
+        track.codecProfile = format.codecProfile;
+    }
+    if (format.duration !== undefined) {
+        track.duration = format.duration;
+    }
+    const bitrate = normalizeBitrate(format.bitrate);
+    if (bitrate !== undefined) {
+        track.bitrate = bitrate;
+    }
+    if (format.lossless !== undefined) {
+        track.lossless = format.lossless;
+    }
+    if (format.sampleRate !== undefined) {
+        audio.samplingFrequency = format.sampleRate;
+    }
+    if (format.numberOfChannels !== undefined) {
+        audio.channels = format.numberOfChannels;
+    }
+    if (format.bitsPerSample !== undefined) {
+        audio.bitDepth = format.bitsPerSample;
+    }
+    if (format.numberOfSamples !== undefined) {
+        audio.numberOfSamples = format.numberOfSamples;
+    }
+    return track;
+}

package/lib/common/Util.d.ts

@@ -19,7 +19,7 @@ export declare function stripNulls(str: string): string;
  * Total offset in bits = byteOffset * 8 + bitOffset
  * @param source Byte buffer
  * @param byteOffset Starting offset in bytes
- * @param bitOffset Starting offset in bits: 0 = lsb
+ * @param bitOffset Starting offset in bits: 0 = most significant bit
  * @param len Length of number in bits
  * @return Decoded bit aligned number
  */

package/lib/common/Util.js

@@ -81,25 +81,19 @@ export function stripNulls(str) {
  * Total offset in bits = byteOffset * 8 + bitOffset
  * @param source Byte buffer
  * @param byteOffset Starting offset in bytes
- * @param bitOffset Starting offset in bits: 0 = lsb
+ * @param bitOffset Starting offset in bits: 0 = most significant bit
  * @param len Length of number in bits
  * @return Decoded bit aligned number
  */
 export function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
     const byteOff = byteOffset + ~~(bitOffset / 8);
     const bitOff = bitOffset % 8;
-    let value = source[byteOff];
-    value &= 0xff >> bitOff;
-    const bitsRead = 8 - bitOff;
-    const bitsLeft = len - bitsRead;
-    if (bitsLeft < 0) {
-        value >>= 8 - bitOff - len;
+    const value = source[byteOff] & (0xff >> bitOff);
+    const bitsLeft = len + bitOff - 8;
+    if (bitsLeft <= 0) {
+        return value >> -bitsLeft;
     }
-    else if (bitsLeft > 0) {
-        value <<= bitsLeft;
-        value |= getBitAllignedNumber(source, byteOffset, bitOffset + bitsRead, bitsLeft);
-    }
-    return value;
+    return (value << bitsLeft) | getBitAllignedNumber(source, byteOff + 1, 0, bitsLeft);
 }
 /**
  * Read bit-aligned number start from buffer

package/lib/core.d.ts

@@ -7,7 +7,7 @@ import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOption
 export type { IFileInfo } from 'strtok3';
 export * from './ParseError.js';
 export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
-export { type IAudioMetadata, type IChapter, type ICommonTagsResult, type IFormat, type ILyricsTag, type IMetadataEvent, type IMetadataEventTag, type INativeTagDict, type IOptions, type IPicture, type IRatio, type ITag, LyricsContentType, TimestampFormat } from './type.js';
+export { type IAudioMetadata, type IAudioTrack, type IChapter, type ICommonTagsResult, type IFormat, type ILyricsTag, type IMetadataEvent, type IMetadataEventTag, type INativeTagDict, type IOptions, type IPicture, type IRatio, type ITag, type ITrackInfo, type IVideoTrack, LyricsContentType, TimestampFormat, TrackType } from './type.js';
 /**
  * Parse Web API File
  * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20

package/lib/core.js

@@ -8,7 +8,7 @@ import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
 import { ParserFactory } from './ParserFactory.js';
 export * from './ParseError.js';
 export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
-export { LyricsContentType, TimestampFormat } from './type.js';
+export { LyricsContentType, TimestampFormat, TrackType } from './type.js';
 /**
  * Parse Web API File
  * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20