music-metadata 11.6.0 → 11.7.0

package/lib/core.js

@@ -1,7 +1,7 @@
 /**
  * Primary entry point, Node.js specific entry point is MusepackParser.ts
  */
-import { fromWebStream, fromBuffer } from 'strtok3';
+import { fromWebStream, fromBuffer, fromBlob } from 'strtok3';
 import { ParserFactory } from './ParserFactory.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
 import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
@@ -17,11 +17,13 @@ export * from './ParseError.js';
  * @returns Metadata
  */
 export async function parseBlob(blob, options = {}) {
-    const fileInfo = { mimeType: blob.type, size: blob.size };
-    if (blob instanceof File) {
-        fileInfo.path = blob.name;
+    const tokenizer = fromBlob(blob);
+    try {
+        return await parseFromTokenizer(tokenizer, options);
+    }
+    finally {
+        await tokenizer.close();
     }
-    return parseWebStream(blob.stream(), fileInfo, options);
 }
 /**
  * Parse audio from Web Stream.Readable

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,28 +1,15 @@
-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 { 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);
@@ -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.js

@@ -8,6 +8,7 @@ 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');
@@ -28,15 +29,12 @@ class OggStream {
         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
-            switch (idData[0]) {
-                case 0x01:
-                case 0x80:
-                    idData[0] = 0x5F; // underscore
-                    break;
-            }
-            const id = new TextDecoder('latin1').decode(idData);
-            switch (id) {
-                case '_vorbis': // Ogg/Vorbis
+            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;
@@ -49,12 +47,16 @@ class OggStream {
                     this.pageConsumer = new SpeexStream(this.metadata, this.options, tokenizer);
                     break;
                 case 'fishead':
-                case '_theora': // Ogg/Theora
+                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=${id})`);
+                    throw new OggContentError(`Ogg codec not recognized (id=${asciiId}`);
             }
         }
         if (header.headerType.lastPage) {

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/vorbis/VorbisStream.d.ts

@@ -39,7 +39,7 @@ export declare class VorbisStream implements IPageConsumer {
     calculateDuration(): void;
     /**
      * Parse first Ogg/Vorbis page
-     * @param header
+     * @param _header
      * @param pageData
      */
     protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;

package/lib/ogg/vorbis/VorbisStream.js

@@ -85,7 +85,7 @@ export class VorbisStream {
     }
     /**
      * Parse first Ogg/Vorbis page
-     * @param header
+     * @param _header
      * @param pageData
      */
     parseFirstPage(_header, pageData) {