spessasynth_lib 3.24.38 → 3.24.40

package/README.md

@@ -43,6 +43,8 @@ Supported formats list:
 - `.rmi` - RIFF MIDI File
 - `.rmi` - RIFF MIDI File With Embedded DLS
 - `.rmi` - [RIFF MIDI File With Embedded SF2](https://github.com/spessasus/sf2-rmidi-specification)
+- `.xmf` - eXtensible Music Format
+- `.mxmf` - Mobile eXtensible Music format
 
 *With [an easy way of converting between them!](https://github.com/spessasus/SpessaSynth/wiki/Converting-Between-Formats)*
 

package/externals/fflate/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Arjun Barrett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/externals/fflate/fflate.min.js

@@ -0,0 +1 @@
+let tr;(()=>{var l=Uint8Array,T=Uint16Array,ur=Int32Array,W=new l([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),X=new l([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),wr=new l([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),Y=function(r,a){for(var e=new T(31),f=0;f<31;++f)e[f]=a+=1<<r[f-1];for(var v=new ur(e[30]),f=1;f<30;++f)for(var g=e[f];g<e[f+1];++g)v[g]=g-e[f]<<5|f;return{b:e,r:v}},Z=Y(W,2),$=Z.b,cr=Z.r;$[28]=258,cr[258]=28;var j=Y(X,0),hr=j.b,Fr=j.r,_=new T(32768);for(i=0;i<32768;++i)c=(i&43690)>>1|(i&21845)<<1,c=(c&52428)>>2|(c&13107)<<2,c=(c&61680)>>4|(c&3855)<<4,_[i]=((c&65280)>>8|(c&255)<<8)>>1;var c,i,A=function(r,a,e){for(var f=r.length,v=0,g=new T(a);v<f;++v)r[v]&&++g[r[v]-1];var k=new T(a);for(v=1;v<a;++v)k[v]=k[v-1]+g[v-1]<<1;var b;if(e){b=new T(1<<a);var m=15-a;for(v=0;v<f;++v)if(r[v])for(var U=v<<4|r[v],x=a-r[v],n=k[r[v]-1]++<<x,o=n|(1<<x)-1;n<=o;++n)b[_[n]>>m]=U}else for(b=new T(f),v=0;v<f;++v)r[v]&&(b[v]=_[k[r[v]-1]++]>>15-r[v]);return b},M=new l(288);for(i=0;i<144;++i)M[i]=8;var i;for(i=144;i<256;++i)M[i]=9;var i;for(i=256;i<280;++i)M[i]=7;var i;for(i=280;i<288;++i)M[i]=8;var i,L=new l(32);for(i=0;i<32;++i)L[i]=5;var i,gr=A(M,9,1),br=A(L,5,1),q=function(r){for(var a=r[0],e=1;e<r.length;++e)r[e]>a&&(a=r[e]);return a},u=function(r,a,e){var f=a/8|0;return(r[f]|r[f+1]<<8)>>(a&7)&e},C=function(r,a){var e=a/8|0;return(r[e]|r[e+1]<<8|r[e+2]<<16)>>(a&7)},kr=function(r){return(r+7)/8|0},xr=function(r,a,e){return(a==null||a<0)&&(a=0),(e==null||e>r.length)&&(e=r.length),new l(r.subarray(a,e))},yr=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],h=function(r,a,e){var f=new Error(a||yr[r]);if(f.code=r,Error.captureStackTrace&&Error.captureStackTrace(f,h),!e)throw f;return f},Sr=function(r,a,e,f){var v=r.length,g=f?f.length:0;if(!v||a.f&&!a.l)return e||new l(0);var k=!e,b=k||a.i!=2,m=a.i;k&&(e=new l(v*3));var U=function(fr){var or=e.length;if(fr>or){var lr=new l(Math.max(or*2,fr));lr.set(e),e=lr}},x=a.f||0,n=a.p||0,o=a.b||0,S=a.l,I=a.d,z=a.m,D=a.n,G=v*8;do{if(!S){x=u(r,n,1);var H=u(r,n+1,3);if(n+=3,H)if(H==1)S=gr,I=br,z=9,D=5;else if(H==2){var N=u(r,n,31)+257,s=u(r,n+10,15)+4,d=N+u(r,n+5,31)+1;n+=14;for(var F=new l(d),P=new l(19),t=0;t<s;++t)P[wr[t]]=u(r,n+t*3,7);n+=s*3;for(var rr=q(P),Ar=(1<<rr)-1,Mr=A(P,rr,1),t=0;t<d;){var ar=Mr[u(r,n,Ar)];n+=ar&15;var w=ar>>4;if(w<16)F[t++]=w;else{var E=0,O=0;for(w==16?(O=3+u(r,n,3),n+=2,E=F[t-1]):w==17?(O=3+u(r,n,7),n+=3):w==18&&(O=11+u(r,n,127),n+=7);O--;)F[t++]=E}}var er=F.subarray(0,N),y=F.subarray(N);z=q(er),D=q(y),S=A(er,z,1),I=A(y,D,1)}else h(1);else{var w=kr(n)+4,J=r[w-4]|r[w-3]<<8,K=w+J;if(K>v){m&&h(0);break}b&&U(o+J),e.set(r.subarray(w,K),o),a.b=o+=J,a.p=n=K*8,a.f=x;continue}if(n>G){m&&h(0);break}}b&&U(o+131072);for(var Ur=(1<<z)-1,zr=(1<<D)-1,Q=n;;Q=n){var E=S[C(r,n)&Ur],p=E>>4;if(n+=E&15,n>G){m&&h(0);break}if(E||h(2),p<256)e[o++]=p;else if(p==256){Q=n,S=null;break}else{var nr=p-254;if(p>264){var t=p-257,B=W[t];nr=u(r,n,(1<<B)-1)+$[t],n+=B}var R=I[C(r,n)&zr],V=R>>4;R||h(3),n+=R&15;var y=hr[V];if(V>3){var B=X[V];y+=C(r,n)&(1<<B)-1,n+=B}if(n>G){m&&h(0);break}b&&U(o+131072);var vr=o+nr;if(o<y){var ir=g-y,Dr=Math.min(y,vr);for(ir+o<0&&h(3);o<Dr;++o)e[o]=f[ir+o]}for(;o<vr;++o)e[o]=e[o-y]}}a.l=S,a.p=Q,a.b=o,a.f=x,S&&(x=1,a.m=z,a.d=I,a.n=D)}while(!x);return o!=e.length&&k?xr(e,0,o):e.subarray(0,o)},Tr=new l(0);function mr(r,a){return Sr(r,{i:2},a&&a.out,a&&a.dictionary)}var Er=typeof TextDecoder<"u"&&new TextDecoder,pr=0;try{Er.decode(Tr,{stream:!0}),pr=1}catch{}tr=mr})();export{tr as inflateSync};

package/midi_parser/basic_midi.js

@@ -59,6 +59,7 @@ class BasicMIDI extends MIDISequenceData
         m.format = mid.format;
         m.bankOffset = mid.bankOffset;
         m.isKaraokeFile = mid.isKaraokeFile;
+        m.isMultiPort = mid.isMultiPort;
         m.isDLSRMIDI = mid.isDLSRMIDI;
         
         // Copying arrays
@@ -452,6 +453,7 @@ class BasicMIDI extends MIDISequenceData
         }
         else
         {
+            this.isMultiPort = true;
             SpessaSynthInfo(`%cMIDI Ports detected!`, consoleColors.recognized);
         }
         

package/midi_parser/midi_data.js

@@ -44,6 +44,7 @@ export class MIDIData extends MIDISequenceData
         this.RMIDInfo = midi.RMIDInfo;
         this.bankOffset = midi.bankOffset;
         this.isKaraokeFile = midi.isKaraokeFile;
+        this.isMultiPort = midi.isMultiPort;
         
         // Set isEmbedded based on the presence of an embeddedSoundFont
         this.isEmbedded = midi.embeddedSoundFont !== undefined;

package/midi_parser/midi_loader.js

@@ -9,6 +9,7 @@ import { readBytesAsString } from "../utils/byte_functions/string.js";
 import { readLittleEndian } from "../utils/byte_functions/little_endian.js";
 import { RMIDINFOChunks } from "./rmidi_writer.js";
 import { BasicMIDI } from "./basic_midi.js";
+import { loadXMF } from "./xmf_loader.js";
 
 /**
  * midi_loader.js
@@ -145,6 +146,11 @@ class MIDI extends BasicMIDI
                 this.bankOffset = 0;
             }
         }
+        else if (initialString === "XMF_")
+        {
+            // XMF file
+            fileByteArray = loadXMF(this, binaryData);
+        }
         else
         {
             fileByteArray = binaryData;
@@ -212,7 +218,7 @@ class MIDI extends BasicMIDI
                 }
                 else
                 { // noinspection PointlessBooleanExpressionJS
-                    if (!runningByte && statusByteCheck < 0x80)
+                    if (runningByte === undefined && statusByteCheck < 0x80)
                     {
                         // if we don't have a running byte and the status byte isn't valid, it's an error.
                         SpessaSynthGroupEnd();

package/midi_parser/midi_sequence.js

@@ -144,6 +144,12 @@ class MIDISequenceData
      */
     isKaraokeFile = false;
     
+    /**
+     * Indicates if this file is a Multi-Port MIDI file.
+     * @type {boolean}
+     */
+    isMultiPort = false;
+    
     /**
      * Converts ticks to time in seconds
      * @param ticks {number} time in MIDI ticks

package/midi_parser/midi_writer.js

@@ -31,7 +31,7 @@ export function writeMIDI()
              */
             let messageData;
             // determine the message
-            if (event.messageStatusByte <= messageTypes.keySignature || event.messageStatusByte === messageTypes.sequenceSpecific)
+            if (event.messageStatusByte <= messageTypes.sequenceSpecific)
             {
                 // this is a meta-message
                 // syntax is FF<type><length><data>

package/midi_parser/xmf_loader.js

@@ -0,0 +1,454 @@
+import { readBytesAsString } from "../utils/byte_functions/string.js";
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
+import { consoleColors } from "../utils/other.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+import { readVariableLengthQuantity } from "../utils/byte_functions/variable_length_quantity.js";
+import { RMIDINFOChunks } from "./rmidi_writer.js";
+import { inflateSync } from "../externals/fflate/fflate.min.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+
+/**
+ * @enum {number}
+ */
+const metadataTypes = {
+    XMFFileType: 0,
+    nodeName: 1,
+    nodeIDNumber: 2,
+    resourceFormat: 3,
+    filenameOnDisk: 4,
+    filenameExtensionOnDisk: 5,
+    macOSFileTypeAndCreator: 6,
+    mimeType: 7,
+    title: 8,
+    copyrightNotice: 9,
+    comment: 10,
+    autoStart: 11,                 // Node Name of the FileNode containing the SMF image to autostart when the XMF file loads
+    preload: 12,                   // Used to preload specific SMF and DLS file images.
+    contentDescription: 13,        // RP-42a (https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp42.pdf)
+    ID3Metadata: 14                // RP-47 (https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp47.pdf)
+};
+
+/**
+ * @enum {number}
+ */
+const referenceTypeIds = {
+    inLineResource: 1,
+    inFileResource: 2,
+    inFileNode: 3,
+    externalFile: 4,
+    externalXMF: 5,
+    XMFFileURIandNodeID: 6
+};
+
+/**
+ * @enum {number}
+ */
+const resourceFormatIDs = {
+    StandardMIDIFile: 0,
+    StandardMIDIFileType1: 1,
+    DLS1: 2,
+    DLS2: 3,
+    DLS22: 4,
+    mobileDLS: 5
+};
+
+/**
+ * @enum {number}
+ */
+const formatTypeIDs = {
+    standard: 0,
+    MMA: 1,
+    registered: 2,
+    nonRegistered: 3
+};
+
+
+/**
+ * @enum {number}
+ */
+const unpackerIDs = {
+    none: 0,
+    MMAUnpacker: 1,
+    registered: 2,
+    nonRegistered: 3
+};
+
+class XMFNode
+{
+    /**
+     * @type {number}
+     */
+    length;
+    /**
+     * 0 means it's a file node
+     * @type {number}
+     */
+    itemCount;
+    /**
+     * @type {number}
+     */
+    metadataLength;
+    
+    /**
+     * @type {Object<string, any>}
+     */
+    metadata = {};
+    
+    /**
+     * @type {IndexedByteArray}
+     */
+    nodeData;
+    
+    /**
+     * @type {XMFNode[]}
+     */
+    innerNodes = [];
+    
+    packedContent = false;
+    
+    nodeUnpackers = [];
+    
+    
+    /**
+     * @type {"StandardMIDIFile"|
+     * "StandardMIDIFileType1"|
+     * "DLS1"|
+     * "DLS2"|
+     * "DLS22"|
+     * "mobileDLS"|
+     * "unknown"|"folder"}
+     */
+    resourceFormat = "unknown";
+    
+    /**
+     * @param binaryData {IndexedByteArray}
+     */
+    constructor(binaryData)
+    {
+        let nodeStartIndex = binaryData.currentIndex;
+        this.length = readVariableLengthQuantity(binaryData);
+        this.itemCount = readVariableLengthQuantity(binaryData);
+        // header length
+        const headerLength = readVariableLengthQuantity(binaryData);
+        const readBytes = binaryData.currentIndex - nodeStartIndex;
+        
+        const remainingHeader = headerLength - readBytes;
+        const headerData = binaryData.slice(
+            binaryData.currentIndex,
+            binaryData.currentIndex + remainingHeader
+        );
+        binaryData.currentIndex += remainingHeader;
+        
+        this.metadataLength = readVariableLengthQuantity(headerData);
+        
+        const metadataChunk = headerData.slice(
+            headerData.currentIndex,
+            headerData.currentIndex + this.metadataLength
+        );
+        headerData.currentIndex += this.metadataLength;
+        
+        /**
+         * @type {metadataTypes|string|number}
+         */
+        let fieldSpecifier;
+        let key;
+        while (metadataChunk.currentIndex < metadataChunk.length)
+        {
+            const firstSpecifierByte = metadataChunk[metadataChunk.currentIndex];
+            if (firstSpecifierByte === 0)
+            {
+                metadataChunk.currentIndex++;
+                fieldSpecifier = readVariableLengthQuantity(metadataChunk);
+                if (Object.values(metadataTypes).indexOf(fieldSpecifier) === -1)
+                {
+                    SpessaSynthWarn(`Unknown field specifier: ${fieldSpecifier}`);
+                    key = `unknown_${fieldSpecifier}`;
+                }
+                else
+                {
+                    key = Object.keys(metadataTypes).find(k => metadataTypes[k] === fieldSpecifier);
+                }
+            }
+            else
+            {
+                // this is the length of string
+                const stringLength = readVariableLengthQuantity(metadataChunk);
+                fieldSpecifier = readBytesAsString(metadataChunk, stringLength);
+                key = fieldSpecifier;
+            }
+            
+            const numberOfVersions = readVariableLengthQuantity(metadataChunk);
+            if (numberOfVersions === 0)
+            {
+                const dataLength = readVariableLengthQuantity(metadataChunk);
+                const contentsChunk = metadataChunk.slice(
+                    metadataChunk.currentIndex,
+                    metadataChunk.currentIndex + dataLength
+                );
+                metadataChunk.currentIndex += dataLength;
+                const formatID = readVariableLengthQuantity(contentsChunk);
+                // text only
+                if (formatID < 4)
+                {
+                    this.metadata[key] = readBytesAsString(contentsChunk, dataLength - 1);
+                }
+                else
+                {
+                    this.metadata[key] = contentsChunk.slice(contentsChunk.currentIndex);
+                }
+            }
+            else
+            {
+                // throw new Error ("International content is not supported.");
+                // Skip the number of versions
+                SpessaSynthWarn(`International content: ${numberOfVersions}`);
+                // Length in bytes
+                // Skip the whole thing!
+                metadataChunk.currentIndex += readVariableLengthQuantity(metadataChunk);
+            }
+        }
+        
+        const unpackersStart = headerData.currentIndex;
+        const unpackersLength = readVariableLengthQuantity(headerData);
+        const unpackersData = headerData.slice(headerData.currentIndex, unpackersStart + unpackersLength);
+        headerData.currentIndex = unpackersStart + unpackersLength;
+        if (unpackersLength > 0)
+        {
+            this.packedContent = true;
+            while (unpackersData.currentIndex < unpackersLength)
+            {
+                const unpacker = {};
+                unpacker.id = readVariableLengthQuantity(unpackersData);
+                switch (unpacker.id)
+                {
+                    case unpackerIDs.nonRegistered:
+                    case unpackerIDs.registered:
+                        SpessaSynthGroupEnd();
+                        throw new Error(`Unsupported unpacker ID: ${unpacker.id}`);
+                    
+                    default:
+                        SpessaSynthGroupEnd();
+                        throw new Error(`Unknown unpacker ID: ${unpacker.id}`);
+                    
+                    case unpackerIDs.none:
+                        unpacker.standardID = readVariableLengthQuantity(unpackersData);
+                        break;
+                    
+                    case unpackerIDs.MMAUnpacker:
+                        let manufacturerID = unpackersData[unpackersData.currentIndex++];
+                        // one or three byte form, depending on if the first byte is zero
+                        if (manufacturerID === 0)
+                        {
+                            manufacturerID <<= 8;
+                            manufacturerID |= unpackersData[unpackersData.currentIndex++];
+                            manufacturerID <<= 8;
+                            manufacturerID |= unpackersData[unpackersData.currentIndex++];
+                        }
+                        const manufacturerInternalID = readVariableLengthQuantity(unpackersData);
+                        unpacker.manufacturerID = manufacturerID;
+                        unpacker.manufacturerInternalID = manufacturerInternalID;
+                        break;
+                }
+                unpacker.decodedSize = readVariableLengthQuantity(unpackersData);
+                this.nodeUnpackers.push(unpacker);
+            }
+        }
+        binaryData.currentIndex = nodeStartIndex + headerLength;
+        /**
+         * @type {referenceTypeIds|number}
+         */
+        this.referenceTypeID = readVariableLengthQuantity(binaryData);
+        this.nodeData = binaryData.slice(binaryData.currentIndex, nodeStartIndex + this.length);
+        binaryData.currentIndex = nodeStartIndex + this.length;
+        switch (this.referenceTypeID)
+        {
+            case referenceTypeIds.inLineResource:
+                break;
+            
+            case referenceTypeIds.externalXMF:
+            case referenceTypeIds.inFileNode:
+            case referenceTypeIds.XMFFileURIandNodeID:
+            case referenceTypeIds.externalFile:
+            case referenceTypeIds.inFileResource:
+                SpessaSynthGroupEnd();
+                throw new Error(`Unsupported reference type: ${this.referenceTypeID}`);
+            
+            default:
+                SpessaSynthGroupEnd();
+                throw new Error(`Unknown reference type: ${this.referenceTypeID}`);
+        }
+        
+        // read the data
+        if (this.isFile)
+        {
+            if (this.packedContent)
+            {
+                const compressed = this.nodeData.slice(2, this.nodeData.length);
+                SpessaSynthInfo(
+                    `%cPacked content. Attemting to deflate. Target size: %c${this.nodeUnpackers[0].decodedSize}`,
+                    consoleColors.warn,
+                    consoleColors.value
+                );
+                try
+                {
+                    this.nodeData = new IndexedByteArray(inflateSync(compressed).buffer);
+                }
+                catch (e)
+                {
+                    SpessaSynthGroupEnd();
+                    throw new Error(`Error unpacking XMF file contents: ${e.message}.`);
+                }
+            }
+            /**
+             * interpret the content
+             * @type {number[]}
+             */
+            const resourceFormat = this.metadata["resourceFormat"];
+            if (resourceFormat === undefined)
+            {
+                SpessaSynthWarn("No resource format for this file node!");
+            }
+            else
+            {
+                const formatTypeID = resourceFormat[0];
+                if (formatTypeID !== formatTypeIDs.standard)
+                {
+                    SpessaSynthWarn(`Non-standard formatTypeID: ${resourceFormat}`);
+                    this.resourceFormat = resourceFormat.toString();
+                }
+                const resourceFormatID = resourceFormat[1];
+                if (Object.values(resourceFormatIDs).indexOf(resourceFormatID) === -1)
+                {
+                    SpessaSynthWarn(`Unrecognized resource format: ${resourceFormatID}`);
+                }
+                else
+                {
+                    this.resourceFormat = Object.keys(resourceFormatIDs)
+                        .find(k => resourceFormatIDs[k] === resourceFormatID);
+                }
+            }
+        }
+        else
+        {
+            // folder node
+            this.resourceFormat = "folder";
+            while (this.nodeData.currentIndex < this.nodeData.length)
+            {
+                const nodeStartIndex = this.nodeData.currentIndex;
+                const nodeLength = readVariableLengthQuantity(this.nodeData);
+                const nodeData = this.nodeData.slice(nodeStartIndex, nodeStartIndex + nodeLength);
+                this.nodeData.currentIndex = nodeStartIndex + nodeLength;
+                this.innerNodes.push(new XMFNode(nodeData));
+            }
+        }
+    }
+    
+    get isFile()
+    {
+        return this.itemCount === 0;
+    }
+}
+
+/**
+ * @param midi {MIDI}
+ * @param binaryData {IndexedByteArray}
+ * @returns {IndexedByteArray} the file byte array
+ */
+export function loadXMF(midi, binaryData)
+{
+    midi.bankOffset = 0;
+    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/xmf-v1a.pdf
+    // https://wiki.multimedia.cx/index.php?title=Extensible_Music_Format_(XMF)
+    const sanityCheck = readBytesAsString(binaryData, 4);
+    if (sanityCheck !== "XMF_")
+    {
+        SpessaSynthGroupEnd();
+        throw new SyntaxError(`Invalid XMF Header! Expected "_XMF", got "${sanityCheck}"`);
+    }
+    
+    SpessaSynthGroup("%cParsing XMF file...", consoleColors.info);
+    const version = readBytesAsString(binaryData, 4);
+    SpessaSynthInfo(
+        `%cXMF version: %c${version}`,
+        consoleColors.info, consoleColors.recognized
+    );
+    // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp43.pdf
+    // version 2.00 has additional bytes
+    if (version === "2.00")
+    {
+        const fileTypeId = readBytesAsUintBigEndian(binaryData, 4);
+        const fileTypeRevisionId = readBytesAsUintBigEndian(binaryData, 4);
+        SpessaSynthInfo(
+            `%cFile Type ID: %c${fileTypeId}%c, File Type Revision ID: %c${fileTypeRevisionId}`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    // file length
+    readVariableLengthQuantity(binaryData);
+    
+    const metadataTableLength = readVariableLengthQuantity(binaryData);
+    // skip metadata
+    binaryData.currentIndex += metadataTableLength;
+    
+    // skip to tree root
+    binaryData.currentIndex = readVariableLengthQuantity(binaryData);
+    const rootNode = new XMFNode(binaryData);
+    /**
+     * @type {IndexedByteArray}
+     */
+    let midiArray;
+    /**
+     * find the stuff we care about
+     * @param node {XMFNode}
+     */
+    const searchNode = node =>
+    {
+        const checkMeta = (xmf, rmid) =>
+        {
+            if (node.metadata[xmf] !== undefined && typeof node.metadata[xmf] === "string")
+            {
+                midi.RMIDInfo[rmid] = node.metadata[xmf];
+            }
+        };
+        // meta
+        checkMeta("nodeName", RMIDINFOChunks.name);
+        checkMeta("title", RMIDINFOChunks.name);
+        checkMeta("copyrightNotice", RMIDINFOChunks.copyright);
+        checkMeta("comment", RMIDINFOChunks.comment);
+        if (node.isFile)
+        {
+            switch (node.resourceFormat)
+            {
+                default:
+                    return;
+                case "DLS1":
+                case "DLS2":
+                case "DLS22":
+                case "mobileDLS":
+                    SpessaSynthInfo("%cFound embedded DLS!", consoleColors.recognized);
+                    midi.embeddedSoundFont = node.nodeData.buffer;
+                    break;
+                
+                case "StandardMIDIFile":
+                case "StandardMIDIFileType1":
+                    SpessaSynthInfo("%cFound embedded MIDI!", consoleColors.recognized);
+                    midiArray = node.nodeData;
+                    break;
+            }
+        }
+        else
+        {
+            for (const n of node.innerNodes)
+            {
+                searchNode(n);
+            }
+        }
+    };
+    searchNode(rootNode);
+    SpessaSynthGroupEnd();
+    return midiArray;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.24.38",
+  "version": "3.24.40",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/sequencer/sequencer.js

@@ -53,7 +53,7 @@ export class Sequencer
 {
     /**
      * Executes when MIDI parsing has an error.
-     * @type {function(string)}
+     * @type {function(Error)}
      */
     onError;
     

package/sequencer/worklet_sequencer/play.js

@@ -138,12 +138,22 @@ export function _playTo(time, ticks = undefined)
                 break;
             
             case messageTypes.programChange:
+                // empty tracks cannot program change
+                if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+                {
+                    break;
+                }
                 const p = programs[channel];
                 p.program = event.messageData[0];
                 p.actualBank = p.bank;
                 break;
             
             case messageTypes.controllerChange:
+                // empty tracks cannot controller change
+                if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+                {
+                    break;
+                }
                 // do not skip data entries
                 const controllerNumber = event.messageData[0];
                 if (isCCNonSkippable(controllerNumber))

package/sequencer/worklet_sequencer/process_event.js

@@ -65,10 +65,20 @@ export function _processEvent(event, trackIndex)
             break;
         
         case messageTypes.controllerChange:
+            // empty tracks cannot cc change
+            if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+            {
+                return;
+            }
             this.synth.controllerChange(statusByteData.channel, event.messageData[0], event.messageData[1]);
             break;
         
         case messageTypes.programChange:
+            // empty tracks cannot program change
+            if (this.midiData.isMultiPort && this.midiData.usedChannelsOnTrack[trackIndex].size === 0)
+            {
+                return;
+            }
             this.synth.programChange(statusByteData.channel, event.messageData[0]);
             break;
         

package/sequencer/worklet_sequencer/song_control.js

@@ -174,7 +174,8 @@ export function loadNewSongList(midiBuffers, autoPlay = true)
         }
         catch (e)
         {
-            this.post(WorkletSequencerReturnMessageType.midiError, e.message);
+            console.error(e);
+            this.post(WorkletSequencerReturnMessageType.midiError, e);
             return mids;
         }
         return mids;

package/synthetizer/audio_effects/reverb.js

@@ -16,7 +16,7 @@ export function getReverbProcessor(context, reverbBuffer = undefined)
     else
     {
         // decode
-        context.decodeAudioData(reverbBufferBinary).then(b =>
+        context.decodeAudioData(reverbBufferBinary.slice(0, reverbBufferBinary.byteLength)).then(b =>
         {
             convolver.buffer = b;
         });