1.1

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+spessasynth_lib/soundfonts/GeneralUserGS.sf3 filter=lfs diff=lfs merge=lfs -text

advanced_demo.js

@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+
+
+
+
+
+// import the modules
+import { WORKLET_URL_ABSOLUTE } from "./spessasynth_lib/synthetizer/worklet_url.js";
+import { Sequencer } from "./spessasynth_lib/sequencer/sequencer.js";
+import { Synthetizer } from "./spessasynth_lib/synthetizer/synthetizer.js";
+
+// load the soundfont
+fetch("./spessasynth_lib/soundfonts/GeneralUserGS.sf3").then(async response =>
+{
+    // load the soundfont into an array buffer
+    let soundFontBuffer = await response.arrayBuffer();
+    document.getElementById("message").innerText = "SoundFont has been loaded!";
+    
+    // create the context and add audio worklet
+    const context = new AudioContext();
+    await context.audioWorklet.addModule(new URL("./spessasynth_lib/" + WORKLET_URL_ABSOLUTE, import.meta.url));
+    const synth = new Synthetizer(context.destination, soundFontBuffer);     // create the synthetizer
+    let seq;
+    
+    // add an event listener for the file inout
+    document.getElementById("midi_input").addEventListener("change", async event =>
+    {
+        // check if any files are added
+        if (!event.target.files[0])
+        {
+            return;
+        }
+        // resume the context if paused
+        await context.resume();
+        // parse all the files
+        const parsedSongs = [];
+        for (let file of event.target.files)
+        {
+            const buffer = await file.arrayBuffer();
+            parsedSongs.push({
+                binary: buffer,     // binary: the binary data of the file
+                altName: file.name  // altName: the fallback name if the MIDI doesn't have one. Here we set it to the file name
+            });
+        }
+        if (seq === undefined)
+        {
+            seq = new Sequencer(parsedSongs, synth);                          // create the sequencer with the parsed midis
+            seq.play();                                                             // play the midi
+        }
+        else
+        {
+            seq.loadNewSongList(parsedSongs); // the sequencer is already created, no need to create a new one.
+        }
+        seq.loop = false;                                                       // the sequencer loops a single song by default
+        
+        // make the slider move with the song
+        let slider = document.getElementById("progress");
+        setInterval(() =>
+        {
+            // slider ranges from 0 to 1000
+            slider.value = (seq.currentTime / seq.duration) * 1000;
+        }, 100);
+        
+        // on song change, show the name
+        seq.addOnSongChangeEvent(e =>
+        {
+            document.getElementById("message").innerText = "Now playing: " + e.midiName;
+        }, "example-time-change"); // make sure to add a unique id!
+        
+        // add time adjustment
+        slider.onchange = () =>
+        {
+            // calculate the time
+            seq.currentTime = (slider.value / 1000) * seq.duration; // switch the time (the sequencer adjusts automatically)
+        };
+        
+        // add button controls
+        document.getElementById("previous").onclick = () =>
+        {
+            seq.previousSong(); // go back by one song
+        };
+        
+        // on pause click
+        document.getElementById("pause").onclick = () =>
+        {
+            if (seq.paused)
+            {
+                document.getElementById("pause").innerText = "Pause";
+                seq.play(); // resume
+            }
+            else
+            {
+                document.getElementById("pause").innerText = "Resume";
+                seq.pause(); // pause
+                
+            }
+        };
+        document.getElementById("next").onclick = () =>
+        {
+            seq.nextSong(); // go to the next song
+        };
+    });
+});

examples.css

@@ -0,0 +1,66 @@
+.txtlogee{
+    text-align: center;
+    text-transform: uppercase !important;
+  }
+  
+  .playcax{
+    text-align: center;
+    margin: 15px 0px;
+  }
+  
+  * {
+    font-family: "Noto Sans Light", "Open Sans Light", sans-serif;
+    color: #ccc;
+    font-size: 1.1rem;
+  }
+  
+  button {
+    background: #444;
+    border: solid #555;
+    padding: 10px;
+    border-radius: 1rem;
+    cursor: pointer;
+    margin: 0.3rem;
+    display: inline-block;
+    text-transform: uppercase !important;
+  }
+  
+  button:hover {
+    filter: brightness(1.1);
+  }
+  
+  button:active {
+    transform: scale(0.9);
+  }
+  
+  canvas {
+    width: 100%;
+    min-height: 0;
+    max-height: 40vh;
+  }
+  
+  input[type="range"] {
+    width: 100%;
+  }
+  
+  body {
+    background: #111;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    max-height: 100vh;
+    margin: 50px;
+  }
+  
+  .example_content {
+    width: 80%;
+    background: #333;
+    padding: 2em;
+    margin: 1rem;
+    /*border-radius: 1rem;*/
+    box-shadow: black 0 0 15px;
+    /*display: flex;*/
+    flex-direction: column;
+    align-items: center;
+  }
+  

index - Copia.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html lang='en'>
+
+<head>
+    <meta charset='UTF-8'>
+    <meta content='width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0'
+        name='viewport'>
+    <meta content='ie=edge' http-equiv='X-UA-Compatible'>
+    <title>SpessaSynth advanced example</title>
+    <link href='./examples.css' rel='stylesheet'>
+</head>
+
+<body>
+
+
+    <div class='example_content'>
+        <p id='message'>Please wait for the soundFont to load.</p>
+        <input accept='.mid, .rmi, .xmf, .mxmf' id='midi_input' multiple type='file'>
+        <br><br>
+        <input id='progress' max='1000' min='0' type='range' value='0'>
+        <br>
+
+        <button id='previous'>Previous song</button>
+        <button id='pause'>Pause</button>
+        <button id='next'>Next song</button>
+
+        <!-- note the type="module" -->
+        <script src='./advanced_demo.js' type='module'></script>
+    </div>
+</body>
+
+</html>

index.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html lang='en'>
+
+<head>
+    <meta charset='UTF-8'>
+    <meta content='width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0'
+        name='viewport'>
+    <meta content='ie=edge' http-equiv='X-UA-Compatible'>
+    <title>SpessaSynth advanced example</title>
+    <link href='./examples.css' rel='stylesheet'>
+</head>
+
+<body>
+
+
+    <div class='example_content'>
+        <p id='message'>Please wait for the soundFont to load.</p>
+        <input accept='.mid, .rmi, .xmf, .mxmf' id='midi_input' multiple type='file'>
+        <br><br>
+        <input id='progress' max='1000' min='0' type='range' value='0'>
+        <br>
+
+        <button id='previous'>Previous song</button>
+        <button id='pause'>Pause</button>
+        <button id='next'>Next song</button>
+
+        <!-- note the type="module" -->
+        <script src='./advanced_demo.js' type='module'></script>
+    </div>
+</body>
+
+</html>

spessasynth_lib/external_midi/README.md

@@ -0,0 +1,4 @@
+## This is the MIDI handling folder.
+
+The code here is respnsible for dealing with MIDI Inputs and outputs
+and also for the WebMidiLink functionality.

spessasynth_lib/external_midi/midi_handler.js

@@ -0,0 +1,130 @@
+import { Synthetizer } from "../synthetizer/synthetizer.js";
+import { consoleColors } from "../utils/other.js";
+import { SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
+
+/**
+ * midi_handler.js
+ * purpose: handles the connection between MIDI devices and synthesizer/sequencer via Web MIDI API
+ */
+
+const NO_INPUT = null;
+
+export class MIDIDeviceHandler
+{
+    constructor()
+    {
+    }
+    
+    /**
+     * @returns {Promise<boolean>} if succeded
+     */
+    async createMIDIDeviceHandler()
+    {
+        /**
+         * @type {MIDIInput}
+         */
+        this.selectedInput = NO_INPUT;
+        /**
+         * @type {MIDIOutput}
+         */
+        this.selectedOutput = NO_INPUT;
+        if (navigator.requestMIDIAccess)
+        {
+            // prepare the midi access
+            try
+            {
+                const response = await navigator.requestMIDIAccess({ sysex: true, software: true });
+                this.inputs = response.inputs;
+                this.outputs = response.outputs;
+                SpessaSynthInfo("%cMIDI handler created!", consoleColors.recognized);
+                return true;
+            }
+            catch (e)
+            {
+                SpessaSynthWarn(`Could not get MIDI Devices:`, e);
+                this.inputs = [];
+                this.outputs = [];
+                return false;
+            }
+        }
+        else
+        {
+            SpessaSynthWarn("Web MIDI Api not supported!", consoleColors.unrecognized);
+            this.inputs = [];
+            this.outputs = [];
+            return false;
+        }
+    }
+    
+    /**
+     * Connects the sequencer to a given MIDI output port
+     * @param output {MIDIOutput}
+     * @param seq {Sequencer}
+     */
+    connectMIDIOutputToSeq(output, seq)
+    {
+        this.selectedOutput = output;
+        seq.connectMidiOutput(output);
+        SpessaSynthInfo(
+            `%cPlaying MIDI to %c${output.name}`,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    /**
+     * Disconnects a midi output port from the sequencer
+     * @param seq {Sequencer}
+     */
+    disconnectSeqFromMIDI(seq)
+    {
+        this.selectedOutput = NO_INPUT;
+        seq.connectMidiOutput(undefined);
+        SpessaSynthInfo(
+            "%cDisconnected from MIDI out.",
+            consoleColors.info
+        );
+    }
+    
+    /**
+     * Connects a MIDI input to the synthesizer
+     * @param input {MIDIInput}
+     * @param synth {Synthetizer}
+     */
+    connectDeviceToSynth(input, synth)
+    {
+        this.selectedInput = input;
+        input.onmidimessage = event =>
+        {
+            synth.sendMessage(event.data);
+        };
+        SpessaSynthInfo(
+            `%cListening for messages on %c${input.name}`,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    /**
+     * @param input {MIDIInput}
+     */
+    disconnectDeviceFromSynth(input)
+    {
+        this.selectedInput = NO_INPUT;
+        input.onmidimessage = undefined;
+        SpessaSynthInfo(
+            `%cDisconnected from %c${input.name}`,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    disconnectAllDevicesFromSynth()
+    {
+        this.selectedInput = NO_INPUT;
+        for (const i of this.inputs)
+        {
+            i[1].onmidimessage = undefined;
+        }
+    }
+}

spessasynth_lib/external_midi/web_midi_link.js

@@ -0,0 +1,43 @@
+import { Synthetizer } from "../synthetizer/synthetizer.js";
+import { consoleColors } from "../utils/other.js";
+import { SpessaSynthInfo } from "../utils/loggin.js";
+
+/**
+ * web_midi_link.js
+ * purpose: handles the web midi link connection to the synthesizer
+ * https://www.g200kg.com/en/docs/webmidilink/
+ */
+
+export class WebMIDILinkHandler
+{
+    /**
+     * @param synth {Synthetizer} the synth to play to
+     */
+    constructor(synth)
+    {
+        
+        window.addEventListener("message", msg =>
+        {
+            if (typeof msg.data !== "string")
+            {
+                return;
+            }
+            /**
+             * @type {string[]}
+             */
+            const data = msg.data.split(",");
+            if (data[0] !== "midi")
+            {
+                return;
+            }
+            
+            data.shift(); // remove MIDI
+            
+            const midiData = data.map(byte => parseInt(byte, 16));
+            
+            synth.sendMessage(midiData);
+        });
+        
+        SpessaSynthInfo("%cWeb MIDI Link handler created!", consoleColors.recognized);
+    }
+}

spessasynth_lib/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.

spessasynth_lib/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};

spessasynth_lib/externals/stbvorbis_sync/@types/stbvorbis_sync.d.ts

@@ -0,0 +1,12 @@
+declare type DecodedData =
+    {
+        data: Float32Array[],
+        error: string | null,
+        sampleRate: number,
+        eof: boolean
+    }
+
+declare const stbvorbis: {
+    decode(buffer: ArrayBuffer): DecodedData
+    isInitialized: Promise<boolean>
+}

spessasynth_lib/externals/stbvorbis_sync/LICENSE

@@ -0,0 +1,202 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

spessasynth_lib/externals/stbvorbis_sync/NOTICE

@@ -0,0 +1,6 @@
+LICENSE is for stbvorbis_sync.js which is licensed under Apache-2.0
+
+Modifications made to stbvorbis_sync.js
+1. minified the code
+2. added types declaration
+3. changed the not initialized error message

spessasynth_lib/midi_parser/README.md

@@ -0,0 +1,32 @@
+## This is the MIDI file parsing folder.
+
+The code here is responsible for parsing the MIDI files and interpreting the messsages.
+All the events are defined in the `midi_message.js` file.
+
+### MIDI Classes hierarchy
+
+#### MIDI Sequence
+- The most basic class, containing all the metadata that inheritors have.
+- It does not contain track data or embedded sound bank.
+- Contains the function for calculating time from ticks.
+- Contains the copying code.
+
+#### MIDI Data
+- Inherits from MIDI Sequence.
+- Has an `isEmbedded` property to mark the existence of embedded bank. This is the class that is available in `sequencer.midiData`.
+
+#### Basic MIDI
+- Inherits from MIDI Sequence.
+- The actual MIDI representation, containing the track data and embedded sound banks.
+- Contains the code for parsing the MIDI and filling in the metadata automatically.
+- Contains the SMF/RMI writing functions.
+- Contains the code for determining used channels on tracks.
+
+#### MIDI Builder
+- Inherits from Basic MIDI.
+- Used for building MIDIs from scratch.
+
+### MIDI
+- Inherits from Basic MIDI.
+- The SMF/RMI/XMF file parser.
+- Called by the sequencer if an `ArrayBuffer` is provided.

spessasynth_lib/midi_parser/basic_midi.js

@@ -0,0 +1,563 @@
+import { MIDISequenceData } from "./midi_sequence.js";
+import { getStringBytes, readBytesAsString } from "../utils/byte_functions/string.js";
+import { messageTypes, MIDIMessage } from "./midi_message.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils/loggin.js";
+import { consoleColors, formatTitle, sanitizeKarLyrics } from "../utils/other.js";
+import { writeMIDI } from "./midi_writer.js";
+import { applySnapshotToMIDI, modifyMIDI } from "./midi_editor.js";
+import { writeRMIDI } from "./rmidi_writer.js";
+import { getUsedProgramsAndKeys } from "./used_keys_loaded.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+
+/**
+ * BasicMIDI is the base of a complete MIDI file, used by the sequencer internally.
+ * BasicMIDI is not available on the main thread, as it contains the actual track data which can be large.
+ * It can be accessed by calling getMIDI() on the Sequencer.
+ */
+class BasicMIDI extends MIDISequenceData
+{
+    
+    /**
+     * The embedded soundfont in the MIDI file, represented as an ArrayBuffer, if available.
+     * @type {ArrayBuffer|undefined}
+     */
+    embeddedSoundFont = undefined;
+    
+    /**
+     * The actual track data of the MIDI file, represented as an array of tracks.
+     * Tracks are arrays of MIDIMessage objects.
+     * @type {MIDIMessage[][]}
+     */
+    tracks = [];
+    
+    /**
+     * If the MIDI file is a DLS RMIDI file.
+     * @type {boolean}
+     */
+    isDLSRMIDI = false;
+    
+    /**
+     * Copies a MIDI
+     * @param mid {BasicMIDI}
+     * @returns {BasicMIDI}
+     */
+    static copyFrom(mid)
+    {
+        const m = new BasicMIDI();
+        m._copyFromSequence(mid);
+        
+        m.isDLSRMIDI = mid.isDLSRMIDI;
+        m.embeddedSoundFont = mid.embeddedSoundFont ? mid.embeddedSoundFont.slice(0) : undefined; // Deep copy
+        m.tracks = mid.tracks.map(track => [...track]); // Shallow copy of each track array
+        
+        return m;
+    }
+    
+    /**
+     * Parses internal MIDI values
+     * @protected
+     */
+    _parseInternal()
+    {
+        SpessaSynthGroup(
+            "%cInterpreting MIDI events...",
+            consoleColors.info
+        );
+        /**
+         * For karaoke files, text events starting with @T are considered titles,
+         * usually the first one is the title, and the latter is things such as "sequenced by" etc.
+         * @type {boolean}
+         */
+        let karaokeHasTitle = false;
+        
+        this.keyRange = { max: 0, min: 127 };
+        
+        /**
+         * Will be joined with "\n" to form the final string
+         * @type {string[]}
+         */
+        let copyrightComponents = [];
+        let copyrightDetected = false;
+        if (typeof this.RMIDInfo["ICOP"] !== "undefined")
+        {
+            // if RMIDI has copyright info, don't try to detect one.
+            copyrightDetected = true;
+        }
+        
+        
+        let nameDetected = false;
+        if (typeof this.RMIDInfo["INAM"] !== "undefined")
+        {
+            // same as with copyright
+            nameDetected = true;
+        }
+        
+        // loop tracking
+        let loopStart = null;
+        let loopEnd = null;
+        
+        for (let i = 0; i < this.tracks.length; i++)
+        {
+            /**
+             * @type {MIDIMessage[]}
+             */
+            const track = this.tracks[i];
+            const usedChannels = new Set();
+            let trackHasVoiceMessages = false;
+            
+            for (const e of track)
+            {
+                // check if it's a voice message
+                if (e.messageStatusByte >= 0x80 && e.messageStatusByte < 0xF0)
+                {
+                    trackHasVoiceMessages = true;
+                    // voice messages are 7-bit always
+                    for (let j = 0; j < e.messageData.length; j++)
+                    {
+                        e.messageData[j] = Math.min(127, e.messageData[j]);
+                    }
+                    // last voice event tick
+                    if (e.ticks > this.lastVoiceEventTick)
+                    {
+                        this.lastVoiceEventTick = e.ticks;
+                    }
+                    
+                    // interpret the voice message
+                    switch (e.messageStatusByte & 0xF0)
+                    {
+                        // cc change: loop points
+                        case messageTypes.controllerChange:
+                            switch (e.messageData[0])
+                            {
+                                case 2:
+                                case 116:
+                                    loopStart = e.ticks;
+                                    break;
+                                
+                                case 4:
+                                case 117:
+                                    if (loopEnd === null)
+                                    {
+                                        loopEnd = e.ticks;
+                                    }
+                                    else
+                                    {
+                                        // this controller has occurred more than once;
+                                        // this means
+                                        // that it doesn't indicate the loop
+                                        loopEnd = 0;
+                                    }
+                                    break;
+                                
+                                case 0:
+                                    // check RMID
+                                    if (this.isDLSRMIDI && e.messageData[1] !== 0 && e.messageData[1] !== 127)
+                                    {
+                                        SpessaSynthInfo(
+                                            "%cDLS RMIDI with offset 1 detected!",
+                                            consoleColors.recognized
+                                        );
+                                        this.bankOffset = 1;
+                                    }
+                            }
+                            break;
+                        
+                        // note on: used notes tracking and key range
+                        case messageTypes.noteOn:
+                            usedChannels.add(e.messageStatusByte & 0x0F);
+                            const note = e.messageData[0];
+                            this.keyRange.min = Math.min(this.keyRange.min, note);
+                            this.keyRange.max = Math.max(this.keyRange.max, note);
+                            break;
+                    }
+                }
+                e.messageData.currentIndex = 0;
+                const eventText = readBytesAsString(e.messageData, e.messageData.length);
+                e.messageData.currentIndex = 0;
+                // interpret the message
+                switch (e.messageStatusByte)
+                {
+                    case messageTypes.setTempo:
+                        // add the tempo change
+                        e.messageData.currentIndex = 0;
+                        this.tempoChanges.push({
+                            ticks: e.ticks,
+                            tempo: 60000000 / readBytesAsUintBigEndian(e.messageData, 3)
+                        });
+                        e.messageData.currentIndex = 0;
+                        break;
+                    
+                    case messageTypes.marker:
+                        // check for loop markers
+                        const text = eventText.trim().toLowerCase();
+                        switch (text)
+                        {
+                            default:
+                                break;
+                            
+                            case "start":
+                            case "loopstart":
+                                loopStart = e.ticks;
+                                break;
+                            
+                            case "loopend":
+                                loopEnd = e.ticks;
+                        }
+                        e.messageData.currentIndex = 0;
+                        break;
+                    
+                    case messageTypes.copyright:
+                        if (!copyrightDetected)
+                        {
+                            e.messageData.currentIndex = 0;
+                            copyrightComponents.push(readBytesAsString(
+                                e.messageData,
+                                e.messageData.length,
+                                undefined,
+                                false
+                            ));
+                            e.messageData.currentIndex = 0;
+                        }
+                        break;
+                    
+                    case messageTypes.lyric:
+                        // note here: .kar files sometimes just use...
+                        // lyrics instead of text because why not (of course)
+                        // perform the same check for @KMIDI KARAOKE FILE
+                        if (eventText.trim().startsWith("@KMIDI KARAOKE FILE"))
+                        {
+                            this.isKaraokeFile = true;
+                            SpessaSynthInfo("%cKaraoke MIDI detected!", consoleColors.recognized);
+                        }
+                        
+                        if (this.isKaraokeFile)
+                        {
+                            // replace the type of the message with text
+                            e.messageStatusByte = messageTypes.text;
+                        }
+                        else
+                        {
+                            // add lyrics like a regular midi file
+                            this.lyrics.push(e.messageData);
+                            this.lyricsTicks.push(e.ticks);
+                            break;
+                        }
+                    
+                    // kar: treat the same as text
+                    // fallthrough
+                    case messageTypes.text:
+                        // possibly Soft Karaoke MIDI file
+                        // it has a text event at the start of the file
+                        // "@KMIDI KARAOKE FILE"
+                        const checkedText = eventText.trim();
+                        if (checkedText.startsWith("@KMIDI KARAOKE FILE"))
+                        {
+                            this.isKaraokeFile = true;
+                            
+                            SpessaSynthInfo("%cKaraoke MIDI detected!", consoleColors.recognized);
+                        }
+                        else if (this.isKaraokeFile)
+                        {
+                            // check for @T (title)
+                            // or @A because it is a title too sometimes?
+                            // IDK it's strange
+                            if (checkedText.startsWith("@T") || checkedText.startsWith("@A"))
+                            {
+                                if (!karaokeHasTitle)
+                                {
+                                    this.midiName = checkedText.substring(2).trim();
+                                    karaokeHasTitle = true;
+                                    nameDetected = true;
+                                    // encode to rawMidiName
+                                    this.rawMidiName = getStringBytes(this.midiName);
+                                }
+                                else
+                                {
+                                    // append to copyright
+                                    copyrightComponents.push(checkedText.substring(2).trim());
+                                }
+                            }
+                            else if (checkedText[0] !== "@")
+                            {
+                                // non @: the lyrics
+                                this.lyrics.push(sanitizeKarLyrics(e.messageData));
+                                this.lyricsTicks.push(e.ticks);
+                            }
+                        }
+                        break;
+                    
+                    case messageTypes.trackName:
+                        break;
+                }
+            }
+            // add used channels
+            this.usedChannelsOnTrack.push(usedChannels);
+            
+            // track name
+            this.trackNames[i] = "";
+            const trackName = track.find(e => e.messageStatusByte === messageTypes.trackName);
+            if (trackName)
+            {
+                trackName.messageData.currentIndex = 0;
+                const name = readBytesAsString(trackName.messageData, trackName.messageData.length);
+                this.trackNames[i] = name;
+                // If the track has no voice messages, its "track name" event (if it has any)
+                // is some metadata.
+                // Add it to copyright
+                if (!trackHasVoiceMessages)
+                {
+                    copyrightComponents.push(name);
+                }
+            }
+        }
+        
+        // reverse the tempo changes
+        this.tempoChanges.reverse();
+        
+        SpessaSynthInfo(
+            `%cCorrecting loops, ports and detecting notes...`,
+            consoleColors.info
+        );
+        
+        const firstNoteOns = [];
+        for (const t of this.tracks)
+        {
+            const firstNoteOn = t.find(e => (e.messageStatusByte & 0xF0) === messageTypes.noteOn);
+            if (firstNoteOn)
+            {
+                firstNoteOns.push(firstNoteOn.ticks);
+            }
+        }
+        this.firstNoteOn = Math.min(...firstNoteOns);
+        
+        SpessaSynthInfo(
+            `%cFirst note-on detected at: %c${this.firstNoteOn}%c ticks!`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info
+        );
+        
+        
+        if (loopStart !== null && loopEnd === null)
+        {
+            // not a loop
+            loopStart = this.firstNoteOn;
+            loopEnd = this.lastVoiceEventTick;
+        }
+        else
+        {
+            if (loopStart === null)
+            {
+                loopStart = this.firstNoteOn;
+            }
+            
+            if (loopEnd === null || loopEnd === 0)
+            {
+                loopEnd = this.lastVoiceEventTick;
+            }
+        }
+        
+        /**
+         *
+         * @type {{start: number, end: number}}
+         */
+        this.loop = { start: loopStart, end: loopEnd };
+        
+        SpessaSynthInfo(
+            `%cLoop points: start: %c${this.loop.start}%c end: %c${this.loop.end}`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+        
+        // determine ports
+        let portOffset = 0;
+        this.midiPorts = [];
+        this.midiPortChannelOffsets = [];
+        for (let trackNum = 0; trackNum < this.tracks.length; trackNum++)
+        {
+            this.midiPorts.push(-1);
+            if (this.usedChannelsOnTrack[trackNum].size === 0)
+            {
+                continue;
+            }
+            for (const e of this.tracks[trackNum])
+            {
+                if (e.messageStatusByte !== messageTypes.midiPort)
+                {
+                    continue;
+                }
+                const port = e.messageData[0];
+                this.midiPorts[trackNum] = port;
+                if (this.midiPortChannelOffsets[port] === undefined)
+                {
+                    this.midiPortChannelOffsets[port] = portOffset;
+                    portOffset += 16;
+                }
+            }
+        }
+        
+        // fix midi ports:
+        // midi tracks without ports will have a value of -1
+        // if all ports have a value of -1, set it to 0,
+        // otherwise take the first midi port and replace all -1 with it,
+        // why would we do this?
+        // some midis (for some reason) specify all channels to port 1 or else,
+        // but leave the conductor track with no port pref.
+        // this spessasynth to reserve the first 16 channels for the conductor track
+        // (which doesn't play anything) and use the additional 16 for the actual ports.
+        let defaultPort = Infinity;
+        for (let port of this.midiPorts)
+        {
+            if (port !== -1)
+            {
+                if (defaultPort > port)
+                {
+                    defaultPort = port;
+                }
+            }
+        }
+        if (defaultPort === Infinity)
+        {
+            defaultPort = 0;
+        }
+        this.midiPorts = this.midiPorts.map(port => port === -1 ? defaultPort : port);
+        // add fake port if empty
+        if (this.midiPortChannelOffsets.length === 0)
+        {
+            this.midiPortChannelOffsets = [0];
+        }
+        if (this.midiPortChannelOffsets.length < 2)
+        {
+            SpessaSynthInfo(`%cNo additional MIDI Ports detected.`, consoleColors.info);
+        }
+        else
+        {
+            this.isMultiPort = true;
+            SpessaSynthInfo(`%cMIDI Ports detected!`, consoleColors.recognized);
+        }
+        
+        // midi name
+        if (!nameDetected)
+        {
+            if (this.tracks.length > 1)
+            {
+                // if more than 1 track and the first track has no notes,
+                // just find the first trackName in the first track.
+                if (
+                    this.tracks[0].find(
+                        message => message.messageStatusByte >= messageTypes.noteOn
+                            &&
+                            message.messageStatusByte < messageTypes.polyPressure
+                    ) === undefined
+                )
+                {
+                    
+                    let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
+                    if (name)
+                    {
+                        this.rawMidiName = name.messageData;
+                        name.messageData.currentIndex = 0;
+                        this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
+                    }
+                }
+            }
+            else
+            {
+                // if only 1 track, find the first "track name" event
+                let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
+                if (name)
+                {
+                    this.rawMidiName = name.messageData;
+                    name.messageData.currentIndex = 0;
+                    this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
+                }
+            }
+        }
+        
+        if (!copyrightDetected)
+        {
+            this.copyright = copyrightComponents
+                // trim and group newlines into one
+                .map(c => c.trim().replace(/(\r?\n)+/g, "\n"))
+                // remove empty strings
+                .filter(c => c.length > 0)
+                // join with newlines
+                .join("\n") || "";
+        }
+        
+        this.midiName = this.midiName.trim();
+        this.midiNameUsesFileName = false;
+        // if midiName is "", use the file name
+        if (this.midiName.length === 0)
+        {
+            SpessaSynthInfo(
+                `%cNo name detected. Using the alt name!`,
+                consoleColors.info
+            );
+            this.midiName = formatTitle(this.fileName);
+            this.midiNameUsesFileName = true;
+            // encode it too
+            this.rawMidiName = new Uint8Array(this.midiName.length);
+            for (let i = 0; i < this.midiName.length; i++)
+            {
+                this.rawMidiName[i] = this.midiName.charCodeAt(i);
+            }
+        }
+        else
+        {
+            SpessaSynthInfo(
+                `%cMIDI Name detected! %c"${this.midiName}"`,
+                consoleColors.info,
+                consoleColors.recognized
+            );
+        }
+        
+        // if the first event is not at 0 ticks, add a track name
+        // https://github.com/spessasus/SpessaSynth/issues/145
+        if (!this.tracks.some(t => t[0].ticks === 0))
+        {
+            const track = this.tracks[0];
+            // can copy
+            track.unshift(new MIDIMessage(
+                0,
+                messageTypes.trackName,
+                new IndexedByteArray(this.rawMidiName.buffer)
+            ));
+        }
+        
+        
+        /**
+         * The total playback time, in seconds
+         * @type {number}
+         */
+        this.duration = this.MIDIticksToSeconds(this.lastVoiceEventTick);
+        
+        SpessaSynthInfo("%cSuccess!", consoleColors.recognized);
+        SpessaSynthGroupEnd();
+    }
+    
+    /**
+     * Updates all internal values
+     */
+    flush()
+    {
+        
+        for (const t of this.tracks)
+        {
+            // sort the track by ticks
+            t.sort((e1, e2) => e1.ticks - e2.ticks);
+        }
+        this._parseInternal();
+    }
+}
+
+BasicMIDI.prototype.writeMIDI = writeMIDI;
+BasicMIDI.prototype.modifyMIDI = modifyMIDI;
+BasicMIDI.prototype.applySnapshotToMIDI = applySnapshotToMIDI;
+BasicMIDI.prototype.writeRMIDI = writeRMIDI;
+BasicMIDI.prototype.getUsedProgramsAndKeys = getUsedProgramsAndKeys;
+
+export { BasicMIDI };

spessasynth_lib/midi_parser/midi_builder.js

@@ -0,0 +1,202 @@
+import { BasicMIDI } from "./basic_midi.js";
+import { messageTypes, MIDIMessage } from "./midi_message.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { SpessaSynthWarn } from "../utils/loggin.js";
+
+/**
+ * A class that helps to build a MIDI file from scratch.
+ */
+export class MIDIBuilder extends BasicMIDI
+{
+    /**
+     * @param name {string} The MIDI's name
+     * @param timeDivision {number} the file's time division
+     * @param initialTempo {number} the file's initial tempo
+     */
+    constructor(name, timeDivision = 480, initialTempo = 120)
+    {
+        super();
+        this.timeDivision = timeDivision;
+        this.midiName = name;
+        this.encoder = new TextEncoder();
+        this.rawMidiName = this.encoder.encode(name);
+        
+        // create the first track with the file name
+        this.addNewTrack(name);
+        this.addSetTempo(0, initialTempo);
+    }
+    
+    /**
+     * Adds a new Set Tempo event
+     * @param ticks {number} the tick number of the event
+     * @param tempo {number} the tempo in beats per minute (BPM)
+     */
+    addSetTempo(ticks, tempo)
+    {
+        const array = new IndexedByteArray(3);
+        
+        tempo = 60000000 / tempo;
+        
+        // Extract each byte in big-endian order
+        array[0] = (tempo >> 16) & 0xFF;
+        array[1] = (tempo >> 8) & 0xFF;
+        array[2] = tempo & 0xFF;
+        
+        this.addEvent(ticks, 0, messageTypes.setTempo, array);
+    }
+    
+    /**
+     * Adds a new MIDI track
+     * @param name {string} the new track's name
+     * @param port {number} the new track's port
+     */
+    addNewTrack(name, port = 0)
+    {
+        this.tracksAmount++;
+        if (this.tracksAmount > 1)
+        {
+            this.format = 1;
+        }
+        this.tracks.push([]);
+        this.tracks[this.tracksAmount - 1].push(
+            new MIDIMessage(0, messageTypes.endOfTrack, new IndexedByteArray(0))
+        );
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.trackName, this.encoder.encode(name));
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.midiPort, [port]);
+    }
+    
+    /**
+     * Adds a new MIDI Event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param event {number} the MIDI event number
+     * @param eventData {Uint8Array|Iterable<number>} the raw event data
+     */
+    addEvent(ticks, track, event, eventData)
+    {
+        if (!this.tracks[track])
+        {
+            throw new Error(`Track ${track} does not exist. Add it via addTrack method.`);
+        }
+        if (event === messageTypes.endOfTrack)
+        {
+            SpessaSynthWarn(
+                "The EndOfTrack is added automatically and does not influence the duration. Consider adding a voice event instead.");
+            return;
+        }
+        // remove the end of track
+        this.tracks[track].pop();
+        this.tracks[track].push(new MIDIMessage(
+            ticks,
+            event,
+            new IndexedByteArray(eventData)
+        ));
+        // add the end of track
+        this.tracks[track].push(new MIDIMessage(
+            ticks,
+            messageTypes.endOfTrack,
+            new IndexedByteArray(0)
+        ));
+    }
+    
+    /**
+     * Adds a new Note On event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the keypress
+     * @param velocity {number} the velocity of the keypress
+     */
+    addNoteOn(ticks, track, channel, midiNote, velocity)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        velocity %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOn | channel,
+            [midiNote, velocity]
+        );
+    }
+    
+    /**
+     * Adds a new Note Off event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the key release
+     */
+    addNoteOff(ticks, track, channel, midiNote)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOff | channel,
+            [midiNote, 64]
+        );
+    }
+    
+    /**
+     * Adds a new Program Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param programNumber {number} the MIDI program to use
+     */
+    addProgramChange(ticks, track, channel, programNumber)
+    {
+        channel %= 16;
+        programNumber %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.programChange | channel,
+            [programNumber]
+        );
+    }
+    
+    /**
+     * Adds a new Controller Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param controllerNumber {number} the MIDI CC to use
+     * @param controllerValue {number} the new CC value
+     */
+    addControllerChange(ticks, track, channel, controllerNumber, controllerValue)
+    {
+        channel %= 16;
+        controllerNumber %= 128;
+        controllerValue %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.controllerChange | channel,
+            [controllerNumber, controllerValue]
+        );
+    }
+    
+    /**
+     * Adds a new Pitch Wheel event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track to use
+     * @param channel {number} the channel to use
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+     */
+    addPitchWheel(ticks, track, channel, MSB, LSB)
+    {
+        channel %= 16;
+        MSB %= 128;
+        LSB %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.pitchBend | channel,
+            [LSB, MSB]
+        );
+    }
+}

spessasynth_lib/midi_parser/midi_data.js

@@ -0,0 +1,63 @@
+import { MIDISequenceData } from "./midi_sequence.js";
+
+/**
+ * A simplified version of the MIDI, accessible at all times from the Sequencer.
+ * Use getMIDI() to get the actual sequence.
+ * This class contains all properties that MIDI does, except for tracks and the embedded soundfont.
+ */
+export class MIDIData extends MIDISequenceData
+{
+    
+    /**
+     * A boolean indicating if the MIDI file contains an embedded soundfont.
+     * If the embedded soundfont is undefined, this will be false.
+     * @type {boolean}
+     */
+    isEmbedded = false;
+    
+    /**
+     * Constructor that copies data from a BasicMIDI instance.
+     * @param {BasicMIDI} midi - The BasicMIDI instance to copy data from.
+     */
+    constructor(midi)
+    {
+        super();
+        this._copyFromSequence(midi);
+        
+        // Set isEmbedded based on the presence of an embeddedSoundFont
+        this.isEmbedded = midi.embeddedSoundFont !== undefined;
+    }
+}
+
+
+/**
+ * Temporary MIDI data used when the MIDI is not loaded.
+ * @type {MIDIData}
+ */
+export const DUMMY_MIDI_DATA = {
+    duration: 99999,
+    firstNoteOn: 0,
+    loop: {
+        start: 0,
+        end: 123456
+    },
+    
+    lastVoiceEventTick: 123456,
+    lyrics: [],
+    copyright: "",
+    midiPorts: [],
+    midiPortChannelOffsets: [],
+    tracksAmount: 0,
+    tempoChanges: [{ ticks: 0, tempo: 120 }],
+    fileName: "NOT_LOADED.mid",
+    midiName: "Loading...",
+    rawMidiName: new Uint8Array([76, 111, 97, 100, 105, 110, 103, 46, 46, 46]), // "Loading..."
+    usedChannelsOnTrack: [],
+    timeDivision: 0,
+    keyRange: { min: 0, max: 127 },
+    isEmbedded: false,
+    RMIDInfo: {},
+    bankOffset: 0,
+    midiNameUsesFileName: false,
+    format: 0
+};

spessasynth_lib/midi_parser/midi_editor.js

@@ -0,0 +1,611 @@
+import { messageTypes, midiControllers, MIDIMessage } from "./midi_message.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils/loggin.js";
+import { consoleColors } from "../utils/other.js";
+
+import { customControllers } from "../synthetizer/worklet_system/worklet_utilities/controller_tables.js";
+import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+import { isGM2On, isGMOn, isGSOn, isXGOn } from "../utils/sysex_detector.js";
+import { isSystemXG, isXGDrums, XG_SFX_VOICE } from "../utils/xg_hacks.js";
+
+/**
+ * @param ticks {number}
+ * @returns {MIDIMessage}
+ */
+export function getGsOn(ticks)
+{
+    return new MIDIMessage(
+        ticks,
+        messageTypes.systemExclusive,
+        new IndexedByteArray([
+            0x41, // Roland
+            0x10, // Device ID (defaults to 16 on roland)
+            0x42, // GS
+            0x12, // Command ID (DT1) (whatever that means...)
+            0x40, // System parameter - Address
+            0x00, // Global parameter -  Address
+            0x7F, // GS Change - Address
+            0x00, // turn on - Data
+            0x41, // checksum
+            0xF7 // end of exclusive
+        ])
+    );
+}
+
+/**
+ * @param channel {number}
+ * @param cc {number}
+ * @param value {number}
+ * @param ticks {number}
+ * @returns {MIDIMessage}
+ */
+function getControllerChange(channel, cc, value, ticks)
+{
+    return new MIDIMessage(
+        ticks,
+        messageTypes.controllerChange | (channel % 16),
+        new IndexedByteArray([cc, value])
+    );
+}
+
+/**
+ * @param channel {number}
+ * @param ticks {number}
+ * @returns {MIDIMessage}
+ */
+function getDrumChange(channel, ticks)
+{
+    const chanAddress = 0x10 | [1, 2, 3, 4, 5, 6, 7, 8, 0, 9, 10, 11, 12, 13, 14, 15][channel % 16];
+    // excluding manufacturerID DeviceID and ModelID (and F7)
+    const sysexData = [
+        0x41, // Roland
+        0x10, // Device ID (defaults to 16 on roland)
+        0x42, // GS
+        0x12, // Command ID (DT1) (whatever that means...)
+        0x40, // System parameter           }
+        chanAddress, // Channel parameter   } Address
+        0x15, // Drum change                }
+        0x01 // Is Drums                    } Data
+    ];
+    // calculate checksum
+    // https://cdn.roland.com/assets/media/pdf/F-20_MIDI_Imple_e01_W.pdf section 4
+    const sum = 0x40 + chanAddress + 0x15 + 0x01;
+    const checksum = 128 - (sum % 128);
+    // add system exclusive to enable drums
+    return new MIDIMessage(
+        ticks,
+        messageTypes.systemExclusive,
+        new IndexedByteArray([
+            ...sysexData,
+            checksum,
+            0xF7
+        ])
+    );
+}
+
+/**
+ * @typedef {Object} DesiredProgramChange
+ * @property {number} channel - The channel number.
+ * @property {number} program - The program number.
+ * @property {number} bank - The bank number.
+ * @property {boolean} isDrum - Indicates if the channel is a drum channel.
+ * If it is, then the bank number is ignored.
+ */
+
+/**
+ * @typedef {Object} DesiredControllerChange
+ * @property {number} channel - The channel number.
+ * @property {number} controllerNumber - The MIDI controller number.
+ * @property {number} controllerValue - The new controller value.
+ */
+
+/**
+ * @typedef {Object} DesiredChanneltranspose
+ * @property {number} channel - The channel number.
+ * @property {number} keyShift - The number of semitones to transpose.
+ * Note that this can use floating point numbers,
+ * which will be used to fine-tune the pitch in cents using RPN.
+ */
+
+
+/**
+ * Allows easy editing of the file by removing channels, changing programs,
+ * changing controllers and transposing channels. Note that this modifies the MIDI in-place.
+ *
+ * @this {BasicMIDI}
+ * @param {DesiredProgramChange[]} desiredProgramChanges - The programs to set on given channels.
+ * @param {DesiredControllerChange[]} desiredControllerChanges - The controllers to set on given channels.
+ * @param {number[]} desiredChannelsToClear - The channels to remove from the sequence.
+ * @param {DesiredChanneltranspose[]} desiredChannelsToTranspose - The channels to transpose.
+ */
+export function modifyMIDI(
+    desiredProgramChanges = [],
+    desiredControllerChanges = [],
+    desiredChannelsToClear = [],
+    desiredChannelsToTranspose = []
+)
+{
+    const midi = this;
+    SpessaSynthGroupCollapsed("%cApplying changes to the MIDI file...", consoleColors.info);
+    
+    SpessaSynthInfo("Desired program changes:", desiredProgramChanges);
+    SpessaSynthInfo("Desired CC changes:", desiredControllerChanges);
+    SpessaSynthInfo("Desired channels to clear:", desiredChannelsToClear);
+    SpessaSynthInfo("Desired channels to transpose:", desiredChannelsToTranspose);
+    
+    /**
+     * @type {Set<number>}
+     */
+    const channelsToChangeProgram = new Set();
+    desiredProgramChanges.forEach(c =>
+    {
+        channelsToChangeProgram.add(c.channel);
+    });
+    
+    
+    // go through all events one by one
+    let system = "gs";
+    let addedGs = false;
+    /**
+     * indexes for tracks
+     * @type {number[]}
+     */
+    const eventIndexes = Array(midi.tracks.length).fill(0);
+    let remainingTracks = midi.tracks.length;
+    
+    function findFirstEventIndex()
+    {
+        let index = 0;
+        let ticks = Infinity;
+        midi.tracks.forEach((track, i) =>
+        {
+            if (eventIndexes[i] >= track.length)
+            {
+                return;
+            }
+            if (track[eventIndexes[i]].ticks < ticks)
+            {
+                index = i;
+                ticks = track[eventIndexes[i]].ticks;
+            }
+        });
+        return index;
+    }
+    
+    // it copies midiPorts everywhere else, but here 0 works so DO NOT CHANGE!
+    /**
+     * midi port number for the corresponding track
+     * @type {number[]}
+     */
+    const midiPorts = midi.midiPorts.slice();
+    /**
+     * midi port: channel offset
+     * @type {Object<number, number>}
+     */
+    const midiPortChannelOffsets = {};
+    let midiPortChannelOffset = 0;
+    
+    function assignMIDIPort(trackNum, port)
+    {
+        // do not assign ports to empty tracks
+        if (midi.usedChannelsOnTrack[trackNum].size === 0)
+        {
+            return;
+        }
+        
+        // assign new 16 channels if the port is not occupied yet
+        if (midiPortChannelOffset === 0)
+        {
+            midiPortChannelOffset += 16;
+            midiPortChannelOffsets[port] = 0;
+        }
+        
+        if (midiPortChannelOffsets[port] === undefined)
+        {
+            midiPortChannelOffsets[port] = midiPortChannelOffset;
+            midiPortChannelOffset += 16;
+        }
+        
+        midiPorts[trackNum] = port;
+    }
+    
+    // assign port offsets
+    midi.midiPorts.forEach((port, trackIndex) =>
+    {
+        assignMIDIPort(trackIndex, port);
+    });
+    
+    const channelsAmount = midiPortChannelOffset;
+    /**
+     * Tracks if the channel already had its first note on
+     * @type {boolean[]}
+     */
+    const isFirstNoteOn = Array(channelsAmount).fill(true);
+    
+    /**
+     * MIDI key transpose
+     * @type {number[]}
+     */
+    const coarseTranspose = Array(channelsAmount).fill(0);
+    /**
+     * RPN fine transpose
+     * @type {number[]}
+     */
+    const fineTranspose = Array(channelsAmount).fill(0);
+    desiredChannelsToTranspose.forEach(transpose =>
+    {
+        const coarse = Math.trunc(transpose.keyShift);
+        const fine = transpose.keyShift - coarse;
+        coarseTranspose[transpose.channel] = coarse;
+        fineTranspose[transpose.channel] = fine;
+    });
+    
+    while (remainingTracks > 0)
+    {
+        let trackNum = findFirstEventIndex();
+        const track = midi.tracks[trackNum];
+        if (eventIndexes[trackNum] >= track.length)
+        {
+            remainingTracks--;
+            continue;
+        }
+        const index = eventIndexes[trackNum]++;
+        const e = track[index];
+        
+        const deleteThisEvent = () =>
+        {
+            track.splice(index, 1);
+            eventIndexes[trackNum]--;
+        };
+        
+        /**
+         * @param e {MIDIMessage}
+         * @param offset{number}
+         */
+        const addEventBefore = (e, offset = 0) =>
+        {
+            track.splice(index + offset, 0, e);
+            eventIndexes[trackNum]++;
+        };
+        
+        
+        let portOffset = midiPortChannelOffsets[midiPorts[trackNum]] || 0;
+        if (e.messageStatusByte === messageTypes.midiPort)
+        {
+            assignMIDIPort(trackNum, e.messageData[0]);
+            continue;
+        }
+        // don't clear meta
+        if (e.messageStatusByte <= messageTypes.sequenceSpecific && e.messageStatusByte >= messageTypes.sequenceNumber)
+        {
+            continue;
+        }
+        const status = e.messageStatusByte & 0xF0;
+        const midiChannel = e.messageStatusByte & 0xF;
+        const channel = midiChannel + portOffset;
+        // clear channel?
+        if (desiredChannelsToClear.indexOf(channel) !== -1)
+        {
+            deleteThisEvent();
+            continue;
+        }
+        switch (status)
+        {
+            case messageTypes.noteOn:
+                // is it first?
+                if (isFirstNoteOn[channel])
+                {
+                    isFirstNoteOn[channel] = false;
+                    // all right, so this is the first note on
+                    // first: controllers
+                    // because FSMP does not like program changes after cc changes in embedded midis
+                    // and since we use splice,
+                    // controllers get added first, then programs before them
+                    // now add controllers
+                    desiredControllerChanges.filter(c => c.channel === channel).forEach(change =>
+                    {
+                        const ccChange = getControllerChange(
+                            midiChannel,
+                            change.controllerNumber,
+                            change.controllerValue,
+                            e.ticks
+                        );
+                        addEventBefore(ccChange);
+                    });
+                    const fineTune = fineTranspose[channel];
+                    
+                    if (fineTune !== 0)
+                    {
+                        // add rpn
+                        // 64 is the center, 96 = 50 cents up
+                        const centsCoarse = (fineTune * 64) + 64;
+                        const rpnCoarse = getControllerChange(midiChannel, midiControllers.RPNMsb, 0, e.ticks);
+                        const rpnFine = getControllerChange(midiChannel, midiControllers.RPNLsb, 1, e.ticks);
+                        const dataEntryCoarse = getControllerChange(
+                            channel,
+                            midiControllers.dataEntryMsb,
+                            centsCoarse,
+                            e.ticks
+                        );
+                        const dataEntryFine = getControllerChange(
+                            midiChannel,
+                            midiControllers.lsbForControl6DataEntry,
+                            0,
+                            e.ticks
+                        );
+                        addEventBefore(dataEntryFine);
+                        addEventBefore(dataEntryCoarse);
+                        addEventBefore(rpnFine);
+                        addEventBefore(rpnCoarse);
+                        
+                    }
+                    
+                    if (channelsToChangeProgram.has(channel))
+                    {
+                        const change = desiredProgramChanges.find(c => c.channel === channel);
+                        let desiredBank = Math.max(0, Math.min(change.bank, 127));
+                        const desiredProgram = change.program;
+                        SpessaSynthInfo(
+                            `%cSetting %c${change.channel}%c to %c${desiredBank}:${desiredProgram}%c. Track num: %c${trackNum}`,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info,
+                            consoleColors.recognized
+                        );
+                        
+                        // note: this is in reverse.
+                        // the output event order is: drums -> lsb -> msb -> program change
+                        
+                        // add program change
+                        const programChange = new MIDIMessage(
+                            e.ticks,
+                            messageTypes.programChange | midiChannel,
+                            new IndexedByteArray([
+                                desiredProgram
+                            ])
+                        );
+                        addEventBefore(programChange);
+                        
+                        const addBank = (isLSB, v) =>
+                        {
+                            const bankChange = getControllerChange(
+                                midiChannel,
+                                isLSB ? midiControllers.lsbForControl0BankSelect : midiControllers.bankSelect,
+                                v,
+                                e.ticks
+                            );
+                            addEventBefore(bankChange);
+                        };
+                        
+                        // on xg, add lsb
+                        if (isSystemXG(system))
+                        {
+                            // xg drums: msb can be 120, 126 or 127
+                            if (change.isDrum)
+                            {
+                                SpessaSynthInfo(
+                                    `%cAdding XG Drum change on track %c${trackNum}`,
+                                    consoleColors.recognized,
+                                    consoleColors.value
+                                );
+                                addBank(false, isXGDrums(desiredBank) ? desiredBank : 127);
+                                addBank(true, 0);
+                            }
+                            else
+                            {
+                                // sfx voice is set via MSB
+                                if (desiredBank === XG_SFX_VOICE)
+                                {
+                                    addBank(false, XG_SFX_VOICE);
+                                    addBank(true, 0);
+                                }
+                                else
+                                {
+                                    // add variation as LSB
+                                    addBank(false, 0);
+                                    addBank(true, desiredBank);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // add just msb
+                            addBank(false, desiredBank);
+                            
+                            if (change.isDrum && midiChannel !== DEFAULT_PERCUSSION)
+                            {
+                                // add gs drum change
+                                SpessaSynthInfo(
+                                    `%cAdding GS Drum change on track %c${trackNum}`,
+                                    consoleColors.recognized,
+                                    consoleColors.value
+                                );
+                                addEventBefore(getDrumChange(midiChannel, e.ticks));
+                            }
+                        }
+                    }
+                }
+                // transpose key (for zero it won't change anyway)
+                e.messageData[0] += coarseTranspose[channel];
+                break;
+            
+            case messageTypes.noteOff:
+                e.messageData[0] += coarseTranspose[channel];
+                break;
+            
+            case messageTypes.programChange:
+                // do we delete it?
+                if (channelsToChangeProgram.has(channel))
+                {
+                    // this channel has program change. BEGONE!
+                    deleteThisEvent();
+                    continue;
+                }
+                break;
+            
+            case messageTypes.controllerChange:
+                const ccNum = e.messageData[0];
+                const changes = desiredControllerChanges.find(c => c.channel === channel && ccNum === c.controllerNumber);
+                if (changes !== undefined)
+                {
+                    // this controller is locked, BEGONE CHANGE!
+                    deleteThisEvent();
+                    continue;
+                }
+                // bank maybe?
+                if (ccNum === midiControllers.bankSelect || ccNum === midiControllers.lsbForControl0BankSelect)
+                {
+                    if (channelsToChangeProgram.has(channel))
+                    {
+                        // BEGONE!
+                        deleteThisEvent();
+                        continue;
+                    }
+                }
+                break;
+            
+            case messageTypes.systemExclusive:
+                // check for xg on
+                if (isXGOn(e))
+                {
+                    SpessaSynthInfo("%cXG system on detected", consoleColors.info);
+                    system = "xg";
+                    addedGs = true; // flag as true so gs won't get added
+                }
+                else
+                    // check for xg program change
+                if (
+                    e.messageData[0] === 0x43 // yamaha
+                    && e.messageData[2] === 0x4C // XG
+                    && e.messageData[3] === 0x08 // part parameter
+                    && e.messageData[5] === 0x03 // program change
+                )
+                {
+                    // do we delete it?
+                    if (channelsToChangeProgram.has(e.messageData[4] + portOffset))
+                    {
+                        // this channel has program change. BEGONE!
+                        deleteThisEvent();
+                    }
+                }
+                else
+                    // check for GS on
+                if (isGSOn(e))
+                {
+                    // that's a GS on, we're done here
+                    addedGs = true;
+                    SpessaSynthInfo(
+                        "%cGS on detected!",
+                        consoleColors.recognized
+                    );
+                    break;
+                }
+                else
+                    // check for GM/2 on
+                if (isGMOn(e) || isGM2On(e))
+                {
+                    // that's a GM1 system change, remove it!
+                    SpessaSynthInfo(
+                        "%cGM/2 on detected, removing!",
+                        consoleColors.info
+                    );
+                    deleteThisEvent();
+                    addedGs = false;
+                }
+        }
+    }
+    // check for gs
+    if (!addedGs && desiredProgramChanges.length > 0)
+    {
+        // gs is not on, add it on the first track at index 0 (or 1 if track name is first)
+        let index = 0;
+        if (midi.tracks[0][0].messageStatusByte === messageTypes.trackName)
+        {
+            index++;
+        }
+        midi.tracks[0].splice(index, 0, getGsOn(0));
+        SpessaSynthInfo("%cGS on not detected. Adding it.", consoleColors.info);
+    }
+    this.flush();
+    SpessaSynthGroupEnd();
+}
+
+/**
+ * Modifies the sequence according to the locked presets and controllers in the given snapshot
+ * @this {BasicMIDI}
+ * @param snapshot {SynthesizerSnapshot}
+ */
+export function applySnapshotToMIDI(snapshot)
+{
+    /**
+     * @type {{
+     *     channel: number,
+     *     keyShift: number
+     * }[]}
+     */
+    const channelsToTranspose = [];
+    /**
+     * @type {number[]}
+     */
+    const channelsToClear = [];
+    /**
+     * @type {{
+     *     channel: number,
+     *     program: number,
+     *     bank: number,
+     *     isDrum: boolean
+     * }[]}
+     */
+    const programChanges = [];
+    /**
+     *
+     * @type {{
+     *     channel: number,
+     *     controllerNumber: number,
+     *     controllerValue: number
+     * }[]}
+     */
+    const controllerChanges = [];
+    snapshot.channelSnapshots.forEach((channel, channelNumber) =>
+    {
+        if (channel.isMuted)
+        {
+            channelsToClear.push(channelNumber);
+            return;
+        }
+        const transposeFloat = channel.channelTransposeKeyShift + channel.customControllers[customControllers.channelTransposeFine] / 100;
+        if (transposeFloat !== 0)
+        {
+            channelsToTranspose.push({
+                channel: channelNumber,
+                keyShift: transposeFloat
+            });
+        }
+        if (channel.lockPreset)
+        {
+            programChanges.push({
+                channel: channelNumber,
+                program: channel.program,
+                bank: channel.bank,
+                isDrum: channel.drumChannel
+            });
+        }
+        // check for locked controllers and change them appropriately
+        channel.lockedControllers.forEach((l, ccNumber) =>
+        {
+            if (!l || ccNumber > 127 || ccNumber === midiControllers.bankSelect)
+            {
+                return;
+            }
+            const targetValue = channel.midiControllers[ccNumber] >> 7; // channel controllers are stored as 14 bit values
+            controllerChanges.push({
+                channel: channelNumber,
+                controllerNumber: ccNumber,
+                controllerValue: targetValue
+            });
+        });
+    });
+    this.modifyMIDI(programChanges, controllerChanges, channelsToClear, channelsToTranspose);
+}

spessasynth_lib/midi_parser/midi_loader.js

@@ -0,0 +1,324 @@
+import { dataBytesAmount, getChannel, MIDIMessage } from "./midi_message.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { consoleColors } from "../utils/other.js";
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
+import { readRIFFChunk } from "../soundfont/basic_soundfont/riff_chunk.js";
+import { readVariableLengthQuantity } from "../utils/byte_functions/variable_length_quantity.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+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
+ * purpose:
+ * parses a midi file for the seqyencer,
+ * including things like marker or CC 2/4 loop detection, copyright detection, etc.
+ */
+
+/**
+ * The MIDI class is a MIDI file parser that reads a MIDI file and extracts all the necessary information from it.
+ * Supported formats are .mid and .rmi files.
+ */
+class MIDI extends BasicMIDI
+{
+    /**
+     * Parses a given midi file
+     * @param arrayBuffer {ArrayBuffer}
+     * @param fileName {string} optional, replaces the decoded title if empty
+     */
+    constructor(arrayBuffer, fileName = "")
+    {
+        super();
+        SpessaSynthGroupCollapsed(`%cParsing MIDI File...`, consoleColors.info);
+        this.fileName = fileName;
+        const binaryData = new IndexedByteArray(arrayBuffer);
+        let fileByteArray;
+        
+        // check for rmid
+        const initialString = readBytesAsString(binaryData, 4);
+        binaryData.currentIndex -= 4;
+        if (initialString === "RIFF")
+        {
+            // possibly an RMID file (https://github.com/spessasus/sf2-rmidi-specification#readme)
+            // skip size
+            binaryData.currentIndex += 8;
+            const rmid = readBytesAsString(binaryData, 4, undefined, false);
+            if (rmid !== "RMID")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid RMIDI Header! Expected "RMID", got "${rmid}"`);
+            }
+            const riff = readRIFFChunk(binaryData);
+            if (riff.header !== "data")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid RMIDI Chunk header! Expected "data", got "${rmid}"`);
+            }
+            // this is a rmid, load the midi into an array for parsing
+            fileByteArray = riff.chunkData;
+            
+            // keep loading chunks until we get the "SFBK" header
+            while (binaryData.currentIndex <= binaryData.length)
+            {
+                const startIndex = binaryData.currentIndex;
+                const currentChunk = readRIFFChunk(binaryData, true);
+                if (currentChunk.header === "RIFF")
+                {
+                    const type = readBytesAsString(currentChunk.chunkData, 4).toLowerCase();
+                    if (type === "sfbk" || type === "sfpk" || type === "dls ")
+                    {
+                        SpessaSynthInfo("%cFound embedded soundfont!", consoleColors.recognized);
+                        this.embeddedSoundFont = binaryData.slice(startIndex, startIndex + currentChunk.size).buffer;
+                    }
+                    else
+                    {
+                        SpessaSynthWarn(`Unknown RIFF chunk: "${type}"`);
+                    }
+                    if (type === "dls ")
+                    {
+                        // Assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                        this.isDLSRMIDI = true;
+                    }
+                }
+                else if (currentChunk.header === "LIST")
+                {
+                    const type = readBytesAsString(currentChunk.chunkData, 4);
+                    if (type === "INFO")
+                    {
+                        SpessaSynthInfo("%cFound RMIDI INFO chunk!", consoleColors.recognized);
+                        this.RMIDInfo = {};
+                        while (currentChunk.chunkData.currentIndex <= currentChunk.size)
+                        {
+                            const infoChunk = readRIFFChunk(currentChunk.chunkData, true);
+                            this.RMIDInfo[infoChunk.header] = infoChunk.chunkData;
+                        }
+                        if (this.RMIDInfo["ICOP"])
+                        {
+                            // special case, overwrites the copyright components array
+                            this.copyright = readBytesAsString(
+                                this.RMIDInfo["ICOP"],
+                                this.RMIDInfo["ICOP"].length,
+                                undefined,
+                                false
+                            ).replaceAll("\n", " ");
+                        }
+                        if (this.RMIDInfo["INAM"])
+                        {
+                            this.rawMidiName = this.RMIDInfo[RMIDINFOChunks.name];
+                            // noinspection JSCheckFunctionSignatures
+                            this.midiName = readBytesAsString(
+                                this.rawMidiName,
+                                this.rawMidiName.length,
+                                undefined,
+                                false
+                            ).replaceAll("\n", " ");
+                        }
+                        // these can be used interchangeably
+                        if (this.RMIDInfo["IALB"] && !this.RMIDInfo["IPRD"])
+                        {
+                            this.RMIDInfo["IPRD"] = this.RMIDInfo["IALB"];
+                        }
+                        if (this.RMIDInfo["IPRD"] && !this.RMIDInfo["IALB"])
+                        {
+                            this.RMIDInfo["IALB"] = this.RMIDInfo["IPRD"];
+                        }
+                        this.bankOffset = 1; // defaults to 1
+                        if (this.RMIDInfo[RMIDINFOChunks.bankOffset])
+                        {
+                            this.bankOffset = readLittleEndian(this.RMIDInfo[RMIDINFOChunks.bankOffset], 2);
+                        }
+                    }
+                }
+            }
+            
+            if (this.isDLSRMIDI)
+            {
+                // Assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                this.bankOffset = 0;
+            }
+            
+            // if no embedded bank, assume 0
+            if (this.embeddedSoundFont === undefined)
+            {
+                this.bankOffset = 0;
+            }
+        }
+        else if (initialString === "XMF_")
+        {
+            // XMF file
+            fileByteArray = loadXMF(this, binaryData);
+        }
+        else
+        {
+            fileByteArray = binaryData;
+        }
+        const headerChunk = this._readMIDIChunk(fileByteArray);
+        if (headerChunk.type !== "MThd")
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid MIDI Header! Expected "MThd", got "${headerChunk.type}"`);
+        }
+        
+        if (headerChunk.size !== 6)
+        {
+            SpessaSynthGroupEnd();
+            throw new RangeError(`Invalid MIDI header chunk size! Expected 6, got ${headerChunk.size}`);
+        }
+        
+        // format
+        this.format = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // tracks count
+        this.tracksAmount = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // time division
+        this.timeDivision = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // read all the tracks
+        for (let i = 0; i < this.tracksAmount; i++)
+        {
+            /**
+             * @type {MIDIMessage[]}
+             */
+            const track = [];
+            const trackChunk = this._readMIDIChunk(fileByteArray);
+            
+            if (trackChunk.type !== "MTrk")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid track header! Expected "MTrk" got "${trackChunk.type}"`);
+            }
+            
+            
+            /**
+             * MIDI running byte
+             * @type {number}
+             */
+            let runningByte = undefined;
+            
+            let totalTicks = 0;
+            // format 2 plays sequentially
+            if (this.format === 2 && i > 0)
+            {
+                totalTicks += this.tracks[i - 1][this.tracks[i - 1].length - 1].ticks;
+            }
+            // loop until we reach the end of track
+            while (trackChunk.data.currentIndex < trackChunk.size)
+            {
+                totalTicks += readVariableLengthQuantity(trackChunk.data);
+                
+                // check if the status byte is valid (IE. larger than 127)
+                const statusByteCheck = trackChunk.data[trackChunk.data.currentIndex];
+                
+                let statusByte;
+                // if we have a running byte and the status byte isn't valid
+                if (runningByte !== undefined && statusByteCheck < 0x80)
+                {
+                    statusByte = runningByte;
+                }
+                else
+                { // noinspection PointlessBooleanExpressionJS
+                    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();
+                        throw new SyntaxError(`Unexpected byte with no running byte. (${statusByteCheck})`);
+                    }
+                    else
+                    {
+                        // if the status byte is valid, use that
+                        statusByte = trackChunk.data[trackChunk.data.currentIndex++];
+                    }
+                }
+                const statusByteChannel = getChannel(statusByte);
+                
+                let eventDataLength;
+                
+                // determine the message's length;
+                switch (statusByteChannel)
+                {
+                    case -1:
+                        // system common/realtime (no length)
+                        eventDataLength = 0;
+                        break;
+                    
+                    case -2:
+                        // meta (the next is the actual status byte)
+                        statusByte = trackChunk.data[trackChunk.data.currentIndex++];
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    
+                    case -3:
+                        // sysex
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    
+                    default:
+                        // voice message
+                        // gets the midi message length
+                        eventDataLength = dataBytesAmount[statusByte >> 4];
+                        // save the status byte
+                        runningByte = statusByte;
+                        break;
+                }
+                
+                // put the event data into the array
+                const eventData = new IndexedByteArray(eventDataLength);
+                eventData.set(trackChunk.data.slice(
+                    trackChunk.data.currentIndex,
+                    trackChunk.data.currentIndex + eventDataLength
+                ), 0);
+                const event = new MIDIMessage(totalTicks, statusByte, eventData);
+                track.push(event);
+                // advance the track chunk
+                trackChunk.data.currentIndex += eventDataLength;
+            }
+            this.tracks.push(track);
+            
+            SpessaSynthInfo(
+                `%cParsed %c${this.tracks.length}%c / %c${this.tracksAmount}`,
+                consoleColors.info,
+                consoleColors.value,
+                consoleColors.info,
+                consoleColors.value
+            );
+        }
+        
+        SpessaSynthInfo(
+            `%cAll tracks parsed correctly!`,
+            consoleColors.recognized
+        );
+        // parse the events
+        this._parseInternal();
+        SpessaSynthGroupEnd();
+        SpessaSynthInfo(
+            `%cMIDI file parsed. Total tick time: %c${this.lastVoiceEventTick}%c, total seconds time: %c${this.duration}`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    /**
+     * @param fileByteArray {IndexedByteArray}
+     * @returns {{type: string, size: number, data: IndexedByteArray}}
+     * @private
+     */
+    _readMIDIChunk(fileByteArray)
+    {
+        const chunk = {};
+        // type
+        chunk.type = readBytesAsString(fileByteArray, 4);
+        // size
+        chunk.size = readBytesAsUintBigEndian(fileByteArray, 4);
+        // data
+        chunk.data = new IndexedByteArray(chunk.size);
+        const dataSlice = fileByteArray.slice(fileByteArray.currentIndex, fileByteArray.currentIndex + chunk.size);
+        chunk.data.set(dataSlice, 0);
+        fileByteArray.currentIndex += chunk.size;
+        return chunk;
+    }
+}
+
+export { MIDI };

spessasynth_lib/midi_parser/midi_message.js

@@ -0,0 +1,254 @@
+import { IndexedByteArray } from "../utils/indexed_array.js";
+
+/**
+ * midi_message.js
+ * purpose: contains enums for midi events and controllers and functions to parse them
+ */
+
+export class MIDIMessage
+{
+    /**
+     * Absolute number of MIDI ticks from the start of the track.
+     * @type {number}
+     */
+    ticks;
+    
+    /**
+     * The MIDI message status byte. Note that for meta events, it is the second byte. (not 0xFF)
+     * @type {number}
+     */
+    messageStatusByte;
+    
+    /**
+     * Message's binary data
+     * @type {IndexedByteArray}
+     */
+    messageData;
+    
+    /**
+     * @param ticks {number}
+     * @param byte {number} the message status byte
+     * @param data {IndexedByteArray}
+     */
+    constructor(ticks, byte, data)
+    {
+        this.ticks = ticks;
+        this.messageStatusByte = byte;
+        this.messageData = data;
+    }
+}
+
+/**
+ * Gets the status byte's channel
+ * @param statusByte
+ * @returns {number} channel is -1 for system messages -2 for meta and -3 for sysex
+ */
+export function getChannel(statusByte)
+{
+    const eventType = statusByte & 0xF0;
+    const channel = statusByte & 0x0F;
+    
+    let resultChannel = channel;
+    
+    switch (eventType)
+    {
+        // midi (and meta and sysex headers)
+        case 0x80:
+        case 0x90:
+        case 0xA0:
+        case 0xB0:
+        case 0xC0:
+        case 0xD0:
+        case 0xE0:
+            break;
+        
+        case 0xF0:
+            switch (channel)
+            {
+                case 0x0:
+                    resultChannel = -3;
+                    break;
+                
+                case 0x1:
+                case 0x2:
+                case 0x3:
+                case 0x4:
+                case 0x5:
+                case 0x6:
+                case 0x7:
+                case 0x8:
+                case 0x9:
+                case 0xA:
+                case 0xB:
+                case 0xC:
+                case 0xD:
+                case 0xE:
+                    resultChannel = -1;
+                    break;
+                
+                case 0xF:
+                    resultChannel = -2;
+                    break;
+            }
+            break;
+        
+        default:
+            resultChannel = -1;
+    }
+    
+    return resultChannel;
+}
+
+// all the midi statuses dictionary
+export const messageTypes = {
+    noteOff: 0x80,
+    noteOn: 0x90,
+    polyPressure: 0xA0,
+    controllerChange: 0xB0,
+    programChange: 0xC0,
+    channelPressure: 0xD0,
+    pitchBend: 0xE0,
+    systemExclusive: 0xF0,
+    timecode: 0xF1,
+    songPosition: 0xF2,
+    songSelect: 0xF3,
+    tuneRequest: 0xF6,
+    clock: 0xF8,
+    start: 0xFA,
+    continue: 0xFB,
+    stop: 0xFC,
+    activeSensing: 0xFE,
+    reset: 0xFF,
+    sequenceNumber: 0x00,
+    text: 0x01,
+    copyright: 0x02,
+    trackName: 0x03,
+    instrumentName: 0x04,
+    lyric: 0x05,
+    marker: 0x06,
+    cuePoint: 0x07,
+    programName: 0x08,
+    midiChannelPrefix: 0x20,
+    midiPort: 0x21,
+    endOfTrack: 0x2F,
+    setTempo: 0x51,
+    smpteOffset: 0x54,
+    timeSignature: 0x58,
+    keySignature: 0x59,
+    sequenceSpecific: 0x7F
+};
+
+
+/**
+ * Gets the event's status and channel from the status byte
+ * @param statusByte {number} the status byte
+ * @returns {{channel: number, status: number}} channel will be -1 for sysex and meta
+ */
+export function getEvent(statusByte)
+{
+    const status = statusByte & 0xF0;
+    const channel = statusByte & 0x0F;
+    
+    let eventChannel = -1;
+    let eventStatus = statusByte;
+    
+    if (status >= 0x80 && status <= 0xE0)
+    {
+        eventChannel = channel;
+        eventStatus = status;
+    }
+    
+    return {
+        status: eventStatus,
+        channel: eventChannel
+    };
+}
+
+
+/**
+ * @enum {number}
+ */
+export const midiControllers = {
+    bankSelect: 0,
+    modulationWheel: 1,
+    breathController: 2,
+    footController: 4,
+    portamentoTime: 5,
+    dataEntryMsb: 6,
+    mainVolume: 7,
+    balance: 8,
+    pan: 10,
+    expressionController: 11,
+    effectControl1: 12,
+    effectControl2: 13,
+    generalPurposeController1: 16,
+    generalPurposeController2: 17,
+    generalPurposeController3: 18,
+    generalPurposeController4: 19,
+    lsbForControl0BankSelect: 32,
+    lsbForControl1ModulationWheel: 33,
+    lsbForControl2BreathController: 34,
+    lsbForControl4FootController: 36,
+    lsbForControl5PortamentoTime: 37,
+    lsbForControl6DataEntry: 38,
+    lsbForControl7MainVolume: 39,
+    lsbForControl8Balance: 40,
+    lsbForControl10Pan: 42,
+    lsbForControl11ExpressionController: 43,
+    lsbForControl12EffectControl1: 44,
+    lsbForControl13EffectControl2: 45,
+    sustainPedal: 64,
+    portamentoOnOff: 65,
+    sostenutoPedal: 66,
+    softPedal: 67,
+    legatoFootswitch: 68,
+    hold2Pedal: 69,
+    soundVariation: 70,
+    filterResonance: 71,
+    releaseTime: 72,
+    attackTime: 73,
+    brightness: 74,
+    decayTime: 75,
+    vibratoRate: 76,
+    vibratoDepth: 77,
+    vibratoDelay: 78,
+    soundController10: 79,
+    generalPurposeController5: 80,
+    generalPurposeController6: 81,
+    generalPurposeController7: 82,
+    generalPurposeController8: 83,
+    portamentoControl: 84,
+    reverbDepth: 91,
+    tremoloDepth: 92,
+    chorusDepth: 93,
+    detuneDepth: 94,
+    phaserDepth: 95,
+    dataIncrement: 96,
+    dataDecrement: 97,
+    NRPNLsb: 98,
+    NRPNMsb: 99,
+    RPNLsb: 100,
+    RPNMsb: 101,
+    allSoundOff: 120,
+    resetAllControllers: 121,
+    localControlOnOff: 122,
+    allNotesOff: 123,
+    omniModeOff: 124,
+    omniModeOn: 125,
+    monoModeOn: 126,
+    polyModeOn: 127
+};
+
+
+/**
+ * @type {{"11": number, "12": number, "13": number, "14": number, "8": number, "9": number, "10": number}}
+ */
+export const dataBytesAmount = {
+    0x8: 2, // note off
+    0x9: 2, // note on
+    0xA: 2, // note at
+    0xB: 2, // cc change
+    0xC: 1, // pg change
+    0xD: 1, // channel after touch
+    0xE: 2  // pitch wheel
+};

spessasynth_lib/midi_parser/midi_sequence.js

@@ -0,0 +1,225 @@
+/**
+ * This is the base type for MIDI files. It contains all the "metadata" and information.
+ * It extends to:
+ * - BasicMIDI, which contains the actual track data of the MIDI file. Essentially the MIDI file itself.
+ * - MIDIData, which contains all properties that MIDI does, except for tracks and the embedded soundfont.
+ * MIDIData is the "shell" of the file which is available on the main thread at all times, containing the metadata.
+ */
+class MIDISequenceData
+{
+    /**
+     * The time division of the sequence, representing the number of ticks per beat.
+     * @type {number}
+     */
+    timeDivision = 0;
+    
+    /**
+     * The duration of the sequence, in seconds.
+     * @type {number}
+     */
+    duration = 0;
+    
+    /**
+     * The tempo changes in the sequence, ordered from the last change to the first.
+     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
+     * @type {{ticks: number, tempo: number}[]}
+     */
+    tempoChanges = [{ ticks: 0, tempo: 120 }];
+    
+    /**
+     * A string containing the copyright information for the MIDI sequence if detected.
+     * @type {string}
+     */
+    copyright = "";
+    
+    /**
+     * The number of tracks in the MIDI sequence.
+     * @type {number}
+     */
+    tracksAmount = 0;
+    
+    /**
+     * The track names in the MIDI file, an empty string if not set.
+     * @type {string[]}
+     */
+    trackNames = [];
+    
+    /**
+     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
+     * @type {Uint8Array[]}
+     */
+    lyrics = [];
+    
+    /**
+     * An array of tick positions where lyrics events occur in the sequence.
+     * @type {number[]}
+     */
+    lyricsTicks = [];
+    
+    /**
+     * The tick position of the first note-on event in the MIDI sequence.
+     * @type {number}
+     */
+    firstNoteOn = 0;
+    
+    /**
+     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
+     * @type {{min: number, max: number}}
+     */
+    keyRange = { min: 0, max: 127 };
+    
+    /**
+     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
+     * @type {number}
+     */
+    lastVoiceEventTick = 0;
+    
+    /**
+     * An array of MIDI port numbers used by each track in the sequence.
+     * @type {number[]}
+     */
+    midiPorts = [0];
+    
+    /**
+     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
+     * @type {number[]}
+     */
+    midiPortChannelOffsets = [0];
+    
+    /**
+     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
+     * @type {Set<number>[]}
+     */
+    usedChannelsOnTrack = [];
+    
+    /**
+     * The loop points (in ticks) of the sequence, including both start and end points.
+     * @type {{start: number, end: number}}
+     */
+    loop = { start: 0, end: 0 };
+    
+    /**
+     * The name of the MIDI sequence.
+     * @type {string}
+     */
+    midiName = "";
+    
+    /**
+     * A boolean indicating if the sequence's name is the same as the file name.
+     * @type {boolean}
+     */
+    midiNameUsesFileName = false;
+    
+    /**
+     * The file name of the MIDI sequence, if provided during parsing.
+     * @type {string}
+     */
+    fileName = "";
+    
+    /**
+     * The raw, encoded MIDI name, represented as a Uint8Array.
+     * Useful when the MIDI file uses a different code page.
+     * @type {Uint8Array}
+     */
+    rawMidiName;
+    
+    /**
+     * The format of the MIDI file, which can be 0, 1, or 2, indicating the type of the MIDI file.
+     * @type {number}
+     */
+    format = 0;
+    
+    /**
+     * The RMID (Resource-Interchangeable MIDI) info data, if the file is RMID formatted.
+     * Otherwise, this field is undefined.
+     * Chunk type (e.g. "INAM"): Chunk data as a binary array.
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo = {};
+    
+    /**
+     * The bank offset used for RMID files.
+     * @type {number}
+     */
+    bankOffset = 0;
+    
+    /**
+     * If the MIDI file is a Soft Karaoke file (.kar), this flag is set to true.
+     * https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
+     * @type {boolean}
+     */
+    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
+     * @returns {number} time in seconds
+     */
+    MIDIticksToSeconds(ticks)
+    {
+        let totalSeconds = 0;
+        
+        while (ticks > 0)
+        {
+            // tempo changes are reversed, so the first element is the last tempo change
+            // and the last element is the first tempo change
+            // (always at tick 0 and tempo 120)
+            // find the last tempo change that has occurred
+            let tempo = this.tempoChanges.find(v => v.ticks < ticks);
+            
+            // calculate the difference and tempo time
+            let timeSinceLastTempo = ticks - tempo.ticks;
+            totalSeconds += (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
+            ticks -= timeSinceLastTempo;
+        }
+        
+        return totalSeconds;
+    }
+    
+    /**
+     * INTERNAL USE ONLY!
+     * DO NOT USE IN SPESSASYNTH_LIB
+     * @param sequence {MIDISequenceData}
+     * @protected
+     */
+    _copyFromSequence(sequence)
+    {
+        // properties can be assigned
+        this.midiName = sequence.midiName;
+        this.midiNameUsesFileName = sequence.midiNameUsesFileName;
+        this.fileName = sequence.fileName;
+        this.timeDivision = sequence.timeDivision;
+        this.duration = sequence.duration;
+        this.copyright = sequence.copyright;
+        this.tracksAmount = sequence.tracksAmount;
+        this.firstNoteOn = sequence.firstNoteOn;
+        this.lastVoiceEventTick = sequence.lastVoiceEventTick;
+        this.format = sequence.format;
+        this.bankOffset = sequence.bankOffset;
+        this.isKaraokeFile = sequence.isKaraokeFile;
+        this.isMultiPort = sequence.isMultiPort;
+        
+        // copying arrays
+        this.tempoChanges = [...sequence.tempoChanges];
+        this.lyrics = sequence.lyrics.map(arr => new Uint8Array(arr));
+        this.lyricsTicks = [...sequence.lyricsTicks];
+        this.midiPorts = [...sequence.midiPorts];
+        this.trackNames = [...sequence.trackNames];
+        this.midiPortChannelOffsets = [...sequence.midiPortChannelOffsets];
+        this.usedChannelsOnTrack = sequence.usedChannelsOnTrack.map(set => new Set(set));
+        this.rawMidiName = sequence.rawMidiName ? new Uint8Array(sequence.rawMidiName) : undefined;
+        
+        // copying objects
+        this.loop = { ...sequence.loop };
+        this.keyRange = { ...sequence.keyRange };
+        this.RMIDInfo = { ...sequence.RMIDInfo };
+    }
+}
+
+export { MIDISequenceData };

spessasynth_lib/midi_parser/midi_writer.js

@@ -0,0 +1,99 @@
+import { messageTypes } from "./midi_message.js";
+import { writeVariableLengthQuantity } from "../utils/byte_functions/variable_length_quantity.js";
+import { writeBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+
+/**
+ * Exports the midi as a standard MIDI file
+ * @this {BasicMIDI}
+ */
+export function writeMIDI()
+{
+    const midi = this;
+    if (!midi.tracks)
+    {
+        throw new Error("MIDI has no tracks!");
+    }
+    /**
+     * @type {Uint8Array[]}
+     */
+    const binaryTrackData = [];
+    for (const track of midi.tracks)
+    {
+        const binaryTrack = [];
+        let currentTick = 0;
+        let runningByte = undefined;
+        for (const event of track)
+        {
+            // Ticks stored in MIDI are absolute, but SMF wants relative. Convert them here.
+            const deltaTicks = event.ticks - currentTick;
+            /**
+             * @type {number[]}
+             */
+            let messageData;
+            // determine the message
+            if (event.messageStatusByte <= messageTypes.sequenceSpecific)
+            {
+                // this is a meta-message
+                // syntax is FF<type><length><data>
+                messageData = [0xff, event.messageStatusByte, ...writeVariableLengthQuantity(event.messageData.length), ...event.messageData];
+            }
+            else if (event.messageStatusByte === messageTypes.systemExclusive)
+            {
+                // this is a system exclusive message
+                // syntax is F0<length><data>
+                messageData = [0xf0, ...writeVariableLengthQuantity(event.messageData.length), ...event.messageData];
+            }
+            else
+            {
+                // this is a midi message
+                messageData = [];
+                if (runningByte !== event.messageStatusByte)
+                {
+                    // Running byte was not the byte we want. Add the byte here.
+                    runningByte = event.messageStatusByte;
+                    // add the status byte to the midi
+                    messageData.push(event.messageStatusByte);
+                }
+                // add the data
+                messageData.push(...event.messageData);
+            }
+            // write VLQ
+            binaryTrack.push(...writeVariableLengthQuantity(deltaTicks));
+            // write the message
+            binaryTrack.push(...messageData);
+            currentTick += deltaTicks;
+        }
+        binaryTrackData.push(new Uint8Array(binaryTrack));
+    }
+    
+    /**
+     * @param text {string}
+     * @param arr {number[]}
+     */
+    function writeText(text, arr)
+    {
+        for (let i = 0; i < text.length; i++)
+        {
+            arr.push(text.charCodeAt(i));
+        }
+    }
+    
+    // write the file
+    const binaryData = [];
+    // write header
+    writeText("MThd", binaryData); // MThd
+    binaryData.push(...writeBytesAsUintBigEndian(6, 4)); // length
+    binaryData.push(0, midi.format); // format
+    binaryData.push(...writeBytesAsUintBigEndian(midi.tracksAmount, 2)); // num tracks
+    binaryData.push(...writeBytesAsUintBigEndian(midi.timeDivision, 2)); // time division
+    
+    // write tracks
+    for (const track of binaryTrackData)
+    {
+        // write track header
+        writeText("MTrk", binaryData); // MTrk
+        binaryData.push(...writeBytesAsUintBigEndian(track.length, 4)); // length
+        binaryData.push(...track); // write data
+    }
+    return new Uint8Array(binaryData);
+}

spessasynth_lib/midi_parser/rmidi_writer.js

@@ -0,0 +1,567 @@
+import { combineArrays, IndexedByteArray } from "../utils/indexed_array.js";
+import { writeRIFFOddSize } from "../soundfont/basic_soundfont/riff_chunk.js";
+import { getStringBytes, getStringBytesZero } from "../utils/byte_functions/string.js";
+import { messageTypes, midiControllers, MIDIMessage } from "./midi_message.js";
+import { getGsOn } from "./midi_editor.js";
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils/loggin.js";
+import { consoleColors } from "../utils/other.js";
+import { writeLittleEndian } from "../utils/byte_functions/little_endian.js";
+import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+import { chooseBank, isSystemXG, parseBankSelect } from "../utils/xg_hacks.js";
+import { isGM2On, isGMOn, isGSDrumsOn, isGSOn, isXGOn } from "../utils/sysex_detector.js";
+
+/**
+ * @enum {string}
+ */
+export const RMIDINFOChunks = {
+    name: "INAM",
+    album: "IPRD",
+    album2: "IALB",
+    artist: "IART",
+    genre: "IGNR",
+    picture: "IPIC",
+    copyright: "ICOP",
+    creationDate: "ICRD",
+    comment: "ICMT",
+    engineer: "IENG",
+    software: "ISFT",
+    encoding: "IENC",
+    midiEncoding: "MENC",
+    bankOffset: "DBNK"
+};
+
+const FORCED_ENCODING = "utf-8";
+const DEFAULT_COPYRIGHT = "Created using SpessaSynth";
+
+/**
+ * @typedef {Object} RMIDMetadata
+ * @property {string|undefined} name - the name of the file
+ * @property {string|undefined} engineer - the engineer who worked on the file
+ * @property {string|undefined} artist - the artist
+ * @property {string|undefined} album - the album
+ * @property {string|undefined} genre - the genre of the song
+ * @property {ArrayBuffer|undefined} picture - the image for the file (album cover)
+ * @property {string|undefined} comment - the coment of the file
+ * @property {string|undefined} creationDate - the creation date of the file
+ * @property {string|undefined} copyright - the copyright of the file
+ * @property {string|unescape} midiEncoding - the encoding of the inner MIDI file
+ */
+
+/**
+ * Writes an RMIDI file
+ * @this {BasicMIDI}
+ * @param soundfontBinary {Uint8Array}
+ * @param soundfont {BasicSoundBank}
+ * @param bankOffset {number} the bank offset for RMIDI
+ * @param encoding {string} the encoding of the RMIDI info chunk
+ * @param metadata {RMIDMetadata} the metadata of the file. Optional. If provided, the encoding is forced to utf-8/
+ * @param correctBankOffset {boolean}
+ * @returns {IndexedByteArray}
+ */
+export function writeRMIDI(
+    soundfontBinary,
+    soundfont,
+    bankOffset = 0,
+    encoding = "Shift_JIS",
+    metadata = {},
+    correctBankOffset = true
+)
+{
+    const mid = this;
+    SpessaSynthGroup("%cWriting the RMIDI File...", consoleColors.info);
+    SpessaSynthInfo(
+        `%cConfiguration: Bank offset: %c${bankOffset}%c, encoding: %c${encoding}`,
+        consoleColors.info,
+        consoleColors.value,
+        consoleColors.info,
+        consoleColors.value
+    );
+    SpessaSynthInfo("metadata", metadata);
+    SpessaSynthInfo("Initial bank offset", mid.bankOffset);
+    if (correctBankOffset)
+    {
+        // Add the offset to the bank.
+        // See https://github.com/spessasus/sf2-rmidi-specification#readme
+        // also fix presets that don't exist
+        // since midi player6 doesn't seem to default to 0 when non-existent...
+        let system = "gm";
+        /**
+         * The unwanted system messages such as gm/gm2 on
+         * @type {{tNum: number, e: MIDIMessage}[]}
+         */
+        let unwantedSystems = [];
+        /**
+         * indexes for tracks
+         * @type {number[]}
+         */
+        const eventIndexes = Array(mid.tracks.length).fill(0);
+        let remainingTracks = mid.tracks.length;
+        
+        function findFirstEventIndex()
+        {
+            let index = 0;
+            let ticks = Infinity;
+            mid.tracks.forEach((track, i) =>
+            {
+                if (eventIndexes[i] >= track.length)
+                {
+                    return;
+                }
+                if (track[eventIndexes[i]].ticks < ticks)
+                {
+                    index = i;
+                    ticks = track[eventIndexes[i]].ticks;
+                }
+            });
+            return index;
+        }
+        
+        // it copies midiPorts everywhere else, but here 0 works so DO NOT CHANGE!
+        const ports = Array(mid.tracks.length).fill(0);
+        const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur : max);
+        /**
+         * @type {{
+         *     program: number,
+         *     drums: boolean,
+         *     lastBank: MIDIMessage,
+         *     lastBankLSB: MIDIMessage,
+         *     hasBankSelect: boolean
+         * }[]}
+         */
+        const channelsInfo = [];
+        for (let i = 0; i < channelsAmount; i++)
+        {
+            channelsInfo.push({
+                program: 0,
+                drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
+                lastBank: undefined,
+                lastBankLSB: undefined,
+                hasBankSelect: false
+            });
+        }
+        while (remainingTracks > 0)
+        {
+            let trackNum = findFirstEventIndex();
+            const track = mid.tracks[trackNum];
+            if (eventIndexes[trackNum] >= track.length)
+            {
+                remainingTracks--;
+                continue;
+            }
+            const e = track[eventIndexes[trackNum]];
+            eventIndexes[trackNum]++;
+            
+            let portOffset = mid.midiPortChannelOffsets[ports[trackNum]];
+            if (e.messageStatusByte === messageTypes.midiPort)
+            {
+                ports[trackNum] = e.messageData[0];
+                continue;
+            }
+            const status = e.messageStatusByte & 0xF0;
+            if (
+                status !== messageTypes.controllerChange &&
+                status !== messageTypes.programChange &&
+                status !== messageTypes.systemExclusive
+            )
+            {
+                continue;
+            }
+            
+            if (status === messageTypes.systemExclusive)
+            {
+                // check for drum sysex
+                if (!isGSDrumsOn(e))
+                {
+                    // check for XG
+                    if (isXGOn(e))
+                    {
+                        system = "xg";
+                    }
+                    else if (isGSOn(e))
+                    {
+                        system = "gs";
+                    }
+                    else if (isGMOn(e))
+                    {
+                        // we do not want gm1
+                        system = "gm";
+                        unwantedSystems.push({
+                            tNum: trackNum,
+                            e: e
+                        });
+                    }
+                    else if (isGM2On(e))
+                    {
+                        system = "gm2";
+                    }
+                    continue;
+                }
+                const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][e.messageData[5] & 0x0F] + portOffset;
+                channelsInfo[sysexChannel].drums = !!(e.messageData[7] > 0 && e.messageData[5] >> 4);
+                continue;
+            }
+            
+            // program change
+            const chNum = (e.messageStatusByte & 0xF) + portOffset;
+            /**
+             * @type {{program: number, drums: boolean, lastBank: MIDIMessage, lastBankLSB: MIDIMessage, hasBankSelect: boolean}}
+             */
+            const channel = channelsInfo[chNum];
+            if (status === messageTypes.programChange)
+            {
+                const isXG = isSystemXG(system);
+                // check if the preset for this program exists
+                const initialProgram = e.messageData[0];
+                if (channel.drums)
+                {
+                    if (soundfont.presets.findIndex(p => p.program === initialProgram && p.isDrumPreset(
+                        isXG,
+                        true
+                    )) === -1)
+                    {
+                        // doesn't exist. pick any preset that has bank 128.
+                        e.messageData[0] = soundfont.presets.find(p => p.isDrumPreset(isXG))?.program || 0;
+                        SpessaSynthInfo(
+                            `%cNo drum preset %c${initialProgram}%c. Channel %c${chNum}%c. Changing program to ${e.messageData[0]}.`,
+                            consoleColors.info,
+                            consoleColors.unrecognized,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
+                    }
+                }
+                else
+                {
+                    if (soundfont.presets.findIndex(p => p.program === initialProgram && !p.isDrumPreset(isXG)) === -1)
+                    {
+                        // doesn't exist. pick any preset that does not have bank 128.
+                        e.messageData[0] = soundfont.presets.find(p => !p.isDrumPreset(isXG))?.program || 0;
+                        SpessaSynthInfo(
+                            `%cNo preset %c${initialProgram}%c. Channel %c${chNum}%c. Changing program to ${e.messageData[0]}.`,
+                            consoleColors.info,
+                            consoleColors.unrecognized,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
+                    }
+                }
+                channel.program = e.messageData[0];
+                // check if this preset exists for program and bank
+                const realBank = Math.max(0, channel.lastBank?.messageData[1] - mid.bankOffset); // make sure to take the previous bank offset into account
+                const bankLSB = (channel?.lastBankLSB?.messageData[1] - mid.bankOffset) || 0;
+                if (channel.lastBank === undefined)
+                {
+                    continue;
+                }
+                // adjust bank for XG
+                let bank = chooseBank(realBank, bankLSB, channel.drums, isXG);
+                if (soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
+                {
+                    // no preset with this bank. find this program with any bank
+                    const targetBank = (soundfont.presets.find(p => p.program === e.messageData[0])?.bank + bankOffset) || bankOffset;
+                    channel.lastBank.messageData[1] = targetBank;
+                    if (channel?.lastBankLSB?.messageData)
+                    {
+                        channel.lastBankLSB.messageData[1] = targetBank;
+                    }
+                    SpessaSynthInfo(
+                        `%cNo preset %c${bank}:${e.messageData[0]}%c. Channel %c${chNum}%c. Changing bank to ${targetBank}.`,
+                        consoleColors.info,
+                        consoleColors.unrecognized,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info
+                    );
+                }
+                else
+                {
+                    // There is a preset with this bank. Add offset. For drums add the normal offset.
+                    let drumBank = bank;
+                    if (isSystemXG(system) && bank === 128)
+                    {
+                        bank = 127;
+                    }
+                    const newBank = (bank === 128 ? 128 : drumBank) + bankOffset;
+                    channel.lastBank.messageData[1] = newBank;
+                    if (channel?.lastBankLSB?.messageData && !channel.drums)
+                    {
+                        channel.lastBankLSB.messageData[1] = channel.lastBankLSB.messageData[1] - mid.bankOffset + bankOffset;
+                    }
+                    SpessaSynthInfo(
+                        `%cPreset %c${bank}:${e.messageData[0]}%c exists. Channel %c${chNum}%c.  Changing bank to ${newBank}.`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info
+                    );
+                }
+                continue;
+            }
+            
+            // controller change
+            // we only care about bank-selects
+            const isLSB = e.messageData[0] === midiControllers.lsbForControl0BankSelect;
+            if (e.messageData[0] !== midiControllers.bankSelect && !isLSB)
+            {
+                continue;
+            }
+            // bank select
+            channel.hasBankSelect = true;
+            const bankNumber = e.messageData[1];
+            // interpret
+            const intepretation = parseBankSelect(
+                channel?.lastBank?.messageData[1] || 0,
+                bankNumber,
+                system,
+                isLSB,
+                channel.drums,
+                chNum
+            );
+            if (intepretation.drumsStatus === 2)
+            {
+                channel.drums = true;
+            }
+            else if (intepretation.drumsStatus === 1)
+            {
+                channel.drums = false;
+            }
+            if (isLSB)
+            {
+                channel.lastBankLSB = e;
+            }
+            else
+            {
+                channel.lastBank = e;
+            }
+        }
+        
+        // add missing bank selects
+        // add all bank selects that are missing for this track
+        channelsInfo.forEach((has, ch) =>
+        {
+            if (has.hasBankSelect === true)
+            {
+                return;
+            }
+            // find the first program change (for the given channel)
+            const midiChannel = ch % 16;
+            const status = messageTypes.programChange | midiChannel;
+            // find track with this channel being used
+            const portOffset = Math.floor(ch / 16) * 16;
+            const port = mid.midiPortChannelOffsets.indexOf(portOffset);
+            const track = mid.tracks.find((t, tNum) => mid.midiPorts[tNum] === port && mid.usedChannelsOnTrack[tNum].has(
+                midiChannel));
+            if (track === undefined)
+            {
+                // this channel is not used at all
+                return;
+            }
+            let indexToAdd = track.findIndex(e => e.messageStatusByte === status);
+            if (indexToAdd === -1)
+            {
+                // no program change...
+                // add programs if they are missing from the track
+                // (need them to activate bank 1 for the embedded sfont)
+                const programIndex = track.findIndex(e => (e.messageStatusByte > 0x80 && e.messageStatusByte < 0xF0) && (e.messageStatusByte & 0xF) === midiChannel);
+                if (programIndex === -1)
+                {
+                    // no voices??? skip
+                    return;
+                }
+                const programTicks = track[programIndex].ticks;
+                const targetProgram = soundfont.getPreset(0, 0).program;
+                track.splice(programIndex, 0, new MIDIMessage(
+                    programTicks,
+                    messageTypes.programChange | midiChannel,
+                    new IndexedByteArray([targetProgram])
+                ));
+                indexToAdd = programIndex;
+            }
+            SpessaSynthInfo(
+                `%cAdding bank select for %c${ch}`,
+                consoleColors.info,
+                consoleColors.recognized
+            );
+            const ticks = track[indexToAdd].ticks;
+            const targetBank = (soundfont.getPreset(
+                0,
+                has.program,
+                isSystemXG(system)
+            )?.bank + bankOffset) || bankOffset;
+            track.splice(indexToAdd, 0, new MIDIMessage(
+                ticks,
+                messageTypes.controllerChange | midiChannel,
+                new IndexedByteArray([midiControllers.bankSelect, targetBank])
+            ));
+        });
+        
+        // make sure to put xg if gm
+        if (system !== "gs" && !isSystemXG(system))
+        {
+            for (const m of unwantedSystems)
+            {
+                mid.tracks[m.tNum].splice(mid.tracks[m.tNum].indexOf(m.e), 1);
+            }
+            let index = 0;
+            if (mid.tracks[0][0].messageStatusByte === messageTypes.trackName)
+            {
+                index++;
+            }
+            mid.tracks[0].splice(index, 0, getGsOn(0));
+        }
+    }
+    const newMid = new IndexedByteArray(mid.writeMIDI().buffer);
+    
+    // info data for RMID
+    /**
+     * @type {Uint8Array[]}
+     */
+    const infoContent = [getStringBytes("INFO")];
+    const encoder = new TextEncoder();
+    // software (SpessaSynth)
+    infoContent.push(
+        writeRIFFOddSize(RMIDINFOChunks.software, encoder.encode("SpessaSynth"), true)
+    );
+    // name
+    if (metadata.name !== undefined)
+    {
+        
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.name, encoder.encode(metadata.name), true)
+        );
+        encoding = FORCED_ENCODING;
+    }
+    else
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.name, mid.rawMidiName, true)
+        );
+    }
+    // creation date
+    if (metadata.creationDate !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.creationDate, encoder.encode(metadata.creationDate), true)
+        );
+    }
+    else
+    {
+        const today = new Date().toLocaleString(undefined, {
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            hour: "numeric",
+            minute: "numeric"
+        });
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.creationDate, getStringBytesZero(today), true)
+        );
+    }
+    // comment
+    if (metadata.comment !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.comment, encoder.encode(metadata.comment))
+        );
+    }
+    // engineer
+    if (metadata.engineer !== undefined)
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.engineer, encoder.encode(metadata.engineer), true)
+        );
+    }
+    // album
+    if (metadata.album !== undefined)
+    {
+        // note that there are two album chunks: IPRD and IALB
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.album, encoder.encode(metadata.album), true)
+        );
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.album2, encoder.encode(metadata.album), true)
+        );
+    }
+    // artist
+    if (metadata.artist !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.artist, encoder.encode(metadata.artist), true)
+        );
+    }
+    // genre
+    if (metadata.genre !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.genre, encoder.encode(metadata.genre), true)
+        );
+    }
+    // picture
+    if (metadata.picture !== undefined)
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.picture, new Uint8Array(metadata.picture))
+        );
+    }
+    // copyright
+    if (metadata.copyright !== undefined)
+    {
+        encoding = FORCED_ENCODING;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.copyright, encoder.encode(metadata.copyright), true)
+        );
+    }
+    else
+    {
+        // use midi copyright if possible
+        const copyright = mid.copyright.length > 0 ? mid.copyright : DEFAULT_COPYRIGHT;
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.copyright, getStringBytesZero(copyright))
+        );
+    }
+    
+    // bank offset
+    const DBNK = new IndexedByteArray(2);
+    writeLittleEndian(DBNK, bankOffset, 2);
+    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.bankOffset, DBNK));
+    // midi encoding
+    if (metadata.midiEncoding !== undefined)
+    {
+        infoContent.push(
+            writeRIFFOddSize(RMIDINFOChunks.midiEncoding, encoder.encode(metadata.midiEncoding))
+        );
+        encoding = FORCED_ENCODING;
+    }
+    // encoding
+    infoContent.push(writeRIFFOddSize(RMIDINFOChunks.encoding, getStringBytesZero(encoding)));
+    
+    // combine and write out
+    const infodata = combineArrays(infoContent);
+    const rmiddata = combineArrays([
+        getStringBytes("RMID"),
+        writeRIFFOddSize(
+            "data",
+            newMid
+        ),
+        writeRIFFOddSize(
+            "LIST",
+            infodata
+        ),
+        soundfontBinary
+    ]);
+    SpessaSynthInfo("%cFinished!", consoleColors.info);
+    SpessaSynthGroupEnd();
+    return writeRIFFOddSize(
+        "RIFF",
+        rmiddata
+    );
+}

spessasynth_lib/midi_parser/used_keys_loaded.js

@@ -0,0 +1,238 @@
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils/loggin.js";
+import { consoleColors } from "../utils/other.js";
+import { messageTypes, midiControllers } from "./midi_message.js";
+import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+import { chooseBank, isSystemXG, parseBankSelect } from "../utils/xg_hacks.js";
+import { isGSDrumsOn, isXGOn } from "../utils/sysex_detector.js";
+
+/**
+ * Gets the used programs and keys for this MIDI file with a given sound bank
+ * @this {BasicMIDI}
+ * @param soundfont {BasicSoundBank|WorkletSoundfontManager} - the sound bank
+ * @returns {Object<string, Set<string>>}
+ */
+export function getUsedProgramsAndKeys(soundfont)
+{
+    const mid = this;
+    SpessaSynthGroupCollapsed(
+        "%cSearching for all used programs and keys...",
+        consoleColors.info
+    );
+    // Find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
+    const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur : max);
+    /**
+     * @type {{program: number, bank: number, bankLSB: number, drums: boolean, string: string, actualBank: number}[]}
+     */
+    const channelPresets = [];
+    for (let i = 0; i < channelsAmount; i++)
+    {
+        const bank = i % 16 === DEFAULT_PERCUSSION ? 128 : 0;
+        channelPresets.push({
+            program: 0,
+            bank: bank,
+            bankLSB: 0,
+            actualBank: bank,
+            drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
+            string: `${bank}:0`
+        });
+    }
+    
+    // check for xg
+    let system = "gs";
+    
+    function updateString(ch)
+    {
+        const bank = chooseBank(ch.bank, ch.bankLSB, ch.drums, isSystemXG(system));
+        // check if this exists in the soundfont
+        let exists = soundfont.getPreset(bank, ch.program, isSystemXG(system));
+        ch.actualBank = exists.bank;
+        ch.program = exists.program;
+        ch.string = ch.actualBank + ":" + ch.program;
+        if (!usedProgramsAndKeys[ch.string])
+        {
+            SpessaSynthInfo(
+                `%cDetected a new preset: %c${ch.string}`,
+                consoleColors.info,
+                consoleColors.recognized
+            );
+            usedProgramsAndKeys[ch.string] = new Set();
+        }
+    }
+    
+    /**
+     * find all programs used and key-velocity combos in them
+     * bank:program each has a set of midiNote-velocity
+     * @type {Object<string, Set<string>>}
+     */
+    const usedProgramsAndKeys = {};
+    
+    /**
+     * indexes for tracks
+     * @type {number[]}
+     */
+    const eventIndexes = Array(mid.tracks.length).fill(0);
+    let remainingTracks = mid.tracks.length;
+    
+    function findFirstEventIndex()
+    {
+        let index = 0;
+        let ticks = Infinity;
+        mid.tracks.forEach((track, i) =>
+        {
+            if (eventIndexes[i] >= track.length)
+            {
+                return;
+            }
+            if (track[eventIndexes[i]].ticks < ticks)
+            {
+                index = i;
+                ticks = track[eventIndexes[i]].ticks;
+            }
+        });
+        return index;
+    }
+    
+    const ports = mid.midiPorts.slice();
+    // initialize
+    channelPresets.forEach(c =>
+    {
+        updateString(c);
+    });
+    while (remainingTracks > 0)
+    {
+        let trackNum = findFirstEventIndex();
+        const track = mid.tracks[trackNum];
+        if (eventIndexes[trackNum] >= track.length)
+        {
+            remainingTracks--;
+            continue;
+        }
+        const event = track[eventIndexes[trackNum]];
+        eventIndexes[trackNum]++;
+        
+        if (event.messageStatusByte === messageTypes.midiPort)
+        {
+            ports[trackNum] = event.messageData[0];
+            continue;
+        }
+        const status = event.messageStatusByte & 0xF0;
+        if (
+            status !== messageTypes.noteOn &&
+            status !== messageTypes.controllerChange &&
+            status !== messageTypes.programChange &&
+            status !== messageTypes.systemExclusive
+        )
+        {
+            continue;
+        }
+        const channel = (event.messageStatusByte & 0xF) + mid.midiPortChannelOffsets[ports[trackNum]] || 0;
+        let ch = channelPresets[channel];
+        switch (status)
+        {
+            case messageTypes.programChange:
+                ch.program = event.messageData[0];
+                updateString(ch);
+                break;
+            
+            case messageTypes.controllerChange:
+                const isLSB = event.messageData[0] === midiControllers.lsbForControl0BankSelect;
+                if (event.messageData[0] !== midiControllers.bankSelect && !isLSB)
+                {
+                    // we only care about bank select
+                    continue;
+                }
+                if (system === "gs" && ch.drums)
+                {
+                    // gs drums get changed via sysex, ignore here
+                    continue;
+                }
+                const bank = event.messageData[1];
+                const realBank = Math.max(0, bank - mid.bankOffset);
+                if (isLSB)
+                {
+                    ch.bankLSB = realBank;
+                }
+                else
+                {
+                    ch.bank = realBank;
+                }
+                // interpret the bank
+                const intepretation = parseBankSelect(
+                    ch.bank,
+                    realBank,
+                    system,
+                    isLSB,
+                    ch.drums,
+                    channel
+                );
+                switch (intepretation.drumsStatus)
+                {
+                    case 0:
+                        // no change
+                        break;
+                    
+                    case 1:
+                        // drums changed to off
+                        // drum change is a program change
+                        ch.drums = false;
+                        updateString(ch);
+                        break;
+                    
+                    case 2:
+                        // drums changed to on
+                        // drum change is a program change
+                        ch.drums = true;
+                        updateString(ch);
+                        break;
+                }
+                // do not update the data, bank change doesn't change the preset
+                break;
+            
+            case messageTypes.noteOn:
+                if (event.messageData[1] === 0)
+                {
+                    // that's a note off
+                    continue;
+                }
+                usedProgramsAndKeys[ch.string].add(`${event.messageData[0]}-${event.messageData[1]}`);
+                break;
+            
+            case messageTypes.systemExclusive:
+                // check for drum sysex
+                if (!isGSDrumsOn(event))
+                {
+                    // check for XG
+                    if (isXGOn(event))
+                    {
+                        system = "xg";
+                        SpessaSynthInfo(
+                            "%cXG on detected!",
+                            consoleColors.recognized
+                        );
+                    }
+                    continue;
+                }
+                const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][event.messageData[5] & 0x0F] + mid.midiPortChannelOffsets[ports[trackNum]];
+                const isDrum = !!(event.messageData[7] > 0 && event.messageData[5] >> 4);
+                ch = channelPresets[sysexChannel];
+                ch.drums = isDrum;
+                updateString(ch);
+                break;
+            
+        }
+    }
+    for (const key of Object.keys(usedProgramsAndKeys))
+    {
+        if (usedProgramsAndKeys[key].size === 0)
+        {
+            SpessaSynthInfo(
+                `%cDetected change but no keys for %c${key}`,
+                consoleColors.info,
+                consoleColors.value
+            );
+            delete usedProgramsAndKeys[key];
+        }
+    }
+    SpessaSynthGroupEnd();
+    return usedProgramsAndKeys;
+}

spessasynth_lib/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;
+}

spessasynth_lib/sequencer/README.md

@@ -0,0 +1,30 @@
+## This is the sequencer's folder.
+
+The code here is responsible for playing back the parsed MIDI sequence with the synthesizer.
+
+### Message protocol:
+
+#### Message structure
+
+```js
+const message = {
+    messageType: number, // WorkletSequencerMessageType
+    messageData: any     // any
+}
+```
+
+#### To worklet
+
+Sequencer uses `Synthetizer`'s `post` method to post a message with `messageData` set to
+`workletMessageType.sequencerSpecific`.
+The `messageData` is set to the sequencer's message.
+
+#### From worklet
+
+`WorkletSequencer` uses `SpessaSynthProcessor`'s post to send a message with `messageData` set to
+`returnMessageType.sequencerSpecific`.
+The `messageData` is set to the sequencer's return message.
+
+### Process tick
+
+`processTick` is called every time the `process` method is called via `SpessaSynthProcessor.processTickCallback`.

spessasynth_lib/sequencer/default_sequencer_options.js

@@ -0,0 +1,8 @@
+/**
+ * @type {SequencerOptions}
+ */
+export const DEFAULT_SEQUENCER_OPTIONS = {
+    skipToFirstNoteOn: true,
+    autoPlay: true,
+    preservePlaybackState: false
+};

spessasynth_lib/sequencer/sequencer.js

@@ -0,0 +1,804 @@
+import { Synthetizer } from "../synthetizer/synthetizer.js";
+import { messageTypes } from "../midi_parser/midi_message.js";
+import { workletMessageType } from "../synthetizer/worklet_system/message_protocol/worklet_message.js";
+import {
+    SongChangeType,
+    WorkletSequencerMessageType,
+    WorkletSequencerReturnMessageType
+} from "./worklet_sequencer/sequencer_message.js";
+import { SpessaSynthWarn } from "../utils/loggin.js";
+import { DUMMY_MIDI_DATA, MIDIData } from "../midi_parser/midi_data.js";
+import { BasicMIDI } from "../midi_parser/basic_midi.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+import { DEFAULT_SEQUENCER_OPTIONS } from "./default_sequencer_options.js";
+
+/**
+ * sequencer.js
+ * purpose: plays back the midi file decoded by midi_loader.js, including support for multichannel midis
+ * (adding channels when more than one midi port is detected)
+ * note: this is the sequencer class that runs on the main thread
+ * and only communicates with the worklet sequencer which does the actual playback
+ */
+
+/**
+ * @typedef MidFile {Object}
+ * @property {ArrayBuffer} binary - the binary data of the file.
+ * @property {string|undefined} altName - the alternative name for the file
+ */
+
+/**
+ * @typedef {BasicMIDI|MidFile} MIDIFile
+ */
+
+// noinspection JSUnusedGlobalSymbols
+/**
+ * @typedef {Object} SequencerOptions
+ * @property {boolean|undefined} skipToFirstNoteOn - if true, the sequencer will skip to the first note
+ * @property {boolean|undefined} autoPlay - if true, the sequencer will automatically start playing the MIDI
+ * @property {boolean|unescape} preservePlaybackState - if true,
+ * the sequencer will stay paused when seeking or changing the playback rate
+ */
+
+// noinspection JSUnusedGlobalSymbols
+export class Sequencer
+{
+    /**
+     * Executes when MIDI parsing has an error.
+     * @type {function(Error)}
+     */
+    onError;
+    
+    /**
+     * Fires on text event
+     * @type {Function}
+     * @param data {Uint8Array} the data text
+     * @param type {number} the status byte of the message (the meta-status byte)
+     * @param lyricsIndex {number} if the text is a lyric, the index of the lyric in midiData.lyrics, otherwise -1
+     */
+    onTextEvent;
+    
+    /**
+     * The current MIDI data, with the exclusion of the embedded sound bank and event data.
+     *  @type {MIDIData}
+     */
+    midiData;
+    
+    /**
+     * The current MIDI data for all songs, like the midiData property.
+     * @type {MIDIData[]}
+     */
+    songListData = [];
+    
+    /**
+     * @type {Object<string, function(MIDIData)>}
+     * @private
+     */
+    onSongChange = {};
+    
+    /**
+     * Fires when CurrentTime changes
+     * @type {Object<string, function(number)>} the time that was changed to
+     * @private
+     */
+    onTimeChange = {};
+    
+    /**
+     * @type {Object<string, function>}
+     * @private
+     */
+    onSongEnded = {};
+    
+    /**
+     * Fires on tempo change
+     * @type {Object<string, function(number)>}
+     */
+    onTempoChange = {};
+    
+    /**
+     * Fires on meta-event
+     * @type {Object<string, function([number, Uint8Array, number, number])>}
+     */
+    onMetaEvent = {};
+    
+    /**
+     * Current song's tempo in BPM
+     * @type {number}
+     */
+    currentTempo = 120;
+    /**
+     * Current song index
+     * @type {number}
+     */
+    songIndex = 0;
+    /**
+     * @type {function(BasicMIDI)}
+     * @private
+     */
+    _getMIDIResolve = undefined;
+    /**
+     * Indicates if the current midiData property has fake data in it (not yet loaded)
+     * @type {boolean}
+     */
+    hasDummyData = true;
+    /**
+     * Indicates whether the sequencer has finished playing a sequence
+     * @type {boolean}
+     */
+    isFinished = false;
+    /**
+     * The current sequence's length, in seconds
+     * @type {number}
+     */
+    duration = 0;
+    
+    /**
+     * Indicates if the sequencer is paused.
+     * Paused if a number, undefined if playing
+     * @type {undefined|number}
+     * @private
+     */
+    pausedTime = undefined;
+    
+    /**
+     * Creates a new Midi sequencer for playing back MIDI files
+     * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
+     * @param synth {Synthetizer} synth to send events to
+     * @param options {SequencerOptions} the sequencer's options
+     */
+    constructor(midiBinaries, synth, options = DEFAULT_SEQUENCER_OPTIONS)
+    {
+        this.ignoreEvents = false;
+        this.synth = synth;
+        this.highResTimeOffset = 0;
+        
+        /**
+         * Absolute playback startTime, bases on the synth's time
+         * @type {number}
+         */
+        this.absoluteStartTime = this.synth.currentTime;
+        
+        this.synth.sequencerCallbackFunction = this._handleMessage.bind(this);
+        
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._skipToFirstNoteOn = options?.skipToFirstNoteOn ?? true;
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._preservePlaybackState = options?.preservePlaybackState ?? false;
+        
+        if (this._skipToFirstNoteOn === false)
+        {
+            // setter sends message
+            this._sendMessage(WorkletSequencerMessageType.setSkipToFirstNote, false);
+        }
+        
+        if (this._preservePlaybackState === true)
+        {
+            this._sendMessage(WorkletSequencerMessageType.setPreservePlaybackState, true);
+        }
+        
+        this.loadNewSongList(midiBinaries, options?.autoPlay ?? true);
+        
+        window.addEventListener("beforeunload", this.resetMIDIOut.bind(this));
+    }
+    
+    /**
+     * Internal loop marker
+     * @type {boolean}
+     * @private
+     */
+    _loop = true;
+    
+    /**
+     * Indicates if the sequencer is currently looping
+     * @returns {boolean}
+     */
+    get loop()
+    {
+        return this._loop;
+    }
+    
+    set loop(value)
+    {
+        this._sendMessage(WorkletSequencerMessageType.setLoop, [value, this._loopsRemaining]);
+        this._loop = value;
+    }
+    
+    /**
+     * Internal loop count marker (-1 is infinite)
+     * @type {number}
+     * @private
+     */
+    _loopsRemaining = -1;
+    
+    /**
+     * The current remaining number of loops. -1 means infinite looping
+     * @returns {number}
+     */
+    get loopsRemaining()
+    {
+        return this._loopsRemaining;
+    }
+    
+    /**
+     * The current remaining number of loops. -1 means infinite looping
+     * @param val {number}
+     */
+    set loopsRemaining(val)
+    {
+        this._loopsRemaining = val;
+        this._sendMessage(WorkletSequencerMessageType.setLoop, [this._loop, val]);
+    }
+    
+    /**
+     * Controls the playback's rate
+     * @type {number}
+     * @private
+     */
+    _playbackRate = 1;
+    
+    /**
+     * @returns {number}
+     */
+    get playbackRate()
+    {
+        return this._playbackRate;
+    }
+    
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value)
+    {
+        this._sendMessage(WorkletSequencerMessageType.setPlaybackRate, value);
+        this.highResTimeOffset *= (value / this._playbackRate);
+        this._playbackRate = value;
+    }
+    
+    /**
+     * @type {boolean}
+     * @private
+     */
+    _shuffleSongs = false;
+    
+    /**
+     * Indicates if the song order is random
+     * @returns {boolean}
+     */
+    get shuffleSongs()
+    {
+        return this._shuffleSongs;
+    }
+    
+    /**
+     * Indicates if the song order is random
+     * @param value {boolean}
+     */
+    set shuffleSongs(value)
+    {
+        this._shuffleSongs = value;
+        if (value)
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, [SongChangeType.shuffleOn]);
+        }
+        else
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, [SongChangeType.shuffleOff]);
+        }
+    }
+    
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @return {boolean}
+     */
+    get skipToFirstNoteOn()
+    {
+        return this._skipToFirstNoteOn;
+    }
+    
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @param val {boolean}
+     */
+    set skipToFirstNoteOn(val)
+    {
+        this._skipToFirstNoteOn = val;
+        this._sendMessage(WorkletSequencerMessageType.setSkipToFirstNote, this._skipToFirstNoteOn);
+    }
+    
+    /**
+     * if true,
+     * the sequencer will stay paused when seeking or changing the playback rate
+     * @returns {boolean}
+     */
+    get preservePlaybackState()
+    {
+        return this._preservePlaybackState;
+    }
+    
+    /**
+     * if true,
+     * the sequencer will stay paused when seeking or changing the playback rate
+     * @param val {boolean}
+     */
+    set preservePlaybackState(val)
+    {
+        this._preservePlaybackState = val;
+        this._sendMessage(WorkletSequencerMessageType.setPreservePlaybackState, val);
+    }
+    
+    /**
+     * @returns {number} Current playback time, in seconds
+     */
+    get currentTime()
+    {
+        // return the paused time if it's set to something other than undefined
+        if (this.pausedTime !== undefined)
+        {
+            return this.pausedTime;
+        }
+        
+        return (this.synth.currentTime - this.absoluteStartTime) * this._playbackRate;
+    }
+    
+    set currentTime(time)
+    {
+        if (!this._preservePlaybackState)
+        {
+            this.unpause();
+        }
+        this._sendMessage(WorkletSequencerMessageType.setTime, time);
+    }
+    
+    /**
+     * Use for visualization as it's not affected by the audioContext stutter
+     * @returns {number}
+     */
+    get currentHighResolutionTime()
+    {
+        if (this.pausedTime !== undefined)
+        {
+            return this.pausedTime;
+        }
+        const highResTimeOffset = this.highResTimeOffset;
+        const absoluteStartTime = this.absoluteStartTime;
+        
+        // sync performance.now to current time
+        const performanceElapsedTime = ((performance.now() / 1000) - absoluteStartTime) * this._playbackRate;
+        
+        let currentPerformanceTime = highResTimeOffset + performanceElapsedTime;
+        const currentAudioTime = this.currentTime;
+        
+        const smoothingFactor = 0.01 * this._playbackRate;
+        
+        // diff times smoothing factor
+        const timeDifference = currentAudioTime - currentPerformanceTime;
+        this.highResTimeOffset += timeDifference * smoothingFactor;
+        
+        // return a smoothed performance time
+        currentPerformanceTime = this.highResTimeOffset + performanceElapsedTime;
+        return currentPerformanceTime;
+    }
+    
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused()
+    {
+        return this.pausedTime !== undefined;
+    }
+    
+    /**
+     * Adds a new event that gets called when the song changes
+     * @param callback {function(MIDIData)}
+     * @param id {string} must be unique
+     */
+    addOnSongChangeEvent(callback, id)
+    {
+        this.onSongChange[id] = callback;
+    }
+    
+    /**
+     * Adds a new event that gets called when the song ends
+     * @param callback {function}
+     * @param id {string} must be unique
+     */
+    addOnSongEndedEvent(callback, id)
+    {
+        this.onSongEnded[id] = callback;
+    }
+    
+    /**
+     * Adds a new event that gets called when the time changes
+     * @param callback {function(number)} the new time, in seconds
+     * @param id {string} must be unique
+     */
+    addOnTimeChangeEvent(callback, id)
+    {
+        this.onTimeChange[id] = callback;
+    }
+    
+    /**
+     * Adds a new event that gets called when the tempo changes
+     * @param callback {function(number)} the new tempo, in BPM
+     * @param id {string} must be unique
+     */
+    addOnTempoChangeEvent(callback, id)
+    {
+        this.onTempoChange[id] = callback;
+    }
+    
+    /**
+     * Adds a new event that gets called when a meta-event occurs
+     * @param callback {function([number, Uint8Array, number, number])} the meta-event type,
+     * its data, the track number and MIDI ticks
+     * @param id {string} must be unique
+     */
+    addOnMetaEvent(callback, id)
+    {
+        this.onMetaEvent[id] = callback;
+    }
+    
+    resetMIDIOut()
+    {
+        if (!this.MIDIout)
+        {
+            return;
+        }
+        for (let i = 0; i < 16; i++)
+        {
+            this.MIDIout.send([messageTypes.controllerChange | i, 120, 0]); // all notes off
+            this.MIDIout.send([messageTypes.controllerChange | i, 123, 0]); // all sound off
+        }
+        this.MIDIout.send([messageTypes.reset]); // reset
+    }
+    
+    /**
+     * @param messageType {WorkletSequencerMessageType}
+     * @param messageData {any}
+     * @private
+     */
+    _sendMessage(messageType, messageData = undefined)
+    {
+        this.synth.post({
+            channelNumber: -1,
+            messageType: workletMessageType.sequencerSpecific,
+            messageData: {
+                messageType: messageType,
+                messageData: messageData
+            }
+        });
+    }
+    
+    /**
+     * Switch to the next song in the playlist
+     */
+    nextSong()
+    {
+        this._sendMessage(WorkletSequencerMessageType.changeSong, [SongChangeType.forwards]);
+    }
+    
+    /**
+     * Switch to the previous song in the playlist
+     */
+    previousSong()
+    {
+        this._sendMessage(WorkletSequencerMessageType.changeSong, [SongChangeType.backwards]);
+    }
+    
+    /**
+     * Sets the song index in the playlist
+     * @param index
+     */
+    setSongIndex(index)
+    {
+        const clamped = Math.max(Math.min(this.songsAmount - 1, index), 0);
+        this._sendMessage(WorkletSequencerMessageType.changeSong, [SongChangeType.index, clamped]);
+    }
+    
+    /**
+     * @param type {Object<string, function>}
+     * @param params {any}
+     * @private
+     */
+    _callEvents(type, params)
+    {
+        for (const key in type)
+        {
+            const callback = type[key];
+            try
+            {
+                callback(params);
+            }
+            catch (e)
+            {
+                SpessaSynthWarn(`Failed to execute callback for ${callback[0]}:`, e);
+            }
+        }
+    }
+    
+    /**
+     * @param {WorkletSequencerReturnMessageType} messageType
+     * @param {any} messageData
+     * @private
+     */
+    _handleMessage(messageType, messageData)
+    {
+        if (this.ignoreEvents)
+        {
+            return;
+        }
+        switch (messageType)
+        {
+            case WorkletSequencerReturnMessageType.midiEvent:
+                /**
+                 * @type {number[]}
+                 */
+                let midiEventData = messageData;
+                if (this.MIDIout)
+                {
+                    if (midiEventData[0] >= 0x80)
+                    {
+                        this.MIDIout.send(midiEventData);
+                        return;
+                    }
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.songChange:
+                this.songIndex = messageData[0];
+                const songChangeData = this.songListData[this.songIndex];
+                this.midiData = songChangeData;
+                this.hasDummyData = false;
+                this.absoluteStartTime = 0;
+                this.duration = this.midiData.duration;
+                this._callEvents(this.onSongChange, songChangeData);
+                // if is auto played, unpause
+                if (messageData[1] === true)
+                {
+                    this.unpause();
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.timeChange:
+                // message data is absolute time
+                const time = this.synth.currentTime - messageData;
+                this._callEvents(this.onTimeChange, time);
+                this._recalculateStartTime(time);
+                if (this.paused && this._preservePlaybackState)
+                {
+                    this.pausedTime = time;
+                }
+                else
+                {
+                    this.unpause();
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.pause:
+                this.pausedTime = this.currentTime;
+                this.isFinished = messageData;
+                if (this.isFinished)
+                {
+                    this._callEvents(this.onSongEnded, undefined);
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.midiError:
+                if (this.onError)
+                {
+                    this.onError(messageData);
+                }
+                else
+                {
+                    throw new Error("Sequencer error: " + messageData);
+                }
+                return;
+            
+            case WorkletSequencerReturnMessageType.getMIDI:
+                if (this._getMIDIResolve)
+                {
+                    this._getMIDIResolve(BasicMIDI.copyFrom(messageData));
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.metaEvent:
+                /**
+                 * @type {MIDIMessage}
+                 */
+                const event = messageData[0];
+                switch (event.messageStatusByte)
+                {
+                    case messageTypes.setTempo:
+                        event.messageData.currentIndex = 0;
+                        const bpm = 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
+                        event.messageData.currentIndex = 0;
+                        this.currentTempo = Math.round(bpm * 100) / 100;
+                        if (this.onTempoChange)
+                        {
+                            this._callEvents(this.onTempoChange, this.currentTempo);
+                        }
+                        break;
+                    
+                    case messageTypes.text:
+                    case messageTypes.lyric:
+                    case messageTypes.copyright:
+                    case messageTypes.trackName:
+                    case messageTypes.marker:
+                    case messageTypes.cuePoint:
+                    case messageTypes.instrumentName:
+                    case messageTypes.programName:
+                        let lyricsIndex = -1;
+                        if (event.messageStatusByte === messageTypes.lyric)
+                        {
+                            lyricsIndex = Math.min(
+                                this.midiData.lyricsTicks.indexOf(event.ticks),
+                                this.midiData.lyrics.length - 1
+                            );
+                        }
+                        let sentStatus = event.messageStatusByte;
+                        // if MIDI is a karaoke file, it uses the "text" event type or "lyrics" for lyrics (duh)
+                        // why?
+                        // because the MIDI standard is a messy pile of garbage,
+                        // and it's not my fault that it's like this :(
+                        // I'm just trying to make the best out of a bad situation.
+                        // I'm sorry
+                        // okay I should get back to work
+                        // anyway,
+                        // check for a karaoke file and change the status byte to "lyric"
+                        // if it's a karaoke file
+                        if (this.midiData.isKaraokeFile && (
+                            event.messageStatusByte === messageTypes.text ||
+                            event.messageStatusByte === messageTypes.lyric
+                        ))
+                        {
+                            lyricsIndex = Math.min(
+                                this.midiData.lyricsTicks.indexOf(event.ticks),
+                                this.midiData.lyricsTicks.length
+                            );
+                            sentStatus = messageTypes.lyric;
+                        }
+                        if (this.onTextEvent)
+                        {
+                            this.onTextEvent(event.messageData, sentStatus, lyricsIndex, event.ticks);
+                        }
+                        break;
+                }
+                this._callEvents(this.onMetaEvent, messageData);
+                break;
+            
+            case WorkletSequencerReturnMessageType.loopCountChange:
+                this._loopsRemaining = messageData;
+                if (this._loopsRemaining === 0)
+                {
+                    this._loop = false;
+                }
+                break;
+            
+            case WorkletSequencerReturnMessageType.songListChange:
+                this.songListData = messageData;
+                break;
+            
+            default:
+                break;
+        }
+    }
+    
+    /**
+     * @param time
+     * @private
+     */
+    _recalculateStartTime(time)
+    {
+        this.absoluteStartTime = this.synth.currentTime - time / this._playbackRate;
+        this.highResTimeOffset = (this.synth.currentTime - (performance.now() / 1000)) * this._playbackRate;
+    }
+    
+    /**
+     * @returns {Promise<MIDI>}
+     */
+    async getMIDI()
+    {
+        return new Promise(resolve =>
+        {
+            this._getMIDIResolve = resolve;
+            this._sendMessage(WorkletSequencerMessageType.getMIDI, undefined);
+        });
+    }
+    
+    /**
+     * Loads a new song list
+     * @param midiBuffers {MIDIFile[]} - the MIDI files to play
+     * @param autoPlay {boolean} - if true, the first sequence will automatically start playing
+     */
+    loadNewSongList(midiBuffers, autoPlay = true)
+    {
+        this.pause();
+        // add some fake data
+        this.midiData = DUMMY_MIDI_DATA;
+        this.hasDummyData = true;
+        this.duration = 99999;
+        /**
+         * sanitize MIDIs
+         * @type {({binary: ArrayBuffer, altName: string}|BasicMIDI)[]}
+         */
+        const sanitizedMidis = midiBuffers.map(m =>
+        {
+            if (m.binary !== undefined)
+            {
+                return m;
+            }
+            return BasicMIDI.copyFrom(m);
+        });
+        this._sendMessage(WorkletSequencerMessageType.loadNewSongList, [sanitizedMidis, autoPlay]);
+        this.songIndex = 0;
+        this.songsAmount = midiBuffers.length;
+        if (this.songsAmount > 1)
+        {
+            this.loop = false;
+        }
+        if (autoPlay === false)
+        {
+            this.pausedTime = this.currentTime;
+        }
+    }
+    
+    /**
+     * @param output {MIDIOutput}
+     */
+    connectMidiOutput(output)
+    {
+        this.resetMIDIOut();
+        this.MIDIout = output;
+        this._sendMessage(WorkletSequencerMessageType.changeMIDIMessageSending, output !== undefined);
+        this.currentTime -= 0.1;
+    }
+    
+    /**
+     * Pauses the playback
+     */
+    pause()
+    {
+        if (this.paused)
+        {
+            SpessaSynthWarn("Already paused");
+            return;
+        }
+        this.pausedTime = this.currentTime;
+        this._sendMessage(WorkletSequencerMessageType.pause);
+    }
+    
+    unpause()
+    {
+        this.pausedTime = undefined;
+        this.isFinished = false;
+    }
+    
+    /**
+     * Starts the playback
+     * @param resetTime {boolean} If true, time is set to 0 s
+     */
+    play(resetTime = false)
+    {
+        if (this.isFinished)
+        {
+            resetTime = true;
+        }
+        this._recalculateStartTime(this.pausedTime || 0);
+        this.unpause();
+        this._sendMessage(WorkletSequencerMessageType.play, resetTime);
+    }
+    
+    /**
+     * Stops the playback
+     */
+    stop()
+    {
+        this._sendMessage(WorkletSequencerMessageType.stop);
+    }
+}

spessasynth_lib/sequencer/worklet_sequencer/events.js

@@ -0,0 +1,199 @@
+import {
+    ALL_CHANNELS_OR_DIFFERENT_ACTION,
+    returnMessageType
+} from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
+import { SongChangeType, WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
+
+import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
+
+/**
+ * @param messageType {WorkletSequencerMessageType}
+ * @param messageData {any}
+ * @this {WorkletSequencer}
+ */
+export function processMessage(messageType, messageData)
+{
+    switch (messageType)
+    {
+        default:
+            break;
+        
+        case WorkletSequencerMessageType.loadNewSongList:
+            this.loadNewSongList(messageData[0], messageData[1]);
+            break;
+        
+        case WorkletSequencerMessageType.pause:
+            this.pause();
+            break;
+        
+        case WorkletSequencerMessageType.play:
+            this.play(messageData);
+            break;
+        
+        case WorkletSequencerMessageType.stop:
+            this.stop();
+            break;
+        
+        case WorkletSequencerMessageType.setTime:
+            this.currentTime = messageData;
+            break;
+        
+        case WorkletSequencerMessageType.changeMIDIMessageSending:
+            this.sendMIDIMessages = messageData;
+            break;
+        
+        case WorkletSequencerMessageType.setPlaybackRate:
+            this.playbackRate = messageData;
+            break;
+        
+        case WorkletSequencerMessageType.setLoop:
+            const [loop, count] = messageData;
+            this.loop = loop;
+            if (count === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                this.loopCount = Infinity;
+            }
+            else
+            {
+                this.loopCount = count;
+            }
+            break;
+        
+        case WorkletSequencerMessageType.changeSong:
+            switch (messageData[0])
+            {
+                case SongChangeType.forwards:
+                    this.nextSong();
+                    break;
+                
+                case SongChangeType.backwards:
+                    this.previousSong();
+                    break;
+                
+                case SongChangeType.shuffleOff:
+                    this.shuffleMode = false;
+                    this.songIndex = this.shuffledSongIndexes[this.songIndex];
+                    break;
+                
+                case SongChangeType.shuffleOn:
+                    this.shuffleMode = true;
+                    this.shuffleSongIndexes();
+                    this.songIndex = 0;
+                    this.loadCurrentSong();
+                    break;
+                
+                case SongChangeType.index:
+                    this.songIndex = messageData[1];
+                    this.loadCurrentSong();
+                    break;
+            }
+            break;
+        
+        case WorkletSequencerMessageType.getMIDI:
+            this.post(WorkletSequencerReturnMessageType.getMIDI, this.midiData);
+            break;
+        
+        case WorkletSequencerMessageType.setSkipToFirstNote:
+            this.skipToFirstNoteOn = messageData;
+            break;
+        
+        case WorkletSequencerMessageType.setPreservePlaybackState:
+            this.preservePlaybackState = messageData;
+    }
+}
+
+/**
+ *
+ * @param messageType {WorkletSequencerReturnMessageType}
+ * @param messageData {any}
+ * @this {WorkletSequencer}
+ */
+export function post(messageType, messageData = undefined)
+{
+    if (!this.synth.enableEventSystem)
+    {
+        return;
+    }
+    this.synth.post({
+        messageType: returnMessageType.sequencerSpecific,
+        messageData: {
+            messageType: messageType,
+            messageData: messageData
+        }
+    });
+}
+
+/**
+ * @param message {number[]}
+ * @this {WorkletSequencer}
+ */
+export function sendMIDIMessage(message)
+{
+    this.post(WorkletSequencerReturnMessageType.midiEvent, message);
+}
+
+/**
+ * @this {WorkletSequencer}
+ * @param channel {number}
+ * @param type {number}
+ * @param value {number}
+ */
+export function sendMIDICC(channel, type, value)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.controllerChange | channel, type, value]);
+}
+
+/**
+ * @this {WorkletSequencer}
+ * @param channel {number}
+ * @param program {number}
+ */
+export function sendMIDIProgramChange(channel, program)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.programChange | channel, program]);
+}
+
+/**
+ * Sets the pitch of the given channel
+ * @this {WorkletSequencer}
+ * @param channel {number} usually 0-15: the channel to change pitch
+ * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+ * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+ */
+export function sendMIDIPitchWheel(channel, MSB, LSB)
+{
+    channel %= 16;
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.pitchBend | channel, LSB, MSB]);
+}
+
+/**
+ * @this {WorkletSequencer}
+ */
+export function sendMIDIReset()
+{
+    if (!this.sendMIDIMessages)
+    {
+        return;
+    }
+    this.sendMIDIMessage([messageTypes.reset]);
+    for (let ch = 0; ch < MIDI_CHANNEL_COUNT; ch++)
+    {
+        this.sendMIDIMessage([messageTypes.controllerChange | ch, midiControllers.allSoundOff, 0]);
+        this.sendMIDIMessage([messageTypes.controllerChange | ch, midiControllers.resetAllControllers, 0]);
+    }
+}

spessasynth_lib/sequencer/worklet_sequencer/play.js

@@ -0,0 +1,355 @@
+import { getEvent, messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { resetArray } from "../../synthetizer/worklet_system/worklet_utilities/controller_tables.js";
+import {
+    nonResetableCCs
+} from "../../synthetizer/worklet_system/worklet_methods/controller_control/reset_controllers.js";
+
+
+// an array with preset default values
+const defaultControllerArray = resetArray.slice(0, 128);
+
+/**
+ * plays from start to the target time, excluding note messages (to get the synth to the correct state)
+ * @private
+ * @param time {number} in seconds
+ * @param ticks {number} optional MIDI ticks, when given is used instead of time
+ * @returns {boolean} true if the midi file is not finished
+ * @this {WorkletSequencer}
+ */
+export function _playTo(time, ticks = undefined)
+{
+    this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+    // reset
+    this.synth.resetAllControllers();
+    this.sendMIDIReset();
+    this._resetTimers();
+    
+    const channelsToSave = this.synth.workletProcessorChannels.length;
+    /**
+     * save pitch bends here and send them only after
+     * @type {number[]}
+     */
+    const pitchBends = Array(channelsToSave).fill(8192);
+    
+    /**
+     * Save programs here and send them only after
+     * @type {{program: number, bank: number, actualBank: number}[]}
+     */
+    const programs = [];
+    for (let i = 0; i < channelsToSave; i++)
+    {
+        programs.push({
+            program: -1,
+            bank: 0,
+            actualBank: 0
+        });
+    }
+    
+    const isCCNonSkippable = controllerNumber => (
+        controllerNumber === midiControllers.dataDecrement ||
+        controllerNumber === midiControllers.dataIncrement ||
+        controllerNumber === midiControllers.dataEntryMsb ||
+        controllerNumber === midiControllers.dataDecrement ||
+        controllerNumber === midiControllers.lsbForControl6DataEntry ||
+        controllerNumber === midiControllers.RPNLsb ||
+        controllerNumber === midiControllers.RPNMsb ||
+        controllerNumber === midiControllers.NRPNLsb ||
+        controllerNumber === midiControllers.NRPNMsb ||
+        controllerNumber === midiControllers.bankSelect ||
+        controllerNumber === midiControllers.lsbForControl0BankSelect ||
+        controllerNumber === midiControllers.resetAllControllers
+    );
+    
+    /**
+     * Save controllers here and send them only after
+     * @type {number[][]}
+     */
+    const savedControllers = [];
+    for (let i = 0; i < channelsToSave; i++)
+    {
+        savedControllers.push(Array.from(defaultControllerArray));
+    }
+    
+    /**
+     * RP-15 compliant reset
+     * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
+     * @param chan {number}
+     */
+    function resetAllControlllers(chan)
+    {
+        // reset pitch bend
+        pitchBends[chan] = 8192;
+        if (savedControllers?.[chan] === undefined)
+        {
+            return;
+        }
+        for (let i = 0; i < defaultControllerArray.length; i++)
+        {
+            if (!nonResetableCCs.has(i))
+            {
+                savedControllers[chan][i] = defaultControllerArray[i];
+            }
+        }
+    }
+    
+    while (true)
+    {
+        // find the next event
+        let trackIndex = this._findFirstEventIndex();
+        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if (ticks !== undefined)
+        {
+            if (event.ticks >= ticks)
+            {
+                break;
+            }
+        }
+        else
+        {
+            if (this.playedTime >= time)
+            {
+                break;
+            }
+        }
+        
+        // skip note ons
+        const info = getEvent(event.messageStatusByte);
+        // Keep in mind midi ports to determine the channel!
+        const channel = info.channel + (this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0);
+        switch (info.status)
+        {
+            // skip note messages
+            case messageTypes.noteOn:
+                // track portamento control as last note
+                if (savedControllers[channel] === undefined)
+                {
+                    savedControllers[channel] = Array.from(defaultControllerArray);
+                }
+                savedControllers[channel][midiControllers.portamentoControl] = event.messageData[0];
+                break;
+            
+            case messageTypes.noteOff:
+                break;
+            
+            // skip pitch bend
+            case messageTypes.pitchBend:
+                pitchBends[channel] = event.messageData[1] << 7 | event.messageData[0];
+                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))
+                {
+                    let ccV = event.messageData[1];
+                    if (controllerNumber === midiControllers.bankSelect)
+                    {
+                        // add the bank to be saved
+                        programs[channel].bank = ccV;
+                        break;
+                    }
+                    else if (controllerNumber === midiControllers.resetAllControllers)
+                    {
+                        resetAllControlllers(channel);
+                    }
+                    if (this.sendMIDIMessages)
+                    {
+                        this.sendMIDICC(channel, controllerNumber, ccV);
+                    }
+                    else
+                    {
+                        this.synth.controllerChange(channel, controllerNumber, ccV);
+                    }
+                }
+                else
+                {
+                    if (savedControllers[channel] === undefined)
+                    {
+                        savedControllers[channel] = Array.from(defaultControllerArray);
+                    }
+                    savedControllers[channel][controllerNumber] = event.messageData[1];
+                }
+                break;
+            
+            default:
+                this._processEvent(event, trackIndex);
+                break;
+        }
+        
+        this.eventIndex[trackIndex]++;
+        // find the next event
+        trackIndex = this._findFirstEventIndex();
+        let nextEvent = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if (nextEvent === undefined)
+        {
+            this.stop();
+            return false;
+        }
+        this.playedTime += this.oneTickToSeconds * (nextEvent.ticks - event.ticks);
+    }
+    
+    // restoring saved controllers
+    if (this.sendMIDIMessages)
+    {
+        for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++)
+        {
+            // restore pitch bends
+            if (pitchBends[channelNumber] !== undefined)
+            {
+                this.sendMIDIPitchWheel(
+                    channelNumber,
+                    pitchBends[channelNumber] >> 7,
+                    pitchBends[channelNumber] & 0x7F
+                );
+            }
+            if (savedControllers[channelNumber] !== undefined)
+            {
+                // every controller that has changed
+                savedControllers[channelNumber].forEach((value, index) =>
+                {
+                    if (value !== defaultControllerArray[index] && !isCCNonSkippable(
+                        index))
+                    {
+                        this.sendMIDICC(channelNumber, index, value);
+                    }
+                });
+            }
+            // restore programs
+            if (programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
+            {
+                const bank = programs[channelNumber].actualBank;
+                this.sendMIDICC(channelNumber, midiControllers.bankSelect, bank);
+                this.sendMIDIProgramChange(channelNumber, programs[channelNumber].program);
+            }
+        }
+    }
+    else
+    {
+        // for all synth channels
+        for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++)
+        {
+            // restore pitch bends
+            if (pitchBends[channelNumber] !== undefined)
+            {
+                this.synth.pitchWheel(channelNumber, pitchBends[channelNumber] >> 7, pitchBends[channelNumber] & 0x7F);
+            }
+            if (savedControllers[channelNumber] !== undefined)
+            {
+                // every controller that has changed
+                savedControllers[channelNumber].forEach((value, index) =>
+                {
+                    if (value !== defaultControllerArray[index] && !isCCNonSkippable(
+                        index))
+                    {
+                        this.synth.controllerChange(
+                            channelNumber,
+                            index,
+                            value
+                        );
+                    }
+                });
+            }
+            // restore programs
+            if (programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
+            {
+                const bank = programs[channelNumber].actualBank;
+                this.synth.controllerChange(channelNumber, midiControllers.bankSelect, bank);
+                this.synth.programChange(channelNumber, programs[channelNumber].program);
+            }
+        }
+    }
+    return true;
+}
+
+/**
+ * Starts the playback
+ * @param resetTime {boolean} If true, time is set to 0 s
+ * @this {WorkletSequencer}
+ */
+export function play(resetTime = false)
+{
+    if (this.midiData === undefined)
+    {
+        return;
+    }
+    
+    // reset the time if necessary
+    if (resetTime)
+    {
+        this.pausedTime = undefined;
+        this.currentTime = 0;
+        return;
+    }
+    
+    if (this.currentTime >= this.duration)
+    {
+        this.pausedTime = undefined;
+        this.currentTime = 0;
+        return;
+    }
+    
+    // unpause if paused
+    if (this.paused)
+    {
+        // adjust the start time
+        this._recalculateStartTime(this.pausedTime);
+        this.pausedTime = undefined;
+    }
+    if (!this.sendMIDIMessages)
+    {
+        this.playingNotes.forEach(n =>
+        {
+            this.synth.noteOn(n.channel, n.midiNote, n.velocity);
+        });
+    }
+    this.setProcessHandler();
+}
+
+/**
+ * @this {WorkletSequencer}
+ * @param ticks {number}
+ */
+export function setTimeTicks(ticks)
+{
+    this.stop();
+    this.playingNotes = [];
+    this.pausedTime = undefined;
+    this.post(
+        WorkletSequencerReturnMessageType.timeChange,
+        currentTime - this.midiData.MIDIticksToSeconds(ticks)
+    );
+    const isNotFinished = this._playTo(0, ticks);
+    this._recalculateStartTime(this.playedTime);
+    if (!isNotFinished)
+    {
+        return;
+    }
+    this.play();
+}
+
+/**
+ * @param time
+ * @private
+ * @this {WorkletSequencer}
+ */
+export function _recalculateStartTime(time)
+{
+    this.absoluteStartTime = currentTime - time / this._playbackRate;
+}

spessasynth_lib/sequencer/worklet_sequencer/process_event.js

@@ -0,0 +1,169 @@
+import { getEvent, messageTypes } from "../../midi_parser/midi_message.js";
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { consoleColors } from "../../utils/other.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+import { readBytesAsUintBigEndian } from "../../utils/byte_functions/big_endian.js";
+
+/**
+ * Processes a single event
+ * @param event {MIDIMessage}
+ * @param trackIndex {number}
+ * @this {WorkletSequencer}
+ * @private
+ */
+export function _processEvent(event, trackIndex)
+{
+    if (this.sendMIDIMessages)
+    {
+        if (event.messageStatusByte >= 0x80)
+        {
+            this.sendMIDIMessage([event.messageStatusByte, ...event.messageData]);
+            return;
+        }
+    }
+    const statusByteData = getEvent(event.messageStatusByte);
+    const offset = this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0;
+    statusByteData.channel += offset;
+    // process the event
+    switch (statusByteData.status)
+    {
+        case messageTypes.noteOn:
+            const velocity = event.messageData[1];
+            if (velocity > 0)
+            {
+                this.synth.noteOn(statusByteData.channel, event.messageData[0], velocity);
+                this.playingNotes.push({
+                    midiNote: event.messageData[0],
+                    channel: statusByteData.channel,
+                    velocity: velocity
+                });
+            }
+            else
+            {
+                this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+                const toDelete = this.playingNotes.findIndex(n =>
+                    n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+                if (toDelete !== -1)
+                {
+                    this.playingNotes.splice(toDelete, 1);
+                }
+            }
+            break;
+        
+        case messageTypes.noteOff:
+            this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+            const toDelete = this.playingNotes.findIndex(n =>
+                n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+            if (toDelete !== -1)
+            {
+                this.playingNotes.splice(toDelete, 1);
+            }
+            break;
+        
+        case messageTypes.pitchBend:
+            this.synth.pitchWheel(statusByteData.channel, event.messageData[1], event.messageData[0]);
+            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;
+        
+        case messageTypes.polyPressure:
+            this.synth.polyPressure(statusByteData.channel, event.messageData[0], event.messageData[1]);
+            break;
+        
+        case messageTypes.channelPressure:
+            this.synth.channelPressure(statusByteData.channel, event.messageData[0]);
+            break;
+        
+        case messageTypes.systemExclusive:
+            this.synth.systemExclusive(event.messageData, offset);
+            break;
+        
+        case messageTypes.setTempo:
+            event.messageData.currentIndex = 0;
+            let tempoBPM = 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
+            this.oneTickToSeconds = 60 / (tempoBPM * this.midiData.timeDivision);
+            if (this.oneTickToSeconds === 0)
+            {
+                this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+                SpessaSynthWarn("invalid tempo! falling back to 120 BPM");
+                tempoBPM = 120;
+            }
+            break;
+        
+        // recognized but ignored
+        case messageTypes.timeSignature:
+        case messageTypes.endOfTrack:
+        case messageTypes.midiChannelPrefix:
+        case messageTypes.songPosition:
+        case messageTypes.activeSensing:
+        case messageTypes.keySignature:
+        case messageTypes.sequenceNumber:
+        case messageTypes.sequenceSpecific:
+        case messageTypes.text:
+        case messageTypes.lyric:
+        case messageTypes.copyright:
+        case messageTypes.trackName:
+        case messageTypes.marker:
+        case messageTypes.cuePoint:
+        case messageTypes.instrumentName:
+        case messageTypes.programName:
+            break;
+        
+        
+        case messageTypes.midiPort:
+            this.assignMIDIPort(trackIndex, event.messageData[0]);
+            break;
+        
+        case messageTypes.reset:
+            this.synth.stopAllChannels();
+            this.synth.resetAllControllers();
+            break;
+        
+        default:
+            SpessaSynthWarn(
+                `%cUnrecognized Event: %c${event.messageStatusByte}%c status byte: %c${Object.keys(
+                    messageTypes).find(k => messageTypes[k] === statusByteData.status)}`,
+                consoleColors.warn,
+                consoleColors.unrecognized,
+                consoleColors.warn,
+                consoleColors.value
+            );
+            break;
+    }
+    if (statusByteData.status >= 0 && statusByteData.status < 0x80)
+    {
+        this.post(
+            WorkletSequencerReturnMessageType.metaEvent,
+            [event, trackIndex]
+        );
+    }
+}
+
+/**
+ * Adds 16 channels to the synth
+ * @this {WorkletSequencer}
+ * @private
+ */
+export function _addNewMidiPort()
+{
+    for (let i = 0; i < 16; i++)
+    {
+        this.synth.createWorkletChannel(true);
+    }
+}

spessasynth_lib/sequencer/worklet_sequencer/process_tick.js

@@ -0,0 +1,106 @@
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+
+/**
+ * Processes a single tick
+ * @this {WorkletSequencer}
+ */
+export function processTick()
+{
+    if (!this.isActive)
+    {
+        return;
+    }
+    let current = this.currentTime;
+    while (this.playedTime < current)
+    {
+        // find the next event
+        let trackIndex = this._findFirstEventIndex();
+        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        this._processEvent(event, trackIndex);
+        
+        this.eventIndex[trackIndex]++;
+        
+        // find the next event
+        trackIndex = this._findFirstEventIndex();
+        if (this.tracks[trackIndex].length <= this.eventIndex[trackIndex])
+        {
+            // the song has ended
+            if (this.loop)
+            {
+                this.setTimeTicks(this.midiData.loop.start);
+                return;
+            }
+            this.eventIndex[trackIndex]--;
+            this.pause(true);
+            if (this.songs.length > 1)
+            {
+                this.nextSong();
+            }
+            return;
+        }
+        let eventNext = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        this.playedTime += this.oneTickToSeconds * (eventNext.ticks - event.ticks);
+        
+        const canLoop = this.loop && (this.loopCount > 0 || this.loopCount === -1);
+        
+        // if we reached loop.end
+        if ((this.midiData.loop.end <= event.ticks) && canLoop)
+        {
+            // loop
+            if (this.loopCount !== Infinity)
+            {
+                this.loopCount--;
+                this.post(WorkletSequencerReturnMessageType.loopCountChange, this.loopCount);
+            }
+            this.setTimeTicks(this.midiData.loop.start);
+            return;
+        }
+        // if the song has ended
+        else if (current >= this.duration)
+        {
+            if (canLoop)
+            {
+                // loop
+                if (this.loopCount !== Infinity)
+                {
+                    this.loopCount--;
+                    this.post(WorkletSequencerReturnMessageType.loopCountChange, this.loopCount);
+                }
+                this.setTimeTicks(this.midiData.loop.start);
+                return;
+            }
+            // stop the playback
+            this.eventIndex[trackIndex]--;
+            this.pause(true);
+            if (this.songs.length > 1)
+            {
+                this.nextSong();
+            }
+            return;
+        }
+    }
+}
+
+
+/**
+ * @returns {number} the index of the first to the current played time
+ * @this {WorkletSequencer}
+ */
+export function _findFirstEventIndex()
+{
+    let index = 0;
+    let ticks = Infinity;
+    this.tracks.forEach((track, i) =>
+    {
+        if (this.eventIndex[i] >= track.length)
+        {
+            return;
+        }
+        if (track[this.eventIndex[i]].ticks < ticks)
+        {
+            index = i;
+            ticks = track[this.eventIndex[i]].ticks;
+        }
+    });
+    return index;
+}

spessasynth_lib/sequencer/worklet_sequencer/sequencer_message.js

@@ -0,0 +1,53 @@
+export const SongChangeType = {
+    backwards: 0,   // no additional data
+    forwards: 1,    // no additional data
+    shuffleOn: 2,   // no additional data
+    shuffleOff: 3,  // no additional data
+    index: 4        // songIndex<number>
+};
+
+/**
+ * @enum {number}
+ * @property {number} loadNewSongList          - 0 -> [...song<MIDI>]
+ * @property {number} pause                    - 1 -> isFinished<boolean>
+ * @property {number} stop                     - 2 -> (no data)
+ * @property {number} play                     - 3 -> resetTime<boolean>
+ * @property {number} setTime                  - 4 -> time<number>
+ * @property {number} changeMIDIMessageSending - 5 -> sendMIDIMessages<boolean>
+ * @property {number} setPlaybackRate          - 6 -> playbackRate<number>
+ * @property {number} setLoop                  - 7 -> [loop<boolean>, count<number>]
+ * @property {number} changeSong               - 8 -> [changeType<SongChangeType>, data<number>]
+ * @property {number} getMIDI                  - 9 -> (no data)
+ * @property {number} setSkipToFirstNote       -10 -> skipToFirstNoteOn<boolean>
+ * @property {number} setPreservePlaybackState -11 -> preservePlaybackState<boolean>
+ */
+export const WorkletSequencerMessageType = {
+    loadNewSongList: 0,
+    pause: 1,
+    stop: 2,
+    play: 3,
+    setTime: 4,
+    changeMIDIMessageSending: 5,
+    setPlaybackRate: 6,
+    setLoop: 7,
+    changeSong: 8,
+    getMIDI: 9,
+    setSkipToFirstNote: 10,
+    setPreservePlaybackState: 11
+};
+
+/**
+ *
+ * @enum {number}
+ */
+export const WorkletSequencerReturnMessageType = {
+    midiEvent: 0,               // [...midiEventBytes<number>]
+    songChange: 1,              // [songIndex<number>, isAutoPlayed<boolean>]
+    timeChange: 2,              // newAbsoluteTime<number>
+    pause: 3,                   // no data
+    getMIDI: 4,                 // midiData<MIDI>
+    midiError: 5,               // errorMSG<string>
+    metaEvent: 6,               // [event<MIDIMessage>, trackNum<number>]
+    loopCountChange: 7,         // newLoopCount<number>
+    songListChange: 8          // songListData<MIDIData[]>
+};

spessasynth_lib/sequencer/worklet_sequencer/song_control.js

@@ -0,0 +1,229 @@
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { consoleColors, formatTime } from "../../utils/other.js";
+import {
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+    SpessaSynthWarn
+} from "../../utils/loggin.js";
+import { MIDIData } from "../../midi_parser/midi_data.js";
+import { MIDI } from "../../midi_parser/midi_loader.js";
+import { BasicMIDI } from "../../midi_parser/basic_midi.js";
+
+
+/**
+ * @param trackNum {number}
+ * @param port {number}
+ * @this {WorkletSequencer}
+ */
+export function assignMIDIPort(trackNum, port)
+{
+    // do not assign ports to empty tracks
+    if (this.midiData.usedChannelsOnTrack[trackNum].size === 0)
+    {
+        return;
+    }
+    
+    // assign new 16 channels if the port is not occupied yet
+    if (this.midiPortChannelOffset === 0)
+    {
+        this.midiPortChannelOffset += 16;
+        this.midiPortChannelOffsets[port] = 0;
+    }
+    
+    if (this.midiPortChannelOffsets[port] === undefined)
+    {
+        if (this.synth.workletProcessorChannels.length < this.midiPortChannelOffset + 15)
+        {
+            this._addNewMidiPort();
+        }
+        this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
+        this.midiPortChannelOffset += 16;
+    }
+    
+    this.midiPorts[trackNum] = port;
+}
+
+/**
+ * Loads a new sequence
+ * @param parsedMidi {BasicMIDI}
+ * @param autoPlay {boolean}
+ * @this {WorkletSequencer}
+ */
+export function loadNewSequence(parsedMidi, autoPlay = true)
+{
+    this.stop();
+    if (!parsedMidi.tracks)
+    {
+        throw new Error("This MIDI has no tracks!");
+    }
+    
+    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision);
+    
+    /**
+     * @type {BasicMIDI}
+     */
+    this.midiData = parsedMidi;
+    
+    // check for embedded soundfont
+    if (this.midiData.embeddedSoundFont !== undefined)
+    {
+        SpessaSynthInfo("%cEmbedded soundfont detected! Using it.", consoleColors.recognized);
+        this.synth.setEmbeddedSoundFont(this.midiData.embeddedSoundFont, this.midiData.bankOffset);
+    }
+    else
+    {
+        if (this.synth.overrideSoundfont)
+        {
+            // clean up the embedded soundfont
+            this.synth.clearSoundFont(true, true);
+        }
+        SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
+        // smart preloading: load only samples used in the midi!
+        const used = this.midiData.getUsedProgramsAndKeys(this.synth.soundfontManager);
+        for (const [programBank, combos] of Object.entries(used))
+        {
+            const bank = parseInt(programBank.split(":")[0]);
+            const program = parseInt(programBank.split(":")[1]);
+            const preset = this.synth.getPreset(bank, program);
+            SpessaSynthInfo(
+                `%cPreloading used samples on %c${preset.presetName}%c...`,
+                consoleColors.info,
+                consoleColors.recognized,
+                consoleColors.info
+            );
+            for (const combo of combos)
+            {
+                const split = combo.split("-");
+                preset.preloadSpecific(parseInt(split[0]), parseInt(split[1]));
+            }
+        }
+        SpessaSynthGroupEnd();
+    }
+    
+    /**
+     * the midi track data
+     * @type {MIDIMessage[][]}
+     */
+    this.tracks = this.midiData.tracks;
+    
+    // copy over the port data
+    this.midiPorts = this.midiData.midiPorts.slice();
+    
+    // clear last port data
+    this.midiPortChannelOffset = 0;
+    this.midiPortChannelOffsets = {};
+    // assign port offsets
+    this.midiData.midiPorts.forEach((port, trackIndex) =>
+    {
+        this.assignMIDIPort(trackIndex, port);
+    });
+    
+    /**
+     * Same as "audio.duration" property (seconds)
+     * @type {number}
+     */
+    this.duration = this.midiData.duration;
+    this.firstNoteTime = this.midiData.MIDIticksToSeconds(this.midiData.firstNoteOn);
+    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
+    
+    this.post(WorkletSequencerReturnMessageType.songChange, [this.songIndex, autoPlay]);
+    
+    if (this.duration <= 1)
+    {
+        SpessaSynthWarn(
+            `%cVery short song: (${formatTime(Math.round(this.duration)).time}). Disabling loop!`,
+            consoleColors.warn
+        );
+        this.loop = false;
+    }
+    if (autoPlay)
+    {
+        this.play(true);
+    }
+    else
+    {
+        // this shall not play: play to the first note and then wait
+        const targetTime = this.skipToFirstNoteOn ? this.midiData.firstNoteOn - 1 : 0;
+        this.setTimeTicks(targetTime);
+        this.pause();
+    }
+}
+
+/**
+ * @param midiBuffers {MIDIFile[]}
+ * @param autoPlay {boolean}
+ * @this {WorkletSequencer}
+ */
+export function loadNewSongList(midiBuffers, autoPlay = true)
+{
+    /**
+     * parse the MIDIs (only the array buffers, MIDI is unchanged)
+     * @type {BasicMIDI[]}
+     */
+    this.songs = midiBuffers.reduce((mids, b) =>
+    {
+        if (b.duration)
+        {
+            mids.push(BasicMIDI.copyFrom(b));
+            return mids;
+        }
+        try
+        {
+            mids.push(new MIDI(b.binary, b.altName || ""));
+        }
+        catch (e)
+        {
+            console.error(e);
+            this.post(WorkletSequencerReturnMessageType.midiError, e);
+            return mids;
+        }
+        return mids;
+    }, []);
+    if (this.songs.length < 1)
+    {
+        return;
+    }
+    this.songIndex = 0;
+    if (this.songs.length > 1)
+    {
+        this.loop = false;
+    }
+    this.shuffleSongIndexes();
+    const midiDatas = this.songs.map(s => new MIDIData(s));
+    this.post(WorkletSequencerReturnMessageType.songListChange, midiDatas);
+    this.loadCurrentSong(autoPlay);
+}
+
+/**
+ * @this {WorkletSequencer}
+ */
+export function nextSong()
+{
+    if (this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex++;
+    this.songIndex %= this.songs.length;
+    this.loadCurrentSong();
+}
+
+/**
+ * @this {WorkletSequencer}
+ */
+export function previousSong()
+{
+    if (this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex--;
+    if (this.songIndex < 0)
+    {
+        this.songIndex = this.songs.length - 1;
+    }
+    this.loadCurrentSong();
+}

spessasynth_lib/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -0,0 +1,336 @@
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { _addNewMidiPort, _processEvent } from "./process_event.js";
+import { _findFirstEventIndex, processTick } from "./process_tick.js";
+import { assignMIDIPort, loadNewSequence, loadNewSongList, nextSong, previousSong } from "./song_control.js";
+import { _playTo, _recalculateStartTime, play, setTimeTicks } from "./play.js";
+import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
+import {
+    post,
+    processMessage,
+    sendMIDICC,
+    sendMIDIMessage,
+    sendMIDIPitchWheel,
+    sendMIDIProgramChange,
+    sendMIDIReset
+} from "./events.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+
+import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
+
+class WorkletSequencer
+{
+    /**
+     * All the sequencer's songs
+     * @type {BasicMIDI[]}
+     */
+    songs = [];
+    
+    /**
+     * Current song index
+     * @type {number}
+     */
+    songIndex = 0;
+    
+    /**
+     * shuffled song indexes
+     * @type {number[]}
+     */
+    shuffledSongIndexes = [];
+    
+    /**
+     * the synth to use
+     * @type {SpessaSynthProcessor}
+     */
+    synth;
+    
+    /**
+     * if the sequencer is active
+     * @type {boolean}
+     */
+    isActive = false;
+    
+    /**
+     * If the event should instead be sent back to the main thread instead of synth
+     * @type {boolean}
+     */
+    sendMIDIMessages = false;
+    
+    /**
+     * sequencer's loop count
+     * @type {number}
+     */
+    loopCount = Infinity;
+    
+    /**
+     * event's number in this.events
+     * @type {number[]}
+     */
+    eventIndex = [];
+    
+    /**
+     * tracks the time that has already been played
+     * @type {number}
+     */
+    playedTime = 0;
+    
+    /**
+     * The (relative) time when the sequencer was paused. If it's not paused, then it's undefined.
+     * @type {number}
+     */
+    pausedTime = undefined;
+    
+    /**
+     * Absolute playback startTime, bases on the synth's time
+     * @type {number}
+     */
+    absoluteStartTime = currentTime;
+    /**
+     * Currently playing notes (for pausing and resuming)
+     * @type {{
+     *     midiNote: number,
+     *     channel: number,
+     *     velocity: number
+     * }[]}
+     */
+    playingNotes = [];
+    
+    /**
+     * controls if the sequencer loops (defaults to true)
+     * @type {boolean}
+     */
+    loop = true;
+    
+    /**
+     * controls if the songs are ordered randomly
+     * @type {boolean}
+     */
+    shuffleMode = false;
+    
+    /**
+     * the current track data
+     * @type {BasicMIDI}
+     */
+    midiData = undefined;
+    
+    /**
+     * midi port number for the corresponding track
+     * @type {number[]}
+     */
+    midiPorts = [];
+    midiPortChannelOffset = 0;
+    /**
+     * stored as:
+     * Object<midi port, channel offset>
+     * @type {Object<number, number>}
+     */
+    midiPortChannelOffsets = {};
+    
+    /**
+     * @type {boolean}
+     */
+    skipToFirstNoteOn = true;
+    
+    /**
+     * If true, seq will stay paused when seeking or changing the playback rate
+     * @type {boolean}
+     */
+    preservePlaybackState = false;
+    
+    /**
+     * @param spessasynthProcessor {SpessaSynthProcessor}
+     */
+    constructor(spessasynthProcessor)
+    {
+        this.synth = spessasynthProcessor;
+    }
+    
+    /**
+     * Controls the playback's rate
+     * @type {number}
+     * @private
+     */
+    _playbackRate = 1;
+    
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value)
+    {
+        const time = this.currentTime;
+        this._playbackRate = value;
+        this.currentTime = time;
+    }
+    
+    get currentTime()
+    {
+        // return the paused time if it's set to something other than undefined
+        if (this.pausedTime !== undefined)
+        {
+            return this.pausedTime;
+        }
+        
+        return (currentTime - this.absoluteStartTime) * this._playbackRate;
+    }
+    
+    set currentTime(time)
+    {
+        if (time > this.duration || time < 0)
+        {
+            // time is 0
+            if (this.skipToFirstNoteOn)
+            {
+                this.setTimeTicks(this.midiData.firstNoteOn - 1);
+            }
+            else
+            {
+                this.setTimeTicks(0);
+            }
+            return;
+        }
+        if (this.skipToFirstNoteOn)
+        {
+            if (time < this.firstNoteTime)
+            {
+                this.setTimeTicks(this.midiData.firstNoteOn - 1);
+                return;
+            }
+        }
+        this.stop();
+        this.playingNotes = [];
+        const wasPaused = this.paused && this.preservePlaybackState;
+        this.pausedTime = undefined;
+        this.post(WorkletSequencerReturnMessageType.timeChange, currentTime - time);
+        if (this.midiData.duration === 0)
+        {
+            SpessaSynthWarn("No duration!");
+            this.post(WorkletSequencerReturnMessageType.pause, true);
+            return;
+        }
+        this._playTo(time);
+        this._recalculateStartTime(time);
+        if (wasPaused)
+        {
+            this.pause();
+        }
+        else
+        {
+            this.play();
+        }
+    }
+    
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused()
+    {
+        return this.pausedTime !== undefined;
+    }
+    
+    /**
+     * Pauses the playback
+     * @param isFinished {boolean}
+     */
+    pause(isFinished = false)
+    {
+        if (this.paused)
+        {
+            SpessaSynthWarn("Already paused");
+            return;
+        }
+        this.pausedTime = this.currentTime;
+        this.stop();
+        this.post(WorkletSequencerReturnMessageType.pause, isFinished);
+    }
+    
+    /**
+     * Stops the playback
+     */
+    stop()
+    {
+        this.clearProcessHandler();
+        // disable sustain
+        for (let i = 0; i < 16; i++)
+        {
+            this.synth.controllerChange(i, midiControllers.sustainPedal, 0);
+        }
+        this.synth.stopAllChannels();
+        if (this.sendMIDIMessages)
+        {
+            for (let note of this.playingNotes)
+            {
+                this.sendMIDIMessage([messageTypes.noteOff | (note.channel % 16), note.midiNote]);
+            }
+            for (let c = 0; c < MIDI_CHANNEL_COUNT; c++)
+            {
+                this.sendMIDICC(c, midiControllers.allNotesOff, 0);
+            }
+        }
+    }
+    
+    loadCurrentSong(autoPlay = true)
+    {
+        let index = this.songIndex;
+        if (this.shuffleMode)
+        {
+            index = this.shuffledSongIndexes[this.songIndex];
+        }
+        this.loadNewSequence(this.songs[index], autoPlay);
+    }
+    
+    _resetTimers()
+    {
+        this.playedTime = 0;
+        this.eventIndex = Array(this.tracks.length).fill(0);
+    }
+    
+    setProcessHandler()
+    {
+        this.isActive = true;
+    }
+    
+    clearProcessHandler()
+    {
+        this.isActive = false;
+    }
+    
+    shuffleSongIndexes()
+    {
+        const indexes = this.songs.map((_, i) => i);
+        this.shuffledSongIndexes = [];
+        while (indexes.length > 0)
+        {
+            const index = indexes[Math.floor(Math.random() * indexes.length)];
+            this.shuffledSongIndexes.push(index);
+            indexes.splice(indexes.indexOf(index), 1);
+        }
+    }
+}
+
+// Web MIDI sending
+WorkletSequencer.prototype.sendMIDIMessage = sendMIDIMessage;
+WorkletSequencer.prototype.sendMIDIReset = sendMIDIReset;
+WorkletSequencer.prototype.sendMIDICC = sendMIDICC;
+WorkletSequencer.prototype.sendMIDIProgramChange = sendMIDIProgramChange;
+WorkletSequencer.prototype.sendMIDIPitchWheel = sendMIDIPitchWheel;
+WorkletSequencer.prototype.assignMIDIPort = assignMIDIPort;
+
+WorkletSequencer.prototype.post = post;
+WorkletSequencer.prototype.processMessage = processMessage;
+
+WorkletSequencer.prototype._processEvent = _processEvent;
+WorkletSequencer.prototype._addNewMidiPort = _addNewMidiPort;
+WorkletSequencer.prototype.processTick = processTick;
+WorkletSequencer.prototype._findFirstEventIndex = _findFirstEventIndex;
+
+WorkletSequencer.prototype.loadNewSequence = loadNewSequence;
+WorkletSequencer.prototype.loadNewSongList = loadNewSongList;
+WorkletSequencer.prototype.nextSong = nextSong;
+WorkletSequencer.prototype.previousSong = previousSong;
+
+WorkletSequencer.prototype.play = play;
+WorkletSequencer.prototype._playTo = _playTo;
+WorkletSequencer.prototype.setTimeTicks = setTimeTicks;
+WorkletSequencer.prototype._recalculateStartTime = _recalculateStartTime;
+
+export { WorkletSequencer };

spessasynth_lib/soundfont/README.md

@@ -0,0 +1,13 @@
+## This is the SoundFont2 parsing library.
+
+The code here is responsible for parsing the SoundFont2 file and
+providing an easy way to get the data out.
+Default modulators are also stored here (in `modulators.js`)
+
+`basic_soundfont` folder contains the classes that represent the soundfont file.
+
+`read_sf2` folder contains the code for reading an `.sf2` file.
+
+`write` folder contains the code for writing out an `.sf2` file.
+
+`dls` folder contains the code for reading a `.dls` file (and converting in into a soundfont representation).

spessasynth_lib/soundfont/basic_soundfont/basic_instrument.js

@@ -0,0 +1,77 @@
+export class BasicInstrument
+{
+    /**
+     * The instrument's name
+     * @type {string}
+     */
+    instrumentName = "";
+    
+    /**
+     * The instrument's zones
+     * @type {BasicInstrumentZone[]}
+     */
+    instrumentZones = [];
+    
+    /**
+     * Instrument's use count, used for trimming
+     * @type {number}
+     * @private
+     */
+    _useCount = 0;
+    
+    /**
+     * @returns {number}
+     */
+    get useCount()
+    {
+        return this._useCount;
+    }
+    
+    addUseCount()
+    {
+        this._useCount++;
+        this.instrumentZones.forEach(z => z.useCount++);
+    }
+    
+    removeUseCount()
+    {
+        this._useCount--;
+        for (let i = 0; i < this.instrumentZones.length; i++)
+        {
+            if (this.safeDeleteZone(i))
+            {
+                i--;
+            }
+        }
+    }
+    
+    deleteInstrument()
+    {
+        this.instrumentZones.forEach(z => z.deleteZone());
+        this.instrumentZones.length = 0;
+    }
+    
+    /**
+     * @param index {number}
+     * @returns {boolean} is the zone has been deleted
+     */
+    safeDeleteZone(index)
+    {
+        this.instrumentZones[index].useCount--;
+        if (this.instrumentZones[index].useCount < 1)
+        {
+            this.deleteZone(index);
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.instrumentZones[index].deleteZone();
+        this.instrumentZones.splice(index, 1);
+    }
+}

spessasynth_lib/soundfont/basic_soundfont/basic_preset.js

@@ -0,0 +1,336 @@
+/**
+ * @typedef {{
+ *  instrumentGenerators: Generator[],
+ *  presetGenerators: Generator[],
+ *  modulators: Modulator[],
+ *  sample: BasicSample,
+ *  sampleID: number,
+ * }} SampleAndGenerators
+ */
+import { generatorTypes } from "./generator.js";
+import { Modulator } from "./modulator.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
+
+export class BasicPreset
+{
+    /**
+     * The parent soundbank instance
+     * Currently used for determining default modulators and XG status
+     * @type {BasicSoundBank}
+     */
+    parentSoundBank;
+    
+    /**
+     * The preset's name
+     * @type {string}
+     */
+    presetName = "";
+    
+    /**
+     * The preset's MIDI program number
+     * @type {number}
+     */
+    program = 0;
+    
+    /**
+     * The preset's MIDI bank number
+     * @type {number}
+     */
+    bank = 0;
+    
+    /**
+     * The preset's zones
+     * @type {BasicPresetZone[]}
+     */
+    presetZones = [];
+    
+    /**
+     * Stores already found getSamplesAndGenerators for reuse
+     * @type {SampleAndGenerators[][][]}
+     */
+    foundSamplesAndGenerators = [];
+    
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    library = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    genre = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    morphology = 0;
+    
+    /**
+     * Creates a new preset representation
+     * @param parentSoundBank {BasicSoundBank}
+     */
+    constructor(parentSoundBank)
+    {
+        this.parentSoundBank = parentSoundBank;
+        for (let i = 0; i < 128; i++)
+        {
+            this.foundSamplesAndGenerators[i] = [];
+        }
+    }
+    
+    /**
+     * @param allowXG {boolean}
+     * @param allowSFX {boolean}
+     * @returns {boolean}
+     */
+    isDrumPreset(allowXG, allowSFX = false)
+    {
+        const xg = allowXG && this.parentSoundBank.isXGBank;
+        // sfx is not cool
+        return this.bank === 128 || (
+            xg &&
+            (isXGDrums(this.bank) && (this.bank !== 126 || allowSFX))
+        );
+    }
+    
+    deletePreset()
+    {
+        this.presetZones.forEach(z => z.deleteZone());
+        this.presetZones.length = 0;
+    }
+    
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.presetZones[index].deleteZone();
+        this.presetZones.splice(index, 1);
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Preloads all samples (async)
+     */
+    preload(keyMin, keyMax)
+    {
+        for (let key = keyMin; key < keyMax + 1; key++)
+        {
+            for (let velocity = 0; velocity < 128; velocity++)
+            {
+                this.getSamplesAndGenerators(key, velocity).forEach(samandgen =>
+                {
+                    if (!samandgen.sample.isSampleLoaded)
+                    {
+                        samandgen.sample.getAudioData();
+                    }
+                });
+            }
+        }
+    }
+    
+    /**
+     * Preloads a specific key/velocity combo
+     * @param key {number}
+     * @param velocity {number}
+     */
+    preloadSpecific(key, velocity)
+    {
+        this.getSamplesAndGenerators(key, velocity).forEach(samandgen =>
+        {
+            if (!samandgen.sample.isSampleLoaded)
+            {
+                samandgen.sample.getAudioData();
+            }
+        });
+    }
+    
+    /**
+     * Returns generatorTranslator and generators for given note
+     * @param midiNote {number}
+     * @param velocity {number}
+     * @returns {SampleAndGenerators[]}
+     */
+    getSamplesAndGenerators(midiNote, velocity)
+    {
+        const memorized = this.foundSamplesAndGenerators[midiNote][velocity];
+        if (memorized)
+        {
+            return memorized;
+        }
+        
+        if (this.presetZones.length < 1)
+        {
+            return [];
+        }
+        
+        /**
+         * @param range {SoundFontRange}
+         * @param number {number}
+         * @returns {boolean}
+         */
+        function isInRange(range, number)
+        {
+            return number >= range.min && number <= range.max;
+        }
+        
+        /**
+         * @param main {Generator[]}
+         * @param adder {Generator[]}
+         */
+        function addUnique(main, adder)
+        {
+            main.push(...adder.filter(g => !main.find(mg => mg.generatorType === g.generatorType)));
+        }
+        
+        /**
+         * @param main {Modulator[]}
+         * @param adder {Modulator[]}
+         */
+        function addUniqueMods(main, adder)
+        {
+            main.push(...adder.filter(m => !main.find(mm => Modulator.isIdentical(m, mm))));
+        }
+        
+        /**
+         * @type {SampleAndGenerators[]}
+         */
+        let parsedGeneratorsAndSamples = [];
+        
+        /**
+         * global zone is always first, so it or nothing
+         * @type {Generator[]}
+         */
+        let globalPresetGenerators = this.presetZones[0].isGlobal ? [...this.presetZones[0].generators] : [];
+        
+        /**
+         * @type {Modulator[]}
+         */
+        let globalPresetModulators = this.presetZones[0].isGlobal ? [...this.presetZones[0].modulators] : [];
+        const globalKeyRange = this.presetZones[0].isGlobal ? this.presetZones[0].keyRange : { min: 0, max: 127 };
+        const globalVelRange = this.presetZones[0].isGlobal ? this.presetZones[0].velRange : { min: 0, max: 127 };
+        
+        // find the preset zones in range
+        let presetZonesInRange = this.presetZones.filter(currentZone =>
+            (
+                isInRange(
+                    currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
+                    midiNote
+                )
+                &&
+                isInRange(
+                    currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
+                    velocity
+                )
+            ) && !currentZone.isGlobal);
+        
+        presetZonesInRange.forEach(zone =>
+        {
+            // the global zone is already taken into account earlier
+            if (zone.instrument.instrumentZones.length < 1)
+            {
+                return;
+            }
+            let presetGenerators = zone.generators;
+            let presetModulators = zone.modulators;
+            const firstZone = zone.instrument.instrumentZones[0];
+            /**
+             * global zone is always first, so it or nothing
+             * @type {Generator[]}
+             */
+            let globalInstrumentGenerators = firstZone.isGlobal ? [...firstZone.generators] : [];
+            let globalInstrumentModulators = firstZone.isGlobal ? [...firstZone.modulators] : [];
+            const globalKeyRange = firstZone.isGlobal ? firstZone.keyRange : { min: 0, max: 127 };
+            const globalVelRange = firstZone.isGlobal ? firstZone.velRange : { min: 0, max: 127 };
+            
+            
+            let instrumentZonesInRange = zone.instrument.instrumentZones
+                .filter(currentZone =>
+                    (
+                        isInRange(
+                            currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
+                            midiNote
+                        )
+                        &&
+                        isInRange(
+                            currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
+                            velocity
+                        )
+                    ) && !currentZone.isGlobal
+                );
+            
+            instrumentZonesInRange.forEach(instrumentZone =>
+            {
+                let instrumentGenerators = [...instrumentZone.generators];
+                let instrumentModulators = [...instrumentZone.modulators];
+                
+                addUnique(
+                    presetGenerators,
+                    globalPresetGenerators
+                );
+                // add the unique global preset generators (local replace global(
+                
+                
+                // add the unique global instrument generators (local replace global)
+                addUnique(
+                    instrumentGenerators,
+                    globalInstrumentGenerators
+                );
+                
+                addUniqueMods(
+                    presetModulators,
+                    globalPresetModulators
+                );
+                addUniqueMods(
+                    instrumentModulators,
+                    globalInstrumentModulators
+                );
+                
+                // default mods
+                addUniqueMods(
+                    instrumentModulators,
+                    this.parentSoundBank.defaultModulators
+                );
+                
+                /**
+                 * sum preset modulators to instruments (amount) sf spec page 54
+                 * @type {Modulator[]}
+                 */
+                const finalModulatorList = [...instrumentModulators];
+                for (let i = 0; i < presetModulators.length; i++)
+                {
+                    let mod = presetModulators[i];
+                    const identicalInstrumentModulator = finalModulatorList.findIndex(
+                        m => Modulator.isIdentical(mod, m));
+                    if (identicalInstrumentModulator !== -1)
+                    {
+                        // sum the amounts
+                        // (this makes a new modulator because otherwise it would overwrite the one in the soundfont!
+                        finalModulatorList[identicalInstrumentModulator] = finalModulatorList[identicalInstrumentModulator].sumTransform(
+                            mod);
+                    }
+                    else
+                    {
+                        finalModulatorList.push(mod);
+                    }
+                }
+                
+                
+                // combine both generators and add to the final result
+                parsedGeneratorsAndSamples.push({
+                    instrumentGenerators: instrumentGenerators,
+                    presetGenerators: presetGenerators,
+                    modulators: finalModulatorList,
+                    sample: instrumentZone.sample,
+                    sampleID: instrumentZone.generators.find(
+                        g => g.generatorType === generatorTypes.sampleID).generatorValue
+                });
+            });
+        });
+        
+        // save and return
+        this.foundSamplesAndGenerators[midiNote][velocity] = parsedGeneratorsAndSamples;
+        return parsedGeneratorsAndSamples;
+    }
+}

spessasynth_lib/soundfont/basic_soundfont/basic_sample.js

@@ -0,0 +1,197 @@
+/**
+ * samples.js
+ * purpose: parses soundfont samples, resamples if needed.
+ * loads sample data, handles async loading of sf3 compressed samples
+ */
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+
+// should be reasonable for most cases
+const RESAMPLE_RATE = 48000;
+
+export class BasicSample
+{
+    
+    /**
+     * The sample's name
+     * @type {string}
+     */
+    sampleName;
+    
+    /**
+     * Sample rate in Hz
+     * @type {number}
+     */
+    sampleRate;
+    
+    /**
+     * Original pitch of the sample as a MIDI note number
+     * @type {number}
+     */
+    samplePitch;
+    
+    /**
+     * Pitch correction, in cents. Can be negative
+     * @type {number}
+     */
+    samplePitchCorrection;
+    
+    /**
+     * Sample link, currently unused here
+     * @type {number}
+     */
+    sampleLink;
+    
+    /**
+     * Type of the sample, currently only used for SF3
+     * @type {number}
+     */
+    sampleType;
+    
+    /**
+     * Relative to the start of the sample in sample points
+     * @type {number}
+     */
+    sampleLoopStartIndex;
+    
+    /**
+     * Relative to the start of the sample in sample points
+     * @type {number}
+     */
+    sampleLoopEndIndex;
+    
+    /**
+     * Indicates if the sample is compressed
+     * @type {boolean}
+     */
+    isCompressed;
+    
+    /**
+     * The compressed sample data if it was compressed by spessasynth
+     * @type {Uint8Array}
+     */
+    compressedData = undefined;
+    
+    /**
+     * The sample's use count
+     * @type {number}
+     */
+    useCount = 0;
+    
+    /**
+     * The sample's audio data
+     * @type {Float32Array}
+     */
+    sampleData = undefined;
+    
+    /**
+     * The basic representation of a soundfont sample
+     * @param sampleName {string} The sample's name
+     * @param sampleRate {number} The sample's rate in Hz
+     * @param samplePitch {number} The sample's pitch as a MIDI note number
+     * @param samplePitchCorrection {number} The sample's pitch correction in cents
+     * @param sampleLink {number} The sample's link, currently unused
+     * @param sampleType {number} The sample's type, an enum
+     * @param loopStart {number} The sample's loop start relative to the sample start in sample points
+     * @param loopEnd {number} The sample's loop end relative to the sample start in sample points
+     */
+    constructor(
+        sampleName,
+        sampleRate,
+        samplePitch,
+        samplePitchCorrection,
+        sampleLink,
+        sampleType,
+        loopStart,
+        loopEnd
+    )
+    {
+        this.sampleName = sampleName;
+        this.sampleRate = sampleRate;
+        this.samplePitch = samplePitch;
+        this.samplePitchCorrection = samplePitchCorrection;
+        this.sampleLink = sampleLink;
+        this.sampleType = sampleType;
+        this.sampleLoopStartIndex = loopStart;
+        this.sampleLoopEndIndex = loopEnd;
+        // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
+        this.isCompressed = (sampleType & 0x10) > 0;
+    }
+    
+    
+    /**
+     * @returns {Uint8Array|IndexedByteArray}
+     */
+    getRawData()
+    {
+        const uint8 = new Uint8Array(this.sampleData.length * 2);
+        for (let i = 0; i < this.sampleData.length; i++)
+        {
+            const sample = Math.floor(this.sampleData[i] * 32768);
+            uint8[i * 2] = sample & 0xFF; // lower byte
+            uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
+        }
+        return uint8;
+    }
+    
+    resampleData(newSampleRate)
+    {
+        let audioData = this.getAudioData();
+        const ratio = newSampleRate / this.sampleRate;
+        const resampled = new Float32Array(Math.floor(audioData.length * ratio));
+        for (let i = 0; i < resampled.length; i++)
+        {
+            resampled[i] = audioData[Math.floor(i * (1 / ratio))];
+        }
+        audioData = resampled;
+        this.sampleRate = newSampleRate;
+        // adjust loop points
+        this.sampleLoopStartIndex = Math.floor(this.sampleLoopStartIndex * ratio);
+        this.sampleLoopEndIndex = Math.floor(this.sampleLoopEndIndex * ratio);
+        this.sampleData = audioData;
+    }
+    
+    /**
+     * @param quality {number}
+     * @param encodeVorbis {EncodeVorbisFunction}
+     */
+    compressSample(quality, encodeVorbis)
+    {
+        // no need to compress
+        if (this.isCompressed)
+        {
+            return;
+        }
+        // compress, always mono!
+        try
+        {
+            // if the sample rate is too low or too high, resample
+            let audioData = this.getAudioData();
+            if (this.sampleRate < 8000 || this.sampleRate > 96000)
+            {
+                this.resampleData(RESAMPLE_RATE);
+                audioData = this.getAudioData();
+            }
+            this.compressedData = encodeVorbis([audioData], 1, this.sampleRate, quality);
+            // flag as compressed
+            this.sampleType |= 0x10;
+            this.isCompressed = true;
+        }
+        catch (e)
+        {
+            SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`);
+            this.isCompressed = false;
+            this.compressedData = undefined;
+            // flag as uncompressed
+            this.sampleType &= 0xEF;
+        }
+        
+    }
+    
+    /**
+     * @returns {Float32Array}
+     */
+    getAudioData()
+    {
+        return this.sampleData;
+    }
+}

spessasynth_lib/soundfont/basic_soundfont/basic_soundfont.js

@@ -0,0 +1,565 @@
+import {
+    SpessaSynthGroup,
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+    SpessaSynthWarn
+} from "../../utils/loggin.js";
+import { consoleColors } from "../../utils/other.js";
+import { write } from "./write_sf2/write.js";
+import { defaultModulators, Modulator } from "./modulator.js";
+import { writeDLS } from "./write_dls/write_dls.js";
+import { BasicSample } from "./basic_sample.js";
+import { BasicInstrumentZone, BasicPresetZone } from "./basic_zones.js";
+import { Generator, generatorTypes } from "./generator.js";
+import { BasicInstrument } from "./basic_instrument.js";
+import { BasicPreset } from "./basic_preset.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
+
+class BasicSoundBank
+{
+    
+    /**
+     * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g., 2.1)
+     * @type {Object<string, string|IndexedByteArray>}
+     */
+    soundFontInfo = {};
+    
+    /**
+     * The soundfont's presets
+     * @type {BasicPreset[]}
+     */
+    presets = [];
+    
+    /**
+     * The soundfont's samples
+     * @type {BasicSample[]}
+     */
+    samples = [];
+    
+    /**
+     * The soundfont's instruments
+     * @type {BasicInstrument[]}
+     */
+    instruments = [];
+    
+    /**
+     * Soundfont's default modulatorss
+     * @type {Modulator[]}
+     */
+    defaultModulators = defaultModulators.map(m => Modulator.copy(m));
+    
+    /**
+     * Checks for XG drumsets and considers if this soundfont is XG.
+     * @type {boolean}
+     */
+    isXGBank = false;
+    
+    /**
+     * Creates a new basic soundfont template
+     * @param data {undefined|{presets: BasicPreset[], info: Object<string, string>}}
+     */
+    constructor(data = undefined)
+    {
+        if (data?.presets)
+        {
+            this.presets.push(...data.presets);
+            this.soundFontInfo = data.info;
+        }
+    }
+    
+    /**
+     * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
+     * @param soundfonts {...BasicSoundBank} the soundfonts to merge, the first overwrites the last
+     * @returns {BasicSoundBank}
+     */
+    static mergeSoundBanks(...soundfonts)
+    {
+        const mainSf = soundfonts.shift();
+        const presets = mainSf.presets;
+        while (soundfonts.length)
+        {
+            const newPresets = soundfonts.shift().presets;
+            newPresets.forEach(newPreset =>
+            {
+                if (
+                    presets.find(existingPreset => existingPreset.bank === newPreset.bank && existingPreset.program === newPreset.program) === undefined
+                )
+                {
+                    presets.push(newPreset);
+                }
+            });
+        }
+        
+        return new BasicSoundBank({ presets: presets, info: mainSf.soundFontInfo });
+    }
+    
+    /**
+     * Creates a simple soundfont with one saw wave preset.
+     * @returns {ArrayBufferLike}
+     */
+    static getDummySoundfontFile()
+    {
+        const font = new BasicSoundBank();
+        const sample = new BasicSample(
+            "Saw",
+            44100,
+            65,
+            20,
+            0,
+            0,
+            0,
+            127
+        );
+        sample.sampleData = new Float32Array(128);
+        for (let i = 0; i < 128; i++)
+        {
+            sample.sampleData[i] = (i / 128) * 2 - 1;
+        }
+        font.samples.push(sample);
+        
+        const gZone = new BasicInstrumentZone();
+        gZone.isGlobal = true;
+        gZone.generators.push(new Generator(generatorTypes.initialAttenuation, 375));
+        gZone.generators.push(new Generator(generatorTypes.releaseVolEnv, -1000));
+        gZone.generators.push(new Generator(generatorTypes.sampleModes, 1));
+        
+        const zone1 = new BasicInstrumentZone();
+        zone1.sample = sample;
+        
+        const zone2 = new BasicInstrumentZone();
+        zone2.sample = sample;
+        zone2.generators.push(new Generator(generatorTypes.fineTune, -9));
+        
+        
+        const inst = new BasicInstrument();
+        inst.instrumentName = "Saw Wave";
+        inst.instrumentZones.push(gZone);
+        inst.instrumentZones.push(zone1);
+        inst.instrumentZones.push(zone2);
+        font.instruments.push(inst);
+        
+        const pZone = new BasicPresetZone();
+        pZone.instrument = inst;
+        
+        const preset = new BasicPreset(font);
+        preset.presetName = "Saw Wave";
+        preset.presetZones.push(pZone);
+        font.presets.push(preset);
+        
+        font.soundFontInfo["ifil"] = "2.1";
+        font.soundFontInfo["isng"] = "EMU8000";
+        font.soundFontInfo["INAM"] = "Dummy";
+        font._parseInternal();
+        return font.write().buffer;
+    }
+    
+    /**
+     * parses the bank after loading is done
+     * @protected
+     */
+    _parseInternal()
+    {
+        this.isXGBank = false;
+        // definitions for XG:
+        // at least one preset with bank 127, 126 or 120
+        // MUST be a valid XG bank.
+        // allowed banks: (see XG specification)
+        // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+        // 25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48, 56, 57, 58,
+        // 64, 65, 66, 126, 127
+        const allowedPrograms = new Set([
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 24,
+            25, 27, 28, 29, 30, 31, 32, 33, 40, 41, 48, 56, 57, 58,
+            64, 65, 66, 126, 127
+        ]);
+        for (const preset of this.presets)
+        {
+            if (isXGDrums(preset.bank))
+            {
+                this.isXGBank = true;
+                if (!allowedPrograms.has(preset.program))
+                {
+                    // not valid!
+                    this.isXGBank = false;
+                    SpessaSynthInfo(
+                        `%cThis bank is not valid XG. Preset %c${preset.bank}:${preset.program}%c is not a valid XG drum. XG mode will use presets on bank 128.`,
+                        consoleColors.info,
+                        consoleColors.value,
+                        consoleColors.info
+                    );
+                    break;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Trims a sound bank to only contain samples in a given MIDI file
+     * @param mid {BasicMIDI} - the MIDI file
+     */
+    trimSoundBank(mid)
+    {
+        const soundfont = this;
+        
+        /**
+         * @param instrument {Instrument}
+         * @param combos {{key: number, velocity: number}[]}
+         * @returns {number}
+         */
+        function trimInstrumentZones(instrument, combos)
+        {
+            let trimmedIZones = 0;
+            for (let iZoneIndex = 0; iZoneIndex < instrument.instrumentZones.length; iZoneIndex++)
+            {
+                const iZone = instrument.instrumentZones[iZoneIndex];
+                if (iZone.isGlobal)
+                {
+                    continue;
+                }
+                const iKeyRange = iZone.keyRange;
+                const iVelRange = iZone.velRange;
+                let isIZoneUsed = false;
+                for (const iCombo of combos)
+                {
+                    if (
+                        (iCombo.key >= iKeyRange.min && iCombo.key <= iKeyRange.max) &&
+                        (iCombo.velocity >= iVelRange.min && iCombo.velocity <= iVelRange.max)
+                    )
+                    {
+                        isIZoneUsed = true;
+                        break;
+                    }
+                }
+                if (!isIZoneUsed)
+                {
+                    SpessaSynthInfo(
+                        `%c${iZone.sample.sampleName} %cremoved from %c${instrument.instrumentName}%c. Use count: %c${iZone.useCount - 1}`,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized
+                    );
+                    if (instrument.safeDeleteZone(iZoneIndex))
+                    {
+                        trimmedIZones++;
+                        iZoneIndex--;
+                        SpessaSynthInfo(
+                            `%c${iZone.sample.sampleName} %cdeleted`,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
+                    }
+                    if (iZone.sample.useCount < 1)
+                    {
+                        soundfont.deleteSample(iZone.sample);
+                    }
+                }
+                
+            }
+            return trimmedIZones;
+        }
+        
+        SpessaSynthGroup(
+            "%cTrimming soundfont...",
+            consoleColors.info
+        );
+        const usedProgramsAndKeys = mid.getUsedProgramsAndKeys(soundfont);
+        
+        SpessaSynthGroupCollapsed(
+            "%cModifying soundfont...",
+            consoleColors.info
+        );
+        SpessaSynthInfo("Detected keys for midi:", usedProgramsAndKeys);
+        // modify the soundfont to only include programs and samples that are used
+        for (let presetIndex = 0; presetIndex < soundfont.presets.length; presetIndex++)
+        {
+            const p = soundfont.presets[presetIndex];
+            const string = p.bank + ":" + p.program;
+            const used = usedProgramsAndKeys[string];
+            if (used === undefined)
+            {
+                SpessaSynthInfo(
+                    `%cDeleting preset %c${p.presetName}%c and its zones`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info
+                );
+                soundfont.deletePreset(p);
+                presetIndex--;
+            }
+            else
+            {
+                const combos = [...used].map(s =>
+                {
+                    const split = s.split("-");
+                    return {
+                        key: parseInt(split[0]),
+                        velocity: parseInt(split[1])
+                    };
+                });
+                SpessaSynthGroupCollapsed(
+                    `%cTrimming %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthInfo(`Keys for ${p.presetName}:`, combos);
+                let trimmedZones = 0;
+                // clean the preset to only use zones that are used
+                for (let zoneIndex = 0; zoneIndex < p.presetZones.length; zoneIndex++)
+                {
+                    const zone = p.presetZones[zoneIndex];
+                    if (zone.isGlobal)
+                    {
+                        continue;
+                    }
+                    const keyRange = zone.keyRange;
+                    const velRange = zone.velRange;
+                    // check if any of the combos matches the zone
+                    let isZoneUsed = false;
+                    for (const combo of combos)
+                    {
+                        if (
+                            (combo.key >= keyRange.min && combo.key <= keyRange.max) &&
+                            (combo.velocity >= velRange.min && combo.velocity <= velRange.max)
+                        )
+                        {
+                            // zone is used, trim the instrument zones
+                            isZoneUsed = true;
+                            const trimmedIZones = trimInstrumentZones(zone.instrument, combos);
+                            SpessaSynthInfo(
+                                `%cTrimmed off %c${trimmedIZones}%c zones from %c${zone.instrument.instrumentName}`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.recognized
+                            );
+                            break;
+                        }
+                    }
+                    if (!isZoneUsed)
+                    {
+                        trimmedZones++;
+                        p.deleteZone(zoneIndex);
+                        if (zone.instrument.useCount < 1)
+                        {
+                            soundfont.deleteInstrument(zone.instrument);
+                        }
+                        zoneIndex--;
+                    }
+                }
+                SpessaSynthInfo(
+                    `%cTrimmed off %c${trimmedZones}%c zones from %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthGroupEnd();
+            }
+        }
+        soundfont.removeUnusedElements();
+        
+        soundfont.soundFontInfo["ICMT"] = `NOTE: This soundfont was trimmed by SpessaSynth to only contain presets used in "${mid.midiName}"\n\n`
+            + soundfont.soundFontInfo["ICMT"];
+        
+        SpessaSynthInfo(
+            "%cSoundfont modified!",
+            consoleColors.recognized
+        );
+        SpessaSynthGroupEnd();
+        SpessaSynthGroupEnd();
+    }
+    
+    removeUnusedElements()
+    {
+        this.instruments.forEach(i =>
+        {
+            if (i.useCount < 1)
+            {
+                i.instrumentZones.forEach(z =>
+                {
+                    if (!z.isGlobal)
+                    {
+                        z.sample.useCount--;
+                    }
+                });
+            }
+        });
+        this.instruments = this.instruments.filter(i => i.useCount > 0);
+        this.samples = this.samples.filter(s => s.useCount > 0);
+    }
+    
+    /**
+     * @param instrument {BasicInstrument}
+     */
+    deleteInstrument(instrument)
+    {
+        if (instrument.useCount > 0)
+        {
+            throw new Error(`Cannot delete an instrument that has ${instrument.useCount} usages.`);
+        }
+        this.instruments.splice(this.instruments.indexOf(instrument), 1);
+        instrument.deleteInstrument();
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * @param preset {BasicPreset}
+     */
+    deletePreset(preset)
+    {
+        preset.deletePreset();
+        this.presets.splice(this.presets.indexOf(preset), 1);
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * @param sample {BasicSample}
+     */
+    deleteSample(sample)
+    {
+        if (sample.useCount > 0)
+        {
+            throw new Error(`Cannot delete sample that has ${sample.useCount} usages.`);
+        }
+        this.samples.splice(this.samples.indexOf(sample), 1);
+        this.removeUnusedElements();
+    }
+    
+    /**
+     * Get the appropriate preset, undefined if not found
+     * @param bankNr {number}
+     * @param programNr {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
+     * @return {BasicPreset}
+     */
+    getPresetNoFallback(bankNr, programNr, allowXGDrums = false)
+    {
+        const isDrum = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
+        // check for exact match
+        let p;
+        if (isDrum)
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            p = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
+        if (p)
+        {
+            return p;
+        }
+        // no match...
+        if (isDrum)
+        {
+            if (allowXGDrums)
+            {
+                // try any drum preset with matching program?
+                const p = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+                if (p)
+                {
+                    return p;
+                }
+            }
+        }
+        return undefined;
+    }
+    
+    /**
+     * Get the appropriate preset
+     * @param bankNr {number}
+     * @param programNr {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
+     * @returns {BasicPreset}
+     */
+    getPreset(bankNr, programNr, allowXGDrums = false)
+    {
+        const isDrums = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
+        // check for exact match
+        let preset;
+        // only allow drums if the preset is considered to be a drum preset
+        if (isDrums)
+        {
+            preset = this.presets.find(p => p.bank === bankNr && p.isDrumPreset(allowXGDrums) && p.program === programNr);
+        }
+        else
+        {
+            preset = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        }
+        if (preset)
+        {
+            return preset;
+        }
+        // no match...
+        if (isDrums)
+        {
+            // drum preset: find any preset with bank 128
+            preset = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+            if (!preset)
+            {
+                // only allow 128, otherwise it would default to XG SFX
+                preset = this.presets.find(p => p.isDrumPreset(allowXGDrums));
+            }
+        }
+        else
+        {
+            // non-drum preset: find any preset with the given program that is not a drum preset
+            preset = this.presets.find(p => p.program === programNr && !p.isDrumPreset(allowXGDrums));
+        }
+        if (preset)
+        {
+            SpessaSynthWarn(
+                `%cPreset ${bankNr}.${programNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
+                consoleColors.warn,
+                consoleColors.recognized
+            );
+        }
+        
+        // no preset, use the first one available
+        if (!preset)
+        {
+            SpessaSynthWarn(`Preset ${programNr} not found. Defaulting to`, this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+    
+    /**
+     * gets preset by name
+     * @param presetName {string}
+     * @returns {BasicPreset}
+     */
+    getPresetByName(presetName)
+    {
+        let preset = this.presets.find(p => p.presetName === presetName);
+        if (!preset)
+        {
+            SpessaSynthWarn("Preset not found. Defaulting to:", this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+    
+    /**
+     * @param error {string}
+     */
+    parsingError(error)
+    {
+        throw new Error(`SF parsing error: ${error} The file may be corrupted.`);
+    }
+    
+    destroySoundBank()
+    {
+        delete this.presets;
+        delete this.instruments;
+        delete this.samples;
+    }
+}
+
+BasicSoundBank.prototype.write = write;
+BasicSoundBank.prototype.writeDLS = writeDLS;
+
+export { BasicSoundBank };

spessasynth_lib/soundfont/basic_soundfont/basic_zone.js

@@ -0,0 +1,64 @@
+/**
+ * @typedef {Object} SoundFontRange
+ * @property {number} min - the minimum midi note
+ * @property {number} max - the maximum midi note
+ */
+
+export class BasicZone
+{
+    /**
+     * The zone's velocity range
+     * min -1 means that it is a default value
+     * @type {SoundFontRange}
+     */
+    velRange = { min: -1, max: 127 };
+    
+    /**
+     * The zone's key range
+     * min -1 means that it is a default value
+     * @type {SoundFontRange}
+     */
+    keyRange = { min: -1, max: 127 };
+    /**
+     * Indicates if the zone is global
+     * @type {boolean}
+     */
+    isGlobal = false;
+    /**
+     * The zone's generators
+     * @type {Generator[]}
+     */
+    generators = [];
+    /**
+     * The zone's modulators
+     * @type {Modulator[]}
+     */
+    modulators = [];
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasKeyRange()
+    {
+        return this.keyRange.min !== -1;
+    }
+    
+    /**
+     * @returns {boolean}
+     */
+    get hasVelRange()
+    {
+        return this.velRange.min !== -1;
+    }
+    
+    /**
+     * @param generatorType {generatorTypes}
+     * @param notFoundValue {number}
+     * @returns {number}
+     */
+    getGeneratorValue(generatorType, notFoundValue)
+    {
+        return this.generators.find(g => g.generatorType === generatorType)?.generatorValue ?? notFoundValue;
+    }
+}
+

spessasynth_lib/soundfont/basic_soundfont/basic_zones.js

@@ -0,0 +1,43 @@
+import { BasicZone } from "./basic_zone.js";
+
+export class BasicInstrumentZone extends BasicZone
+{
+    /**
+     * Zone's sample. Undefined if global
+     * @type {BasicSample|undefined}
+     */
+    sample = undefined;
+    /**
+     * The zone's use count
+     * @type {number}
+     */
+    useCount = 0;
+    
+    deleteZone()
+    {
+        this.useCount--;
+        if (this.isGlobal)
+        {
+            return;
+        }
+        this.sample.useCount--;
+    }
+}
+
+export class BasicPresetZone extends BasicZone
+{
+    /**
+     * Zone's instrument. Undefined if global
+     * @type {BasicInstrument|undefined}
+     */
+    instrument = undefined;
+    
+    deleteZone()
+    {
+        if (this.isGlobal)
+        {
+            return;
+        }
+        this.instrument.removeUseCount();
+    }
+}

spessasynth_lib/soundfont/basic_soundfont/generator.js

@@ -0,0 +1,220 @@
+/**
+ * @enum {number}
+ */
+export const generatorTypes = {
+    INVALID: -1,                        // invalid generator
+    startAddrsOffset: 0,                // sample control - moves sample start point
+    endAddrOffset: 1,                   // sample control - moves sample end point
+    startloopAddrsOffset: 2,            // loop control - moves loop start point
+    endloopAddrsOffset: 3,              // loop control - moves loop end point
+    startAddrsCoarseOffset: 4,          // sample control - moves sample start point in 32,768 increments
+    modLfoToPitch: 5,                   // pitch modulation - modulation lfo pitch modulation in cents
+    vibLfoToPitch: 6,                   // pitch modulation - vibrato lfo pitch modulation in cents
+    modEnvToPitch: 7,                   // pitch modulation - modulation envelope pitch modulation in cents
+    initialFilterFc: 8,                 // filter - lowpass filter cutoff in cents
+    initialFilterQ: 9,                  // filter - lowpass filter resonance
+    modLfoToFilterFc: 10,               // filter modulation - modulation lfo lowpass filter cutoff in cents
+    modEnvToFilterFc: 11,               // filter modulation - modulation envelope lowpass filter cutoff in cents
+    endAddrsCoarseOffset: 12,           // ample control - move sample end point in 32,768 increments
+    modLfoToVolume: 13,                 // modulation lfo - volume (tremolo), where 100 = 10dB
+    unused1: 14,                        // unused
+    chorusEffectsSend: 15,              // effect send - how much is sent to chorus 0 - 1000
+    reverbEffectsSend: 16,              // effect send - how much is sent to reverb 0 - 1000
+    pan: 17,                            // panning - where -500 = left, 0 = center, 500 = right
+    unused2: 18,                        // unused
+    unused3: 19,                        // unused
+    unused4: 20,                        // unused
+    delayModLFO: 21,                    // mod lfo - delay for mod lfo to start from zero
+    freqModLFO: 22,                     // mod lfo - frequency of mod lfo, 0 = 8.176 Hz, units: f => 1200log2(f/8.176)
+    delayVibLFO: 23,                    // vib lfo - delay for vibrato lfo to start from zero
+    freqVibLFO: 24,                     // vib lfo - frequency of vibrato lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
+    delayModEnv: 25,                    // mod env - 0 = 1 s decay till mod env starts
+    attackModEnv: 26,                   // mod env - attack of mod env
+    holdModEnv: 27,                     // mod env - hold of mod env
+    decayModEnv: 28,                    // mod env - decay of mod env
+    sustainModEnv: 29,                  // mod env - sustain of mod env
+    releaseModEnv: 30,                  // mod env - release of mod env
+    keyNumToModEnvHold: 31,             // mod env - also modulating mod envelope hold with key number
+    keyNumToModEnvDecay: 32,            // mod env - also modulating mod envelope decay with key number
+    delayVolEnv: 33,                    // vol env - delay of envelope from zero (weird scale)
+    attackVolEnv: 34,                   // vol env - attack of envelope
+    holdVolEnv: 35,                     // vol env - hold of envelope
+    decayVolEnv: 36,                    // vol env - decay of envelope
+    sustainVolEnv: 37,                  // vol env - sustain of envelope
+    releaseVolEnv: 38,                  // vol env - release of envelope
+    keyNumToVolEnvHold: 39,             // vol env - key number to volume envelope hold
+    keyNumToVolEnvDecay: 40,            // vol env - key number to volume envelope decay
+    instrument: 41,                     // zone - instrument index to use for preset zone
+    reserved1: 42,                      // reserved
+    keyRange: 43,                       // zone - key range for which preset / instrument zone is active
+    velRange: 44,                       // zone - velocity range for which preset / instrument zone is active
+    startloopAddrsCoarseOffset: 45,     // sample control - moves sample loop start point in 32,768 increments
+    keyNum: 46,                         // zone - instrument only: always use this midi number (ignore what's pressed)
+    velocity: 47,                       // zone - instrument only: always use this velocity (ignore what's pressed)
+    initialAttenuation: 48,             // zone - allows turning down the volume, 10 = -1dB
+    reserved2: 49,                      // reserved
+    endloopAddrsCoarseOffset: 50,       // sample control - moves sample loop end point in 32,768 increments
+    coarseTune: 51,                     // tune - pitch offset in semitones
+    fineTune: 52,                       // tune - pitch offset in cents
+    sampleID: 53,                       // sample - instrument zone only: which sample to use
+    sampleModes: 54,                    // sample - 0 = no loop, 1 = loop, 2 = reserved, 3 = loop and play till the end in release phase
+    reserved3: 55,                      // reserved
+    scaleTuning: 56,                    // sample - the degree to which MIDI key number influences pitch, 100 = default
+    exclusiveClass: 57,                 // sample - = cut = choke group
+    overridingRootKey: 58,              // sample - can override the sample's original pitch
+    unused5: 59,                        // unused
+    endOper: 60                         // end marker
+};
+/**
+ * @type {{min: number, max: number, def: number}[]}
+ */
+export const generatorLimits = [];
+// offsets
+generatorLimits[generatorTypes.startAddrsOffset] = { min: 0, max: 32768, def: 0 };
+generatorLimits[generatorTypes.endAddrOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.startloopAddrsOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.endloopAddrsOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.startAddrsCoarseOffset] = { min: 0, max: 32768, def: 0 };
+
+// pitch influence
+generatorLimits[generatorTypes.modLfoToPitch] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.vibLfoToPitch] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.modEnvToPitch] = { min: -12000, max: 12000, def: 0 };
+
+// lowpass
+generatorLimits[generatorTypes.initialFilterFc] = { min: 1500, max: 13500, def: 13500 };
+generatorLimits[generatorTypes.initialFilterQ] = { min: 0, max: 960, def: 0 };
+generatorLimits[generatorTypes.modLfoToFilterFc] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.modEnvToFilterFc] = { min: -12000, max: 12000, def: 0 };
+
+generatorLimits[generatorTypes.endAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+
+generatorLimits[generatorTypes.modLfoToVolume] = { min: -960, max: 960, def: 0 };
+
+// effects, pan
+generatorLimits[generatorTypes.chorusEffectsSend] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.reverbEffectsSend] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.pan] = { min: -500, max: 500, def: 0 };
+
+// lfo
+generatorLimits[generatorTypes.delayModLFO] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.freqModLFO] = { min: -16000, max: 4500, def: 0 };
+generatorLimits[generatorTypes.delayVibLFO] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.freqVibLFO] = { min: -16000, max: 4500, def: 0 };
+
+// mod env
+generatorLimits[generatorTypes.delayModEnv] = { min: -32768, max: 5000, def: -32768 }; // -32,768 indicates instant phase,
+// this is done to prevent click at the start of filter modenv
+generatorLimits[generatorTypes.attackModEnv] = { min: -32768, max: 8000, def: -32768 };
+generatorLimits[generatorTypes.holdModEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.decayModEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.sustainModEnv] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.releaseModEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 to prevent lowpass clicks
+// key num to mod env
+generatorLimits[generatorTypes.keyNumToModEnvHold] = { min: -1200, max: 1200, def: 0 };
+generatorLimits[generatorTypes.keyNumToModEnvDecay] = { min: -1200, max: 1200, def: 0 };
+
+// vol env
+generatorLimits[generatorTypes.delayVolEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.attackVolEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.holdVolEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.decayVolEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.sustainVolEnv] = { min: 0, max: 1440, def: 0 };
+generatorLimits[generatorTypes.releaseVolEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 prevent clicks
+// key num to vol env
+generatorLimits[generatorTypes.keyNumToVolEnvHold] = { min: -1200, max: 1200, def: 0 };
+generatorLimits[generatorTypes.keyNumToVolEnvDecay] = { min: -1200, max: 1200, def: 0 };
+
+generatorLimits[generatorTypes.startloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.keyNum] = { min: -1, max: 127, def: -1 };
+generatorLimits[generatorTypes.velocity] = { min: -1, max: 127, def: -1 };
+
+generatorLimits[generatorTypes.initialAttenuation] = { min: 0, max: 1440, def: 0 };
+
+generatorLimits[generatorTypes.endloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+
+generatorLimits[generatorTypes.coarseTune] = { min: -120, max: 120, def: 0 };
+generatorLimits[generatorTypes.fineTune] = { min: -12700, max: 12700, def: 0 }; // this generator is used as initial pitch, hence this range
+generatorLimits[generatorTypes.scaleTuning] = { min: 0, max: 1200, def: 100 };
+generatorLimits[generatorTypes.exclusiveClass] = { min: 0, max: 99999, def: 0 };
+generatorLimits[generatorTypes.overridingRootKey] = { min: 0 - 1, max: 127, def: -1 };
+generatorLimits[generatorTypes.sampleModes] = { min: 0, max: 3, def: 0 };
+
+export class Generator
+{
+    /**
+     * The generator's enum number
+     * @type {generatorTypes|number}
+     */
+    generatorType = generatorTypes.INVALID;
+    /**
+     * The generator's 16-bit value
+     * @type {number}
+     */
+    generatorValue = 0;
+    
+    /**
+     * Constructs a new generator
+     * @param type {generatorTypes|number}
+     * @param value {number}
+     * @param validate {boolean}
+     */
+    constructor(type = generatorTypes.INVALID, value = 0, validate = true)
+    {
+        this.generatorType = type;
+        if (value === undefined)
+        {
+            throw new Error("No value provided.");
+        }
+        this.generatorValue = Math.round(value);
+        if (validate)
+        {
+            const lim = generatorLimits[type];
+            
+            if (lim !== undefined)
+            {
+                this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+            }
+        }
+    }
+}
+
+/**
+ * generator.js
+ * purpose: contains enums for generators,
+ * and their limis parses reads soundfont generators, sums them and applies limits
+ */
+/**
+ * @param generatorType {number}
+ * @param presetGens {Generator[]}
+ * @param instrumentGens {Generator[]}
+ */
+export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
+{
+    const limits = generatorLimits[generatorType] || { min: 0, max: 32768, def: 0 };
+    let presetGen = presetGens.find(g => g.generatorType === generatorType);
+    let presetValue = 0;
+    if (presetGen)
+    {
+        presetValue = presetGen.generatorValue;
+    }
+    
+    let instruGen = instrumentGens.find(g => g.generatorType === generatorType);
+    let instruValue = limits.def;
+    if (instruGen)
+    {
+        instruValue = instruGen.generatorValue;
+    }
+    
+    let value = instruValue + presetValue;
+    
+    // Special case, initial attenuation.
+    // Shall get clamped in the volume envelope,
+    // so the modulators can be affected by negative generators (the "Brass" patch was problematic...)
+    if (generatorType === generatorTypes.initialAttenuation)
+    {
+        return value;
+    }
+    
+    return Math.max(limits.min, Math.min(limits.max, value));
+}

spessasynth_lib/soundfont/basic_soundfont/modulator.js

@@ -0,0 +1,378 @@
+import { generatorTypes } from "./generator.js";
+import { midiControllers } from "../../midi_parser/midi_message.js";
+
+/**
+ * modulators.js
+ * purpose: parses soundfont modulators and the source enums, also includes the default modulators list
+ **/
+
+export const modulatorSources = {
+    noController: 0,
+    noteOnVelocity: 2,
+    noteOnKeyNum: 3,
+    polyPressure: 10,
+    channelPressure: 13,
+    pitchWheel: 14,
+    pitchWheelRange: 16,
+    link: 127
+    
+};
+export const modulatorCurveTypes = {
+    linear: 0,
+    concave: 1,
+    convex: 2,
+    switch: 3
+};
+
+export class Modulator
+{
+    /**
+     * The current computed value of this modulator
+     * @type {number}
+     */
+    currentValue = 0;
+    
+    /**
+     * The source enumeration for this modulator
+     * @type {number}
+     */
+    sourceEnum;
+    
+    /**
+     * The secondary source enumeration for this modulator
+     * @type {number}
+     */
+    secondarySourceEnum;
+    
+    /**
+     * The generator destination of this modulator
+     * @type {generatorTypes}
+     */
+    modulatorDestination;
+    
+    /**
+     * The transform amount for this modulator
+     * @type {number}
+     */
+    transformAmount;
+    
+    /**
+     * The transform type for this modulator
+     * @type {0|2}
+     */
+    transformType;
+    
+    /**
+     * creates a modulator
+     * @param srcEnum {number}
+     * @param secSrcEnum {number}
+     * @param destination {generatorTypes|number}
+     * @param amount {number}
+     * @param transformType {number}
+     */
+    constructor(srcEnum, secSrcEnum, destination, amount, transformType)
+    {
+        this.sourceEnum = srcEnum;
+        this.modulatorDestination = destination;
+        this.secondarySourceEnum = secSrcEnum;
+        this.transformAmount = amount;
+        this.transformType = transformType;
+        
+        
+        if (this.modulatorDestination > 58)
+        {
+            this.modulatorDestination = generatorTypes.INVALID; // flag as invalid (for linked ones)
+        }
+        
+        // decode the source
+        this.sourcePolarity = this.sourceEnum >> 9 & 1;
+        this.sourceDirection = this.sourceEnum >> 8 & 1;
+        this.sourceUsesCC = this.sourceEnum >> 7 & 1;
+        this.sourceIndex = this.sourceEnum & 127;
+        this.sourceCurveType = this.sourceEnum >> 10 & 3;
+        
+        // decode the secondary source
+        this.secSrcPolarity = this.secondarySourceEnum >> 9 & 1;
+        this.secSrcDirection = this.secondarySourceEnum >> 8 & 1;
+        this.secSrcUsesCC = this.secondarySourceEnum >> 7 & 1;
+        this.secSrcIndex = this.secondarySourceEnum & 127;
+        this.secSrcCurveType = this.secondarySourceEnum >> 10 & 3;
+        
+        /**
+         * Indicates if the given modulator is chorus or reverb effects modulator.
+         * This is done to simulate BASSMIDI effects behavior:
+         * - defaults to 1000 transform amount rather than 200
+         * - values can be changed, but anything above 200 is 1000
+         * (except for values above 1000, they are copied directly)
+         * - all values below are multiplied by 5 (200 * 5 = 1000)
+         * - still can be disabled if the soundfont has its own modulator curve
+         * - this fixes the very low amount of reverb by default and doesn't break soundfonts
+         * @type {boolean}
+         */
+        this.isEffectModulator =
+            (
+                this.sourceEnum === 0x00DB
+                || this.sourceEnum === 0x00DD
+            )
+            && this.secondarySourceEnum === 0x0
+            && (
+                this.modulatorDestination === generatorTypes.reverbEffectsSend
+                || this.modulatorDestination === generatorTypes.chorusEffectsSend
+            );
+    }
+    
+    /**
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    static copy(modulator)
+    {
+        return new Modulator(
+            modulator.sourceEnum,
+            modulator.secondarySourceEnum,
+            modulator.modulatorDestination,
+            modulator.transformAmount,
+            modulator.transformType
+        );
+    }
+    
+    /**
+     * @param mod1 {Modulator}
+     * @param mod2 {Modulator}
+     * @param checkAmount {boolean}
+     * @returns {boolean}
+     */
+    static isIdentical(mod1, mod2, checkAmount = false)
+    {
+        return (mod1.sourceEnum === mod2.sourceEnum)
+            && (mod1.modulatorDestination === mod2.modulatorDestination)
+            && (mod1.secondarySourceEnum === mod2.secondarySourceEnum)
+            && (mod1.transformType === mod2.transformType)
+            && (!checkAmount || (mod1.transformAmount === mod2.transformAmount));
+    }
+    
+    /**
+     * @param mod {Modulator}
+     * @returns {string}
+     */
+    static debugString(mod)
+    {
+        function getKeyByValue(object, value)
+        {
+            return Object.keys(object).find(key => object[key] === value);
+        }
+        
+        let sourceString = getKeyByValue(modulatorCurveTypes, mod.sourceCurveType);
+        sourceString += mod.sourcePolarity === 0 ? " unipolar " : " bipolar ";
+        sourceString += mod.sourceDirection === 0 ? "forwards " : "backwards ";
+        if (mod.sourceUsesCC)
+        {
+            sourceString += getKeyByValue(midiControllers, mod.sourceIndex);
+        }
+        else
+        {
+            sourceString += getKeyByValue(modulatorSources, mod.sourceIndex);
+        }
+        
+        let secSrcString = getKeyByValue(modulatorCurveTypes, mod.secSrcCurveType);
+        secSrcString += mod.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
+        secSrcString += mod.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        if (mod.secSrcUsesCC)
+        {
+            secSrcString += getKeyByValue(midiControllers, mod.secSrcIndex);
+        }
+        else
+        {
+            secSrcString += getKeyByValue(modulatorSources, mod.secSrcIndex);
+        }
+        return `Modulator:
+        Source: ${sourceString}
+        Secondary source: ${secSrcString}
+        Destination: ${getKeyByValue(generatorTypes, mod.modulatorDestination)}
+        Trasform amount: ${mod.transformAmount}
+        Transform type: ${mod.transformType}
+        \n\n`;
+    }
+    
+    /**
+     * Sum transform and create a NEW modulator
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    sumTransform(modulator)
+    {
+        return new Modulator(
+            this.sourceEnum,
+            this.secondarySourceEnum,
+            this.modulatorDestination,
+            this.transformAmount + modulator.transformAmount,
+            this.transformType
+        );
+    }
+}
+
+export const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
+export const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
+
+export function getModSourceEnum(curveType, polarity, direction, isCC, index)
+{
+    return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
+}
+
+const soundFontModulators = [
+    // vel to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            0,
+            modulatorSources.noteOnVelocity
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // mod wheel to vibrato
+    new Modulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    
+    // vol to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            1,
+            midiControllers.mainVolume
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // channel pressure to vibrato
+    new Modulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    
+    // pitch wheel to tuning
+    new Modulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
+    
+    // pan to uhh, pan
+    // amount is 500 instead of 1000, see #59
+    new Modulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
+    
+    // expression to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            1,
+            midiControllers.expressionController
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // reverb effects to send
+    new Modulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
+    
+    // chorus effects to send
+    new Modulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
+];
+
+const customModulators = [
+    // custom modulators heck yeah
+    // poly pressure to vibrato
+    new Modulator(
+        getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 0, modulatorSources.polyPressure),
+        0x0,
+        generatorTypes.vibLfoToPitch,
+        50,
+        0
+    ),
+    
+    // cc 92 (tremolo) to modLFO volume
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            0,
+            0,
+            1,
+            midiControllers.tremoloDepth
+        ), /*linear forward unipolar cc 92 */
+        0x0, // no controller
+        generatorTypes.modLfoToVolume,
+        24,
+        0
+    ),
+    
+    // cc 73 (attack time) to volEnv attack
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.convex,
+            1,
+            0,
+            1,
+            midiControllers.attackTime
+        ), // linear forward bipolar cc 72
+        0x0, // no controller
+        generatorTypes.attackVolEnv,
+        6000,
+        0
+    ),
+    
+    // cc 72 (release time) to volEnv release
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.releaseTime
+        ), // linear forward bipolar cc 72
+        0x0, // no controller
+        generatorTypes.releaseVolEnv,
+        3600,
+        0
+    ),
+    
+    // cc 74 (brightness) to filterFc
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.brightness
+        ), // linear forwards bipolar cc 74
+        0x0, // no controller
+        generatorTypes.initialFilterFc,
+        6000,
+        0
+    ),
+    
+    // cc 71 (filter Q) to filter Q
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.filterResonance
+        ), // linear forwards bipolar cc 74
+        0x0, // no controller
+        generatorTypes.initialFilterQ,
+        250,
+        0
+    )
+];
+
+/**
+ * @type {Modulator[]}
+ */
+export const defaultModulators = soundFontModulators.concat(customModulators);

spessasynth_lib/soundfont/basic_soundfont/riff_chunk.js

@@ -0,0 +1,149 @@
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { readLittleEndian, writeDword } from "../../utils/byte_functions/little_endian.js";
+import { readBytesAsString, writeStringAsBytes } from "../../utils/byte_functions/string.js";
+
+/**
+ * riff_chunk.js
+ * reads a riff read and stores it as a class
+ */
+
+export class RiffChunk
+{
+    /**
+     * Creates a new riff read
+     * @constructor
+     * @param header {string}
+     * @param size {number}
+     * @param data {IndexedByteArray}
+     */
+    constructor(header, size, data)
+    {
+        this.header = header;
+        this.size = size;
+        this.chunkData = data;
+    }
+    
+}
+
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param readData {boolean}
+ * @param forceShift {boolean}
+ * @returns {RiffChunk}
+ */
+export function readRIFFChunk(dataArray, readData = true, forceShift = false)
+{
+    let header = readBytesAsString(dataArray, 4);
+    
+    let size = readLittleEndian(dataArray, 4);
+    let chunkData = undefined;
+    if (readData)
+    {
+        chunkData = new IndexedByteArray(dataArray.buffer.slice(dataArray.currentIndex, dataArray.currentIndex + size));
+    }
+    if (readData || forceShift)
+    {
+        dataArray.currentIndex += size;
+    }
+    
+    if (size % 2 !== 0)
+    {
+        if (dataArray[dataArray.currentIndex] === 0)
+        {
+            dataArray.currentIndex++;
+        }
+    }
+    
+    return new RiffChunk(header, size, chunkData);
+}
+
+/**
+ * @param chunk {RiffChunk}
+ * @param prepend {IndexedByteArray}
+ * @returns {IndexedByteArray}
+ */
+export function writeRIFFChunk(chunk, prepend = undefined)
+{
+    let size = 8 + chunk.size;
+    if (chunk.size % 2 !== 0)
+    {
+        size++;
+    }
+    if (prepend)
+    {
+        size += prepend.length;
+    }
+    const array = new IndexedByteArray(size);
+    // prepend data (for example, type before the read)
+    if (prepend)
+    {
+        array.set(prepend, array.currentIndex);
+        array.currentIndex += prepend.length;
+    }
+    // write header
+    writeStringAsBytes(array, chunk.header);
+    // write size (excluding header and the size itself) and then prepend if specified
+    writeDword(array, size - 8 - (prepend?.length || 0));
+    // write data
+    array.set(chunk.chunkData, array.currentIndex);
+    return array;
+}
+
+/**
+ * @param header {string}
+ * @param data {Uint8Array}
+ * @param addZeroByte {Boolean}
+ * @param isList {boolean}
+ * @returns {IndexedByteArray}
+ */
+export function writeRIFFOddSize(header, data, addZeroByte = false, isList = false)
+{
+    if (addZeroByte)
+    {
+        const tempData = new Uint8Array(data.length + 1);
+        tempData.set(data);
+        data = tempData;
+    }
+    let offset = 8;
+    let finalSize = offset + data.length;
+    let writtenSize = data.length;
+    if (finalSize % 2 !== 0)
+    {
+        finalSize++;
+    }
+    let headerWritten = header;
+    if (isList)
+    {
+        finalSize += 4;
+        writtenSize += 4;
+        offset += 4;
+        headerWritten = "LIST";
+    }
+    const outArray = new IndexedByteArray(finalSize);
+    writeStringAsBytes(outArray, headerWritten);
+    writeDword(outArray, writtenSize);
+    if (isList)
+    {
+        writeStringAsBytes(outArray, header);
+    }
+    outArray.set(data, offset);
+    return outArray;
+}
+
+/**
+ * @param collection {RiffChunk[]}
+ * @param type {string}
+ * @returns {RiffChunk|undefined}
+ */
+export function findRIFFListType(collection, type)
+{
+    return collection.find(c =>
+    {
+        if (c.header !== "LIST")
+        {
+            return false;
+        }
+        c.chunkData.currentIndex = 0;
+        return readBytesAsString(c.chunkData, 4) === type;
+    });
+}

spessasynth_lib/soundfont/basic_soundfont/write_dls/art2.js

@@ -0,0 +1,173 @@
+import { getDLSArticulatorFromSf2Generator, getDLSArticulatorFromSf2Modulator } from "./modulator_converter.js";
+import { writeRIFFOddSize } from "../riff_chunk.js";
+import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
+import { Generator, generatorTypes } from "../generator.js";
+import { writeDword } from "../../../utils/byte_functions/little_endian.js";
+import { consoleColors } from "../../../utils/other.js";
+import { SpessaSynthInfo, SpessaSynthWarn } from "../../../utils/loggin.js";
+import { Modulator } from "../modulator.js";
+import {
+    DEFAULT_DLS_CHORUS,
+    DEFAULT_DLS_REVERB,
+    DLS_1_NO_VIBRATO_MOD,
+    DLS_1_NO_VIBRATO_PRESSURE
+} from "../../dls/dls_sources.js";
+
+const invalidGeneratorTypes = new Set([
+    generatorTypes.sampleModes,
+    generatorTypes.initialAttenuation,
+    generatorTypes.keyRange,
+    generatorTypes.velRange,
+    generatorTypes.sampleID,
+    generatorTypes.fineTune,
+    generatorTypes.coarseTune,
+    generatorTypes.startAddrsOffset,
+    generatorTypes.startAddrsCoarseOffset,
+    generatorTypes.endAddrOffset,
+    generatorTypes.endAddrsCoarseOffset,
+    generatorTypes.startloopAddrsOffset,
+    generatorTypes.startloopAddrsCoarseOffset,
+    generatorTypes.endloopAddrsOffset,
+    generatorTypes.endloopAddrsCoarseOffset,
+    generatorTypes.overridingRootKey,
+    generatorTypes.exclusiveClass
+]);
+
+/**
+ * @param zone {BasicInstrumentZone}
+ * @returns {IndexedByteArray}
+ */
+export function writeArticulator(zone)
+{
+    
+    
+    // envelope generators are limited to 40 seconds
+    // in timecents, this is 1200 * log2(10) = 6386
+    
+    for (let i = 0; i < zone.generators.length; i++)
+    {
+        const g = zone.generators[i];
+        if (
+            g.generatorType === generatorTypes.delayVolEnv ||
+            g.generatorType === generatorTypes.attackVolEnv ||
+            g.generatorType === generatorTypes.holdVolEnv ||
+            g.generatorType === generatorTypes.decayVolEnv ||
+            g.generatorType === generatorTypes.releaseVolEnv ||
+            g.generatorType === generatorTypes.delayModEnv ||
+            g.generatorType === generatorTypes.attackModEnv ||
+            g.generatorType === generatorTypes.holdModEnv ||
+            g.generatorType === generatorTypes.decayModEnv
+        )
+        {
+            zone.generators[i] = new Generator(g.generatorType, Math.min(g.generatorValue, 6386), false);
+        }
+    }
+    
+    
+    // read_articulation.js:
+    // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
+    // it shall be divided by -128,
+    // and a strange correction needs to be applied to the real value:
+    // real + (60 / 128) * scale
+    // we invert this here
+    for (let i = 0; i < zone.generators.length; i++)
+    {
+        const relativeGenerator = zone.generators[i];
+        let absoluteCounterpart = undefined;
+        switch (relativeGenerator.generatorType)
+        {
+            default:
+                continue;
+            
+            case generatorTypes.keyNumToVolEnvDecay:
+                absoluteCounterpart = generatorTypes.decayVolEnv;
+                break;
+            case generatorTypes.keyNumToVolEnvHold:
+                absoluteCounterpart = generatorTypes.holdVolEnv;
+                break;
+            case generatorTypes.keyNumToModEnvDecay:
+                absoluteCounterpart = generatorTypes.decayModEnv;
+                break;
+            case generatorTypes.keyNumToModEnvHold:
+                absoluteCounterpart = generatorTypes.holdModEnv;
+        }
+        let absoluteGenerator = zone.generators.find(g => g.generatorType === absoluteCounterpart);
+        if (absoluteGenerator === undefined)
+        {
+            // there's no absolute generator here.
+            continue;
+        }
+        const dlsRelative = relativeGenerator.generatorValue * -128;
+        const subtraction = (60 / 128) * dlsRelative;
+        const newAbsolute = absoluteGenerator.generatorValue - subtraction;
+        
+        const iR = zone.generators.indexOf(relativeGenerator);
+        const iA = zone.generators.indexOf(absoluteGenerator);
+        zone.generators[iA] =
+            new Generator(absoluteCounterpart, newAbsolute, false);
+        zone.generators[iR] =
+            new Generator(relativeGenerator.generatorType, dlsRelative, false);
+    }
+    /**
+     * @type {Articulator[]}
+     */
+    const generators = zone.generators.reduce((arrs, g) =>
+    {
+        if (invalidGeneratorTypes.has(g.generatorType))
+        {
+            return arrs;
+        }
+        const art = getDLSArticulatorFromSf2Generator(g);
+        if (art !== undefined)
+        {
+            arrs.push(art);
+            SpessaSynthInfo("%cSucceeded converting to DLS Articulator!", consoleColors.recognized);
+            
+        }
+        else
+        {
+            SpessaSynthWarn("Failed converting to DLS Articulator!");
+        }
+        return arrs;
+    }, []);
+    /**
+     * @type {Articulator[]}
+     */
+    const modulators = zone.modulators.reduce((arrs, m) =>
+    {
+        // do not write the default DLS modulators
+        if (
+            Modulator.isIdentical(m, DEFAULT_DLS_CHORUS, true) ||
+            Modulator.isIdentical(m, DEFAULT_DLS_REVERB, true) ||
+            Modulator.isIdentical(m, DLS_1_NO_VIBRATO_MOD, true) ||
+            Modulator.isIdentical(m, DLS_1_NO_VIBRATO_PRESSURE, true)
+        )
+        {
+            return arrs;
+        }
+        const art = getDLSArticulatorFromSf2Modulator(m);
+        if (art !== undefined)
+        {
+            arrs.push(art);
+            SpessaSynthInfo("%cSucceeded converting to DLS Articulator!", consoleColors.recognized);
+            
+        }
+        else
+        {
+            SpessaSynthWarn("Failed converting to DLS Articulator!");
+        }
+        return arrs;
+    }, []);
+    generators.push(...modulators);
+    
+    const art2Data = new IndexedByteArray(8);
+    writeDword(art2Data, 8); // cbSize
+    writeDword(art2Data, generators.length); // cbConnectionBlocks
+    
+    
+    const out = generators.map(a => a.writeArticulator());
+    return writeRIFFOddSize(
+        "art2",
+        combineArrays([art2Data, ...out])
+    );
+}

spessasynth_lib/soundfont/basic_soundfont/write_dls/articulator.js

@@ -0,0 +1,49 @@
+import { IndexedByteArray } from "../../../utils/indexed_array.js";
+import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
+
+export class Articulator
+{
+    /**
+     * @type {DLSSources}
+     */
+    source;
+    /**
+     * @type {DLSSources}
+     */
+    control;
+    /**
+     * @type {DLSDestinations}
+     */
+    destination;
+    /**
+     * @type {number}
+     */
+    scale;
+    /**
+     * @type {number}
+     */
+    transform;
+    
+    constructor(source, control, destination, scale, transform)
+    {
+        this.source = source;
+        this.control = control;
+        this.destination = destination;
+        this.scale = scale;
+        this.transform = transform;
+    }
+    
+    /**
+     * @returns {IndexedByteArray}
+     */
+    writeArticulator()
+    {
+        const out = new IndexedByteArray(12);
+        writeWord(out, this.source);
+        writeWord(out, this.control);
+        writeWord(out, this.destination);
+        writeWord(out, this.transform);
+        writeDword(out, this.scale << 16);
+        return out;
+    }
+}

spessasynth_lib/soundfont/basic_soundfont/write_dls/combine_zones.js

@@ -0,0 +1,400 @@
+import { Modulator } from "../modulator.js";
+import { BasicInstrumentZone } from "../basic_zones.js";
+import { Generator, generatorLimits, generatorTypes } from "../generator.js";
+
+const notGlobalizedTypes = new Set([
+    generatorTypes.velRange,
+    generatorTypes.keyRange,
+    generatorTypes.instrument,
+    generatorTypes.exclusiveClass,
+    generatorTypes.endOper,
+    generatorTypes.sampleModes,
+    generatorTypes.startloopAddrsOffset,
+    generatorTypes.startloopAddrsCoarseOffset,
+    generatorTypes.endloopAddrsOffset,
+    generatorTypes.endloopAddrsCoarseOffset,
+    generatorTypes.startAddrsOffset,
+    generatorTypes.startAddrsCoarseOffset,
+    generatorTypes.endAddrOffset,
+    generatorTypes.endAddrsCoarseOffset,
+    generatorTypes.initialAttenuation, // written into wsmp, there's no global wsmp
+    generatorTypes.fineTune,           // written into wsmp, there's no global wsmp
+    generatorTypes.coarseTune,         // written into wsmp, there's no global wsmp
+    generatorTypes.keyNumToVolEnvHold, // KEY TO SOMETHING:
+    generatorTypes.keyNumToVolEnvDecay,// cannot be globalized as they modify their respective generators
+    generatorTypes.keyNumToModEnvHold, // (for example, keyNumToVolEnvDecay modifies VolEnvDecay)
+    generatorTypes.keyNumToModEnvDecay
+]);
+
+/**
+ * Combines preset zones
+ * @param preset {BasicPreset}
+ * @param globalize {boolean}
+ * @returns {BasicInstrumentZone[]}
+ */
+export function combineZones(preset, globalize = true)
+{
+    /**
+     * @param main {Generator[]}
+     * @param adder {Generator[]}
+     */
+    function addUnique(main, adder)
+    {
+        main.push(...adder.filter(g => !main.find(mg => mg.generatorType === g.generatorType)));
+    }
+    
+    /**
+     * @param r1 {SoundFontRange}
+     * @param r2 {SoundFontRange}
+     * @returns {SoundFontRange}
+     */
+    function subtractRanges(r1, r2)
+    {
+        return { min: Math.max(r1.min, r2.min), max: Math.min(r1.max, r2.max) };
+    }
+    
+    /**
+     * @param main {Modulator[]}
+     * @param adder {Modulator[]}
+     */
+    function addUniqueMods(main, adder)
+    {
+        main.push(...adder.filter(m => !main.find(mm => Modulator.isIdentical(m, mm))));
+    }
+    
+    /**
+     * @type {BasicInstrumentZone[]}
+     */
+    const finalZones = [];
+    
+    /**
+     * @type {Generator[]}
+     */
+    const globalPresetGenerators = [];
+    /**
+     * @type {Modulator[]}
+     */
+    const globalPresetModulators = [];
+    let globalPresetKeyRange = { min: 0, max: 127 };
+    let globalPresetVelRange = { min: 0, max: 127 };
+    
+    // find the global zone and apply ranges, generators, and modulators
+    const globalPresetZone = preset.presetZones.find(z => z.isGlobal);
+    if (globalPresetZone)
+    {
+        globalPresetGenerators.push(...globalPresetZone.generators);
+        globalPresetModulators.push(...globalPresetZone.modulators);
+        globalPresetKeyRange = globalPresetZone.keyRange;
+        globalPresetVelRange = globalPresetZone.velRange;
+    }
+    // for each non-global preset zone
+    for (const presetZone of preset.presetZones)
+    {
+        if (presetZone.isGlobal)
+        {
+            continue;
+        }
+        // use global ranges if not provided
+        let presetZoneKeyRange = presetZone.keyRange;
+        if (!presetZone.hasKeyRange)
+        {
+            presetZoneKeyRange = globalPresetKeyRange;
+        }
+        let presetZoneVelRange = presetZone.velRange;
+        if (!presetZone.hasVelRange)
+        {
+            presetZoneVelRange = globalPresetVelRange;
+        }
+        // add unique generators and modulators from the global zone
+        const presetGenerators = presetZone.generators.map(g => new Generator(g.generatorType, g.generatorValue));
+        addUnique(presetGenerators, globalPresetGenerators);
+        const presetModulators = [...presetZone.modulators];
+        addUniqueMods(presetModulators, globalPresetModulators);
+        
+        const iZones = presetZone.instrument.instrumentZones;
+        /**
+         * @type {Generator[]}
+         */
+        const globalInstGenerators = [];
+        /**
+         * @type {Modulator[]}
+         */
+        const globalInstModulators = [];
+        let globalInstKeyRange = { min: 0, max: 127 };
+        let globalInstVelRange = { min: 0, max: 127 };
+        const globalInstZone = iZones.find(z => z.isGlobal);
+        if (globalInstZone)
+        {
+            globalInstGenerators.push(...globalInstZone.generators);
+            globalInstModulators.push(...globalInstZone.modulators);
+            globalInstKeyRange = globalInstZone.keyRange;
+            globalInstVelRange = globalInstZone.velRange;
+        }
+        // for each non-global instrument zone
+        for (const instZone of iZones)
+        {
+            if (instZone.isGlobal)
+            {
+                continue;
+            }
+            // use global ranges if not provided
+            let instZoneKeyRange = instZone.keyRange;
+            if (!instZone.hasKeyRange)
+            {
+                instZoneKeyRange = globalInstKeyRange;
+            }
+            let instZoneVelRange = instZone.velRange;
+            if (!instZone.hasVelRange)
+            {
+                instZoneVelRange = globalInstVelRange;
+            }
+            instZoneKeyRange = subtractRanges(instZoneKeyRange, presetZoneKeyRange);
+            instZoneVelRange = subtractRanges(instZoneVelRange, presetZoneVelRange);
+            
+            // if either of the zones is out of range (i.e.m min larger than the max),
+            // then we discard that zone
+            if (instZoneKeyRange.max < instZoneKeyRange.min || instZoneVelRange.max < instZoneVelRange.min)
+            {
+                continue;
+            }
+            
+            // add unique generators and modulators from the global zone
+            const instGenerators = instZone.generators.map(g => new Generator(g.generatorType, g.generatorValue));
+            addUnique(instGenerators, globalInstGenerators);
+            const instModulators = [...instZone.modulators];
+            addUniqueMods(instModulators, globalInstModulators);
+            
+            /**
+             * sum preset modulators to instruments (amount) sf spec page 54
+             * @type {Modulator[]}
+             */
+            const finalModList = [...instModulators];
+            for (const mod of presetModulators)
+            {
+                const identicalInstMod = finalModList.findIndex(
+                    m => Modulator.isIdentical(mod, m));
+                if (identicalInstMod !== -1)
+                {
+                    // sum the amounts
+                    // (this makes a new modulator
+                    // because otherwise it would overwrite the one in the soundfont!
+                    finalModList[identicalInstMod] = finalModList[identicalInstMod].sumTransform(
+                        mod);
+                }
+                else
+                {
+                    finalModList.push(mod);
+                }
+            }
+            
+            // clone the generators as the values are modified during DLS conversion (keyNumToSomething)
+            let finalGenList = instGenerators.map(g => new Generator(g.generatorType, g.generatorValue));
+            for (const gen of presetGenerators)
+            {
+                if (gen.generatorType === generatorTypes.velRange ||
+                    gen.generatorType === generatorTypes.keyRange ||
+                    gen.generatorType === generatorTypes.instrument ||
+                    gen.generatorType === generatorTypes.endOper ||
+                    gen.generatorType === generatorTypes.sampleModes)
+                {
+                    continue;
+                }
+                const identicalInstGen = instGenerators.findIndex(g => g.generatorType === gen.generatorType);
+                if (identicalInstGen !== -1)
+                {
+                    // if exists, sum to that generator
+                    const newAmount = finalGenList[identicalInstGen].generatorValue + gen.generatorValue;
+                    finalGenList[identicalInstGen] = new Generator(gen.generatorType, newAmount);
+                }
+                else
+                {
+                    // if not, sum to the default generator
+                    const newAmount = generatorLimits[gen.generatorType].def + gen.generatorValue;
+                    finalGenList.push(new Generator(gen.generatorType, newAmount));
+                }
+            }
+            
+            // remove unwanted
+            finalGenList = finalGenList.filter(g =>
+                g.generatorType !== generatorTypes.sampleID &&
+                g.generatorType !== generatorTypes.keyRange &&
+                g.generatorType !== generatorTypes.velRange &&
+                g.generatorType !== generatorTypes.endOper &&
+                g.generatorType !== generatorTypes.instrument &&
+                g.generatorValue !== generatorLimits[g.generatorType].def
+            );
+            
+            // create the zone and copy over values
+            const zone = new BasicInstrumentZone();
+            zone.keyRange = instZoneKeyRange;
+            zone.velRange = instZoneVelRange;
+            if (zone.keyRange.min === 0 && zone.keyRange.max === 127)
+            {
+                zone.keyRange.min = -1;
+            }
+            if (zone.velRange.min === 0 && zone.velRange.max === 127)
+            {
+                zone.velRange.min = -1;
+            }
+            zone.isGlobal = false;
+            zone.sample = instZone.sample;
+            zone.generators = finalGenList;
+            zone.modulators = finalModList;
+            finalZones.push(zone);
+        }
+    }
+    
+    if (globalize)
+    {
+        // create a global zone and add repeating generators to it
+        // also modulators
+        const globalZone = new BasicInstrumentZone();
+        globalZone.isGlobal = true;
+        // iterate over every type of generator
+        for (let checkedType = 0; checkedType < 58; checkedType++)
+        {
+            // not these though
+            if (notGlobalizedTypes.has(checkedType))
+            {
+                continue;
+            }
+            /**
+             * @type {Object<string, number>}
+             */
+            let occurencesForValues = {};
+            const defaultForChecked = generatorLimits[checkedType]?.def || 0;
+            occurencesForValues[defaultForChecked] = 0;
+            for (const z of finalZones)
+            {
+                const gen = z.generators.find(g => g.generatorType === checkedType);
+                if (gen)
+                {
+                    const value = gen.generatorValue;
+                    if (occurencesForValues[value] === undefined)
+                    {
+                        occurencesForValues[value] = 1;
+                    }
+                    else
+                    {
+                        occurencesForValues[value]++;
+                    }
+                }
+                else
+                {
+                    occurencesForValues[defaultForChecked]++;
+                }
+                
+                // if the checked type has the keyNumTo something generator set, it cannot be globalized.
+                let relativeCounterpart;
+                switch (checkedType)
+                {
+                    default:
+                        continue;
+                    
+                    case generatorTypes.decayVolEnv:
+                        relativeCounterpart = generatorTypes.keyNumToVolEnvDecay;
+                        break;
+                    case generatorTypes.holdVolEnv:
+                        relativeCounterpart = generatorTypes.keyNumToVolEnvHold;
+                        break;
+                    case generatorTypes.decayModEnv:
+                        relativeCounterpart = generatorTypes.keyNumToModEnvDecay;
+                        break;
+                    case generatorTypes.holdModEnv:
+                        relativeCounterpart = generatorTypes.keyNumToModEnvHold;
+                }
+                const relative = z.generators.find(g => g.generatorType === relativeCounterpart);
+                if (relative !== undefined)
+                {
+                    occurencesForValues = {};
+                    break;
+                }
+            }
+            // if at least one occurrence, find the most used one and add it to global
+            if (Object.keys(occurencesForValues).length > 0)
+            {
+                // [value, occurrences]
+                const valueToGlobalize = Object.entries(occurencesForValues).reduce((max, curr) =>
+                {
+                    if (max[1] < curr[1])
+                    {
+                        return curr;
+                    }
+                    return max;
+                }, [0, 0]);
+                const targetValue = parseInt(valueToGlobalize[0]);
+                
+                // if the global value is the default value just remove it, no need to add it
+                if (targetValue !== defaultForChecked)
+                {
+                    globalZone.generators.push(new Generator(checkedType, targetValue));
+                }
+                // remove from the zones
+                finalZones.forEach(z =>
+                {
+                    const gen = z.generators.findIndex(g =>
+                        g.generatorType === checkedType);
+                    if (gen !== -1)
+                    {
+                        if (z.generators[gen].generatorValue === targetValue)
+                        {
+                            // That exact value exists. Since it's global now, remove it
+                            z.generators.splice(gen, 1);
+                        }
+                    }
+                    else
+                    {
+                        // That type does not exist at all here.
+                        // Since we're globalizing, we need to add the default here.
+                        if (targetValue !== defaultForChecked)
+                        {
+                            z.generators.push(new Generator(checkedType, defaultForChecked));
+                        }
+                    }
+                });
+            }
+        }
+        
+        // globalize only modulators that exist in all zones
+        const firstZone = finalZones.find(z => !z.isGlobal);
+        const modulators = firstZone.modulators.map(m => Modulator.copy(m));
+        for (const checkedModulator of modulators)
+        {
+            let existsForAllZones = true;
+            for (const zone of finalZones)
+            {
+                if (zone.isGlobal || !existsForAllZones)
+                {
+                    continue;
+                }
+                // check if that zone has an existing modulator
+                const mod = zone.modulators.find(m => Modulator.isIdentical(m, checkedModulator));
+                if (!mod)
+                {
+                    // does not exist for this zone, so it's not global.
+                    existsForAllZones = false;
+                }
+                // exists.
+                
+            }
+            if (existsForAllZones === true)
+            {
+                globalZone.modulators.push(Modulator.copy(checkedModulator));
+                // delete it from local zones.
+                for (const zone of finalZones)
+                {
+                    const modulator = zone.modulators.find(m => Modulator.isIdentical(m, checkedModulator));
+                    // Check if the amount is correct.
+                    // If so, delete it since it's global.
+                    // If not, then it will simply override global as it's identical.
+                    if (modulator.transformAmount === checkedModulator.transformAmount)
+                    {
+                        zone.modulators.splice(zone.modulators.indexOf(modulator), 1);
+                    }
+                }
+            }
+        }
+        finalZones.splice(0, 0, globalZone);
+    }
+    return finalZones;
+}