@dragon708/docmind-markdown 1.2.3 → 1.2.6

package/node_modules/music-metadata/lib/mp4/MP4Parser.js

@@ -1,14 +1,14 @@
-import initDebug from 'debug';
-import * as Token from 'token-types';
-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 { TrackType } from '../type.js';
-import { uint8ArrayToHex } from 'uint8array-extras';
-import { textDecode } from '@borewit/text-codec';
-const debug = initDebug('music-metadata:parser:MP4');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MP4Parser = void 0;
+const debug_1 = require("debug");
+const Token = require("token-types");
+const BasicParser_1 = require("../common/BasicParser");
+const ID3v1Parser_1 = require("../id3v1/ID3v1Parser");
+const type_1 = require("../type");
+const Atom_1 = require("./Atom");
+const AtomToken = require("./AtomToken");
+const debug = (0, debug_1.default)('music-metadata:parser:MP4');
 const tagFormat = 'iTunes';
 const encoderDict = {
     raw: {
@@ -90,12 +90,9 @@ function distinct(value, index, self) {
  *   https://github.com/sergiomb2/libmp4v2/wiki/iTunesMetadata
  *   https://wiki.multimedia.cx/index.php/QuickTime_container
  */
-export class MP4Parser extends BasicParser {
+class MP4Parser extends BasicParser_1.BasicParser {
     constructor() {
         super(...arguments);
-        this.tracks = new Map();
-        this.hasVideoTrack = false;
-        this.hasAudioTrack = true;
         this.atomParsers = {
             /**
              * Parse movie header (mvhd) atom
@@ -106,6 +103,19 @@ export class MP4Parser extends BasicParser {
                 this.metadata.setFormat('creationTime', mvhd.creationTime);
                 this.metadata.setFormat('modificationTime', mvhd.modificationTime);
             },
+            /**
+             * Parse media header (mdhd) atom
+             * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25615
+             */
+            mdhd: async (len) => {
+                const mdhd_data = await this.tokenizer.readToken(new AtomToken.MdhdAtom(len));
+                // this.parse_mxhd(mdhd_data, this.currentTrack);
+                const td = this.getTrackDescription();
+                td.creationTime = mdhd_data.creationTime;
+                td.modificationTime = mdhd_data.modificationTime;
+                td.timeScale = mdhd_data.timeScale;
+                td.duration = mdhd_data.duration;
+            },
             chap: async (len) => {
                 const td = this.getTrackDescription();
                 const trackIds = [];
@@ -115,16 +125,22 @@ export class MP4Parser extends BasicParser {
                 }
                 td.chapterList = trackIds;
             },
+            tkhd: async (len) => {
+                const track = (await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(len)));
+                this.tracks.push(track);
+            },
             /**
              * Parse mdat atom.
              * 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);
+                    const trackWithChapters = this.tracks.filter(track => track.chapterList);
                     if (trackWithChapters.length === 1) {
                         const chapterTrackIds = trackWithChapters[0].chapterList;
-                        const chapterTracks = [...this.tracks.values()].filter(track => chapterTrackIds.indexOf(track.header.trackId) !== -1);
+                        const chapterTracks = this.tracks.filter(track => chapterTrackIds.indexOf(track.trackId) !== -1);
                         if (chapterTracks.length === 1) {
                             return this.parseChapterTrack(chapterTracks[0], trackWithChapters[0], len);
                         }
@@ -154,6 +170,20 @@ export class MP4Parser extends BasicParser {
                 const trackDescription = this.getTrackDescription();
                 trackDescription.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
             },
+            /**
+             * sample-to-Chunk Atoms
+             */
+            stsc: async (len) => {
+                const stsc = await this.tokenizer.readToken(new AtomToken.StscAtom(len));
+                this.getTrackDescription().sampleToChunkTable = stsc.entries;
+            },
+            /**
+             * time-to-sample table
+             */
+            stts: async (len) => {
+                const stts = await this.tokenizer.readToken(new AtomToken.SttsAtom(len));
+                this.getTrackDescription().timeToSampleTable = stts.entries;
+            },
             /**
              * Parse sample-sizes atom ('stsz')
              */
@@ -163,9 +193,16 @@ export class MP4Parser extends BasicParser {
                 td.sampleSize = stsz.sampleSize;
                 td.sampleSizeTable = stsz.entries;
             },
+            /**
+             * Parse chunk-offset atom ('stco')
+             */
+            stco: async (len) => {
+                const stco = await this.tokenizer.readToken(new AtomToken.StcoAtom(len));
+                this.getTrackDescription().chunkOffsetTable = stco.entries; // remember chunk offsets
+            },
             date: async (len) => {
                 const date = await this.tokenizer.readToken(new Token.StringType(len, 'utf-8'));
-                await this.addTag('date', date);
+                this.addTag('date', date);
             }
         };
     }
@@ -173,15 +210,13 @@ export class MP4Parser extends BasicParser {
         const integerType = (signed ? 'INT' : 'UINT') + array.length * 8 + (array.length > 1 ? '_BE' : '');
         const token = Token[integerType];
         if (!token) {
-            throw new Mp4ContentError(`Token for integer type not found: "${integerType}"`);
+            throw new Error('Token for integer type not found: "' + integerType + '"');
         }
         return Number(token.get(array, 0));
     }
     async parse() {
-        this.hasVideoTrack = false;
-        this.hasAudioTrack = true;
-        this.tracks.clear();
-        let remainingFileSize = this.tokenizer.fileInfo.size || 0;
+        this.tracks = [];
+        let remainingFileSize = this.tokenizer.fileInfo.size;
         while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
             try {
                 const token = await this.tokenizer.peekToken(AtomToken.Header);
@@ -193,16 +228,12 @@ export class MP4Parser extends BasicParser {
                 }
             }
             catch (error) {
-                if (error instanceof Error) {
-                    const errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
-                    debug(errMsg);
-                    this.addWarning(errMsg);
-                }
-                else
-                    throw error;
+                const errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
+                debug(errMsg);
+                this.addWarning(errMsg);
                 break;
             }
-            const rootAtom = await Atom.readAtom(this.tokenizer, (atom, remaining) => this.handleAtom(atom, remaining), null, remainingFileSize);
+            const rootAtom = await Atom_1.Atom.readAtom(this.tokenizer, (atom, remaining) => this.handleAtom(atom, remaining), null, remainingFileSize);
             remainingFileSize -= rootAtom.header.length === BigInt(0) ? remainingFileSize : Number(rootAtom.header.length);
         }
         // Post process metadata
@@ -222,7 +253,7 @@ export class MP4Parser extends BasicParser {
                 if (ssd.description) {
                     const { description } = ssd;
                     if (description.sampleRate > 0) {
-                        streamInfo.type = TrackType.audio;
+                        streamInfo.type = type_1.TrackType.audio;
                         streamInfo.audio = {
                             samplingFrequency: description.sampleRate,
                             bitDepth: description.sampleSize,
@@ -239,75 +270,34 @@ export class MP4Parser extends BasicParser {
         if (formatList.length > 0) {
             this.metadata.setFormat('codec', formatList.filter(distinct).join('+'));
         }
-        const audioTracks = [...this.tracks.values()].filter(track => {
+        const audioTracks = this.tracks.filter(track => {
             return track.soundSampleDescription.length >= 1 && track.soundSampleDescription[0].description && track.soundSampleDescription[0].description.numAudioChannels > 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');
-                    audioTrack.samples = audioTrack.media.header.duration;
-                    audioTrack.duration = audioTrack.samples / audioTrack.sampleRate;
-                }
-                if (audioTrack.fragments.length > 0) {
-                    debug('Calculate duration defined in track fragments');
-                    let totalTimeUnits = 0;
-                    audioTrack.sizeInBytes = 0;
-                    for (const fragment of audioTrack.fragments) {
-                        for (const sample of fragment.trackRun.samples) {
-                            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;
-                        }
-                    }
-                    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);
-                }
+        if (audioTracks.length >= 1) {
+            const audioTrack = audioTracks[0];
+            if (audioTrack.timeScale > 0) {
+                const duration = audioTrack.duration / audioTrack.timeScale; // calculate duration in seconds
+                this.metadata.setFormat('duration', duration);
             }
             const ssd = audioTrack.soundSampleDescription[0];
-            if (ssd.description && audioTrack.media.header) {
+            if (ssd.description) {
                 this.metadata.setFormat('sampleRate', ssd.description.sampleRate);
                 this.metadata.setFormat('bitsPerSample', ssd.description.sampleSize);
                 this.metadata.setFormat('numberOfChannels', ssd.description.numAudioChannels);
-                if (audioTrack.media.header.timeScale === 0 && audioTrack.timeToSampleTable.length > 0) {
+                if (audioTrack.timeScale === 0 && audioTrack.timeToSampleTable.length > 0) {
                     const totalSampleSize = audioTrack.timeToSampleTable
                         .map(ttstEntry => ttstEntry.count * ttstEntry.duration)
                         .reduce((total, sampleSize) => total + sampleSize);
-                    audioTrack.duration = totalSampleSize / ssd.description.sampleRate;
+                    const duration = totalSampleSize / ssd.description.sampleRate;
+                    this.metadata.setFormat('duration', duration);
                 }
             }
             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);
     }
     async handleAtom(atom, remaining) {
         if (atom.parent) {
@@ -315,38 +305,30 @@ export class MP4Parser extends BasicParser {
                 case 'ilst':
                 case '<id>':
                     return this.parseMetadataItemData(atom);
-                case 'moov':
-                    switch (atom.header.name) {
-                        case 'trak':
-                            return this.parseTrackBox(atom);
-                        case 'udta':
-                            return this.parseTrackBox(atom);
-                    }
-                    break;
-                case 'moof':
-                    switch (atom.header.name) {
-                        case 'traf':
-                            return this.parseTrackFragmentBox(atom);
-                    }
             }
         }
         // const payloadLength = atom.getPayloadLength(remaining);
         if (this.atomParsers[atom.header.name]) {
             return this.atomParsers[atom.header.name](remaining);
         }
-        debug(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`);
-        await this.tokenizer.ignore(remaining);
+        else {
+            debug(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`);
+            await this.tokenizer.ignore(remaining);
+        }
     }
     getTrackDescription() {
-        // ToDo: pick the right track, not the last track!!!!
-        const tracks = [...this.tracks.values()];
-        return tracks[tracks.length - 1];
+        return this.tracks[this.tracks.length - 1];
     }
-    async addTag(id, value) {
-        await this.metadata.addTag(tagFormat, id, value);
+    calculateBitRate() {
+        if (this.audioLengthInBytes && this.metadata.format.duration) {
+            this.metadata.setFormat('bitrate', 8 * this.audioLengthInBytes / this.metadata.format.duration);
+        }
+    }
+    addTag(id, value) {
+        this.metadata.addTag(tagFormat, id, value);
     }
     addWarning(message) {
-        debug(`Warning: ${message}`);
+        debug('Warning: ' + message);
         this.metadata.addWarning(message);
     }
     /**
@@ -363,22 +345,20 @@ export class MP4Parser extends BasicParser {
                     return this.parseValueAtom(tagKey, child);
                 case 'name': // name atom (optional)
                 case 'mean':
-                case 'rate': {
+                case 'rate':
                     const name = await this.tokenizer.readToken(new AtomToken.NameAtom(payLoadLength));
-                    tagKey += `:${name.name}`;
+                    tagKey += ':' + name.name;
                     break;
-                }
-                default: {
-                    const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(payLoadLength));
-                    this.addWarning(`Unsupported meta-item: ${tagKey}[${child.header.name}] => value=${uint8ArrayToHex(uint8Array)} ascii=${textDecode(uint8Array, 'ascii')}`);
-                }
+                default:
+                    const dataAtom = await this.tokenizer.readToken(new Token.BufferType(payLoadLength));
+                    this.addWarning('Unsupported meta-item: ' + tagKey + '[' + child.header.name + '] => value=' + dataAtom.toString('hex') + ' ascii=' + dataAtom.toString('ascii'));
             }
         }, metaAtom.getPayloadLength(0));
     }
     async parseValueAtom(tagKey, metaAtom) {
         const dataAtom = await this.tokenizer.readToken(new AtomToken.DataAtom(Number(metaAtom.header.length) - AtomToken.Header.len));
         if (dataAtom.type.set !== 0) {
-            throw new Mp4ContentError(`Unsupported type-set != 0: ${dataAtom.type.set}`);
+            throw new Error('Unsupported type-set != 0: ' + dataAtom.type.set);
         }
         // Use well-known-type table
         // Ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW35
@@ -386,171 +366,65 @@ export class MP4Parser extends BasicParser {
             case 0: // reserved: Reserved for use where no type needs to be indicated
                 switch (tagKey) {
                     case 'trkn':
-                    case 'disk': {
+                    case 'disk':
                         const num = Token.UINT8.get(dataAtom.value, 3);
                         const of = Token.UINT8.get(dataAtom.value, 5);
                         // console.log("  %s[data] = %s/%s", tagKey, num, of);
-                        await this.addTag(tagKey, `${num}/${of}`);
+                        this.addTag(tagKey, num + '/' + of);
                         break;
-                    }
-                    case 'gnre': {
+                    case 'gnre':
                         const genreInt = Token.UINT8.get(dataAtom.value, 1);
-                        const genreStr = Genres[genreInt - 1];
+                        const genreStr = ID3v1Parser_1.Genres[genreInt - 1];
                         // console.log("  %s[data] = %s", tagKey, genreStr);
-                        await this.addTag(tagKey, genreStr);
+                        this.addTag(tagKey, genreStr);
                         break;
-                    }
-                    case 'rate': {
-                        const rate = textDecode(dataAtom.value, 'ascii');
-                        await this.addTag(tagKey, rate);
+                    case 'rate':
+                        const rate = dataAtom.value.toString('ascii');
+                        this.addTag(tagKey, rate);
                         break;
-                    }
                     default:
-                        debug(`unknown proprietary value type for: ${metaAtom.atomPath}`);
+                        debug('unknown proprietary value type for: ' + metaAtom.atomPath);
                 }
                 break;
             case 1: // UTF-8: Without any count or NULL terminator
             case 18: // Unknown: Found in m4b in combination with a '©gen' tag
-                await this.addTag(tagKey, textDecode(dataAtom.value));
+                this.addTag(tagKey, dataAtom.value.toString('utf-8'));
                 break;
             case 13: // JPEG
                 if (this.options.skipCovers)
                     break;
-                await this.addTag(tagKey, {
+                this.addTag(tagKey, {
                     format: 'image/jpeg',
-                    data: Uint8Array.from(dataAtom.value)
+                    data: Buffer.from(dataAtom.value)
                 });
                 break;
             case 14: // PNG
                 if (this.options.skipCovers)
                     break;
-                await this.addTag(tagKey, {
+                this.addTag(tagKey, {
                     format: 'image/png',
-                    data: Uint8Array.from(dataAtom.value)
+                    data: Buffer.from(dataAtom.value)
                 });
                 break;
             case 21: // BE Signed Integer
-                await this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, true));
+                this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, true));
                 break;
             case 22: // BE Unsigned Integer
-                await this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, false));
+                this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, false));
                 break;
             case 65: // An 8-bit signed integer
-                await this.addTag(tagKey, Token.UINT8.get(dataAtom.value, 0));
+                this.addTag(tagKey, dataAtom.value.readInt8(0));
                 break;
             case 66: // A big-endian 16-bit signed integer
-                await this.addTag(tagKey, Token.UINT16_BE.get(dataAtom.value, 0));
+                this.addTag(tagKey, dataAtom.value.readInt16BE(0));
                 break;
             case 67: // A big-endian 32-bit signed integer
-                await this.addTag(tagKey, Token.UINT32_BE.get(dataAtom.value, 0));
+                this.addTag(tagKey, dataAtom.value.readInt32BE(0));
                 break;
             default:
                 this.addWarning(`atom key=${tagKey}, has unknown well-known-type (data-type): ${dataAtom.type.type}`);
         }
     }
-    async parseTrackBox(trakBox) {
-        // @ts-expect-error
-        const track = {
-            media: {},
-            fragments: []
-        };
-        await trakBox.readAtoms(this.tokenizer, async (child, remaining) => {
-            const payLoadLength = child.getPayloadLength(remaining);
-            switch (child.header.name) {
-                case 'chap': {
-                    const chap = await this.tokenizer.readToken(new ChapterTrackReferenceBox(remaining));
-                    track.chapterList = chap;
-                    break;
-                }
-                case 'tkhd': // TrackHeaderBox
-                    track.header = await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(payLoadLength));
-                    break;
-                case 'hdlr': // TrackHeaderBox
-                    track.handler = await this.tokenizer.readToken(new AtomToken.HandlerBox(payLoadLength));
-                    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
-                    const mdhd_data = await this.tokenizer.readToken(new AtomToken.MdhdAtom(payLoadLength));
-                    track.media.header = mdhd_data;
-                    break;
-                }
-                case 'stco': {
-                    const stco = await this.tokenizer.readToken(new AtomToken.StcoAtom(payLoadLength));
-                    track.chunkOffsetTable = stco.entries; // remember chunk offsets
-                    break;
-                }
-                case 'stsc': { // sample-to-Chunk box
-                    const stsc = await this.tokenizer.readToken(new AtomToken.StscAtom(payLoadLength));
-                    track.sampleToChunkTable = stsc.entries;
-                    break;
-                }
-                case 'stsd': { // sample description box
-                    const stsd = await this.tokenizer.readToken(new AtomToken.StsdAtom(payLoadLength));
-                    track.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
-                    break;
-                }
-                case 'stts': { // time-to-sample table
-                    const stts = await this.tokenizer.readToken(new AtomToken.SttsAtom(payLoadLength));
-                    track.timeToSampleTable = stts.entries;
-                    break;
-                }
-                case 'stsz': {
-                    const stsz = await this.tokenizer.readToken(new AtomToken.StszAtom(payLoadLength));
-                    track.sampleSize = stsz.sampleSize;
-                    track.sampleSizeTable = stsz.entries;
-                    break;
-                }
-                case 'dinf':
-                case 'vmhd':
-                case 'smhd':
-                    debug(`Ignoring: ${child.header.name}`);
-                    await this.tokenizer.ignore(payLoadLength);
-                    break;
-                default: {
-                    debug(`Unexpected track box: ${child.header.name}`);
-                    await this.tokenizer.ignore(payLoadLength);
-                }
-            }
-        }, trakBox.getPayloadLength(0));
-        // Register track
-        this.tracks.set(track.header.trackId, track);
-    }
-    parseTrackFragmentBox(trafBox) {
-        let tfhd;
-        return trafBox.readAtoms(this.tokenizer, async (child, remaining) => {
-            const payLoadLength = child.getPayloadLength(remaining);
-            switch (child.header.name) {
-                case 'tfhd': { // TrackFragmentHeaderBox
-                    const fragmentHeaderBox = new AtomToken.TrackFragmentHeaderBox(child.getPayloadLength(remaining));
-                    tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
-                    break;
-                }
-                case 'tfdt': // TrackFragmentBaseMediaDecodeTimeBo
-                    await this.tokenizer.ignore(payLoadLength);
-                    break;
-                case 'trun': { // TrackRunBox
-                    const trackRunBox = new AtomToken.TrackRunBox(payLoadLength);
-                    const trun = await this.tokenizer.readToken(trackRunBox);
-                    if (tfhd) {
-                        const track = this.tracks.get(tfhd.trackId);
-                        track?.fragments.push({ header: tfhd, trackRun: trun });
-                    }
-                    break;
-                }
-                default: {
-                    debug(`Unexpected box: ${child.header.name}`);
-                    await this.tokenizer.ignore(payLoadLength);
-                }
-            }
-        }, trafBox.getPayloadLength(0));
-    }
     /**
      * @param sampleDescription
      * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html#//apple_ref/doc/uid/TP40000939-CH205-128916
@@ -561,16 +435,14 @@ export class MP4Parser extends BasicParser {
             dataReferenceIndex: sampleDescription.dataReferenceIndex
         };
         let offset = 0;
-        if (sampleDescription.description) {
-            const version = AtomToken.SoundSampleDescriptionVersion.get(sampleDescription.description, offset);
-            offset += AtomToken.SoundSampleDescriptionVersion.len;
-            if (version.version === 0 || version.version === 1) {
-                // Sound Sample Description (Version 0)
-                ssd.description = AtomToken.SoundSampleDescriptionV0.get(sampleDescription.description, offset);
-            }
-            else {
-                debug(`Warning: sound-sample-description ${version} not implemented`);
-            }
+        const version = AtomToken.SoundSampleDescriptionVersion.get(sampleDescription.description, offset);
+        offset += AtomToken.SoundSampleDescriptionVersion.len;
+        if (version.version === 0 || version.version === 1) {
+            // Sound Sample Description (Version 0)
+            ssd.description = AtomToken.SoundSampleDescriptionV0.get(sampleDescription.description, offset);
+        }
+        else {
+            debug(`Warning: sound-sample-description ${version} not implemented`);
         }
         return ssd;
     }
@@ -581,31 +453,31 @@ export class MP4Parser extends BasicParser {
         }
         const chapters = [];
         for (let i = 0; i < chapterTrack.chunkOffsetTable.length && len > 0; ++i) {
-            const start = chapterTrack.timeToSampleTable
-                .slice(0, i)
-                .reduce((acc, cur) => acc + cur.duration, 0);
             const chunkOffset = chapterTrack.chunkOffsetTable[i];
             const nextChunkLen = chunkOffset - this.tokenizer.position;
             const sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i];
             len -= nextChunkLen + sampleSize;
             if (len < 0)
-                throw new Mp4ContentError('Chapter chunk exceeding token length');
+                throw new Error('Chapter chunk exceeding token length');
             await this.tokenizer.ignore(nextChunkLen);
             const title = await this.tokenizer.readToken(new AtomToken.ChapterText(sampleSize));
             debug(`Chapter ${i + 1}: ${title}`);
             const chapter = {
                 title,
-                timeScale: chapterTrack.media.header ? chapterTrack.media.header.timeScale : 0,
-                start,
                 sampleOffset: this.findSampleOffset(track, this.tokenizer.position)
             };
-            debug(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${track.header.duration}`); // ToDo, use media duration if required!!!
+            debug(`Chapter title=${chapter.title}, offset=${chapter.sampleOffset}/${this.tracks[0].duration}`);
             chapters.push(chapter);
         }
         this.metadata.setFormat('chapters', chapters);
         await this.tokenizer.ignore(len);
     }
     findSampleOffset(track, chapterOffset) {
+        let totalDuration = 0;
+        track.timeToSampleTable.forEach(e => {
+            totalDuration += e.count * e.duration;
+        });
+        debug(`Total duration=${totalDuration}`);
         let chunkIndex = 0;
         while (chunkIndex < track.chunkOffsetTable.length && track.chunkOffsetTable[chunkIndex] < chapterOffset) {
             ++chunkIndex;
@@ -645,3 +517,4 @@ export class MP4Parser extends BasicParser {
         return stcTable[stcTable.length - 1].samplesPerChunk;
     }
 }
+exports.MP4Parser = MP4Parser;

package/node_modules/music-metadata/lib/mp4/MP4TagMapper.d.ts

@@ -1,8 +1,8 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-import type { ITag } from "../type.js";
-import type { INativeMetadataCollector } from "../common/MetadataCollector.js";
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap';
+import { ITag } from "../type";
+import { INativeMetadataCollector } from "../common/MetadataCollector";
 export declare const tagType = "iTunes";
 export declare class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor();
-    protected postMap(tag: ITag, _warnings: INativeMetadataCollector): void;
+    protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
 }

package/node_modules/music-metadata/lib/mp4/MP4TagMapper.js

@@ -1,4 +1,7 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MP4TagMapper = exports.tagType = void 0;
+const CaseInsensitiveTagMap_1 = require("../common/CaseInsensitiveTagMap");
 /**
  * Ref: https://github.com/sergiomb2/libmp4v2/wiki/iTunesMetadata
  */
@@ -84,12 +87,11 @@ const mp4TagMap = {
     '----:com.apple.iTunes:replaygain_album_minmax': 'replaygain_album_minmax',
     '----:com.apple.iTunes:replaygain_undo': 'replaygain_undo',
     // Additional mappings:
-    gnre: 'genre', // ToDo: check mapping
+    gnre: 'genre',
     '----:com.apple.iTunes:ALBUMARTISTSORT': 'albumartistsort',
     '----:com.apple.iTunes:ARTISTS': 'artists',
     '----:com.apple.iTunes:ORIGINALDATE': 'originaldate',
     '----:com.apple.iTunes:ORIGINALYEAR': 'originalyear',
-    '----:com.apple.iTunes:RELEASEDATE': 'releasedate',
     // '----:com.apple.iTunes:PERFORMER': 'performer'
     desc: 'description',
     ldes: 'longDescription',
@@ -105,19 +107,21 @@ const mp4TagMap = {
     stik: 'stik',
     rate: 'rating'
 };
-export const tagType = 'iTunes';
-export class MP4TagMapper extends CaseInsensitiveTagMap {
+exports.tagType = 'iTunes';
+class MP4TagMapper extends CaseInsensitiveTagMap_1.CaseInsensitiveTagMap {
     constructor() {
-        super([tagType], mp4TagMap);
+        super([exports.tagType], mp4TagMap);
     }
-    postMap(tag, _warnings) {
+    postMap(tag, warnings) {
         switch (tag.id) {
             case 'rate':
                 tag.value = {
                     source: undefined,
-                    rating: Number.parseFloat(tag.value) / 100
+                    rating: parseFloat(tag.value) / 100
                 };
                 break;
         }
     }
 }
+exports.MP4TagMapper = MP4TagMapper;
+//# sourceMappingURL=MP4TagMapper.js.map