music-metadata 11.4.0 → 11.5.0

package/lib/ParserFactory.d.ts

@@ -1,6 +1,6 @@
 import { type MediaType } from 'media-typer';
 import { type INativeMetadataCollector } from './common/MetadataCollector.js';
-import type { IAudioMetadata, IOptions, ParserType } from './type.js';
+import { type IAudioMetadata, type IOptions, type ParserType } from './type.js';
 import type { ITokenizer } from 'strtok3';
 export interface IParserLoader {
     /**

package/lib/ParserFactory.js

@@ -3,6 +3,7 @@ import ContentType from 'content-type';
 import { parse as mimeTypeParse } from 'media-typer';
 import initDebug from 'debug';
 import { MetadataCollector } from './common/MetadataCollector.js';
+import { TrackType } from './type.js';
 import { mpegParserLoader } from './mpeg/MpegLoader.js';
 import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
 import { apeParserLoader } from './apev2/Apev2Loader.js';
@@ -89,6 +90,14 @@ export class ParserFactory {
         const parser = new ParserImpl(metadata, tokenizer, opts ?? {});
         debug(`Parser ${parserLoader.parserType} loaded`);
         await parser.parse();
+        if (metadata.format.trackInfo) {
+            if (metadata.format.hasAudio === undefined) {
+                metadata.setFormat('hasAudio', !!metadata.format.trackInfo.find(track => track.type === TrackType.audio));
+            }
+            if (metadata.format.hasVideo === undefined) {
+                metadata.setFormat('hasVideo', !!metadata.format.trackInfo.find(track => track.type === TrackType.video));
+            }
+        }
         return metadata.toCommonMetadata();
     }
     /**

package/lib/aiff/AiffParser.js

@@ -38,6 +38,7 @@ export class AIFFParser extends BasicParser {
                 throw new AiffContentError(`Unsupported AIFF type: ${type}`);
         }
         this.metadata.setFormat('lossless', !this.isCompressed);
+        this.metadata.setAudioOnly();
         try {
             while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
                 debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);

package/lib/apev2/APEv2Parser.js

@@ -96,6 +96,7 @@ export class APEv2Parser extends BasicParser {
         this.ape.descriptor = descriptor;
         const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
         const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
+        this.metadata.setAudioOnly();
         await this.tokenizer.ignore(header.forwardBytes);
         return this.tryParseApeHeader();
     }

package/lib/common/MetadataCollector.d.ts

@@ -24,6 +24,7 @@ export interface INativeMetadataCollector extends IWarningCollector {
     setFormat(key: FormatId, value: AnyTagValue): void;
     addTag(tagType: TagType, tagId: string, value: AnyTagValue): Promise<void>;
     addStreamInfo(streamInfo: ITrackInfo): void;
+    setAudioOnly(): void;
 }
 /**
  * Provided to the parser to uodate the metadata result.
@@ -51,6 +52,7 @@ export declare class MetadataCollector implements INativeMetadataCollector {
     hasAny(): boolean;
     addStreamInfo(streamInfo: ITrackInfo): void;
     setFormat(key: FormatId, value: AnyTagValue): void;
+    setAudioOnly(): void;
     addTag(tagType: TagType, tagId: string, value: AnyTagValue): Promise<void>;
     addWarning(warning: string): void;
     postMap(tagType: TagType | 'artificial', tag: IGenericTag): Promise<void>;

package/lib/common/MetadataCollector.js

@@ -1,4 +1,4 @@
-import { TrackTypeValueToKeyMap } from '../type.js';
+import { TrackTypeValueToKeyMap, } from '../type.js';
 import initDebug from 'debug';
 import { isSingleton, isUnique } from './GenericTagTypes.js';
 import { CombinedTagMapper } from './CombinedTagMapper.js';
@@ -61,6 +61,10 @@ export class MetadataCollector {
             this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
         }
     }
+    setAudioOnly() {
+        this.setFormat('hasAudio', true);
+        this.setFormat('hasVideo', false);
+    }
     async addTag(tagType, tagId, value) {
         debug(`tag ${tagType}.${tagId} = ${value}`);
         if (!this.native[tagType]) {

package/lib/core.js

@@ -69,10 +69,7 @@ export function parseFromTokenizer(tokenizer, options) {
 export function orderTags(nativeTags) {
     const tags = {};
     for (const { id, value } of nativeTags) {
-        if (!tags[id]) {
-            tags[id] = [];
-        }
-        tags[id].push(value);
+        (tags[id] || (tags[id] = [])).push(value);
     }
     return tags;
 }

package/lib/dsdiff/DsdiffParser.js

@@ -20,6 +20,7 @@ export class DsdiffParser extends BasicParser {
         const header = await this.tokenizer.readToken(ChunkHeader64);
         if (header.chunkID !== 'FRM8')
             throw new DsdiffContentParseError('Unexpected chunk-ID');
+        this.metadata.setAudioOnly();
         const type = (await this.tokenizer.readToken(FourCcToken)).trim();
         switch (type) {
             case 'DSD':

package/lib/dsf/DsfParser.js

@@ -18,6 +18,7 @@ export class DsfParser extends AbstractID3Parser {
             throw new DsdContentParseError('Invalid chunk signature');
         this.metadata.setFormat('container', 'DSF');
         this.metadata.setFormat('lossless', true);
+        this.metadata.setAudioOnly();
         const dsdChunk = await this.tokenizer.readToken(DsdChunk);
         if (dsdChunk.metadataPointer === BigInt(0)) {
             debug("No ID3v2 tag present");

package/lib/flac/FlacParser.js

@@ -34,6 +34,7 @@ export class FlacParser extends AbstractID3Parser {
         if (fourCC.toString() !== 'fLaC') {
             throw new FlacContentError('Invalid FLAC preamble');
         }
+        this.metadata.setAudioOnly();
         let blockHeader;
         do {
             // Read block header

package/lib/mp4/Atom.js

@@ -43,7 +43,6 @@ export class Atom {
             // "Container" atoms, contains nested atoms
             case 'moov': // The Movie Atom: contains other atoms
             case 'udta': // User defined atom
-            case 'trak':
             case 'mdia': // Media atom
             case 'minf': // Media Information Atom
             case 'stbl': // The Sample Table Atom

package/lib/mp4/AtomToken.d.ts

@@ -121,7 +121,6 @@ export declare const Header: IToken<IAtomHeader>;
  */
 export declare const ExtendedSize: IToken<bigint>;
 export declare const ftyp: IGetToken<IAtomFtyp>;
-export declare const tkhd: IGetToken<IAtomFtyp>;
 /**
  * Token: Movie Header Atom
  */
@@ -269,7 +268,7 @@ export interface ITrackHeaderAtom extends IVersionAndFlags {
     volume: number;
 }
 /**
- * Track Header Atoms structure
+ * Track Header Atoms structure (`tkhd`)
  * Ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25550
  */
 export declare class TrackHeaderAtom implements IGetToken<ITrackHeaderAtom> {
@@ -462,4 +461,27 @@ export declare class TrackRunBox implements IGetToken<ITrackRunBox> {
     constructor(len: number);
     get(buf: Uint8Array, off: number): ITrackRunBox;
 }
+export interface IHandlerBox {
+    version: number;
+    flags: number;
+    componentType: string;
+    handlerType: string;
+    componentName: string;
+}
+/**
+ * HandlerBox (`hdlr`)
+ */
+export declare class HandlerBox implements IGetToken<IHandlerBox> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): IHandlerBox;
+}
+/**
+ * Chapter Track Reference Box (`chap`)
+ */
+export declare class ChapterTrackReferenceBox implements IGetToken<number[]> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): number[];
+}
 export {};

package/lib/mp4/AtomToken.js

@@ -34,14 +34,6 @@ export const ftyp = {
         };
     }
 };
-export const tkhd = {
-    len: 4,
-    get: (buf, off) => {
-        return {
-            type: new Token.StringType(4, 'ascii').get(buf, off)
-        };
-    }
-};
 /**
  * Token: Movie Header Atom
  */
@@ -174,7 +166,7 @@ export class NameAtom {
     }
 }
 /**
- * Track Header Atoms structure
+ * Track Header Atoms structure (`tkhd`)
  * Ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25550
  */
 export class TrackHeaderAtom {
@@ -494,4 +486,40 @@ export class TrackRunBox {
         return trun;
     }
 }
+/**
+ * HandlerBox (`hdlr`)
+ */
+export class HandlerBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        const _flagOffset = off + 1;
+        const charTypeToken = new Token.StringType(4, 'utf-8');
+        return {
+            version: Token.INT8.get(buf, off),
+            flags: Token.UINT24_BE.get(buf, off + 1),
+            componentType: charTypeToken.get(buf, off + 4),
+            handlerType: charTypeToken.get(buf, off + 8),
+            componentName: new Token.StringType(this.len - 28, 'utf-8').get(buf, off + 28),
+        };
+    }
+}
+/**
+ * Chapter Track Reference Box (`chap`)
+ */
+export class ChapterTrackReferenceBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        let dynOffset = 0;
+        const trackIds = [];
+        while (dynOffset < this.len) {
+            trackIds.push(Token.UINT32_BE.get(buf, off + dynOffset));
+            dynOffset += 4;
+        }
+        return trackIds;
+    }
+}
 //# sourceMappingURL=AtomToken.js.map

package/lib/mp4/MP4Parser.d.ts

@@ -4,7 +4,8 @@ export declare class MP4Parser extends BasicParser {
     private static read_BE_Integer;
     private audioLengthInBytes;
     private tracks;
-    private getTrackById;
+    private hasVideoTrack;
+    private hasAudioTrack;
     parse(): Promise<void>;
     handleAtom(atom: Atom, remaining: number): Promise<void>;
     private getTrackDescription;
@@ -18,6 +19,7 @@ export declare class MP4Parser extends BasicParser {
      */
     private parseMetadataItemData;
     private parseValueAtom;
+    private parseTrackBox;
     private parseTrackFragmentBox;
     private atomParsers;
     /**

package/lib/mp4/MP4Parser.js

@@ -4,7 +4,7 @@ import { BasicParser } from '../common/BasicParser.js';
 import { Genres } from '../id3v1/ID3v1Parser.js';
 import { Atom } from './Atom.js';
 import * as AtomToken from './AtomToken.js';
-import { Mp4ContentError } from './AtomToken.js';
+import { ChapterTrackReferenceBox, Mp4ContentError, } from './AtomToken.js';
 import { TrackType } from '../type.js';
 import { uint8ArrayToHex, uint8ArrayToString } from 'uint8array-extras';
 const debug = initDebug('music-metadata:parser:MP4');
@@ -92,7 +92,9 @@ function distinct(value, index, self) {
 export class MP4Parser extends BasicParser {
     constructor() {
         super(...arguments);
-        this.tracks = [];
+        this.tracks = new Map();
+        this.hasVideoTrack = false;
+        this.hasAudioTrack = true;
         this.atomParsers = {
             /**
              * Parse movie header (mvhd) atom
@@ -103,19 +105,6 @@ export class MP4Parser extends BasicParser {
                 this.metadata.setFormat('creationTime', mvhd.creationTime);
                 this.metadata.setFormat('modificationTime', mvhd.modificationTime);
             },
-            /**
-             * Parse media header (mdhd) atom
-             * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25615
-             */
-            mdhd: async (len) => {
-                const mdhd_data = await this.tokenizer.readToken(new AtomToken.MdhdAtom(len));
-                // this.parse_mxhd(mdhd_data, this.currentTrack);
-                const td = this.getTrackDescription();
-                td.creationTime = mdhd_data.creationTime;
-                td.modificationTime = mdhd_data.modificationTime;
-                td.timeScale = mdhd_data.timeScale;
-                td.duration = mdhd_data.duration;
-            },
             chap: async (len) => {
                 const td = this.getTrackDescription();
                 const trackIds = [];
@@ -125,11 +114,6 @@ export class MP4Parser extends BasicParser {
                 }
                 td.chapterList = trackIds;
             },
-            tkhd: async (len) => {
-                const track = (await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(len)));
-                track.fragments = [];
-                this.tracks.push(track);
-            },
             /**
              * Parse mdat atom.
              * Will scan for chapters
@@ -138,10 +122,10 @@ export class MP4Parser extends BasicParser {
                 this.audioLengthInBytes = len;
                 this.calculateBitRate();
                 if (this.options.includeChapters) {
-                    const trackWithChapters = this.tracks.filter(track => track.chapterList);
+                    const trackWithChapters = [...this.tracks.values()].filter(track => track.chapterList);
                     if (trackWithChapters.length === 1) {
                         const chapterTrackIds = trackWithChapters[0].chapterList;
-                        const chapterTracks = this.tracks.filter(track => chapterTrackIds.indexOf(track.trackId) !== -1);
+                        const chapterTracks = [...this.tracks.values()].filter(track => chapterTrackIds.indexOf(track.header.trackId) !== -1);
                         if (chapterTracks.length === 1) {
                             return this.parseChapterTrack(chapterTracks[0], trackWithChapters[0], len);
                         }
@@ -171,20 +155,6 @@ export class MP4Parser extends BasicParser {
                 const trackDescription = this.getTrackDescription();
                 trackDescription.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
             },
-            /**
-             * sample-to-Chunk Atoms
-             */
-            stsc: async (len) => {
-                const stsc = await this.tokenizer.readToken(new AtomToken.StscAtom(len));
-                this.getTrackDescription().sampleToChunkTable = stsc.entries;
-            },
-            /**
-             * time-to-sample table
-             */
-            stts: async (len) => {
-                const stts = await this.tokenizer.readToken(new AtomToken.SttsAtom(len));
-                this.getTrackDescription().timeToSampleTable = stts.entries;
-            },
             /**
              * Parse sample-sizes atom ('stsz')
              */
@@ -194,13 +164,6 @@ export class MP4Parser extends BasicParser {
                 td.sampleSize = stsz.sampleSize;
                 td.sampleSizeTable = stsz.entries;
             },
-            /**
-             * Parse chunk-offset atom ('stco')
-             */
-            stco: async (len) => {
-                const stco = await this.tokenizer.readToken(new AtomToken.StcoAtom(len));
-                this.getTrackDescription().chunkOffsetTable = stco.entries; // remember chunk offsets
-            },
             date: async (len) => {
                 const date = await this.tokenizer.readToken(new Token.StringType(len, 'utf-8'));
                 await this.addTag('date', date);
@@ -215,11 +178,10 @@ export class MP4Parser extends BasicParser {
         }
         return Number(token.get(array, 0));
     }
-    getTrackById(trackId) {
-        return this.tracks.find(track => track.trackId === trackId);
-    }
     async parse() {
-        this.tracks = [];
+        this.hasVideoTrack = false;
+        this.hasAudioTrack = true;
+        this.tracks.clear();
         let remainingFileSize = this.tokenizer.fileInfo.size || 0;
         while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
             try {
@@ -278,15 +240,15 @@ export class MP4Parser extends BasicParser {
         if (formatList.length > 0) {
             this.metadata.setFormat('codec', formatList.filter(distinct).join('+'));
         }
-        const audioTracks = this.tracks.filter(track => {
+        const audioTracks = [...this.tracks.values()].filter(track => {
             return track.soundSampleDescription.length >= 1 && track.soundSampleDescription[0].description && track.soundSampleDescription[0].description.numAudioChannels > 0;
         });
         if (audioTracks.length >= 1) {
             const audioTrack = audioTracks[0];
-            if (audioTrack.timeScale > 0) {
-                if (audioTrack.duration > 0) {
+            if (audioTrack.media.header && audioTrack.media.header.timeScale > 0) {
+                if (audioTrack.media.header.duration > 0) {
                     debug('Using duration defined on audio track');
-                    const duration = audioTrack.duration / audioTrack.timeScale; // calculate duration in seconds
+                    const duration = audioTrack.media.header.duration / audioTrack.media.header.timeScale; // calculate duration in seconds
                     this.metadata.setFormat('duration', duration);
                 }
                 else if (audioTrack.fragments.length > 0) {
@@ -302,15 +264,15 @@ export class MP4Parser extends BasicParser {
                             totalTimeUnits += dur;
                         }
                     }
-                    this.metadata.setFormat('duration', totalTimeUnits / audioTrack.timeScale);
+                    this.metadata.setFormat('duration', totalTimeUnits / audioTrack.media.header.timeScale);
                 }
             }
             const ssd = audioTrack.soundSampleDescription[0];
-            if (ssd.description) {
+            if (ssd.description && audioTrack.media.header) {
                 this.metadata.setFormat('sampleRate', ssd.description.sampleRate);
                 this.metadata.setFormat('bitsPerSample', ssd.description.sampleSize);
                 this.metadata.setFormat('numberOfChannels', ssd.description.numAudioChannels);
-                if (audioTrack.timeScale === 0 && audioTrack.timeToSampleTable.length > 0) {
+                if (audioTrack.media.header.timeScale === 0 && audioTrack.timeToSampleTable.length > 0) {
                     const totalSampleSize = audioTrack.timeToSampleTable
                         .map(ttstEntry => ttstEntry.count * ttstEntry.duration)
                         .reduce((total, sampleSize) => total + sampleSize);
@@ -324,6 +286,8 @@ export class MP4Parser extends BasicParser {
             }
             this.calculateBitRate();
         }
+        this.metadata.setFormat('hasAudio', this.hasAudioTrack);
+        this.metadata.setFormat('hasVideo', this.hasVideoTrack);
     }
     async handleAtom(atom, remaining) {
         if (atom.parent) {
@@ -331,6 +295,12 @@ export class MP4Parser extends BasicParser {
                 case 'ilst':
                 case '<id>':
                     return this.parseMetadataItemData(atom);
+                case 'moov':
+                    switch (atom.header.name) {
+                        case 'trak':
+                            return this.parseTrackBox(atom);
+                    }
+                    break;
                 case 'moof':
                     switch (atom.header.name) {
                         case 'traf':
@@ -346,7 +316,9 @@ export class MP4Parser extends BasicParser {
         await this.tokenizer.ignore(remaining);
     }
     getTrackDescription() {
-        return this.tracks[this.tracks.length - 1];
+        // ToDo: pick the right track, not the last track!!!!
+        const tracks = [...this.tracks.values()];
+        return tracks[tracks.length - 1];
     }
     calculateBitRate() {
         if (this.audioLengthInBytes && this.metadata.format.duration) {
@@ -459,6 +431,82 @@ export class MP4Parser extends BasicParser {
                 this.addWarning(`atom key=${tagKey}, has unknown well-known-type (data-type): ${dataAtom.type.type}`);
         }
     }
+    async parseTrackBox(trakBox) {
+        // @ts-ignore
+        const track = {
+            media: {},
+            fragments: []
+        };
+        await trakBox.readAtoms(this.tokenizer, async (child, remaining) => {
+            const payLoadLength = child.getPayloadLength(remaining);
+            switch (child.header.name) {
+                case 'chap': {
+                    const chap = await this.tokenizer.readToken(new ChapterTrackReferenceBox(remaining));
+                    track.chapterList = chap;
+                    break;
+                }
+                case 'tkhd': // TrackHeaderBox
+                    track.header = await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(payLoadLength));
+                    break;
+                case 'hdlr': // TrackHeaderBox
+                    track.handler = await this.tokenizer.readToken(new AtomToken.HandlerBox(payLoadLength));
+                    switch (track.handler.handlerType) {
+                        case 'audi':
+                            debug('Contains audio track');
+                            this.hasAudioTrack = true;
+                            break;
+                        case 'vide':
+                            debug('Contains video track');
+                            this.hasVideoTrack = true;
+                            break;
+                    }
+                    break;
+                case 'mdhd': { // Parse media header (mdhd) box
+                    const mdhd_data = await this.tokenizer.readToken(new AtomToken.MdhdAtom(payLoadLength));
+                    track.media.header = mdhd_data;
+                    break;
+                }
+                case 'stco': {
+                    const stco = await this.tokenizer.readToken(new AtomToken.StcoAtom(payLoadLength));
+                    track.chunkOffsetTable = stco.entries; // remember chunk offsets
+                    break;
+                }
+                case 'stsc': { // sample-to-Chunk box
+                    const stsc = await this.tokenizer.readToken(new AtomToken.StscAtom(payLoadLength));
+                    track.sampleToChunkTable = stsc.entries;
+                    break;
+                }
+                case 'stsd': { // sample description box
+                    const stsd = await this.tokenizer.readToken(new AtomToken.StsdAtom(payLoadLength));
+                    track.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
+                    break;
+                }
+                case 'stts': { // time-to-sample table
+                    const stts = await this.tokenizer.readToken(new AtomToken.SttsAtom(payLoadLength));
+                    track.timeToSampleTable = stts.entries;
+                    break;
+                }
+                case 'stsz': {
+                    const stsz = await this.tokenizer.readToken(new AtomToken.StszAtom(payLoadLength));
+                    track.sampleSize = stsz.sampleSize;
+                    track.sampleSizeTable = stsz.entries;
+                    break;
+                }
+                case 'dinf':
+                case 'vmhd':
+                case 'smhd':
+                    debug(`Ignoring: ${child.header.name}`);
+                    await this.tokenizer.ignore(payLoadLength);
+                    break;
+                default: {
+                    debug(`Unexpected track box: ${child.header.name}`);
+                    await this.tokenizer.ignore(payLoadLength);
+                }
+            }
+        }, trakBox.getPayloadLength(0));
+        // Register track
+        this.tracks.set(track.header.trackId, track);
+    }
     parseTrackFragmentBox(trafBox) {
         let tfhd;
         return trafBox.readAtoms(this.tokenizer, async (child, remaining) => {
@@ -476,7 +524,7 @@ export class MP4Parser extends BasicParser {
                     const trackRunBox = new AtomToken.TrackRunBox(payLoadLength);
                     const trun = await this.tokenizer.readToken(trackRunBox);
                     if (tfhd) {
-                        const track = this.getTrackById(tfhd.trackId);
+                        const track = this.tracks.get(tfhd.trackId);
                         track?.fragments.push({ header: tfhd, trackRun: trun });
                     }
                     break;
@@ -532,11 +580,11 @@ export class MP4Parser extends BasicParser {
             debug(`Chapter ${i + 1}: ${title}`);
             const chapter = {
                 title,
-                timeScale: chapterTrack.timeScale,
+                timeScale: chapterTrack.media.header ? chapterTrack.media.header.timeScale : 0,
                 start,
                 sampleOffset: this.findSampleOffset(track, this.tokenizer.position)
             };
-            debug(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${this.tracks[0].duration}`);
+            debug(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${track.header.duration}`); // ToDo, use media duration if required!!!
             chapters.push(chapter);
         }
         this.metadata.setFormat('chapters', chapters);

package/lib/mpeg/MpegParser.js

@@ -256,6 +256,7 @@ export class MpegParser extends AbstractID3Parser {
      */
     async postId3v2Parse() {
         this.metadata.setFormat('lossless', false);
+        this.metadata.setAudioOnly();
         try {
             let quit = false;
             while (!quit) {

package/lib/musepack/MusepackParser.js

@@ -24,6 +24,7 @@ export class MusepackParser extends AbstractID3Parser {
                 throw new MusepackContentError('Invalid signature prefix');
             }
         }
+        this.metadata.setAudioOnly();
         return mpcParser.parse();
     }
 }

package/lib/ogg/opus/OpusParser.js

@@ -27,6 +27,7 @@ export class OpusParser extends VorbisParser {
             throw new OpusContentError("Illegal ogg/Opus magic-signature");
         this.metadata.setFormat('sampleRate', this.idHeader.inputSampleRate);
         this.metadata.setFormat('numberOfChannels', this.idHeader.channelCount);
+        this.metadata.setAudioOnly();
     }
     async parseFullPage(pageData) {
         const magicSignature = new Token.StringType(8, 'ascii').get(pageData, 0);

package/lib/ogg/speex/SpeexParser.js

@@ -27,6 +27,7 @@ export class SpeexParser extends VorbisParser {
         if (speexHeader.bitrate !== -1) {
             this.metadata.setFormat('bitrate', speexHeader.bitrate);
         }
+        this.metadata.setAudioOnly();
     }
 }
 //# sourceMappingURL=SpeexParser.js.map

package/lib/ogg/theora/TheoraParser.js

@@ -34,6 +34,7 @@ export class TheoraParser {
         this.metadata.setFormat('codec', 'Theora');
         const idHeader = IdentificationHeader.get(pageData, 0);
         this.metadata.setFormat('bitrate', idHeader.nombr);
+        this.metadata.setAudioOnly();
     }
 }
 //# sourceMappingURL=TheoraParser.js.map

package/lib/ogg/vorbis/VorbisParser.js

@@ -92,6 +92,7 @@ export class VorbisParser {
      */
     parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Vorbis I');
+        this.metadata.setAudioOnly();
         debug('Parse first page');
         // Parse  Vorbis common header
         const commonHeader = CommonHeader.get(pageData, 0);

package/lib/type.d.ts

@@ -370,7 +370,7 @@ export interface IRatio {
      */
     dB: number;
 }
-export type FormatId = 'container' | 'duration' | 'bitrate' | 'sampleRate' | 'bitsPerSample' | 'codec' | 'tool' | 'codecProfile' | 'lossless' | 'numberOfChannels' | 'numberOfSamples' | 'audioMD5' | 'chapters' | 'modificationTime' | 'creationTime' | 'trackPeakLevel' | 'trackGain' | 'albumGain';
+export type FormatId = 'container' | 'duration' | 'bitrate' | 'sampleRate' | 'bitsPerSample' | 'codec' | 'tool' | 'codecProfile' | 'lossless' | 'numberOfChannels' | 'numberOfSamples' | 'audioMD5' | 'chapters' | 'modificationTime' | 'creationTime' | 'trackPeakLevel' | 'trackGain' | 'albumGain' | 'hasAudio' | 'hasVideo';
 export interface IAudioTrack {
     samplingFrequency?: number;
     outputSamplingFrequency?: number;
@@ -470,6 +470,14 @@ export interface IFormat {
     readonly trackGain?: number;
     readonly trackPeakLevel?: number;
     readonly albumGain?: number;
+    /**
+     * Indicates if the audio files contains an audio stream
+     */
+    hasAudio?: boolean;
+    /**
+     * Indicates if the media files contains a video stream
+     */
+    hasVideo?: boolean;
 }
 export interface ITag {
     id: string;

package/lib/wav/WaveParser.js

@@ -31,6 +31,7 @@ export class WaveParser extends BasicParser {
         debug(`pos=${this.tokenizer.position}, parse: chunkID=${riffHeader.chunkID}`);
         if (riffHeader.chunkID !== 'RIFF')
             return; // Not RIFF format
+        this.metadata.setAudioOnly();
         return this.parseRiffChunk(riffHeader.chunkSize).catch(err => {
             if (!(err instanceof strtok3.EndOfStreamError)) {
                 throw err;

package/lib/wavpack/WavPackParser.js

@@ -18,6 +18,7 @@ export class WavPackParser extends BasicParser {
         this.audioDataSize = 0;
     }
     async parse() {
+        this.metadata.setAudioOnly();
         this.audioDataSize = 0;
         // First parse all WavPack blocks
         await this.parseWavPackBlocks();

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.4.0",
+  "version": "11.5.0",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -110,18 +110,18 @@
     "file-type": "^21.0.0",
     "media-typer": "^1.1.0",
     "strtok3": "^10.3.1",
-    "token-types": "^6.0.0",
+    "token-types": "^6.0.3",
     "uint8array-extras": "^1.4.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.0.5",
+    "@biomejs/biome": "2.0.6",
     "@types/chai": "^5.2.2",
     "@types/chai-as-promised": "^8.0.2",
     "@types/content-type": "^1.1.9",
     "@types/debug": "^4.1.12",
     "@types/media-typer": "^1.1.3",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.0.4",
     "c8": "^10.1.3",
     "chai": "^5.2.0",
     "chai-as-promised": "^8.0.1",