music-metadata 11.5.0 → 11.6.0

package/lib/flac/FlacParser.js

@@ -4,7 +4,7 @@ import * as util from '../common/Util.js';
 import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
-import { VorbisParser } from '../ogg/vorbis/VorbisParser.js';
+import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:FLAC');
@@ -26,7 +26,7 @@ const BlockType = {
 export class FlacParser extends AbstractID3Parser {
     constructor() {
         super(...arguments);
-        this.vorbisParser = new VorbisParser(this.metadata, this.options);
+        this.vorbisParser = new VorbisStream(this.metadata, this.options);
         this.padding = 0;
     }
     async postId3v2Parse() {

package/lib/ogg/OggParser.d.ts

@@ -1,6 +1,4 @@
-import { type IGetToken } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type * as Ogg from './Ogg.js';
 declare const OggContentError_base: {
     new (message: string): {
         readonly fileType: string;
@@ -15,20 +13,11 @@ declare const OggContentError_base: {
 };
 export declare class OggContentError extends OggContentError_base {
 }
-export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {
-    private static sum;
-    len: number;
-    constructor(header: Ogg.IPageHeader);
-    get(buf: Uint8Array, off: number): Ogg.ISegmentTable;
-}
 /**
  * Parser for Ogg logical bitstream framing
  */
 export declare class OggParser extends BasicParser {
-    private static Header;
-    private header;
-    private pageNumber;
-    private pageConsumer;
+    private streams;
     /**
      * Parse page
      * @returns {Promise<void>}

package/lib/ogg/OggParser.js

@@ -1,33 +1,70 @@
 import * as Token from 'token-types';
 import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
-import * as util from '../common/Util.js';
-import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
-import { VorbisParser } from './vorbis/VorbisParser.js';
-import { OpusParser } from './opus/OpusParser.js';
-import { SpeexParser } from './speex/SpeexParser.js';
-import { TheoraParser } from './theora/TheoraParser.js';
+import { VorbisStream } from './vorbis/VorbisStream.js';
+import { OpusStream } from './opus/OpusStream.js';
+import { SpeexStream } from './speex/SpeexStream.js';
+import { TheoraStream } from './theora/TheoraStream.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { PageHeader, SegmentTable } from './OggToken.js';
 export class OggContentError extends makeUnexpectedFileContentError('Ogg') {
 }
 const debug = initDebug('music-metadata:parser:ogg');
-export class SegmentTable {
-    static sum(buf, off, len) {
-        const dv = new DataView(buf.buffer, 0);
-        let s = 0;
-        for (let i = off; i < off + len; ++i) {
-            s += dv.getUint8(i);
-        }
-        return s;
-    }
-    constructor(header) {
-        this.len = header.page_segments;
+class OggStream {
+    constructor(metadata, streamSerial, options) {
+        this.pageNumber = 0;
+        this.closed = false;
+        this.metadata = metadata;
+        this.streamSerial = streamSerial;
+        this.options = options;
     }
-    get(buf, off) {
-        return {
-            totalPageSize: SegmentTable.sum(buf, off, this.len)
-        };
+    async parsePage(tokenizer, header) {
+        this.pageNumber = header.pageSequenceNo;
+        debug('serial=%s page#=%s, Ogg.id=%s', header.streamSerialNumber, header.pageSequenceNo, header.capturePattern);
+        const segmentTable = await tokenizer.readToken(new SegmentTable(header));
+        debug('totalPageSize=%s', segmentTable.totalPageSize);
+        const pageData = await 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 idData = pageData.slice(0, 7); // Copy this portion
+            switch (idData[0]) {
+                case 0x01:
+                case 0x80:
+                    idData[0] = 0x5F; // underscore
+                    break;
+            }
+            const id = new TextDecoder('latin1').decode(idData);
+            switch (id) {
+                case '_vorbis': // Ogg/Vorbis
+                    debug(`Set Ogg stream serial ${header.streamSerialNumber}, codec=Vorbis`);
+                    this.pageConsumer = new VorbisStream(this.metadata, this.options);
+                    break;
+                case 'OpusHea': // Ogg/Opus
+                    debug('Set page consumer to Ogg/Opus');
+                    this.pageConsumer = new OpusStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'Speex  ': // Ogg/Speex
+                    debug('Set page consumer to Ogg/Speex');
+                    this.pageConsumer = new SpeexStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'fishead':
+                case '_theora': // Ogg/Theora
+                    debug('Set page consumer to Ogg/Theora');
+                    this.pageConsumer = new TheoraStream(this.metadata, this.options, tokenizer);
+                    break;
+                default:
+                    throw new OggContentError(`Ogg codec not recognized (id=${id})`);
+            }
+        }
+        if (header.headerType.lastPage) {
+            this.closed = true;
+        }
+        if (this.pageConsumer) {
+            await this.pageConsumer.parsePage(header, pageData);
+        }
+        else
+            throw new Error('pageConsumer should be initialized');
     }
 }
 /**
@@ -36,98 +73,47 @@ export class SegmentTable {
 export class OggParser extends BasicParser {
     constructor() {
         super(...arguments);
-        this.header = null;
-        this.pageNumber = 0;
-        this.pageConsumer = null;
+        this.streams = new Map();
     }
     /**
      * Parse page
      * @returns {Promise<void>}
      */
     async parse() {
+        this.streams = new Map();
         debug('pos=%s, parsePage()', this.tokenizer.position);
+        let header;
         try {
-            let header;
             do {
-                header = await this.tokenizer.readToken(OggParser.Header);
+                header = await this.tokenizer.readToken(PageHeader);
                 if (header.capturePattern !== 'OggS')
                     throw new OggContentError('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 TextDecoder('ascii').decode(pageData.subarray(0, 7));
-                    switch (id) {
-                        case '\x01vorbis': // Ogg/Vorbis
-                            debug('Set page consumer to Ogg/Vorbis');
-                            this.pageConsumer = new VorbisParser(this.metadata, this.options);
-                            break;
-                        case 'OpusHea': // Ogg/Opus
-                            debug('Set page consumer to Ogg/Opus');
-                            this.pageConsumer = new OpusParser(this.metadata, this.options, this.tokenizer);
-                            break;
-                        case 'Speex  ': // Ogg/Speex
-                            debug('Set page consumer to Ogg/Speex');
-                            this.pageConsumer = new 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(this.metadata, this.options, this.tokenizer);
-                            break;
-                        default:
-                            throw new OggContentError(`gg audio-codec not recognized (id=${id})`);
-                    }
+                let stream = this.streams.get(header.streamSerialNumber);
+                if (!stream) {
+                    stream = new OggStream(this.metadata, header.streamSerialNumber, this.options);
+                    this.streams.set(header.streamSerialNumber, stream);
                 }
-                await this.pageConsumer.parsePage(header, pageData);
-            } while (!header.headerType.lastPage);
+                await stream.parsePage(this.tokenizer, header);
+            } while (![...this.streams.values()].every(item => item.closed));
         }
         catch (err) {
-            if (err instanceof Error) {
-                if (err instanceof 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');
-                        await this.pageConsumer.flush();
-                    }
-                }
+            if (err instanceof EndOfStreamError) {
+                debug("Reached end-of-stream");
+            }
+            else if (err instanceof OggContentError) {
+                this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
             }
             else
                 throw err;
         }
+        for (const stream of this.streams.values()) {
+            if (!stream.closed) {
+                this.metadata.addWarning(`End-of-stream reached before reaching last page in Ogg stream serial=${stream.streamSerial}`);
+                await stream.pageConsumer?.flush();
+            }
+            stream.pageConsumer?.calculateDuration();
+        }
     }
 }
-OggParser.Header = {
-    len: 27,
-    get: (buf, off) => {
-        return {
-            capturePattern: 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: Token.UINT8.get(buf, 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)
-        };
-    }
-};
 //# sourceMappingURL=OggParser.js.map

package/lib/ogg/{Ogg.d.ts → OggToken.d.ts}

@@ -1,3 +1,4 @@
+import type { IGetToken } from 'strtok3';
 /**
  * Page header
  * Ref: https://www.xiph.org/ogg/doc/framing.html#page_header
@@ -50,21 +51,27 @@ export interface IPageHeader {
      */
     page_segments: number;
 }
+export declare const PageHeader: IGetToken<IPageHeader>;
 export interface ISegmentTable {
     totalPageSize: number;
 }
+export declare class SegmentTable implements IGetToken<ISegmentTable> {
+    private static sum;
+    len: number;
+    constructor(header: IPageHeader);
+    get(buf: Uint8Array, off: number): ISegmentTable;
+}
 export interface IPageConsumer {
     /**
      * Parse Ogg page
-     * @param {IPageHeader} header Ogg page header
-     * @param {Buffer} pageData Ogg page data
+     * @param header Ogg page header
+     * @param pageData Ogg page data
      */
     parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
     /**
      * Calculate duration of provided header
-     * @param header Ogg header
      */
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Force to parse pending segments
      */

package/lib/ogg/OggToken.js

@@ -0,0 +1,42 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import { StringType } from 'token-types';
+export const PageHeader = {
+    len: 27,
+    get: (buf, off) => {
+        return {
+            capturePattern: new StringType(4, 'latin1').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: Token.UINT8.get(buf, 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)
+        };
+    }
+};
+export class SegmentTable {
+    static sum(buf, off, len) {
+        const dv = new DataView(buf.buffer, 0);
+        let s = 0;
+        for (let i = off; i < off + len; ++i) {
+            s += dv.getUint8(i);
+        }
+        return s;
+    }
+    constructor(header) {
+        this.len = header.page_segments;
+    }
+    get(buf, off) {
+        return {
+            totalPageSize: SegmentTable.sum(buf, off, this.len)
+        };
+    }
+}
+//# sourceMappingURL=OggToken.js.map

package/lib/ogg/opus/{OpusParser.d.ts → OpusStream.d.ts}

@@ -1,14 +1,14 @@
 import type { ITokenizer } from 'strtok3';
-import type { IPageHeader } from '../Ogg.js';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
- * Used by OggParser
+ * Used by OggStream
  */
-export declare class OpusParser extends VorbisParser {
+export declare class OpusStream extends VorbisStream {
     private idHeader;
     private lastPos;
     private tokenizer;
@@ -20,5 +20,5 @@ export declare class OpusParser extends VorbisParser {
      */
     protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
     protected parseFullPage(pageData: Uint8Array): Promise<void>;
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
 }

package/lib/ogg/opus/{OpusParser.js → OpusStream.js}

@@ -1,13 +1,13 @@
 import * as Token from 'token-types';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import * as Opus from './Opus.js';
 import { OpusContentError } from './Opus.js';
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
- * Used by OggParser
+ * Used by OggStream
  */
-export class OpusParser extends VorbisParser {
+export class OpusStream extends VorbisStream {
     constructor(metadata, options, tokenizer) {
         super(metadata, options);
         this.idHeader = null;
@@ -40,10 +40,10 @@ export class OpusParser extends VorbisParser {
                 break;
         }
     }
-    calculateDuration(header) {
-        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+    calculateDuration() {
+        if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
-            const pos_48bit = header.absoluteGranulePosition - this.idHeader.preSkip;
+            const pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
             this.metadata.setFormat('numberOfSamples', pos_48bit);
             this.metadata.setFormat('duration', pos_48bit / 48000);
             if (this.lastPos !== -1 && this.tokenizer.fileInfo.size && this.metadata.format.duration) {
@@ -53,4 +53,4 @@ export class OpusParser extends VorbisParser {
         }
     }
 }
-//# sourceMappingURL=OpusParser.js.map
+//# sourceMappingURL=OpusStream.js.map

package/lib/ogg/speex/{SpeexParser.d.ts → SpeexStream.d.ts}

@@ -1,6 +1,6 @@
 import type { ITokenizer } from 'strtok3';
-import type { IPageHeader } from '../Ogg.js';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
@@ -9,7 +9,7 @@ import type { INativeMetadataCollector } from '../../common/MetadataCollector.js
  * - https://www.speex.org/docs/manual/speex-manual/
  * - https://tools.ietf.org/html/rfc5574
  */
-export declare class SpeexParser extends VorbisParser {
+export declare class SpeexStream extends VorbisStream {
     private tokenizer;
     constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
     /**

package/lib/ogg/speex/{SpeexParser.js → SpeexStream.js}

@@ -1,5 +1,5 @@
 import initDebug from 'debug';
-import { VorbisParser } from '../vorbis/VorbisParser.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
 import * as Speex from './Speex.js';
 const debug = initDebug('music-metadata:parser:ogg:speex');
 /**
@@ -8,7 +8,7 @@ const debug = initDebug('music-metadata:parser:ogg:speex');
  * - https://www.speex.org/docs/manual/speex-manual/
  * - https://tools.ietf.org/html/rfc5574
  */
-export class SpeexParser extends VorbisParser {
+export class SpeexStream extends VorbisStream {
     constructor(metadata, options, tokenizer) {
         super(metadata, options);
         this.tokenizer = tokenizer;
@@ -30,4 +30,4 @@ export class SpeexParser extends VorbisParser {
         this.metadata.setAudioOnly();
     }
 }
-//# sourceMappingURL=SpeexParser.js.map
+//# sourceMappingURL=SpeexStream.js.map

package/lib/ogg/theora/{TheoraParser.d.ts → TheoraStream.d.ts}

@@ -1,12 +1,12 @@
 import type { ITokenizer } from 'strtok3';
-import type * as Ogg from '../Ogg.js';
+import type * as Ogg from '../OggToken.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 /**
  * Ref:
  * - https://theora.org/doc/Theora.pdf
  */
-export declare class TheoraParser implements Ogg.IPageConsumer {
+export declare class TheoraStream implements Ogg.IPageConsumer {
     private metadata;
     private tokenizer;
     constructor(metadata: INativeMetadataCollector, _options: IOptions, tokenizer: ITokenizer);
@@ -16,10 +16,10 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      * @param pageData Page data
      */
     parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
-    flush(): Promise<void>;
-    calculateDuration(_header: Ogg.IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Parse first Theora Ogg page. the initial identification header packet
      */
     protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    flush(): Promise<void>;
 }

package/lib/ogg/theora/{TheoraParser.js → TheoraStream.js}

@@ -5,7 +5,7 @@ const debug = initDebug('music-metadata:parser:ogg:theora');
  * Ref:
  * - https://theora.org/doc/Theora.pdf
  */
-export class TheoraParser {
+export class TheoraStream {
     constructor(metadata, _options, tokenizer) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
@@ -20,10 +20,7 @@ export class TheoraParser {
             await this.parseFirstPage(header, pageData);
         }
     }
-    async flush() {
-        debug('flush');
-    }
-    calculateDuration(_header) {
+    calculateDuration() {
         debug('duration calculation not implemented');
     }
     /**
@@ -34,7 +31,10 @@ export class TheoraParser {
         this.metadata.setFormat('codec', 'Theora');
         const idHeader = IdentificationHeader.get(pageData, 0);
         this.metadata.setFormat('bitrate', idHeader.nombr);
-        this.metadata.setAudioOnly();
+        this.metadata.setFormat('hasVideo', true);
+    }
+    flush() {
+        return Promise.resolve();
     }
 }
-//# sourceMappingURL=TheoraParser.js.map
+//# sourceMappingURL=TheoraStream.js.map

package/lib/ogg/vorbis/{VorbisParser.d.ts → VorbisStream.d.ts}

@@ -1,5 +1,5 @@
 import { type IVorbisPicture } from './Vorbis.js';
-import type { IPageConsumer, IPageHeader } from '../Ogg.js';
+import type { IPageConsumer, IPageHeader } from '../OggToken.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
 declare const VorbisContentError_base: {
@@ -18,12 +18,13 @@ export declare class VorbisContentError extends VorbisContentError_base {
 }
 /**
  * Vorbis 1 Parser.
- * Used by OggParser
+ * Used by OggStream
  */
-export declare class VorbisParser implements IPageConsumer {
+export declare class VorbisStream implements IPageConsumer {
     private pageSegments;
     protected metadata: INativeMetadataCollector;
     protected options: IOptions;
+    protected lastPageHeader?: IPageHeader;
     constructor(metadata: INativeMetadataCollector, options: IOptions);
     /**
      * Vorbis 1 parser
@@ -35,7 +36,7 @@ export declare class VorbisParser implements IPageConsumer {
     flush(): Promise<void>;
     parseUserComment(pageData: Uint8Array, offset: number): Promise<number>;
     addTag(id: string, value: string | IVorbisPicture): Promise<void>;
-    calculateDuration(header: IPageHeader): void;
+    calculateDuration(): void;
     /**
      * Parse first Ogg/Vorbis page
      * @param header

package/lib/ogg/vorbis/{VorbisParser.js → VorbisStream.js}

@@ -8,9 +8,9 @@ export class VorbisContentError extends makeUnexpectedFileContentError('Vorbis')
 }
 /**
  * Vorbis 1 Parser.
- * Used by OggParser
+ * Used by OggStream
  */
-export class VorbisParser {
+export class VorbisStream {
     constructor(metadata, options) {
         this.pageSegments = [];
         this.metadata = metadata;
@@ -22,6 +22,7 @@ export class VorbisParser {
      * @param pageData Page data
      */
     async parsePage(header, pageData) {
+        this.lastPageHeader = header;
         if (header.headerType.firstPage) {
             this.parseFirstPage(header, pageData);
         }
@@ -35,16 +36,13 @@ export class VorbisParser {
             if (header.headerType.lastPage || !header.headerType.continued) {
                 // Flush page segments
                 if (this.pageSegments.length > 0) {
-                    const fullPage = VorbisParser.mergeUint8Arrays(this.pageSegments);
+                    const fullPage = VorbisStream.mergeUint8Arrays(this.pageSegments);
                     await this.parseFullPage(fullPage);
                 }
                 // Reset page segments
                 this.pageSegments = header.headerType.lastPage ? [] : [pageData];
             }
         }
-        if (header.headerType.lastPage) {
-            this.calculateDuration(header);
-        }
     }
     static mergeUint8Arrays(arrays) {
         const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
@@ -56,7 +54,7 @@ export class VorbisParser {
         return merged;
     }
     async flush() {
-        await this.parseFullPage(VorbisParser.mergeUint8Arrays(this.pageSegments));
+        await this.parseFullPage(VorbisStream.mergeUint8Arrays(this.pageSegments));
     }
     async parseUserComment(pageData, offset) {
         const decoder = new VorbisDecoder(pageData, offset);
@@ -78,11 +76,11 @@ export class VorbisParser {
         }
         await this.metadata.addTag('vorbis', id, value);
     }
-    calculateDuration(header) {
-        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+    calculateDuration() {
+        if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
-            this.metadata.setFormat('numberOfSamples', header.absoluteGranulePosition);
-            this.metadata.setFormat('duration', header.absoluteGranulePosition / this.metadata.format.sampleRate);
+            this.metadata.setFormat('numberOfSamples', this.lastPageHeader.absoluteGranulePosition);
+            this.metadata.setFormat('duration', this.lastPageHeader.absoluteGranulePosition / this.metadata.format.sampleRate);
         }
     }
     /**
@@ -92,7 +90,7 @@ export class VorbisParser {
      */
     parseFirstPage(_header, pageData) {
         this.metadata.setFormat('codec', 'Vorbis I');
-        this.metadata.setAudioOnly();
+        this.metadata.setFormat('hasAudio', true);
         debug('Parse first page');
         // Parse  Vorbis common header
         const commonHeader = CommonHeader.get(pageData, 0);
@@ -135,4 +133,4 @@ export class VorbisParser {
         }
     }
 }
-//# sourceMappingURL=VorbisParser.js.map
+//# sourceMappingURL=VorbisStream.js.map