music-metadata 12.1.0 → 12.2.0

package/README.md

@@ -51,6 +51,7 @@ If you find this project useful and would like to support its development, consi
 | [APE](https://wikipedia.org/wiki/Monkey's_Audio)                          | Monkey's Audio                                            | <img src="./image/logo-APE-AI.svg" width="40" alt="Monkey's Audio logo">                         |
 | [ASF](https://wikipedia.org/wiki/Advanced_Systems_Format)                 | Advanced Systems Format                                   |                                                                                                  |
 | [BWF](https://en.wikipedia.org/wiki/Broadcast_Wave_Format)                | Extended WAV format for broadcast and archiving           |                                                                                                  |
+| [CAF](https://en.wikipedia.org/wiki/Core_Audio_File_Format)               | Core Audio File Format                                    | <img src="./image/logo-Apple_Computer_Logo_rainbow.svg" width="40" alt="Apple rainbow logo">     |
 | [DSDIFF](https://wikipedia.org/wiki/Direct_Stream_Digital)                | Philips DSDIFF                                            | <img src="./image/logo-DSD.svg" width="80" alt="DSD logo">                                       |
 | [DSF](https://wikipedia.org/wiki/Direct_Stream_Digital)                   | Sony's DSD Stream File                                    | <img src="./image/logo-DSD.svg" width="80" alt="DSD logo">                                       |
 | [FLAC](https://wikipedia.org/wiki/FLAC)                                   | Free Lossless Audio Codec                                 | <img src="./image/logo-FLAC.svg" width="80" alt="FLAC logo">                                     |
@@ -80,6 +81,7 @@ Following tag header formats are supported:
 - [RIFF](https://wikipedia.org/wiki/Resource_Interchange_File_Format)/INFO
 - [Vorbis comment](https://wikipedia.org/wiki/Vorbis_comment)
 - [AIFF](https://wikipedia.org/wiki/Audio_Interchange_File_Format)
+- [CAF](https://developer.apple.com/library/archive/documentation/MusicAudio/Reference/CAFSpec/CAF_spec/CAF_spec.html)
  
 Following lyric formats are supported:
 - [LRC](https://en.wikipedia.org/wiki/LRC_(file_format))
@@ -611,6 +613,17 @@ Returns a list of supported MIME-types. This may include some MIME-types which a
   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`)
 
   When `true`, the parser uses the SeekHead index in Matroska (MKV) files to skip segment and cluster elements.
@@ -655,8 +668,10 @@ Audio format information. Defined in the TypeScript `IFormat` interface:
 - `format.codec?` Name of the codec (algorithm used for the audio compression)
 - `format.codecProfile?: string` Codec profile / settings
 - `format.tagTypes?: TagType[]`  List of tagging formats found in parsed audio file
-- `format.duration?: number` Duration in seconds
-- `format.bitrate?: number` Number bits per second of encoded audio file
+- `format.duration?: number` Duration in seconds (existing audio/container summary; complete presentation duration for video-only files)
+- `format.bitrate?: number` Existing audio/container summary bitrate in bits per second
+- `format.containerDuration?: number` Complete media presentation duration in seconds, including video
+- `format.overallBitrate?: number` Average bitrate of the entire file in bits per second, including container overhead; requires a known file size and presentation duration
 - `format.sampleRate?: number` Sampling rate in Samples per second (S/s)
 - `format.bitsPerSample?: number` Audio bit depth
 - `format.lossless?: boolean` True if lossless,  false for lossy encoding
@@ -675,9 +690,14 @@ metadata. Import `TrackType` from `music-metadata` to select tracks without know
 ```js
 import { parseFile, TrackType } from 'music-metadata';
 
-const { format } = await parseFile('movie.mp4');
+const { format } = await parseFile('movie.mp4', { duration: true });
 const audioTracks = format.trackInfo.filter(track => track.type === TrackType.audio);
 const videoTracks = format.trackInfo.filter(track => track.type === TrackType.video);
+for (const track of videoTracks) {
+  console.log(track.duration, track.bitrate, track.video?.pixelWidth, track.video?.pixelHeight);
+  console.log(track.video?.frameRate);
+}
+console.log(format.containerDuration, format.overallBitrate);
 ```
 
 Each entry describes one discovered track. The order follows container discovery and does not identify
@@ -687,12 +707,27 @@ logical media streams; Skeleton headers do not create media tracks. Single-strea
 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.
+or summary bitrate is not a per-track bitrate. The existing `format.duration` and `format.bitrate`
+fields retain their summary semantics. Use `containerDuration` for the complete presentation and
+`overallBitrate` for the actual file size multiplied by eight and divided by that duration. These
+statistics remain unset when timing is unavailable; `overallBitrate` also requires a known input size.
+
+MPEG-4 derives audio and video timing from media headers, sample tables, and fragments, including
+fragment defaults and decode timestamps. Track bitrates use sample sizes and duration; video properties
+include encoded dimensions, display dimensions, and average frame rate. ASF supplies stream dimensions,
+stream bitrates, and extended stream timing and frame rate when present. Standalone and nested Stream
+Properties Objects describe actual streams; Codec List entries supply names without creating unused tracks.
+
+Matroska applies specified defaults for flags, language, channels, and sample rate, and prefers IETF
+language tags when present. Track statistics tags provide duration, bitrate, and frame count; without
+these tags, per-track timing may be unavailable even when segment duration is known. Media clusters
+are not scanned to calculate missing track statistics.
+
+Ogg/Theora duration comes from granule positions. Set `duration: true` to allow scanning beyond the
+initial metadata pages. Once a video stream has been fully read, its average bitrate uses that logical
+stream's payload bytes, including codec headers and excluding Ogg framing and other streams. Resolution
+and frame rate are available from the identification header. Audio streams retain their own codec
+bitrate 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

package/lib/ParserFactory.js

@@ -5,8 +5,10 @@ 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 { cafParserLoader } from './caf/CafLoader.js';
+import { getMaxMemoryAllocation } from './common/Allocation.js';
 import { MetadataCollector } from './common/MetadataCollector.js';
-import { createAudioTrackInfo } from './common/TrackInfo.js';
+import { createAudioTrackInfo, finalizeContainerInfo } from './common/TrackInfo.js';
 import { scanAppendingHeaders } from './core.js';
 import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
 import { dsfParserLoader } from './dsf/DsfLoader.js';
@@ -47,7 +49,8 @@ export class ParserFactory {
             wavpackParserLoader,
             musepackParserLoader,
             dsfParserLoader,
-            dsdiffParserLoader
+            dsdiffParserLoader,
+            cafParserLoader
         ].forEach(parser => {
             this.registerParser(parser);
         });
@@ -56,6 +59,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);
@@ -90,7 +94,7 @@ 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.
@@ -106,6 +110,7 @@ export class ParserFactory {
                 metadata.setFormat('hasVideo', !!metadata.format.trackInfo.find(track => track.type === TrackType.video));
             }
         }
+        finalizeContainerInfo(metadata, tokenizer.fileInfo.size);
         return metadata.toCommonMetadata();
     }
     /**

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);

package/lib/asf/AsfParser.d.ts

@@ -12,6 +12,7 @@ import { BasicParser } from '../common/BasicParser.js';
 export declare class AsfParser extends BasicParser {
     private streams;
     private codecs;
+    private extendedStreams;
     private streamBitrates;
     parse(): Promise<void>;
     private parseObjectHeaders;

package/lib/asf/AsfParser.js

@@ -1,6 +1,7 @@
 import initDebug from 'debug';
 import { EndOfStreamError } from 'strtok3';
 import * as Token from 'token-types';
+import { validateAllocation } from '../common/Allocation.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { TrackType } from '../type.js';
 import AsfGuid from './AsfGuid.js';
@@ -8,7 +9,6 @@ import * as AsfObject from './AsfObject.js';
 import { AsfContentParseError } from './AsfObject.js';
 const debug = initDebug('music-metadata:parser:ASF');
 const headerType = 'asf';
-const maxAsfMetadataObjectSize = 16 * 1024 * 1024;
 /**
  * Windows Media Metadata Usage Guidelines
  * - Ref: https://msdn.microsoft.com/en-us/library/ms867702.aspx
@@ -22,9 +22,10 @@ const maxAsfMetadataObjectSize = 16 * 1024 * 1024;
 export class AsfParser extends BasicParser {
     streams = new Map();
     codecs = [];
+    extendedStreams = new Map();
     streamBitrates = new Map();
     async parse() {
-        const header = await this.tokenizer.readToken(AsfObject.TopLevelHeaderObjectToken);
+        const header = await this.readToken(AsfObject.TopLevelHeaderObjectToken);
         if (!header.objectId.equals(AsfGuid.HeaderObject)) {
             throw new AsfContentParseError(`expected asf header; but was not found; got: ${header.objectId.str}`);
         }
@@ -52,6 +53,7 @@ export class AsfParser extends BasicParser {
                     stream.codecId === new Token.StringType(4, 'ascii').get(codec.information, 0));
             });
             const track = { id: stream.streamNumber, type };
+            const extended = this.extendedStreams.get(stream.streamNumber);
             if (stream.codecId !== undefined) {
                 track.codecId = stream.codecId;
             }
@@ -64,7 +66,20 @@ export class AsfParser extends BasicParser {
             if (stream.video) {
                 track.video = stream.video;
             }
-            const bitrate = this.streamBitrates.get(stream.streamNumber) ?? stream.bitrate;
+            if (extended) {
+                if (extended.endTime > extended.startTime) {
+                    track.duration = Number(extended.endTime - extended.startTime) / 1000;
+                }
+                const name = extended.streamNames[0]?.streamName;
+                if (name) {
+                    track.name = name;
+                }
+                if (track.video && extended.averageTimePerFrame > 0) {
+                    track.video.frameRate = 1e7 / extended.averageTimePerFrame;
+                }
+            }
+            const bitrate = this.streamBitrates.get(stream.streamNumber) ??
+                (extended && extended.dataBitrate > 0 ? extended.dataBitrate : stream.bitrate);
             if (bitrate !== undefined) {
                 track.bitrate = bitrate;
             }
@@ -89,15 +104,21 @@ export class AsfParser extends BasicParser {
                 case AsfObject.FilePropertiesObject.guid.str: {
                     // 3.2
                     this.validateAllocationSize(payloadSize, 'File Properties Object');
-                    const fpo = await this.tokenizer.readToken(new AsfObject.FilePropertiesObject(header));
-                    this.metadata.setFormat('duration', Number(fpo.playDuration / BigInt(1000)) / 10000 - Number(fpo.preroll) / 1000);
+                    const fpo = await this.readToken(new AsfObject.FilePropertiesObject(header));
+                    if (!fpo.flags.broadcast) {
+                        const duration = Number(fpo.playDuration) / 1e7 - Number(fpo.preroll) / 1000;
+                        if (Number.isFinite(duration) && duration > 0) {
+                            this.metadata.setFormat('duration', duration);
+                            this.metadata.setFormat('containerDuration', duration);
+                        }
+                    }
                     this.metadata.setFormat('bitrate', fpo.maximumBitrate);
                     break;
                 }
                 case AsfObject.StreamPropertiesObject.guid.str: {
                     // 3.3
                     this.validateAllocationSize(payloadSize, 'Stream Properties Object');
-                    const spo = await this.tokenizer.readToken(new AsfObject.StreamPropertiesObject(header));
+                    const spo = await this.readToken(new AsfObject.StreamPropertiesObject(header));
                     this.metadata.setFormat('container', `ASF/${spo.streamType}`);
                     if (spo.streamType === 'audio') {
                         this.metadata.setFormat('hasAudio', true);
@@ -114,7 +135,7 @@ export class AsfParser extends BasicParser {
                     if (payloadSize < extensionHeaderToken.len) {
                         throw new AsfContentParseError(`ASF Header Extension Object payload is too small: ${payloadSize} bytes`);
                     }
-                    const extHeader = await this.tokenizer.readToken(extensionHeaderToken);
+                    const extHeader = await this.readToken(extensionHeaderToken);
                     const expectedExtensionSize = payloadSize - extensionHeaderToken.len;
                     if (extHeader.extensionDataSize !== expectedExtensionSize) {
                         throw new AsfContentParseError(`ASF extension data size ${extHeader.extensionDataSize} does not match enclosing payload size ${expectedExtensionSize}`);
@@ -124,12 +145,12 @@ export class AsfParser extends BasicParser {
                 }
                 case AsfObject.ContentDescriptionObjectState.guid.str: // 3.10
                     this.validateAllocationSize(payloadSize, 'Content Description Object');
-                    tags = await this.tokenizer.readToken(new AsfObject.ContentDescriptionObjectState(header));
+                    tags = await this.readToken(new AsfObject.ContentDescriptionObjectState(header));
                     await this.addTags(tags);
                     break;
                 case AsfObject.ExtendedContentDescriptionObjectState.guid.str: // 3.11
                     this.validateAllocationSize(payloadSize, 'Extended Content Description Object');
-                    tags = await this.tokenizer.readToken(new AsfObject.ExtendedContentDescriptionObjectState(header));
+                    tags = await this.readToken(new AsfObject.ExtendedContentDescriptionObjectState(header));
                     await this.addTags(tags);
                     break;
                 case AsfGuid.CodecListObject.str: {
@@ -154,13 +175,13 @@ export class AsfParser extends BasicParser {
                     if (payloadSize < 2) {
                         throw new AsfContentParseError('Truncated Stream Bitrate Properties Object');
                     }
-                    const count = await this.tokenizer.readToken(Token.UINT16_LE);
+                    const count = await this.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));
+                        const streamNumber = (await this.readToken(Token.UINT16_LE)) & 0x7f;
+                        this.streamBitrates.set(streamNumber, await this.readToken(Token.UINT32_LE));
                     }
                     await this.ignorePayload(payloadSize - 2 - count * 6, 'Stream Bitrate Properties Object');
                     break;
@@ -188,7 +209,7 @@ export class AsfParser extends BasicParser {
         if (remainingSize < AsfObject.HeaderObjectToken.len) {
             throw new AsfContentParseError(`Insufficient ASF ${containerType} data for an object header: ${remainingSize} bytes`);
         }
-        const header = await this.tokenizer.readToken(AsfObject.HeaderObjectToken);
+        const header = await this.readToken(AsfObject.HeaderObjectToken);
         if (header.objectSize > remainingSize) {
             throw new AsfContentParseError(`ASF ${containerType} object size ${header.objectSize} exceeds remaining ${containerType} payload size ${remainingSize}`);
         }
@@ -209,9 +230,7 @@ export class AsfParser extends BasicParser {
         return payloadSize;
     }
     validateAllocationSize(payloadSize, objectType) {
-        if (payloadSize > maxAsfMetadataObjectSize) {
-            throw new AsfContentParseError(`ASF ${objectType} payload size ${payloadSize} exceeds allocation limit ${maxAsfMetadataObjectSize}`);
-        }
+        validateAllocation(payloadSize, this.options, message => new AsfContentParseError(`ASF ${objectType}: ${message}`));
     }
     async ignorePayload(payloadSize, objectType) {
         let ignored;
@@ -236,7 +255,8 @@ export class AsfParser extends BasicParser {
                 case AsfObject.ExtendedStreamPropertiesObjectState.guid.str: {
                     // 4.1
                     this.validateAllocationSize(payloadSize, 'Extended Stream Properties Object');
-                    const extended = await this.tokenizer.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
+                    const extended = await this.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
+                    this.extendedStreams.set(extended.streamNumber, extended);
                     if (extended.streamPropertiesObject) {
                         const stream = extended.streamPropertiesObject;
                         this.streams.set(stream.streamNumber, stream);
@@ -247,14 +267,14 @@ export class AsfParser extends BasicParser {
                 case AsfObject.MetadataObjectState.guid.str: {
                     // 4.7
                     this.validateAllocationSize(payloadSize, 'Metadata Object');
-                    const moTags = await this.tokenizer.readToken(new AsfObject.MetadataObjectState(header));
+                    const moTags = await this.readToken(new AsfObject.MetadataObjectState(header));
                     await this.addTags(moTags);
                     break;
                 }
                 case AsfObject.MetadataLibraryObjectState.guid.str: {
                     // 4.8
                     this.validateAllocationSize(payloadSize, 'Metadata Library Object');
-                    const mlTags = await this.tokenizer.readToken(new AsfObject.MetadataLibraryObjectState(header));
+                    const mlTags = await this.readToken(new AsfObject.MetadataLibraryObjectState(header));
                     await this.addTags(mlTags);
                     break;
                 }

package/lib/caf/CafLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const cafParserLoader: IParserLoader;

package/lib/caf/CafLoader.js

@@ -0,0 +1,8 @@
+export const cafParserLoader = {
+    parserType: 'caf',
+    extensions: ['.caf', '.caff'],
+    mimeTypes: ['audio/caf', 'application/caf'],
+    async load() {
+        return (await import('./CafParser.js')).CafParser;
+    }
+};

package/lib/caf/CafParser.d.ts

@@ -0,0 +1,37 @@
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * CAF - Core Audio File Format
+ *
+ * Ref: https://developer.apple.com/library/archive/documentation/MusicAudio/Reference/CAFSpec/CAF_spec/CAF_spec.html
+ */
+export declare class CafParser extends BasicParser {
+    private desc;
+    private packetTable;
+    private dataBytes;
+    private expectedFirstChunk;
+    private reachedEndOfFile;
+    parse(): Promise<void>;
+    private endOfFileReached;
+    private readChunk;
+    private readAudioDescription;
+    private applyAudioDescription;
+    private readPacketTable;
+    private readAudioData;
+    private readInfo;
+    private readChannelLayout;
+    private addChannelLayout;
+    /**
+     * Rejects a whole chunk whose declared size exceeds the remaining input.
+     * Only applicable when the total input size is known.
+     */
+    private validateChunkAvailability;
+    /**
+     * Reads a chunk body without trusting its declared size.
+     * @param chunkSize Declared body size
+     * @param chunkType Chunk name for error messages
+     */
+    private readChunkBody;
+    private skipUnknownChunk;
+    private applyDerivedFormat;
+    private deriveFrameCount;
+}