music-metadata 8.0.0 → 8.1.0

package/lib/musepack/sv8/StreamVersion8.d.ts

@@ -0,0 +1,40 @@
+import { ITokenizer } from 'strtok3/core';
+export interface IPacketHeader {
+    key: string;
+    payloadLength: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader1 {
+    crc: number;
+    streamVersion: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader3 {
+    sampleFrequency: number;
+    maxUsedBands: number;
+    channelCount: number;
+    msUsed: boolean;
+    audioBlockFrames: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader extends IStreamHeader1, IStreamHeader3 {
+    sampleCount: number;
+    beginningOfSilence: number;
+}
+export declare class StreamReader {
+    private tokenizer;
+    constructor(tokenizer: ITokenizer);
+    readPacketHeader(): Promise<IPacketHeader>;
+    readStreamHeader(size: number): Promise<IStreamHeader>;
+    private readVariableSizeField;
+}
+export {};

package/lib/ogg/Ogg.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Page header
+ * Ref: https://www.xiph.org/ogg/doc/framing.html#page_header
+ */
+export interface IPageHeader {
+    /**
+     * capture_pattern
+     * A header begins with a capture pattern that simplifies identifying pages;
+     * once the decoder has found the capture pattern it can do a more intensive job of verifying that it has in fact found a page boundary (as opposed to an inadvertent coincidence in the byte stream).
+     */
+    capturePattern: string;
+    /**
+     * stream_structure_version
+     */
+    version: number;
+    /**
+     * header_type_flag
+     */
+    headerType: {
+        /**
+         * True: continued packet;
+         * False: fresh packet
+         */
+        continued: boolean;
+        /**
+         * True: first page of logical bitstream (bos)
+         * False: not first page of logical bitstream
+         */
+        firstPage: boolean;
+        /**
+         * True: last page of logical bitstream (eos)
+         * False: not last page of logical bitstream
+         */
+        lastPage: boolean;
+    };
+    /**
+     * The total samples encoded after including all packets finished on this page
+     * The position specified in the frame header of the last page tells how long the data coded by the bitstream is.
+     */
+    absoluteGranulePosition: number;
+    streamSerialNumber: number;
+    pageSequenceNo: number;
+    pageChecksum: number;
+    /**
+     * The number of segment entries to appear in the segment table.
+     * The maximum number of 255 segments (255 bytes each) sets the maximum possible physical page size at 65307 bytes or
+     * just under 64kB (thus we know that a header corrupted so as destroy sizing/alignment information will not cause a
+     * runaway bitstream. We'll read in the page according to the corrupted size information that's guaranteed to be a
+     * reasonable size regardless, notice the checksum mismatch, drop sync and then look for recapture).
+     */
+    page_segments: number;
+}
+export interface ISegmentTable {
+    totalPageSize: number;
+}
+export interface IPageConsumer {
+    /**
+     * Parse Ogg page
+     * @param {IPageHeader} header Ogg page header
+     * @param {Buffer} pageData Ogg page data
+     */
+    parsePage(header: IPageHeader, pageData: Uint8Array): any;
+    /**
+     * Calculate duration of provided header
+     * @param header Ogg header
+     */
+    calculateDuration(header: IPageHeader): any;
+    /**
+     * Force to parse pending segments
+     */
+    flush(): any;
+}

package/lib/ogg/OggParser.d.ts

@@ -0,0 +1,23 @@
+import { IGetToken } from 'strtok3/core';
+import { BasicParser } from '../common/BasicParser.js';
+import * as Ogg from './Ogg.js';
+export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {
+    private static sum;
+    len: number;
+    constructor(header: Ogg.IPageHeader);
+    get(buf: any, off: any): Ogg.ISegmentTable;
+}
+/**
+ * Parser for Ogg logical bitstream framing
+ */
+export declare class OggParser extends BasicParser {
+    private static Header;
+    private header;
+    private pageNumber;
+    private pageConsumer;
+    /**
+     * Parse page
+     * @returns {Promise<void>}
+     */
+    parse(): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+import { IGetToken } from 'strtok3/core';
+/**
+ * Opus ID Header interface
+ * Ref: https://wiki.xiph.org/OggOpus#ID_Header
+ */
+export interface IIdHeader {
+    /**
+     * Magic signature: "OpusHead" (64 bits)
+     */
+    magicSignature: string;
+    /**
+     * Version number (8 bits unsigned): 0x01 for this spec
+     */
+    version: number;
+    /**
+     * Channel count 'c' (8 bits unsigned): MUST be > 0
+     */
+    channelCount: number;
+    /**
+     * Pre-skip (16 bits unsigned, little endian)
+     */
+    preSkip: number;
+    /**
+     * Input sample rate (32 bits unsigned, little endian): informational only
+     */
+    inputSampleRate: number;
+    /**
+     * Output gain (16 bits, little endian, signed Q7.8 in dB) to apply when decoding
+     */
+    outputGain: number;
+    /**
+     * Channel mapping family (8 bits unsigned)
+     * -  0 = one stream: mono or L,R stereo
+     * -  1 = channels in vorbis spec order: mono or L,R stereo or ... or FL,C,FR,RL,RR,LFE, ...
+     * -  2..254 = reserved (treat as 255)
+     * -  255 = no defined channel meaning
+     */
+    channelMapping: number;
+}
+/**
+ * Opus ID Header parser
+ * Ref: https://wiki.xiph.org/OggOpus#ID_Header
+ */
+export declare class IdHeader implements IGetToken<IIdHeader> {
+    len: number;
+    constructor(len: number);
+    get(buf: any, off: any): IIdHeader;
+}

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

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ITokenizer } from 'strtok3/core';
+import { IPageHeader } from '../Ogg.js';
+import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { IOptions } from '../../type.js';
+import { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Opus parser
+ * Internet Engineering Task Force (IETF) - RFC 6716
+ * Used by OggParser
+ */
+export declare class OpusParser extends VorbisParser {
+    private tokenizer;
+    private idHeader;
+    private lastPos;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Parse first Opus Ogg page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+    protected parseFullPage(pageData: Buffer): void;
+    calculateDuration(header: IPageHeader): void;
+}

package/lib/ogg/speex/Speex.d.ts

@@ -0,0 +1,36 @@
+import { IGetToken } from 'strtok3/core';
+/**
+ * Speex Header Packet
+ * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
+ */
+export interface IHeader {
+    /**
+     * speex_string, char[] 8
+     */
+    speex: string;
+    /**
+     * speex_version, char[] 20
+     */
+    version: string;
+    /**
+     * Version id
+     */
+    version_id: number;
+    header_size: number;
+    rate: number;
+    mode: number;
+    mode_bitstream_version: number;
+    nb_channels: number;
+    bitrate: number;
+    frame_size: number;
+    vbr: number;
+    frames_per_packet: number;
+    extra_headers: number;
+    reserved1: number;
+    reserved2: number;
+}
+/**
+ * Speex Header Packet
+ * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
+ */
+export declare const Header: IGetToken<IHeader>;

package/lib/ogg/speex/SpeexParser.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ITokenizer } from 'strtok3/core';
+import { IPageHeader } from '../Ogg.js';
+import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { IOptions } from '../../type.js';
+import { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Speex, RFC 5574
+ * Ref:
+ * - https://www.speex.org/docs/manual/speex-manual/
+ * - https://tools.ietf.org/html/rfc5574
+ */
+export declare class SpeexParser extends VorbisParser {
+    private tokenizer;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Parse first Speex Ogg page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+}

package/lib/ogg/theora/Theora.d.ts

@@ -0,0 +1,20 @@
+import { IGetToken } from 'strtok3/core';
+/**
+ * 6.2 Identification Header
+ * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
+ */
+export interface IIdentificationHeader {
+    id: string;
+    vmaj: number;
+    vmin: number;
+    vrev: number;
+    vmbw: number;
+    vmbh: number;
+    nombr: number;
+    nqual: number;
+}
+/**
+ * 6.2 Identification Header
+ * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
+ */
+export declare const IdentificationHeader: IGetToken<IIdentificationHeader>;

package/lib/ogg/theora/TheoraParser.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ITokenizer } from 'strtok3/core';
+import * as Ogg from '../Ogg.js';
+import { IOptions } from '../../type.js';
+import { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Ref:
+ * - https://theora.org/doc/Theora.pdf
+ */
+export declare class TheoraParser implements Ogg.IPageConsumer {
+    private metadata;
+    private tokenizer;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Buffer): void;
+    flush(): 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: Buffer): void;
+}

package/lib/ogg/vorbis/Vorbis.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IPicture } from '../../type.js';
+import { IGetToken } from 'strtok3/core';
+/**
+ * Interface to parsed result of METADATA_BLOCK_PICTURE
+ * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
+ * Ref: https://xiph.org/flac/format.html#metadata_block_picture
+ */
+export interface IVorbisPicture extends IPicture {
+    type: string;
+    description: string;
+    width: number;
+    height: number;
+    colour_depth: number;
+    indexed_color: number;
+}
+/**
+ * Parse the METADATA_BLOCK_PICTURE
+ * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
+ * Ref: https://xiph.org/flac/format.html#metadata_block_picture
+ * // ToDo: move to ID3 / APIC?
+ */
+export declare class VorbisPictureToken implements IGetToken<IVorbisPicture> {
+    len: any;
+    static fromBase64(base64str: string): IVorbisPicture;
+    static fromBuffer(buffer: Buffer): IVorbisPicture;
+    constructor(len: any);
+    get(buffer: Buffer, offset: number): IVorbisPicture;
+}
+/**
+ * Vorbis 1 decoding tokens
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+/**
+ * Comment header interface
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+export interface ICommonHeader {
+    /**
+     * Packet Type
+     */
+    packetType: number;
+    /**
+     * Should be 'vorbis'
+     */
+    vorbis: string;
+}
+/**
+ * Comment header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+export declare const CommonHeader: IGetToken<ICommonHeader>;
+/**
+ * Identification header interface
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+ */
+export interface IFormatInfo {
+    version: number;
+    channelMode: number;
+    sampleRate: number;
+    bitrateMax: number;
+    bitrateNominal: number;
+    bitrateMin: number;
+}
+/**
+ * Identification header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+ */
+export declare const IdentificationHeader: IGetToken<IFormatInfo>;

package/lib/ogg/vorbis/VorbisDecoder.d.ts

@@ -0,0 +1,12 @@
+export declare class VorbisDecoder {
+    private readonly data;
+    private offset;
+    constructor(data: Uint8Array, offset: any);
+    readInt32(): number;
+    readStringUtf8(): string;
+    parseUserComment(): {
+        key: string;
+        value: string;
+        len: number;
+    };
+}

package/lib/ogg/vorbis/VorbisParser.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IVorbisPicture } from './Vorbis.js';
+import { IPageConsumer, IPageHeader } from '../Ogg.js';
+import { IOptions } from '../../type.js';
+import { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Vorbis 1 Parser.
+ * Used by OggParser
+ */
+export declare class VorbisParser implements IPageConsumer {
+    protected metadata: INativeMetadataCollector;
+    protected options: IOptions;
+    private pageSegments;
+    constructor(metadata: INativeMetadataCollector, options: IOptions);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: IPageHeader, pageData: Buffer): void;
+    flush(): void;
+    parseUserComment(pageData: Buffer, offset: number): number;
+    addTag(id: string, value: string | IVorbisPicture): void;
+    calculateDuration(header: IPageHeader): void;
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param header
+     * @param pageData
+     */
+    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+    protected parseFullPage(pageData: Buffer): void;
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    protected parseUserCommentList(pageData: Buffer, offset: number): void;
+}

package/lib/ogg/vorbis/VorbisTagMapper.d.ts

@@ -0,0 +1,7 @@
+import { CommonTagMapper } from '../../common/GenericTagMapper.js';
+import { IRating, ITag } from '../../type.js';
+export declare class VorbisTagMapper extends CommonTagMapper {
+    static toRating(email: string, rating: string): IRating;
+    constructor();
+    protected postMap(tag: ITag): void;
+}

package/lib/riff/RiffChunk.d.ts

@@ -0,0 +1,16 @@
+import { IGetToken } from 'strtok3/core';
+import { IChunkHeader } from '../iff/index.js';
+export { IChunkHeader } from '../iff/index.js';
+/**
+ * Common RIFF chunk header
+ */
+export declare const Header: IGetToken<IChunkHeader>;
+/**
+ * Token to parse RIFF-INFO tag value
+ */
+export declare class ListInfoTagValue implements IGetToken<string> {
+    private tagHeader;
+    len: number;
+    constructor(tagHeader: IChunkHeader);
+    get(buf: any, off: any): string;
+}

package/lib/riff/RiffInfoTagMap.d.ts

@@ -0,0 +1,10 @@
+import { INativeTagMap } from '../common/GenericTagTypes.js';
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+/**
+ * RIFF Info Tags; part of the EXIF 2.3
+ * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
+ */
+export declare const riffInfoTagMap: INativeTagMap;
+export declare class RiffInfoTagMapper extends CommonTagMapper {
+    constructor();
+}