music-metadata 11.5.0 → 11.6.1

package/lib/flac/FlacParser.d.ts

@@ -1,4 +1,6 @@
+import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import type { IBlockStreamInfo } from './FlacToken.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;
     private padding;
@@ -7,11 +9,22 @@ export declare class FlacParser extends AbstractID3Parser {
     /**
      * Parse STREAMINFO
      */
-    private parseBlockStreamInfo;
+    private readBlockStreamInfo;
+    /**
+     * Parse STREAMINFO
+     */
+    processsStreamInfo(streamInfo: IBlockStreamInfo): void;
+    /**
+     * Read VORBIS_COMMENT from tokenizer
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    private readComment;
     /**
      * Parse VORBIS_COMMENT
      * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
      */
-    private parseComment;
+    parseComment(data: Uint8Array): Promise<void>;
     private parsePicture;
+    addPictureTag(picture: IVorbisPicture): Promise<void>;
+    private addTag;
 }

package/lib/flac/FlacParser.js

@@ -1,32 +1,19 @@
-import { UINT16_BE, UINT24_BE, Uint8ArrayType } from 'token-types';
 import initDebug from 'debug';
-import * as util from '../common/Util.js';
+import { Uint8ArrayType } from 'token-types';
 import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
-import { VorbisParser } from '../ogg/vorbis/VorbisParser.js';
+import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import * as Flac from './FlacToken.js';
 const debug = initDebug('music-metadata:parser:FLAC');
 class FlacContentError extends makeUnexpectedFileContentError('FLAC') {
 }
-/**
- * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
- * ref: https://xiph.org/flac/format.html#metadata_block
- */
-const BlockType = {
-    STREAMINFO: 0, // STREAMINFO
-    PADDING: 1, // PADDING
-    APPLICATION: 2, // APPLICATION
-    SEEKTABLE: 3, // SEEKTABLE
-    VORBIS_COMMENT: 4, // VORBIS_COMMENT
-    CUESHEET: 5, // CUESHEET
-    PICTURE: 6 // PICTURE
-};
 export class FlacParser extends AbstractID3Parser {
     constructor() {
         super(...arguments);
-        this.vorbisParser = new VorbisParser(this.metadata, this.options);
+        this.vorbisParser = new VorbisStream(this.metadata, this.options);
         this.padding = 0;
     }
     async postId3v2Parse() {
@@ -34,11 +21,10 @@ export class FlacParser extends AbstractID3Parser {
         if (fourCC.toString() !== 'fLaC') {
             throw new FlacContentError('Invalid FLAC preamble');
         }
-        this.metadata.setAudioOnly();
         let blockHeader;
         do {
             // Read block header
-            blockHeader = await this.tokenizer.readToken(BlockHeader);
+            blockHeader = await this.tokenizer.readToken(Flac.BlockHeader);
             // Parse block data
             await this.parseDataBlock(blockHeader);
         } while (!blockHeader.lastBlock);
@@ -50,20 +36,20 @@ export class FlacParser extends AbstractID3Parser {
     async parseDataBlock(blockHeader) {
         debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
         switch (blockHeader.type) {
-            case BlockType.STREAMINFO:
-                return this.parseBlockStreamInfo(blockHeader.length);
-            case BlockType.PADDING:
+            case Flac.BlockType.STREAMINFO:
+                return this.readBlockStreamInfo(blockHeader.length);
+            case Flac.BlockType.PADDING:
                 this.padding += blockHeader.length;
                 break;
-            case BlockType.APPLICATION:
+            case Flac.BlockType.APPLICATION:
                 break;
-            case BlockType.SEEKTABLE:
+            case Flac.BlockType.SEEKTABLE:
                 break;
-            case BlockType.VORBIS_COMMENT:
-                return this.parseComment(blockHeader.length);
-            case BlockType.CUESHEET:
+            case Flac.BlockType.VORBIS_COMMENT:
+                return this.readComment(blockHeader.length);
+            case Flac.BlockType.CUESHEET:
                 break;
-            case BlockType.PICTURE:
+            case Flac.BlockType.PICTURE:
                 await this.parsePicture(blockHeader.length);
                 return;
             default:
@@ -75,12 +61,19 @@ export class FlacParser extends AbstractID3Parser {
     /**
      * Parse STREAMINFO
      */
-    async parseBlockStreamInfo(dataLen) {
-        if (dataLen !== BlockStreamInfo.len)
+    async readBlockStreamInfo(dataLen) {
+        if (dataLen !== Flac.BlockStreamInfo.len)
             throw new FlacContentError('Unexpected block-stream-info length');
-        const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
+        const streamInfo = await this.tokenizer.readToken(Flac.BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
+        this.processsStreamInfo(streamInfo);
+    }
+    /**
+     * Parse STREAMINFO
+     */
+    processsStreamInfo(streamInfo) {
         this.metadata.setFormat('codec', 'FLAC');
+        this.metadata.setFormat('hasAudio', true);
         this.metadata.setFormat('lossless', true);
         this.metadata.setFormat('numberOfChannels', streamInfo.channels);
         this.metadata.setFormat('bitsPerSample', streamInfo.bitsPerSample);
@@ -90,11 +83,18 @@ export class FlacParser extends AbstractID3Parser {
         }
     }
     /**
-     * Parse VORBIS_COMMENT
+     * Read VORBIS_COMMENT from tokenizer
      * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
      */
-    async parseComment(dataLen) {
+    async readComment(dataLen) {
         const data = await this.tokenizer.readToken(new Uint8ArrayType(dataLen));
+        return this.parseComment(data);
+    }
+    /**
+     * Parse VORBIS_COMMENT
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    async parseComment(data) {
         const decoder = new VorbisDecoder(data, 0);
         decoder.readStringUtf8(); // vendor (skip)
         const commentListLength = decoder.readInt32();
@@ -102,62 +102,19 @@ export class FlacParser extends AbstractID3Parser {
         for (let i = 0; i < commentListLength; i++) {
             tags[i] = decoder.parseUserComment();
         }
-        await Promise.all(tags.map(tag => this.vorbisParser.addTag(tag.key, tag.value)));
+        await Promise.all(tags.map(tag => this.addTag(tag.key, tag.value)));
     }
     async parsePicture(dataLen) {
         if (this.options.skipCovers) {
             return this.tokenizer.ignore(dataLen);
         }
-        const picture = await this.tokenizer.readToken(new VorbisPictureToken(dataLen));
-        this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
+        return this.addPictureTag(await this.tokenizer.readToken(new VorbisPictureToken(dataLen)));
     }
-}
-const BlockHeader = {
-    len: 4,
-    get: (buf, off) => {
-        return {
-            lastBlock: util.getBit(buf, off, 7),
-            type: util.getBitAllignedNumber(buf, off, 1, 7),
-            length: UINT24_BE.get(buf, off + 1)
-        };
+    addPictureTag(picture) {
+        return this.addTag('METADATA_BLOCK_PICTURE', picture);
     }
-};
-/**
- * METADATA_BLOCK_DATA
- * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
- */
-const BlockStreamInfo = {
-    len: 34,
-    get: (buf, off) => {
-        return {
-            // The minimum block size (in samples) used in the stream.
-            minimumBlockSize: UINT16_BE.get(buf, off),
-            // The maximum block size (in samples) used in the stream.
-            // (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
-            maximumBlockSize: UINT16_BE.get(buf, off + 2) / 1000,
-            // The minimum frame size (in bytes) used in the stream.
-            // May be 0 to imply the value is not known.
-            minimumFrameSize: UINT24_BE.get(buf, off + 4),
-            // The maximum frame size (in bytes) used in the stream.
-            // May be 0 to imply the value is not known.
-            maximumFrameSize: UINT24_BE.get(buf, off + 7),
-            // Sample rate in Hz. Though 20 bits are available,
-            // the maximum sample rate is limited by the structure of frame headers to 655350Hz.
-            // Also, a value of 0 is invalid.
-            sampleRate: UINT24_BE.get(buf, off + 10) >> 4,
-            // probably slower: sampleRate: common.getBitAllignedNumber(buf, off + 10, 0, 20),
-            // (number of channels)-1. FLAC supports from 1 to 8 channels
-            channels: util.getBitAllignedNumber(buf, off + 12, 4, 3) + 1,
-            // bits per sample)-1.
-            // FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
-            bitsPerSample: util.getBitAllignedNumber(buf, off + 12, 7, 5) + 1,
-            // Total samples in stream.
-            // 'Samples' means inter-channel sample, i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
-            // A value of zero here means the number of total samples is unknown.
-            totalSamples: util.getBitAllignedNumber(buf, off + 13, 4, 36),
-            // the MD5 hash of the file (see notes for usage... it's a littly tricky)
-            fileMD5: new Uint8ArrayType(16).get(buf, off + 18)
-        };
+    addTag(id, value) {
+        return this.vorbisParser.addTag(id, value);
     }
-};
+}
 //# sourceMappingURL=FlacParser.js.map

package/lib/flac/FlacToken.d.ts

@@ -0,0 +1,45 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
+ * ref: https://xiph.org/flac/format.html#metadata_block
+ */
+export declare const BlockType: {
+    STREAMINFO: number;
+    PADDING: number;
+    APPLICATION: number;
+    SEEKTABLE: number;
+    VORBIS_COMMENT: number;
+    CUESHEET: number;
+    PICTURE: number;
+};
+export type BlockType = typeof BlockType[keyof typeof BlockType];
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export interface IBlockHeader {
+    lastBlock: boolean;
+    type: BlockType;
+    length: number;
+}
+export declare const BlockHeader: IGetToken<IBlockHeader>;
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export interface IBlockStreamInfo {
+    minimumBlockSize: number;
+    maximumBlockSize: number;
+    minimumFrameSize: number;
+    maximumFrameSize: number;
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+    totalSamples: number;
+    fileMD5: Uint8Array;
+}
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export declare const BlockStreamInfo: IGetToken<IBlockStreamInfo>;

package/lib/flac/FlacToken.js

@@ -0,0 +1,64 @@
+import * as util from '../common/Util.js';
+import { UINT16_BE, UINT24_BE, Uint8ArrayType } from 'token-types';
+/**
+ * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
+ * ref: https://xiph.org/flac/format.html#metadata_block
+ */
+export const BlockType = {
+    STREAMINFO: 0, // STREAMINFO
+    PADDING: 1, // PADDING
+    APPLICATION: 2, // APPLICATION
+    SEEKTABLE: 3, // SEEKTABLE
+    VORBIS_COMMENT: 4, // VORBIS_COMMENT
+    CUESHEET: 5, // CUESHEET
+    PICTURE: 6 // PICTURE
+};
+export const BlockHeader = {
+    len: 4,
+    get: (buf, off) => {
+        return {
+            lastBlock: util.getBit(buf, off, 7),
+            type: util.getBitAllignedNumber(buf, off, 1, 7),
+            length: UINT24_BE.get(buf, off + 1)
+        };
+    }
+};
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export const BlockStreamInfo = {
+    len: 34,
+    get: (buf, off) => {
+        return {
+            // The minimum block size (in samples) used in the stream.
+            minimumBlockSize: UINT16_BE.get(buf, off),
+            // The maximum block size (in samples) used in the stream.
+            // (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
+            maximumBlockSize: UINT16_BE.get(buf, off + 2) / 1000,
+            // The minimum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            minimumFrameSize: UINT24_BE.get(buf, off + 4),
+            // The maximum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            maximumFrameSize: UINT24_BE.get(buf, off + 7),
+            // Sample rate in Hz. Though 20 bits are available,
+            // the maximum sample rate is limited by the structure of frame headers to 655350Hz.
+            // Also, a value of 0 is invalid.
+            sampleRate: UINT24_BE.get(buf, off + 10) >> 4,
+            // probably slower: sampleRate: common.getBitAllignedNumber(buf, off + 10, 0, 20),
+            // (number of channels)-1. FLAC supports from 1 to 8 channels
+            channels: util.getBitAllignedNumber(buf, off + 12, 4, 3) + 1,
+            // bits per sample)-1.
+            // FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
+            bitsPerSample: util.getBitAllignedNumber(buf, off + 12, 7, 5) + 1,
+            // Total samples in stream.
+            // 'Samples' means inter-channel sample, i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
+            // A value of zero here means the number of total samples is unknown.
+            totalSamples: util.getBitAllignedNumber(buf, off + 13, 4, 36),
+            // the MD5 hash of the file (see notes for usage... it's a littly tricky)
+            fileMD5: new Uint8ArrayType(16).get(buf, off + 18)
+        };
+    }
+};
+//# sourceMappingURL=FlacToken.js.map

package/lib/ogg/OggParser.d.ts

@@ -1,6 +1,4 @@
-import { type IGetToken } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type * as Ogg from './Ogg.js';
 declare const OggContentError_base: {
     new (message: string): {
         readonly fileType: string;
@@ -15,20 +13,11 @@ declare const OggContentError_base: {
 };
 export declare class OggContentError extends OggContentError_base {
 }
-export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {
-    private static sum;
-    len: number;
-    constructor(header: Ogg.IPageHeader);
-    get(buf: Uint8Array, off: number): Ogg.ISegmentTable;
-}
 /**
  * Parser for Ogg logical bitstream framing
  */
 export declare class OggParser extends BasicParser {
-    private static Header;
-    private header;
-    private pageNumber;
-    private pageConsumer;
+    private streams;
     /**
      * Parse page
      * @returns {Promise<void>}

package/lib/ogg/OggParser.js

@@ -1,33 +1,72 @@
 import * as Token from 'token-types';
 import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
-import * as util from '../common/Util.js';
-import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
-import { VorbisParser } from './vorbis/VorbisParser.js';
-import { OpusParser } from './opus/OpusParser.js';
-import { SpeexParser } from './speex/SpeexParser.js';
-import { TheoraParser } from './theora/TheoraParser.js';
+import { VorbisStream } from './vorbis/VorbisStream.js';
+import { OpusStream } from './opus/OpusStream.js';
+import { SpeexStream } from './speex/SpeexStream.js';
+import { TheoraStream } from './theora/TheoraStream.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { PageHeader, SegmentTable } from './OggToken.js';
+import { FlacStream } from './flac/FlacStream.js';
 export class OggContentError extends makeUnexpectedFileContentError('Ogg') {
 }
 const debug = initDebug('music-metadata:parser:ogg');
-export class SegmentTable {
-    static sum(buf, off, len) {
-        const dv = new DataView(buf.buffer, 0);
-        let s = 0;
-        for (let i = off; i < off + len; ++i) {
-            s += dv.getUint8(i);
-        }
-        return s;
-    }
-    constructor(header) {
-        this.len = header.page_segments;
+class OggStream {
+    constructor(metadata, streamSerial, options) {
+        this.pageNumber = 0;
+        this.closed = false;
+        this.metadata = metadata;
+        this.streamSerial = streamSerial;
+        this.options = options;
     }
-    get(buf, off) {
-        return {
-            totalPageSize: SegmentTable.sum(buf, off, this.len)
-        };
+    async parsePage(tokenizer, header) {
+        this.pageNumber = header.pageSequenceNo;
+        debug('serial=%s page#=%s, Ogg.id=%s', header.streamSerialNumber, header.pageSequenceNo, header.capturePattern);
+        const segmentTable = await tokenizer.readToken(new SegmentTable(header));
+        debug('totalPageSize=%s', segmentTable.totalPageSize);
+        const pageData = await tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
+        debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
+        if (header.headerType.firstPage) {
+            const idData = pageData.slice(0, 7); // Copy this portion
+            const asciiId = Array.from(idData)
+                .filter(b => b >= 32 && b <= 126) // Keep only printable ASCII
+                .map(b => String.fromCharCode(b))
+                .join('');
+            switch (asciiId) {
+                case 'vorbis': // Ogg/Vorbis
+                    debug(`Set Ogg stream serial ${header.streamSerialNumber}, codec=Vorbis`);
+                    this.pageConsumer = new VorbisStream(this.metadata, this.options);
+                    break;
+                case 'OpusHea': // Ogg/Opus
+                    debug('Set page consumer to Ogg/Opus');
+                    this.pageConsumer = new OpusStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'Speex  ': // Ogg/Speex
+                    debug('Set page consumer to Ogg/Speex');
+                    this.pageConsumer = new SpeexStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'fishead':
+                case 'theora': // Ogg/Theora
+                    debug('Set page consumer to Ogg/Theora');
+                    this.pageConsumer = new TheoraStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'FLAC': // Ogg/Theora
+                    debug('Set page consumer to Vorbis');
+                    this.pageConsumer = new FlacStream(this.metadata, this.options, tokenizer);
+                    break;
+                default:
+                    throw new OggContentError(`Ogg codec not recognized (id=${asciiId}`);
+            }
+        }
+        if (header.headerType.lastPage) {
+            this.closed = true;
+        }
+        if (this.pageConsumer) {
+            await this.pageConsumer.parsePage(header, pageData);
+        }
+        else
+            throw new Error('pageConsumer should be initialized');
     }
 }
 /**
@@ -36,98 +75,47 @@ export class SegmentTable {
 export class OggParser extends BasicParser {
     constructor() {
         super(...arguments);
-        this.header = null;
-        this.pageNumber = 0;
-        this.pageConsumer = null;
+        this.streams = new Map();
     }
     /**
      * Parse page
      * @returns {Promise<void>}
      */
     async parse() {
+        this.streams = new Map();
         debug('pos=%s, parsePage()', this.tokenizer.position);
+        let header;
         try {
-            let header;
             do {
-                header = await this.tokenizer.readToken(OggParser.Header);
+                header = await this.tokenizer.readToken(PageHeader);
                 if (header.capturePattern !== 'OggS')
                     throw new OggContentError('Invalid Ogg capture pattern');
                 this.metadata.setFormat('container', 'Ogg');
-                this.header = header;
-                this.pageNumber = header.pageSequenceNo;
-                debug('page#=%s, Ogg.id=%s', header.pageSequenceNo, header.capturePattern);
-                const segmentTable = await this.tokenizer.readToken(new SegmentTable(header));
-                debug('totalPageSize=%s', segmentTable.totalPageSize);
-                const pageData = await this.tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
-                debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
-                if (header.headerType.firstPage) {
-                    const id = new TextDecoder('ascii').decode(pageData.subarray(0, 7));
-                    switch (id) {
-                        case '\x01vorbis': // Ogg/Vorbis
-                            debug('Set page consumer to Ogg/Vorbis');
-                            this.pageConsumer = new VorbisParser(this.metadata, this.options);
-                            break;
-                        case 'OpusHea': // Ogg/Opus
-                            debug('Set page consumer to Ogg/Opus');
-                            this.pageConsumer = new OpusParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        case 'Speex  ': // Ogg/Speex
-                            debug('Set page consumer to Ogg/Speex');
-                            this.pageConsumer = new SpeexParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        case 'fishead':
-                        case '\x00theora': // Ogg/Theora
-                            debug('Set page consumer to Ogg/Theora');
-                            this.pageConsumer = new TheoraParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        default:
-                            throw new OggContentError(`gg audio-codec not recognized (id=${id})`);
-                    }
+                let stream = this.streams.get(header.streamSerialNumber);
+                if (!stream) {
+                    stream = new OggStream(this.metadata, header.streamSerialNumber, this.options);
+                    this.streams.set(header.streamSerialNumber, stream);
                 }
-                await this.pageConsumer.parsePage(header, pageData);
-            } while (!header.headerType.lastPage);
+                await stream.parsePage(this.tokenizer, header);
+            } while (![...this.streams.values()].every(item => item.closed));
         }
         catch (err) {
-            if (err instanceof Error) {
-                if (err instanceof EndOfStreamError) {
-                    this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
-                    debug("End-of-stream");
-                    this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
-                    if (this.header) {
-                        this.pageConsumer.calculateDuration(this.header);
-                    }
-                }
-                else if (err.message.startsWith('FourCC')) {
-                    if (this.pageNumber > 0) {
-                        // ignore this error: work-around if last OGG-page is not marked with last-page flag
-                        this.metadata.addWarning('Invalid FourCC ID, maybe last OGG-page is not marked with last-page flag');
-                        await this.pageConsumer.flush();
-                    }
-                }
+            if (err instanceof EndOfStreamError) {
+                debug("Reached end-of-stream");
+            }
+            else if (err instanceof OggContentError) {
+                this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
             }
             else
                 throw err;
         }
+        for (const stream of this.streams.values()) {
+            if (!stream.closed) {
+                this.metadata.addWarning(`End-of-stream reached before reaching last page in Ogg stream serial=${stream.streamSerial}`);
+                await stream.pageConsumer?.flush();
+            }
+            stream.pageConsumer?.calculateDuration();
+        }
     }
 }
-OggParser.Header = {
-    len: 27,
-    get: (buf, off) => {
-        return {
-            capturePattern: FourCcToken.get(buf, off),
-            version: Token.UINT8.get(buf, off + 4),
-            headerType: {
-                continued: util.getBit(buf, off + 5, 0),
-                firstPage: util.getBit(buf, off + 5, 1),
-                lastPage: util.getBit(buf, off + 5, 2)
-            },
-            // packet_flag: Token.UINT8.get(buf, off + 5),
-            absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
-            streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
-            pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),
-            pageChecksum: Token.UINT32_LE.get(buf, off + 22),
-            page_segments: Token.UINT8.get(buf, off + 26)
-        };
-    }
-};
 //# sourceMappingURL=OggParser.js.map

package/lib/ogg/{Ogg.d.ts → OggToken.d.ts}

@@ -1,3 +1,4 @@
+import type { IGetToken } from 'strtok3';
 /**
  * Page header
  * Ref: https://www.xiph.org/ogg/doc/framing.html#page_header
@@ -50,21 +51,27 @@ export interface IPageHeader {
      */
     page_segments: number;
 }
+export declare const PageHeader: IGetToken<IPageHeader>;
 export interface ISegmentTable {
     totalPageSize: number;
 }
+export declare class SegmentTable implements IGetToken<ISegmentTable> {
+    private static sum;
+    len: number;
+    constructor(header: IPageHeader);
+    get(buf: Uint8Array, off: number): ISegmentTable;
+}
 export interface IPageConsumer {
     /**
      * Parse Ogg page
-     * @param {IPageHeader} header Ogg page header
-     * @param {Buffer} pageData Ogg page data
+     * @param header Ogg page header
+     * @param pageData Ogg page data
      */
     parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
     /**
      * Calculate duration of provided header
-     * @param header Ogg header
      */
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Force to parse pending segments
      */

package/lib/ogg/OggToken.js

@@ -0,0 +1,42 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import { StringType } from 'token-types';
+export const PageHeader = {
+    len: 27,
+    get: (buf, off) => {
+        return {
+            capturePattern: new StringType(4, 'latin1').get(buf, off),
+            version: Token.UINT8.get(buf, off + 4),
+            headerType: {
+                continued: util.getBit(buf, off + 5, 0),
+                firstPage: util.getBit(buf, off + 5, 1),
+                lastPage: util.getBit(buf, off + 5, 2)
+            },
+            // packet_flag: Token.UINT8.get(buf, off + 5),
+            absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
+            streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
+            pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),
+            pageChecksum: Token.UINT32_LE.get(buf, off + 22),
+            page_segments: Token.UINT8.get(buf, off + 26)
+        };
+    }
+};
+export class SegmentTable {
+    static sum(buf, off, len) {
+        const dv = new DataView(buf.buffer, 0);
+        let s = 0;
+        for (let i = off; i < off + len; ++i) {
+            s += dv.getUint8(i);
+        }
+        return s;
+    }
+    constructor(header) {
+        this.len = header.page_segments;
+    }
+    get(buf, off) {
+        return {
+            totalPageSize: SegmentTable.sum(buf, off, this.len)
+        };
+    }
+}
+//# sourceMappingURL=OggToken.js.map

package/lib/ogg/flac/FlacStream.d.ts

@@ -0,0 +1,28 @@
+import type { ITokenizer } from 'strtok3';
+import type * as Ogg from '../OggToken.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Ref:
+ * - https://xiph.org/flac/ogg_mapping.html
+ */
+export declare class FlacStream implements Ogg.IPageConsumer {
+    private metadata;
+    private options;
+    private tokenizer;
+    private flacParser;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    calculateDuration(): void;
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    private parseDataBlock;
+    flush(): Promise<void>;
+}

package/lib/ogg/flac/FlacStream.js

@@ -0,0 +1,74 @@
+import initDebug from 'debug';
+import * as Flac from '../../flac/FlacToken.js';
+import { FlacParser } from '../../flac/FlacParser.js';
+import { FourCcToken } from '../../common/FourCC.js';
+import { VorbisPictureToken } from '../vorbis/Vorbis.js';
+const debug = initDebug('music-metadata:parser:ogg:theora');
+/**
+ * Ref:
+ * - https://xiph.org/flac/ogg_mapping.html
+ */
+export class FlacStream {
+    constructor(metadata, options, tokenizer) {
+        this.metadata = metadata;
+        this.options = options;
+        this.tokenizer = tokenizer;
+        this.flacParser = new FlacParser(this.metadata, this.tokenizer, options);
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    async parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            await this.parseFirstPage(header, pageData);
+        }
+    }
+    calculateDuration() {
+        debug('duration calculation not implemented');
+    }
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    async parseFirstPage(_header, pageData) {
+        debug('First Ogg/FLAC page');
+        const fourCC = await FourCcToken.get(pageData, 9);
+        if (fourCC.toString() !== 'fLaC') {
+            throw new Error('Invalid FLAC preamble');
+        }
+        const blockHeader = await Flac.BlockHeader.get(pageData, 13);
+        await this.parseDataBlock(blockHeader, pageData.subarray(13 + Flac.BlockHeader.len));
+    }
+    async parseDataBlock(blockHeader, pageData) {
+        debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
+        switch (blockHeader.type) {
+            case Flac.BlockType.STREAMINFO: {
+                const streamInfo = Flac.BlockStreamInfo.get(pageData, 0);
+                return this.flacParser.processsStreamInfo(streamInfo);
+            }
+            case Flac.BlockType.PADDING:
+                break;
+            case Flac.BlockType.APPLICATION:
+                break;
+            case Flac.BlockType.SEEKTABLE:
+                break;
+            case Flac.BlockType.VORBIS_COMMENT:
+                return this.flacParser.parseComment(pageData);
+            case Flac.BlockType.PICTURE:
+                if (!this.options.skipCovers) {
+                    const picture = new VorbisPictureToken(pageData.length).get(pageData, 0);
+                    return this.flacParser.addPictureTag(picture);
+                }
+                break;
+            default:
+                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+        }
+        // Ignore data block
+        return this.tokenizer.ignore(blockHeader.length).then();
+    }
+    flush() {
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=FlacStream.js.map

package/lib/ogg/opus/{OpusParser.d.ts → OpusStream.d.ts}

@@ -1,14 +1,14 @@
 import type { ITokenizer } from 'strtok3';
-import type { IPageHeader } from '../Ogg.js';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
- * Used by OggParser
+ * Used by OggStream
  */
-export declare class OpusParser extends VorbisParser {
+export declare class OpusStream extends VorbisStream {
     private idHeader;
     private lastPos;
     private tokenizer;
@@ -20,5 +20,5 @@ export declare class OpusParser extends VorbisParser {
      */
     protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
 }

package/lib/ogg/opus/{OpusParser.js → OpusStream.js}

@@ -1,13 +1,13 @@
 import * as Token from 'token-types';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import * as Opus from './Opus.js';
 import { OpusContentError } from './Opus.js';
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
- * Used by OggParser
+ * Used by OggStream
  */
-export class OpusParser extends VorbisParser {
+export class OpusStream extends VorbisStream {
     constructor(metadata, options, tokenizer) {
         super(metadata, options);
         this.idHeader = null;
@@ -40,10 +40,10 @@ export class OpusParser extends VorbisParser {
                 break;
         }
     }
-    calculateDuration(header) {
-        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+    calculateDuration() {
+        if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
-            const pos_48bit = header.absoluteGranulePosition - this.idHeader.preSkip;
+            const pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
             this.metadata.setFormat('numberOfSamples', pos_48bit);
             this.metadata.setFormat('duration', pos_48bit / 48000);
             if (this.lastPos !== -1 && this.tokenizer.fileInfo.size && this.metadata.format.duration) {
@@ -53,4 +53,4 @@ export class OpusParser extends VorbisParser {
         }
     }
 }
-//# sourceMappingURL=OpusParser.js.map
+//# sourceMappingURL=OpusStream.js.map

package/lib/ogg/speex/{SpeexParser.d.ts → SpeexStream.d.ts}

@@ -1,6 +1,6 @@
 import type { ITokenizer } from 'strtok3';
-import type { IPageHeader } from '../Ogg.js';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
@@ -9,7 +9,7 @@ import type { INativeMetadataCollector } from '../../common/MetadataCollector.js
  * - https://www.speex.org/docs/manual/speex-manual/
  * - https://tools.ietf.org/html/rfc5574
  */
-export declare class SpeexParser extends VorbisParser {
+export declare class SpeexStream extends VorbisStream {
     private tokenizer;
     constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
     /**

package/lib/ogg/speex/{SpeexParser.js → SpeexStream.js}

@@ -1,5 +1,5 @@
 import initDebug from 'debug';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import * as Speex from './Speex.js';
 const debug = initDebug('music-metadata:parser:ogg:speex');
 /**
@@ -8,7 +8,7 @@ const debug = initDebug('music-metadata:parser:ogg:speex');
  * - https://www.speex.org/docs/manual/speex-manual/
  * - https://tools.ietf.org/html/rfc5574
  */
-export class SpeexParser extends VorbisParser {
+export class SpeexStream extends VorbisStream {
     constructor(metadata, options, tokenizer) {
         super(metadata, options);
         this.tokenizer = tokenizer;
@@ -30,4 +30,4 @@ export class SpeexParser extends VorbisParser {
         this.metadata.setAudioOnly();
     }
 }
-//# sourceMappingURL=SpeexParser.js.map
+//# sourceMappingURL=SpeexStream.js.map

package/lib/ogg/theora/{TheoraParser.d.ts → TheoraStream.d.ts}

@@ -1,12 +1,12 @@
 import type { ITokenizer } from 'strtok3';
-import type * as Ogg from '../Ogg.js';
+import type * as Ogg from '../OggToken.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
  * Ref:
  * - https://theora.org/doc/Theora.pdf
  */
-export declare class TheoraParser implements Ogg.IPageConsumer {
+export declare class TheoraStream implements Ogg.IPageConsumer {
     private metadata;
     private tokenizer;
     constructor(metadata: INativeMetadataCollector, _options: IOptions, tokenizer: ITokenizer);
@@ -16,10 +16,10 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      * @param pageData Page data
      */
     parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
-    flush(): Promise<void>;
-    calculateDuration(_header: Ogg.IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Parse first Theora Ogg page. the initial identification header packet
      */
     protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    flush(): Promise<void>;
 }

package/lib/ogg/theora/{TheoraParser.js → TheoraStream.js}

@@ -5,7 +5,7 @@ const debug = initDebug('music-metadata:parser:ogg:theora');
  * Ref:
  * - https://theora.org/doc/Theora.pdf
  */
-export class TheoraParser {
+export class TheoraStream {
     constructor(metadata, _options, tokenizer) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
@@ -20,10 +20,7 @@ export class TheoraParser {
             await this.parseFirstPage(header, pageData);
         }
     }
-    async flush() {
-        debug('flush');
-    }
-    calculateDuration(_header) {
+    calculateDuration() {
         debug('duration calculation not implemented');
     }
     /**
@@ -34,7 +31,10 @@ export class TheoraParser {
         this.metadata.setFormat('codec', 'Theora');
         const idHeader = IdentificationHeader.get(pageData, 0);
         this.metadata.setFormat('bitrate', idHeader.nombr);
-        this.metadata.setAudioOnly();
+        this.metadata.setFormat('hasVideo', true);
+    }
+    flush() {
+        return Promise.resolve();
     }
 }
-//# sourceMappingURL=TheoraParser.js.map
+//# sourceMappingURL=TheoraStream.js.map

package/lib/ogg/vorbis/{VorbisParser.d.ts → VorbisStream.d.ts}

@@ -1,5 +1,5 @@
 import { type IVorbisPicture } from './Vorbis.js';
-import type { IPageConsumer, IPageHeader } from '../Ogg.js';
+import type { IPageConsumer, IPageHeader } from '../OggToken.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 declare const VorbisContentError_base: {
@@ -18,12 +18,13 @@ export declare class VorbisContentError extends VorbisContentError_base {
 }
 /**
  * Vorbis 1 Parser.
- * Used by OggParser
+ * Used by OggStream
  */
-export declare class VorbisParser implements IPageConsumer {
+export declare class VorbisStream implements IPageConsumer {
     private pageSegments;
     protected metadata: INativeMetadataCollector;
     protected options: IOptions;
+    protected lastPageHeader?: IPageHeader;
     constructor(metadata: INativeMetadataCollector, options: IOptions);
     /**
      * Vorbis 1 parser
@@ -35,10 +36,10 @@ export declare class VorbisParser implements IPageConsumer {
     flush(): Promise<void>;
     parseUserComment(pageData: Uint8Array, offset: number): Promise<number>;
     addTag(id: string, value: string | IVorbisPicture): Promise<void>;
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Parse first Ogg/Vorbis page
-     * @param header
+     * @param _header
      * @param pageData
      */
     protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;

package/lib/ogg/vorbis/{VorbisParser.js → VorbisStream.js}

@@ -8,9 +8,9 @@ export class VorbisContentError extends makeUnexpectedFileContentError('Vorbis')
 }
 /**
  * Vorbis 1 Parser.
- * Used by OggParser
+ * Used by OggStream
  */
-export class VorbisParser {
+export class VorbisStream {
     constructor(metadata, options) {
         this.pageSegments = [];
         this.metadata = metadata;
@@ -22,6 +22,7 @@ export class VorbisParser {
      * @param pageData Page data
      */
     async parsePage(header, pageData) {
+        this.lastPageHeader = header;
         if (header.headerType.firstPage) {
             this.parseFirstPage(header, pageData);
         }
@@ -35,16 +36,13 @@ export class VorbisParser {
             if (header.headerType.lastPage || !header.headerType.continued) {
                 // Flush page segments
                 if (this.pageSegments.length > 0) {
-                    const fullPage = VorbisParser.mergeUint8Arrays(this.pageSegments);
+                    const fullPage = VorbisStream.mergeUint8Arrays(this.pageSegments);
                     await this.parseFullPage(fullPage);
                 }
                 // Reset page segments
                 this.pageSegments = header.headerType.lastPage ? [] : [pageData];
             }
         }
-        if (header.headerType.lastPage) {
-            this.calculateDuration(header);
-        }
     }
     static mergeUint8Arrays(arrays) {
         const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
@@ -56,7 +54,7 @@ export class VorbisParser {
         return merged;
     }
     async flush() {
-        await this.parseFullPage(VorbisParser.mergeUint8Arrays(this.pageSegments));
+        await this.parseFullPage(VorbisStream.mergeUint8Arrays(this.pageSegments));
     }
     async parseUserComment(pageData, offset) {
         const decoder = new VorbisDecoder(pageData, offset);
@@ -78,21 +76,21 @@ export class VorbisParser {
         }
         await this.metadata.addTag('vorbis', id, value);
     }
-    calculateDuration(header) {
-        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+    calculateDuration() {
+        if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
-            this.metadata.setFormat('numberOfSamples', header.absoluteGranulePosition);
-            this.metadata.setFormat('duration', header.absoluteGranulePosition / this.metadata.format.sampleRate);
+            this.metadata.setFormat('numberOfSamples', this.lastPageHeader.absoluteGranulePosition);
+            this.metadata.setFormat('duration', this.lastPageHeader.absoluteGranulePosition / this.metadata.format.sampleRate);
         }
     }
     /**
      * Parse first Ogg/Vorbis page
-     * @param header
+     * @param _header
      * @param pageData
      */
     parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Vorbis I');
-        this.metadata.setAudioOnly();
+        this.metadata.setFormat('hasAudio', true);
         debug('Parse first page');
         // Parse  Vorbis common header
         const commonHeader = CommonHeader.get(pageData, 0);
@@ -135,4 +133,4 @@ export class VorbisParser {
         }
     }
 }
-//# sourceMappingURL=VorbisParser.js.map
+//# sourceMappingURL=VorbisStream.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "11.5.0",
+  "version": "11.6.1",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -98,6 +98,7 @@
     "lint": "yarn run lint:ts && yarn run lint:md",
     "test": "mocha",
     "build": "yarn run clean && yarn compile && yarn run doc-gen",
+    "prepublishOnly": "yarn run build",
     "test-coverage": "c8 yarn run test",
     "send-codacy": "c8 report --reporter=text-lcov | codacy-coverage",
     "doc-gen": "yarn node doc-gen/gen.js",

package/lib/ogg/Ogg.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Ogg.js.map