music-metadata 11.10.2 → 11.10.3

package/lib/mp4/MP4Parser.d.ts

@@ -2,14 +2,12 @@ import { BasicParser } from '../common/BasicParser.js';
 import { Atom } from './Atom.js';
 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;
-    private calculateBitRate;
     private addTag;
     private addWarning;
     /**

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 { ChapterTrackReferenceBox, Mp4ContentError, } from './AtomToken.js';
+import { ChapterTrackReferenceBox, Mp4ContentError } from './AtomToken.js';
 import { TrackType } from '../type.js';
 import { uint8ArrayToHex } from 'uint8array-extras';
 import { textDecode } from '@borewit/text-codec';
@@ -93,7 +93,6 @@ function distinct(value, index, self) {
 export class MP4Parser extends BasicParser {
     constructor() {
         super(...arguments);
-        this.audioLengthInBytes = 0;
         this.tracks = new Map();
         this.hasVideoTrack = false;
         this.hasAudioTrack = true;
@@ -121,8 +120,6 @@ export class MP4Parser extends BasicParser {
              * Will scan for chapters
              */
             mdat: async (len) => {
-                this.audioLengthInBytes += len;
-                this.calculateBitRate();
                 if (this.options.includeChapters) {
                     const trackWithChapters = [...this.tracks.values()].filter(track => track.chapterList);
                     if (trackWithChapters.length === 1) {
@@ -183,7 +180,6 @@ export class MP4Parser extends BasicParser {
     async parse() {
         this.hasVideoTrack = false;
         this.hasAudioTrack = true;
-        this.audioLengthInBytes = 0;
         this.tracks.clear();
         let remainingFileSize = this.tokenizer.fileInfo.size || 0;
         while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
@@ -246,28 +242,42 @@ export class MP4Parser extends BasicParser {
         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];
+        // Calculate duration and bitrate of audio tracks
+        for (const audioTrack of audioTracks) {
             if (audioTrack.media.header && audioTrack.media.header.timeScale > 0) {
+                audioTrack.sampleRate = audioTrack.media.header.timeScale;
                 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);
+                    audioTrack.samples = audioTrack.media.header.duration;
+                    audioTrack.duration = audioTrack.samples / audioTrack.sampleRate;
                 }
-                else if (audioTrack.fragments.length > 0) {
+                if (audioTrack.fragments.length > 0) {
                     debug('Calculate duration defined in track fragments');
                     let totalTimeUnits = 0;
+                    audioTrack.sizeInBytes = 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");
+                            const dur = sample.sampleDuration ?? fragment.header.defaultSampleDuration ?? 0;
+                            const size = sample.sampleSize ?? fragment.header.defaultSampleSize ?? 0;
+                            if (dur === 0) {
+                                throw new Error("Missing sampleDuration and no defaultSampleDuration in track fragment header");
+                            }
+                            if (size === 0) {
+                                throw new Error("Missing sampleSize and no defaultSampleSize in track fragment header");
                             }
                             totalTimeUnits += dur;
+                            audioTrack.sizeInBytes += size;
                         }
                     }
-                    this.metadata.setFormat('duration', totalTimeUnits / audioTrack.media.header.timeScale);
+                    if (!audioTrack.samples) {
+                        audioTrack.samples = totalTimeUnits;
+                    }
+                    if (!audioTrack.duration) {
+                        audioTrack.duration = totalTimeUnits / audioTrack.sampleRate;
+                    }
+                }
+                else if (audioTrack.sampleSizeTable.length > 0) {
+                    audioTrack.sizeInBytes = audioTrack.sampleSizeTable.reduce((sum, n) => sum + n, 0);
                 }
             }
             const ssd = audioTrack.soundSampleDescription[0];
@@ -279,15 +289,22 @@ export class MP4Parser extends BasicParser {
                     const totalSampleSize = audioTrack.timeToSampleTable
                         .map(ttstEntry => ttstEntry.count * ttstEntry.duration)
                         .reduce((total, sampleSize) => total + sampleSize);
-                    const duration = totalSampleSize / ssd.description.sampleRate;
-                    this.metadata.setFormat('duration', duration);
+                    audioTrack.duration = totalSampleSize / ssd.description.sampleRate;
                 }
             }
             const encoderInfo = encoderDict[ssd.dataFormat];
             if (encoderInfo) {
                 this.metadata.setFormat('lossless', !encoderInfo.lossy);
             }
-            this.calculateBitRate();
+        }
+        if (audioTracks.length >= 1) {
+            const firstAudioTrack = audioTracks[0];
+            if (firstAudioTrack.duration) {
+                this.metadata.setFormat('duration', firstAudioTrack.duration);
+                if (firstAudioTrack.sizeInBytes) {
+                    this.metadata.setFormat('bitrate', 8 * firstAudioTrack.sizeInBytes / firstAudioTrack.duration);
+                }
+            }
         }
         this.metadata.setFormat('hasAudio', this.hasAudioTrack);
         this.metadata.setFormat('hasVideo', this.hasVideoTrack);
@@ -325,11 +342,6 @@ export class MP4Parser extends BasicParser {
         const tracks = [...this.tracks.values()];
         return tracks[tracks.length - 1];
     }
-    calculateBitRate() {
-        if (this.audioLengthInBytes && this.metadata.format.duration) {
-            this.metadata.setFormat('bitrate', 8 * this.audioLengthInBytes / this.metadata.format.duration);
-        }
-    }
     async addTag(id, value) {
         await this.metadata.addTag(tagFormat, id, value);
     }
@@ -455,15 +467,13 @@ export class MP4Parser extends BasicParser {
                     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;
+                    track.isAudio = () => track.handler.handlerType === 'audi' || track.handler.handlerType === 'soun';
+                    track.isVideo = () => track.handler.handlerType === 'vide';
+                    if (track.isAudio()) {
+                        this.hasAudioTrack = true;
+                    }
+                    else if (track.isVideo()) {
+                        this.hasVideoTrack = true;
                     }
                     break;
                 case 'mdhd': { // Parse media header (mdhd) box

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "11.10.2",
+  "version": "11.10.3",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -117,7 +117,7 @@
     "uint8array-extras": "^1.5.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.5",
+    "@biomejs/biome": "2.3.7",
     "@types/chai": "^5.2.2",
     "@types/chai-as-promised": "^8.0.2",
     "@types/content-type": "^1.1.9",