music-metadata 7.11.3 → 7.11.7

package/lib/musepack/sv8/StreamVersion8.js

@@ -1,80 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamReader = void 0;
-const Token = require("token-types");
-const util = require("../../common/Util");
-const initDebug = require("debug");
-const debug = initDebug('music-metadata:parser:musepack:sv8');
-const PacketKey = new Token.StringType(2, 'binary');
-/**
- * Stream Header Packet part 1
- * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
- */
-const SH_part1 = {
-    len: 5,
-    get: (buf, off) => {
-        return {
-            crc: Token.UINT32_LE.get(buf, off),
-            streamVersion: Token.UINT8.get(buf, off + 4)
-        };
-    }
-};
-/**
- * Stream Header Packet part 3
- * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
- */
-const SH_part3 = {
-    len: 2,
-    get: (buf, off) => {
-        return {
-            sampleFrequency: [44100, 48000, 37800, 32000][util.getBitAllignedNumber(buf, off, 0, 3)],
-            maxUsedBands: util.getBitAllignedNumber(buf, off, 3, 5),
-            channelCount: util.getBitAllignedNumber(buf, off + 1, 0, 4) + 1,
-            msUsed: util.isBitSet(buf, off + 1, 4),
-            audioBlockFrames: util.getBitAllignedNumber(buf, off + 1, 5, 3)
-        };
-    }
-};
-class StreamReader {
-    constructor(tokenizer) {
-        this.tokenizer = tokenizer;
-    }
-    async readPacketHeader() {
-        const key = await this.tokenizer.readToken(PacketKey);
-        const size = await this.readVariableSizeField();
-        return {
-            key,
-            payloadLength: size.value - 2 - size.len
-        };
-    }
-    async readStreamHeader(size) {
-        const streamHeader = {};
-        debug(`Reading SH at offset=${this.tokenizer.position}`);
-        const part1 = await this.tokenizer.readToken(SH_part1);
-        size -= SH_part1.len;
-        Object.assign(streamHeader, part1);
-        debug(`SH.streamVersion = ${part1.streamVersion}`);
-        const sampleCount = await this.readVariableSizeField();
-        size -= sampleCount.len;
-        streamHeader.sampleCount = sampleCount.value;
-        const bs = await this.readVariableSizeField();
-        size -= bs.len;
-        streamHeader.beginningOfSilence = bs.value;
-        const part3 = await this.tokenizer.readToken(SH_part3);
-        size -= SH_part3.len;
-        Object.assign(streamHeader, part3);
-        // assert.equal(size, 0);
-        await this.tokenizer.ignore(size);
-        return streamHeader;
-    }
-    async readVariableSizeField(len = 1, hb = 0) {
-        let n = await this.tokenizer.readNumber(Token.UINT8);
-        if ((n & 0x80) === 0) {
-            return { len, value: hb + n };
-        }
-        n &= 0x7F;
-        n += hb;
-        return this.readVariableSizeField(len + 1, n << 7);
-    }
-}
-exports.StreamReader = StreamReader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamReader = void 0;
+const Token = require("token-types");
+const initDebug = require("debug");
+const util = require("../../common/Util");
+const debug = initDebug('music-metadata:parser:musepack:sv8');
+const PacketKey = new Token.StringType(2, 'binary');
+/**
+ * Stream Header Packet part 1
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+const SH_part1 = {
+    len: 5,
+    get: (buf, off) => {
+        return {
+            crc: Token.UINT32_LE.get(buf, off),
+            streamVersion: Token.UINT8.get(buf, off + 4)
+        };
+    }
+};
+/**
+ * Stream Header Packet part 3
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+const SH_part3 = {
+    len: 2,
+    get: (buf, off) => {
+        return {
+            sampleFrequency: [44100, 48000, 37800, 32000][util.getBitAllignedNumber(buf, off, 0, 3)],
+            maxUsedBands: util.getBitAllignedNumber(buf, off, 3, 5),
+            channelCount: util.getBitAllignedNumber(buf, off + 1, 0, 4) + 1,
+            msUsed: util.isBitSet(buf, off + 1, 4),
+            audioBlockFrames: util.getBitAllignedNumber(buf, off + 1, 5, 3)
+        };
+    }
+};
+class StreamReader {
+    constructor(tokenizer) {
+        this.tokenizer = tokenizer;
+    }
+    async readPacketHeader() {
+        const key = await this.tokenizer.readToken(PacketKey);
+        const size = await this.readVariableSizeField();
+        return {
+            key,
+            payloadLength: size.value - 2 - size.len
+        };
+    }
+    async readStreamHeader(size) {
+        const streamHeader = {};
+        debug(`Reading SH at offset=${this.tokenizer.position}`);
+        const part1 = await this.tokenizer.readToken(SH_part1);
+        size -= SH_part1.len;
+        Object.assign(streamHeader, part1);
+        debug(`SH.streamVersion = ${part1.streamVersion}`);
+        const sampleCount = await this.readVariableSizeField();
+        size -= sampleCount.len;
+        streamHeader.sampleCount = sampleCount.value;
+        const bs = await this.readVariableSizeField();
+        size -= bs.len;
+        streamHeader.beginningOfSilence = bs.value;
+        const part3 = await this.tokenizer.readToken(SH_part3);
+        size -= SH_part3.len;
+        Object.assign(streamHeader, part3);
+        // assert.equal(size, 0);
+        await this.tokenizer.ignore(size);
+        return streamHeader;
+    }
+    async readVariableSizeField(len = 1, hb = 0) {
+        let n = await this.tokenizer.readNumber(Token.UINT8);
+        if ((n & 0x80) === 0) {
+            return { len, value: hb + n };
+        }
+        n &= 0x7F;
+        n += hb;
+        return this.readVariableSizeField(len + 1, n << 7);
+    }
+}
+exports.StreamReader = StreamReader;

package/lib/ogg/Ogg.d.ts

@@ -1,72 +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;
-}
+/**
+ * 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/Ogg.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ogg/OggParser.d.ts

@@ -1,23 +1,23 @@
-import * as Ogg from './Ogg';
-import { BasicParser } from '../common/BasicParser';
-import { IGetToken } from 'strtok3/lib/core';
-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>;
-}
+import { IGetToken } from 'strtok3/lib/core';
+import { BasicParser } from '../common/BasicParser';
+import * as Ogg from './Ogg';
+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/OggParser.js

@@ -1,126 +1,126 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OggParser = exports.SegmentTable = void 0;
-const Token = require("token-types");
-const initDebug = require("debug");
-const util = require("../common/Util");
-const FourCC_1 = require("../common/FourCC");
-const VorbisParser_1 = require("./vorbis/VorbisParser");
-const OpusParser_1 = require("./opus/OpusParser");
-const SpeexParser_1 = require("./speex/SpeexParser");
-const BasicParser_1 = require("../common/BasicParser");
-const TheoraParser_1 = require("./theora/TheoraParser");
-const core_1 = require("strtok3/lib/core");
-const debug = initDebug('music-metadata:parser:ogg');
-class SegmentTable {
-    constructor(header) {
-        this.len = header.page_segments;
-    }
-    static sum(buf, off, len) {
-        let s = 0;
-        for (let i = off; i < off + len; ++i) {
-            s += buf[i];
-        }
-        return s;
-    }
-    get(buf, off) {
-        return {
-            totalPageSize: SegmentTable.sum(buf, off, this.len)
-        };
-    }
-}
-exports.SegmentTable = SegmentTable;
-/**
- * Parser for Ogg logical bitstream framing
- */
-class OggParser extends BasicParser_1.BasicParser {
-    /**
-     * Parse page
-     * @returns {Promise<void>}
-     */
-    async parse() {
-        debug('pos=%s, parsePage()', this.tokenizer.position);
-        try {
-            let header;
-            do {
-                header = await this.tokenizer.readToken(OggParser.Header);
-                if (header.capturePattern !== 'OggS')
-                    throw new Error('Invalid Ogg capture pattern');
-                this.metadata.setFormat('container', 'Ogg');
-                this.header = header;
-                this.pageNumber = header.pageSequenceNo;
-                debug('page#=%s, Ogg.id=%s', header.pageSequenceNo, header.capturePattern);
-                const segmentTable = await this.tokenizer.readToken(new SegmentTable(header));
-                debug('totalPageSize=%s', segmentTable.totalPageSize);
-                const pageData = await this.tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
-                debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
-                if (header.headerType.firstPage) {
-                    const id = new Token.StringType(7, 'ascii').get(Buffer.from(pageData), 0);
-                    switch (id) {
-                        case '\x01vorbis': // Ogg/Vorbis
-                            debug('Set page consumer to Ogg/Vorbis');
-                            this.pageConsumer = new VorbisParser_1.VorbisParser(this.metadata, this.options);
-                            break;
-                        case 'OpusHea': // Ogg/Opus
-                            debug('Set page consumer to Ogg/Opus');
-                            this.pageConsumer = new OpusParser_1.OpusParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        case 'Speex  ': // Ogg/Speex
-                            debug('Set page consumer to Ogg/Speex');
-                            this.pageConsumer = new SpeexParser_1.SpeexParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        case 'fishead':
-                        case '\x00theora': // Ogg/Theora
-                            debug('Set page consumer to Ogg/Theora');
-                            this.pageConsumer = new TheoraParser_1.TheoraParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        default:
-                            throw new Error('gg audio-codec not recognized (id=' + id + ')');
-                    }
-                }
-                this.pageConsumer.parsePage(header, pageData);
-            } while (!header.headerType.lastPage);
-        }
-        catch (err) {
-            if (err instanceof core_1.EndOfStreamError) {
-                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
-                debug(`End-of-stream`);
-                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
-                if (this.header) {
-                    this.pageConsumer.calculateDuration(this.header);
-                }
-            }
-            else if (err.message.startsWith('FourCC')) {
-                if (this.pageNumber > 0) {
-                    // ignore this error: work-around if last OGG-page is not marked with last-page flag
-                    this.metadata.addWarning('Invalid FourCC ID, maybe last OGG-page is not marked with last-page flag');
-                    this.pageConsumer.flush();
-                }
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-}
-exports.OggParser = OggParser;
-OggParser.Header = {
-    len: 27,
-    get: (buf, off) => {
-        return {
-            capturePattern: FourCC_1.FourCcToken.get(buf, off),
-            version: Token.UINT8.get(buf, off + 4),
-            headerType: {
-                continued: util.getBit(buf, off + 5, 0),
-                firstPage: util.getBit(buf, off + 5, 1),
-                lastPage: util.getBit(buf, off + 5, 2)
-            },
-            // packet_flag: buf.readUInt8(off + 5),
-            absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
-            streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
-            pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),
-            pageChecksum: Token.UINT32_LE.get(buf, off + 22),
-            page_segments: Token.UINT8.get(buf, off + 26)
-        };
-    }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OggParser = exports.SegmentTable = void 0;
+const Token = require("token-types");
+const core_1 = require("strtok3/lib/core");
+const initDebug = require("debug");
+const util = require("../common/Util");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const VorbisParser_1 = require("./vorbis/VorbisParser");
+const OpusParser_1 = require("./opus/OpusParser");
+const SpeexParser_1 = require("./speex/SpeexParser");
+const TheoraParser_1 = require("./theora/TheoraParser");
+const debug = initDebug('music-metadata:parser:ogg');
+class SegmentTable {
+    constructor(header) {
+        this.len = header.page_segments;
+    }
+    static sum(buf, off, len) {
+        let s = 0;
+        for (let i = off; i < off + len; ++i) {
+            s += buf[i];
+        }
+        return s;
+    }
+    get(buf, off) {
+        return {
+            totalPageSize: SegmentTable.sum(buf, off, this.len)
+        };
+    }
+}
+exports.SegmentTable = SegmentTable;
+/**
+ * Parser for Ogg logical bitstream framing
+ */
+class OggParser extends BasicParser_1.BasicParser {
+    /**
+     * Parse page
+     * @returns {Promise<void>}
+     */
+    async parse() {
+        debug('pos=%s, parsePage()', this.tokenizer.position);
+        try {
+            let header;
+            do {
+                header = await this.tokenizer.readToken(OggParser.Header);
+                if (header.capturePattern !== 'OggS')
+                    throw new Error('Invalid Ogg capture pattern');
+                this.metadata.setFormat('container', 'Ogg');
+                this.header = header;
+                this.pageNumber = header.pageSequenceNo;
+                debug('page#=%s, Ogg.id=%s', header.pageSequenceNo, header.capturePattern);
+                const segmentTable = await this.tokenizer.readToken(new SegmentTable(header));
+                debug('totalPageSize=%s', segmentTable.totalPageSize);
+                const pageData = await this.tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
+                debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
+                if (header.headerType.firstPage) {
+                    const id = new Token.StringType(7, 'ascii').get(Buffer.from(pageData), 0);
+                    switch (id) {
+                        case '\x01vorbis': // Ogg/Vorbis
+                            debug('Set page consumer to Ogg/Vorbis');
+                            this.pageConsumer = new VorbisParser_1.VorbisParser(this.metadata, this.options);
+                            break;
+                        case 'OpusHea': // Ogg/Opus
+                            debug('Set page consumer to Ogg/Opus');
+                            this.pageConsumer = new OpusParser_1.OpusParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        case 'Speex  ': // Ogg/Speex
+                            debug('Set page consumer to Ogg/Speex');
+                            this.pageConsumer = new SpeexParser_1.SpeexParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        case 'fishead':
+                        case '\x00theora': // Ogg/Theora
+                            debug('Set page consumer to Ogg/Theora');
+                            this.pageConsumer = new TheoraParser_1.TheoraParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        default:
+                            throw new Error('gg audio-codec not recognized (id=' + id + ')');
+                    }
+                }
+                this.pageConsumer.parsePage(header, pageData);
+            } while (!header.headerType.lastPage);
+        }
+        catch (err) {
+            if (err instanceof core_1.EndOfStreamError) {
+                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
+                debug(`End-of-stream`);
+                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
+                if (this.header) {
+                    this.pageConsumer.calculateDuration(this.header);
+                }
+            }
+            else if (err.message.startsWith('FourCC')) {
+                if (this.pageNumber > 0) {
+                    // ignore this error: work-around if last OGG-page is not marked with last-page flag
+                    this.metadata.addWarning('Invalid FourCC ID, maybe last OGG-page is not marked with last-page flag');
+                    this.pageConsumer.flush();
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+}
+exports.OggParser = OggParser;
+OggParser.Header = {
+    len: 27,
+    get: (buf, off) => {
+        return {
+            capturePattern: FourCC_1.FourCcToken.get(buf, off),
+            version: Token.UINT8.get(buf, off + 4),
+            headerType: {
+                continued: util.getBit(buf, off + 5, 0),
+                firstPage: util.getBit(buf, off + 5, 1),
+                lastPage: util.getBit(buf, off + 5, 2)
+            },
+            // packet_flag: buf.readUInt8(off + 5),
+            absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
+            streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
+            pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),
+            pageChecksum: Token.UINT32_LE.get(buf, off + 22),
+            page_segments: Token.UINT8.get(buf, off + 26)
+        };
+    }
+};