music-metadata 11.3.0 → 11.5.0

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,10 +114,6 @@ export class MP4Parser extends BasicParser {
                 }
                 td.chapterList = trackIds;
             },
-            tkhd: async (len) => {
-                const track = (await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(len)));
-                this.tracks.push(track);
-            },
             /**
              * Parse mdat atom.
              * Will scan for chapters
@@ -137,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);
                         }
@@ -170,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')
              */
@@ -193,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,7 +179,9 @@ export class MP4Parser extends BasicParser {
         return Number(token.get(array, 0));
     }
     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 {
@@ -274,21 +240,39 @@ 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) {
-                const duration = audioTrack.duration / audioTrack.timeScale; // calculate duration in seconds
-                this.metadata.setFormat('duration', duration);
+            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.media.header.duration / audioTrack.media.header.timeScale; // calculate duration in seconds
+                    this.metadata.setFormat('duration', duration);
+                }
+                else if (audioTrack.fragments.length > 0) {
+                    debug('Calculate duration defined in track fragments');
+                    let totalTimeUnits = 0;
+                    for (const fragment of audioTrack.fragments) {
+                        const defaultDuration = fragment.header.defaultSampleDuration;
+                        for (const sample of fragment.trackRun.samples) {
+                            const dur = sample.sampleDuration ?? defaultDuration;
+                            if (dur == null) {
+                                throw new Error("Missing sampleDuration and no default_sample_duration in tfhd");
+                            }
+                            totalTimeUnits += dur;
+                        }
+                    }
+                    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);
@@ -302,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) {
@@ -309,6 +295,17 @@ 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':
+                            return this.parseTrackFragmentBox(atom);
+                    }
             }
         }
         // const payloadLength = atom.getPayloadLength(remaining);
@@ -319,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) {
@@ -432,6 +431,111 @@ 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) => {
+            const payLoadLength = child.getPayloadLength(remaining);
+            switch (child.header.name) {
+                case 'tfhd': { // TrackFragmentHeaderBox
+                    const fragmentHeaderBox = new AtomToken.TrackFragmentHeaderBox(child.getPayloadLength(remaining));
+                    tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
+                    break;
+                }
+                case 'tfdt': // TrackFragmentBaseMediaDecodeTimeBo
+                    await this.tokenizer.ignore(payLoadLength);
+                    break;
+                case 'trun': { // TrackRunBox
+                    const trackRunBox = new AtomToken.TrackRunBox(payLoadLength);
+                    const trun = await this.tokenizer.readToken(trackRunBox);
+                    if (tfhd) {
+                        const track = this.tracks.get(tfhd.trackId);
+                        track?.fragments.push({ header: tfhd, trackRun: trun });
+                    }
+                    break;
+                }
+                default: {
+                    debug(`Unexpected box: ${child.header.name}`);
+                    await this.tokenizer.ignore(payLoadLength);
+                }
+            }
+        }, trafBox.getPayloadLength(0));
+    }
     /**
      * @param sampleDescription
      * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-128916
@@ -476,22 +580,17 @@ 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);
         await this.tokenizer.ignore(len);
     }
     findSampleOffset(track, chapterOffset) {
-        let totalDuration = 0;
-        track.timeToSampleTable.forEach(e => {
-            totalDuration += e.count * e.duration;
-        });
-        debug(`Total duration=${totalDuration}`);
         let chunkIndex = 0;
         while (chunkIndex < track.chunkOffsetTable.length && track.chunkOffsetTable[chunkIndex] < chapterOffset) {
             ++chunkIndex;

package/lib/mp4/MP4TagMapper.d.ts

@@ -4,5 +4,5 @@ import type { INativeMetadataCollector } from "../common/MetadataCollector.js";
 export declare const tagType = "iTunes";
 export declare class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor();
-    protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
+    protected postMap(tag: ITag, _warnings: INativeMetadataCollector): void;
 }

package/lib/mp4/MP4TagMapper.js

@@ -110,7 +110,7 @@ export class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor() {
         super([tagType], mp4TagMap);
     }
-    postMap(tag, warnings) {
+    postMap(tag, _warnings) {
         switch (tag.id) {
             case 'rate':
                 tag.value = {

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/musepack/sv7/MpcSv7Parser.js

@@ -1,6 +1,6 @@
 import initDebug from 'debug';
 import { BasicParser } from '../../common/BasicParser.js';
-import { APEv2Parser } from '../../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
 import { BitReader } from './BitReader.js';
 import * as SV7 from './StreamVersion7.js';
 import { MusepackContentError } from '../MusepackConentError.js';
@@ -29,7 +29,7 @@ export class MpcSv7Parser extends BasicParser {
         this.metadata.setFormat('codec', (version / 100).toFixed(2));
         await this.skipAudioData(header.frameCount);
         debug(`End of audio stream, switching to APEv2, offset=${this.tokenizer.position}`);
-        return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
     }
     async skipAudioData(frameCount) {
         while (frameCount-- > 0) {

package/lib/musepack/sv8/MpcSv8Parser.js

@@ -1,6 +1,6 @@
 import initDebug from 'debug';
 import { BasicParser } from '../../common/BasicParser.js';
-import { APEv2Parser } from '../../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
 import { FourCcToken } from '../../common/FourCC.js';
 import * as SV8 from './StreamVersion8.js';
 import { MusepackContentError } from '../MusepackConentError.js';
@@ -46,7 +46,7 @@ export class MpcSv8Parser extends BasicParser {
                     if (this.metadata.format.duration) {
                         this.metadata.setFormat('bitrate', this.audioLength * 8 / this.metadata.format.duration);
                     }
-                    return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+                    return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
                 default:
                     throw new MusepackContentError(`Unexpected header: ${header.key}`);
             }

package/lib/ogg/opus/OpusParser.d.ts

@@ -18,7 +18,7 @@ export declare class OpusParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
     calculateDuration(header: IPageHeader): void;
 }

package/lib/ogg/opus/OpusParser.js

@@ -19,7 +19,7 @@ export class OpusParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    parseFirstPage(header, pageData) {
+    parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Opus');
         // Parse Opus ID Header
         this.idHeader = new Opus.IdHeader(pageData.length).get(pageData, 0);
@@ -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.d.ts

@@ -17,5 +17,5 @@ export declare class SpeexParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
 }

package/lib/ogg/speex/SpeexParser.js

@@ -18,7 +18,7 @@ export class SpeexParser extends VorbisParser {
      * @param {IPageHeader} header
      * @param {Uint8Array} pageData
      */
-    parseFirstPage(header, pageData) {
+    parseFirstPage(_header, pageData) {
         debug('First Ogg/Speex page');
         const speexHeader = Speex.Header.get(pageData, 0);
         this.metadata.setFormat('codec', `Speex ${speexHeader.version}`);
@@ -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.d.ts

@@ -9,7 +9,7 @@ import type { INativeMetadataCollector } from '../../common/MetadataCollector.js
 export declare class TheoraParser implements Ogg.IPageConsumer {
     private metadata;
     private tokenizer;
-    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    constructor(metadata: INativeMetadataCollector, _options: IOptions, tokenizer: ITokenizer);
     /**
      * Vorbis 1 parser
      * @param header Ogg Page Header
@@ -17,11 +17,9 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      */
     parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
     flush(): Promise<void>;
-    calculateDuration(header: Ogg.IPageHeader): void;
+    calculateDuration(_header: Ogg.IPageHeader): void;
     /**
      * Parse first Theora Ogg page. the initial identification header packet
-     * @param {IPageHeader} header
-     * @param {Buffer} pageData
      */
-    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
 }

package/lib/ogg/theora/TheoraParser.js

@@ -6,7 +6,7 @@ const debug = initDebug('music-metadata:parser:ogg:theora');
  * - https://theora.org/doc/Theora.pdf
  */
 export class TheoraParser {
-    constructor(metadata, options, tokenizer) {
+    constructor(metadata, _options, tokenizer) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
     }
@@ -23,19 +23,18 @@ export class TheoraParser {
     async flush() {
         debug('flush');
     }
-    calculateDuration(header) {
+    calculateDuration(_header) {
         debug('duration calculation not implemented');
     }
     /**
      * Parse first Theora Ogg page. the initial identification header packet
-     * @param {IPageHeader} header
-     * @param {Buffer} pageData
      */
-    async parseFirstPage(header, pageData) {
+    async parseFirstPage(_header, pageData) {
         debug('First Ogg/Theora page');
         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.d.ts

@@ -41,7 +41,7 @@ export declare class VorbisParser implements IPageConsumer {
      * @param header
      * @param pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
     /**
      * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2

package/lib/ogg/vorbis/VorbisParser.js

@@ -90,8 +90,9 @@ export class VorbisParser {
      * @param header
      * @param pageData
      */
-    parseFirstPage(header, pageData) {
+    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

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { APEv2Parser } from '../apev2/APEv2Parser.js';
+import { tryParseApeHeader } from '../apev2/APEv2Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { BlockHeaderToken, MetadataIdToken } from './WavPackToken.js';
@@ -18,11 +18,12 @@ export class WavPackParser extends BasicParser {
         this.audioDataSize = 0;
     }
     async parse() {
+        this.metadata.setAudioOnly();
         this.audioDataSize = 0;
         // First parse all WavPack blocks
         await this.parseWavPackBlocks();
         // try to parse APEv2 header
-        return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
     }
     async parseWavPackBlocks() {
         do {