music-metadata 11.3.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();
     }
     /**
@@ -108,7 +117,7 @@ export class ParserFactory {
         try {
             mime = parseHttpContentType(httpContentType);
         }
-        catch (err) {
+        catch (_err) {
             debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
             return;
         }

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.d.ts

@@ -18,8 +18,8 @@ declare const ApeContentError_base: {
 };
 export declare class ApeContentError extends ApeContentError_base {
 }
+export declare function tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
 export declare class APEv2Parser extends BasicParser {
-    static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
     /**
      * Calculate the media file duration
      * @param ah ApeHeader

package/lib/apev2/APEv2Parser.js

@@ -11,15 +11,15 @@ const tagFormat = 'APEv2';
 const preamble = 'APETAGEX';
 export class ApeContentError extends makeUnexpectedFileContentError('APEv2') {
 }
+export function tryParseApeHeader(metadata, tokenizer, options) {
+    const apeParser = new APEv2Parser(metadata, tokenizer, options);
+    return apeParser.tryParseApeHeader();
+}
 export class APEv2Parser extends BasicParser {
     constructor() {
         super(...arguments);
         this.ape = {};
     }
-    static tryParseApeHeader(metadata, tokenizer, options) {
-        const apeParser = new APEv2Parser(metadata, tokenizer, options);
-        return apeParser.tryParseApeHeader();
-    }
     /**
      * Calculate the media file duration
      * @param ah ApeHeader
@@ -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/asf/AsfObject.d.ts

@@ -82,7 +82,7 @@ export declare abstract class State<T> implements IGetToken<T> {
     protected postProcessTag(tags: ITag[], name: string, valueType: number, data: AnyTagValue): void;
 }
 export declare class IgnoreObjectState extends State<unknown> {
-    get(buf: Uint8Array, off: number): null;
+    get(_buf: Uint8Array, _off: number): null;
 }
 /**
  * Interface for: 3.2: File Properties Object (mandatory, one only)

package/lib/asf/AsfObject.js

@@ -83,7 +83,7 @@ export class State {
 }
 // ToDo: use ignore type
 export class IgnoreObjectState extends State {
-    get(buf, off) {
+    get(_buf, _off) {
         return null;
     }
 }

package/lib/common/GenericTagMapper.d.ts

@@ -47,5 +47,5 @@ export declare class CommonTagMapper implements IGenericTagMapper {
      * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
      * @param warnings Used to register warnings
      */
-    protected postMap(tag: ITag, warnings: IWarningCollector): void;
+    protected postMap(_tag: ITag, _warnings: IWarningCollector): void;
 }

package/lib/common/GenericTagMapper.js

@@ -44,7 +44,7 @@ export class CommonTagMapper {
      * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
      * @param warnings Used to register warnings
      */
-    postMap(tag, warnings) {
+    postMap(_tag, _warnings) {
         return;
     }
 }

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.d.ts

@@ -63,12 +63,12 @@ export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer,
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export declare function parseFile(filePath: string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseFile(_filePath: string, _options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export declare function parseStream(stream: Readable, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseStream(_stream: Readable, _fileInfo?: IFileInfo | string, _options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Return a list of supported mime-types
  */

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;
 }
@@ -109,14 +106,14 @@ export async function scanAppendingHeaders(tokenizer, options = {}) {
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export async function parseFile(filePath, options = {}) {
+export async function parseFile(_filePath, _options = {}) {
     throw new Error('This function require a Node engine. To load Web API File objects use parseBlob instead.');
 }
 /**
  * Implementation only available when loaded as Node.js
  * This method will throw an Error, always.
  */
-export async function parseStream(stream, fileInfo, options = {}) {
+export async function parseStream(_stream, _fileInfo, _options = {}) {
     throw new Error('This function require a Node engine.');
 }
 /**

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/ebml/EbmlIterator.js

@@ -194,7 +194,7 @@ function readUIntBeAsBigInt(buf, len) {
         normalizedNumber.set(cleanNumber, 8 - len);
         return Token.UINT64_BE.get(normalizedNumber, 0);
     }
-    catch (error) {
+    catch (_error) {
         return BigInt(-1);
     }
 }

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,13 +43,13 @@ 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
             case '<id>':
             case 'ilst':
             case 'tref':
+            case 'moof':
                 return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
             case 'meta': { // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
                 // meta has 4 bytes of padding, ignore

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> {
@@ -402,4 +401,87 @@ export declare class ChapterText implements IGetToken<string> {
     constructor(len: number);
     get(buf: Uint8Array, off: number): string;
 }
+interface ITrackFragmentHeaderBoxFlags {
+    baseDataOffsetPresent: boolean;
+    sampleDescriptionIndexPresent: boolean;
+    defaultSampleDurationPresent: boolean;
+    defaultSampleSizePresent: boolean;
+    defaultSampleFlagsPresent: boolean;
+    defaultDurationIsEmpty: boolean;
+    defaultBaseIsMoof: boolean;
+}
+export interface ITrackFragmentHeaderBox {
+    version: number;
+    flags: ITrackFragmentHeaderBoxFlags;
+    trackId: number;
+    baseDataOffset?: bigint;
+    sampleDescriptionIndex?: number;
+    defaultSampleDuration?: number;
+    defaultSampleSize?: number;
+    defaultSampleFlags?: number;
+}
+/**
+ * Sample-size ('tfhd') TrackFragmentHeaderBox
+ */
+export declare class TrackFragmentHeaderBox implements IGetToken<ITrackFragmentHeaderBox> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): ITrackFragmentHeaderBox;
+}
+interface ITrackRunBoxFlags {
+    dataOffsetPresent: boolean;
+    firstSampleFlagsPresent: boolean;
+    sampleDurationPresent: boolean;
+    sampleSizePresent: boolean;
+    sampleFlagsPresent: boolean;
+    sampleCompositionTimeOffsetsPresent: boolean;
+}
+/**
+ * trun atom
+ */
+export interface ITrackRunBox {
+    version: number;
+    flags: ITrackRunBoxFlags;
+    samples: ITrackRunBoxSample[];
+    sampleCount: number;
+    dataOffset?: number;
+    firstSampleFlags?: number;
+}
+interface ITrackRunBoxSample {
+    sampleDuration?: number;
+    sampleSize?: number;
+    sampleFlags?: number;
+    sampleCompositionTimeOffset?: number;
+}
+/**
+ * Sample-size ('trun') TrackRunBox
+ */
+export declare class TrackRunBox implements IGetToken<ITrackRunBox> {
+    len: number;
+    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

@@ -2,6 +2,7 @@ import * as Token from 'token-types';
 import initDebug from 'debug';
 import { FourCcToken } from '../common/FourCC.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import * as util from '../common/Util.js';
 const debug = initDebug('music-metadata:parser:MP4:atom');
 export class Mp4ContentError extends makeUnexpectedFileContentError('MP4') {
 }
@@ -33,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
  */
@@ -173,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 {
@@ -390,4 +383,143 @@ function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
     }
     return entries;
 }
+/**
+ * Sample-size ('tfhd') TrackFragmentHeaderBox
+ */
+export class TrackFragmentHeaderBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        const flagOffset = off + 1;
+        const header = {
+            version: Token.INT8.get(buf, off),
+            flags: {
+                baseDataOffsetPresent: util.getBit(buf, flagOffset + 2, 0),
+                sampleDescriptionIndexPresent: util.getBit(buf, flagOffset + 2, 1),
+                defaultSampleDurationPresent: util.getBit(buf, flagOffset + 2, 3),
+                defaultSampleSizePresent: util.getBit(buf, flagOffset + 2, 4),
+                defaultSampleFlagsPresent: util.getBit(buf, flagOffset + 2, 5),
+                defaultDurationIsEmpty: util.getBit(buf, flagOffset, 0),
+                defaultBaseIsMoof: util.getBit(buf, flagOffset, 1)
+            },
+            trackId: Token.UINT32_BE.get(buf, 4)
+        };
+        let dynOffset = 8;
+        if (header.flags.baseDataOffsetPresent) {
+            header.baseDataOffset = Token.UINT64_BE.get(buf, dynOffset);
+            dynOffset += 8;
+        }
+        if (header.flags.sampleDescriptionIndexPresent) {
+            header.sampleDescriptionIndex = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleDurationPresent) {
+            header.defaultSampleDuration = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleSizePresent) {
+            header.defaultSampleSize = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (header.flags.defaultSampleFlagsPresent) {
+            header.defaultSampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+        }
+        return header;
+    }
+}
+/**
+ * Sample-size ('trun') TrackRunBox
+ */
+export class TrackRunBox {
+    constructor(len) {
+        this.len = len;
+    }
+    get(buf, off) {
+        const flagOffset = off + 1;
+        const trun = {
+            version: Token.INT8.get(buf, off),
+            flags: {
+                dataOffsetPresent: util.getBit(buf, flagOffset + 2, 0),
+                firstSampleFlagsPresent: util.getBit(buf, flagOffset + 2, 2),
+                sampleDurationPresent: util.getBit(buf, flagOffset + 1, 0),
+                sampleSizePresent: util.getBit(buf, flagOffset + 1, 1),
+                sampleFlagsPresent: util.getBit(buf, flagOffset + 1, 2),
+                sampleCompositionTimeOffsetsPresent: util.getBit(buf, flagOffset + 1, 3)
+            },
+            sampleCount: Token.UINT32_BE.get(buf, off + 4),
+            samples: []
+        };
+        let dynOffset = off + 8;
+        if (trun.flags.dataOffsetPresent) {
+            trun.dataOffset = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        if (trun.flags.firstSampleFlagsPresent) {
+            trun.firstSampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+            dynOffset += 4;
+        }
+        for (let n = 0; n < trun.sampleCount; ++n) {
+            if (dynOffset >= this.len) {
+                debug("TrackRunBox size mismatch");
+                break;
+            }
+            const sample = {};
+            if (trun.flags.sampleDurationPresent) {
+                sample.sampleDuration = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleSizePresent) {
+                sample.sampleSize = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleFlagsPresent) {
+                sample.sampleFlags = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            if (trun.flags.sampleCompositionTimeOffsetsPresent) {
+                sample.sampleCompositionTimeOffset = Token.UINT32_BE.get(buf, dynOffset);
+                dynOffset += 4;
+            }
+            trun.samples.push(sample);
+        }
+        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,6 +4,8 @@ export declare class MP4Parser extends BasicParser {
     private static read_BE_Integer;
     private audioLengthInBytes;
     private tracks;
+    private hasVideoTrack;
+    private hasAudioTrack;
     parse(): Promise<void>;
     handleAtom(atom: Atom, remaining: number): Promise<void>;
     private getTrackDescription;
@@ -17,6 +19,8 @@ export declare class MP4Parser extends BasicParser {
      */
     private parseMetadataItemData;
     private parseValueAtom;
+    private parseTrackBox;
+    private parseTrackFragmentBox;
     private atomParsers;
     /**
      * @param sampleDescription