spessasynth_core 1.1.3 → 1.1.5

package/README.md

@@ -1,474 +1,156 @@
-# spessasynth_core
-A SoundFont2 synthesizer library, made for use with node.js. 
-A fork of [SpessaSynth](https://github.com/spessasus/SpessaSynth).
-
-[Jump to the API reference](#api-reference)
-
-`npm install --save spessasynth_core`
-
-> Looking for a browser version? Try [SpessaSynth](https://github.com/spessasus/SpessaSynth).
-
-## Features:
-- SoundFont2 support (both modulators and generators)
-- SoundFont3 support (vorbis compressed sf2)
-- GS, XG, GM2, GM1 system exclusive support
-- NRPN, RPN support
-- Integrated sequencer
-- Additional custom modulators
-- Multi-port MIDIs support (more than 16 channels)
-- No SoundFont size limit
-- No dependencies
-
-### Example: Render a MIDI file to a .wav file
-```js
-const fs = require('fs');
-// spessasynth_core is an es6 module
-import("spessasynth_core").then(core => {
-    // usage: node test.js <sf path> <midi path> <output path>
-    const [,, soundfontName, midiName, outputName] = process.argv;
-    // read the input files
-    const soundfont = fs.readFileSync(soundfontName);
-    const mid = new core.MIDI(fs.readFileSync(midiName))
-
-    // initialize synth and sequencer
-    const synth = new core.Synthesizer(soundfont, 44100);
-    const seq = new core.Sequencer(synth);
-    // load new song and disable the loop
-    seq.loadNewSongList([mid]);
-    seq.loop = false;
-
-    // calculate length and allocate buffers
-    const lengthSamples = mid.duration * 44100;
-    const outLeft = new Float32Array(lengthSamples);
-    const outRight = new Float32Array(lengthSamples);
-
-    // wait for sf3 support to load and render
-    synth.sf3supportReady.then(() => {
-        // note: this discards reverb and chorus outputs!
-        synth.render([outLeft, outRight]);
-        // write output data
-        const wav = core.rawDataToWav(44100, outLeft, outRight);
-        fs.writeFileSync(outputName, Buffer.from(wav));
-    });
-});
-```
-
-### Example 2: play a MIDI file to speakers
-via npm package `speaker`
-```js
-const fs = require('fs');
-const Speaker = require("speaker");
-const SAMPLE_RATE = 44100; // hertz
-const BLOCK_SIZE = 128; // samples
-
-// usage: node test.js <sf path> <midi path>
-import("spessasynth_core").then(core => {
-    // Disable logging
-    core.SpessaSynthLogging(false, false, false, false);
-
-    // Read arguments and load the input files
-    const [,, soundfontName, midiName] = process.argv;
-    const soundfont = fs.readFileSync(soundfontName);
-    const mid = new core.MIDI(fs.readFileSync(midiName)); // parse the midi
-
-
-    // Initialize synth and sequencer
-    const synth = new core.Synthesizer(soundfont, SAMPLE_RATE, BLOCK_SIZE);
-    const seq = new core.Sequencer(synth);
-
-    // Load new song and disable the loop
-    seq.loadNewSongList([mid]);
-    seq.loop = false;
-
-    // make the program stop after the sequence is finished
-    const time = seq.duration + 1
-    let isPlaying = true;
-    setTimeout(() => isPlaying = false, time * 1000);
-    console.log(`Playing "${mid.midiName || "<unnamed song>"}"`);
-
-    // Calculate length and allocate buffers
-    const outLeft = new Float32Array(BLOCK_SIZE);
-    const outRight = new Float32Array(BLOCK_SIZE);
-
-    // Wait for sf3 support to load and render
-    synth.sf3supportReady.then(() => {
-        const speakerOut = new Speaker({
-            channels: 2,
-            bitDepth: 16,
-            sampleRate: SAMPLE_RATE,
-        });
-
-        function render()
-        {
-            // Render audio samples from the synthesizer
-            synth.render([outLeft, outRight]);
-
-            // Prepare buffer for WAV output
-            const wavData = new Int16Array(outLeft.length * 2); // 2 channels
-
-            // Interleave audio data
-            let offset = 0;
-            for (let i = 0; i < outLeft.length; i++)
-            {
-                // Float ranges from -1 to 1, int16 ranges from -32768 to 32767, convert it here
-                const sampleL = Math.max(-1, Math.min(1, outLeft[i])) * 32767;
-                const sampleR = Math.max(-1, Math.min(1, outRight[i])) * 32767;
-
-                // Interleave data: L, R, L, R, etc...
-                wavData[offset++] = sampleL;
-                wavData[offset++] = sampleR;
-            }
-            // Write WAV data to speaker
-            speakerOut.write(wavData);
-
-            if(isPlaying)
-            {
-                setImmediate(render);
-            }
-            else
-            {
-                process.exit(0);
-            }
-        }
-
-        render();
-    });
-});
-```
-
-## API reference
-### Contents
- - [Importing the library](#importing-the-library)
- - [Synthesizer](#synthesizer)
- - [Sequencer](#sequencer)
- - [MIDI](#midi)
- - [SoundFont2](#soundfont2)
- - [How to disable console output](#logging)
-
-### Importing the library
-spessasynth_core is an es6 package.
-```js
-// es6
-import {Synthesizer} from "spessasynth_core"
-// commonjs
-import("spessasynth_core").then(core => {
-    // use core.Synthesizer
-})
-```
-## Synthesizer
-The main synth module.
-### Initialization
-```js
-const synth = new Synthesizer(soundFontBuffer, sampleRate, blockSize)
-```
-- soundFontBuffer - a `Buffer` or `ArrayBufferLike`, represents the soundfont file.
-- sampleRate - number, the output sample rate in hertz.
-- blockSize - optional, a number. Sets the interval of the synth updating parameters like the sequencer tick processing and modulation envelope.
-Default value is 128, and it's recommended to leave it as the default.
-
-### sf3supportReady
-A promise that gets resolved when the vorbis decoder is ready. You must await it if you use sf3 soundfonts.
-```js
-await synth.sf3supportReady;
-```
-
-### render
-Synthesizes audio the output buffers
-```js
-synth.render(outputChannels, reverbOutputChannels, chorusOutputChannels);
-```
-- outputChannels - two `Float32Arrays` that get filled with the audio data. Left is the left channel and right is the right channel. Can be any length. (except zero)
-- reverbOutputChannels - two `Float32Arrays` that get filled with the unprocessed audio data for reverb processing. Left is the left channel and right is the right channel. Can be undefined.
-- reverbOutputChannels - two `Float32Arrays` that get filled with the unprocessed audio data for chorus processing. Left is the left channel and right is the right channel. Can be undefined.
-
-**All arrays must be the same length.**
-
-### noteOn
-
-Plays the given note.
-
-```js
-synth.noteOn(channel, midiNote, velocity, enableDebugging);
-```
-
-- channel - the MIDI channel to use. Usually ranges from 0 to 15, but it depends on the channel count.
-- midiNote - the note to play. Ranges from 0 to 127.
-- velocity - controls how loud the note is. 127 is normal loudness and 1 is the quietest. Note that velocity of 0 has the same effect as using `noteOff`. Ranges from 0 to 127.
-- enableDebugging - boolean, used only for debugging. When `true`, the console will print out tables of the soundfont generator data used to play the note.
-
-### noteOff
-
-Stops the given note.
-
-```js
-synth.noteOff(channel, midiNote);
-```
-
-- channel - the MIDI channel to use. Usually ranges from 0 to 15, but it depends on the channel count.
-- midiNote - the note to play. Ranges from 0 to 127.
-> To stop a note instantly, use `synth.killNote` (takes the same arguments)
-
-### stopAllChannels
-
-Stops all notes. Equivalent of MIDI "panic".
-
-```js
-synth.stopAllChannels(force);
-```
-- force - `boolean`, if true, ignores the release time and stops everything instantly. Defaults to false.
-> To stop all notes on a specific channel, use `synth.stopAll(channel, force)`. channel is the channel number.
-
-### programChange
-
-Changes the preset for the given channel.
-
-```js
-synth.programChange(channel, programNumber);
-```
-
-- channel - the MIDI channel to change. Usually ranges from 0 to 15, but it depends on the channel count.
-- programNumber - the MIDI program number to use. Ranges from 0 to 127. To use other banks, go to [controllerChange](#controllerchange).
-> To lock the preset (prevent MIDI file from changing it) use `synth.workletProcessorChannels[channel].lockPreset = true;`
-
-### pitchWheel
-
-Changes the channel's pitch, including the currently playing notes.
-
-```js
-synth.pitchWheel(channel, MSB, LSB);
-```
-
-- channel - the MIDI channel to use. Usually ranges from 0 to 15, but it depends on the channel count.
-- MSB and LSB. 7-bit numbers that form a 14-bit pitch bend value.
-> [I highly recommend this article for more info.](https://www.recordingblogs.com/wiki/midi-pitch-wheel-message)
-
-### systemExclusive
-
-Handles a MIDI System Exclusive message.
-
-```js
-synth.systemExclusive(messageData);
-```
-
-- message data - Uint8Array, the message byte data **Excluding the 0xF0 byte!**
-> Refer to [this table](https://github.com/spessasus/SpessaSynth/wiki/Synthetizer-Class#supported-system-exclusives) for the list of supported System Exclusives.
-
-### setMainVolume
-Sets the main volume of the synthesizer.
-```js
-synth.setMainVolume(volume);
-```
-- volume - the volume, ranges from 0 to 1.
-
-### setMasterPan
-Sets the master panning of the synthesizer.
-```js
-synth.setMasterPan(pan);
-```
-- pan - ranges from -1 to 1, -1 is left, 0 is middle, 1 is right.
-
-### lockController
-
-Causes the given midi channel to ignore controller messages for the given controller number.
-
-```js
-synth.lockController(channel, controllerNumber, isLocked);
-```
-
-- channel - the channel to lock. Usually ranges from 0 to 15, but it depends on the channel count.
-- controllerNumber - the MIDI CC to lock. Ranges from 0 to 127.
-- isLocked - boolean, if true then locked, if false then unlocked.
-
-### muteChannel
-
-Mutes or unmutes a given channel
-
-```js
-synth.muteChannel(channel, isMuted);
-```
-
-- channel - the channel to mute/unmute. Usually ranges from 0 to 15, but it depends on the channel count.
-- isMuted - if the channel should be muted. boolean.
-
-### transposeAllChannels
-
-Transposes the synth up or down in semitones. Floating point values can be used for more precise tuning.
-
-```js
-synth.transposeAllChannels(semitones);
-```
-
-- semitones - the amount of semitones to transpose the synth by. Can be positive or negative or zero. Zero resets the pitch.
-
-### controllerChange
-
-Sets a given MIDI controller to a given value.
-
-```js
-synth.controllerChange(channel, controllerNumber, controllerValue);
-```
-
-- channel - the MIDI channel to use. Usually ranges from 0 to 15, but it depends on the channel count.
-- controllerName - the MIDI CC number. Refer to [this table](https://github.com/spessasus/SpessaSynth/wiki/Synthetizer-Class#default-supported-controllers) for the list of controllers supported by default.
-- controllerValue - the value to set the given controller to. Ranges from 0 to 127.
-> Note that theoreticallly all controllers are supported as it depends on the SoundFont's modulators.
-
-### resetAllControllers
-Resets all controllers and programs to their default values. Also resets the system.
-```js
-synth.resetAllControllers();
-```
-
-### addNewChannel
-
-Adds a new channel.
-```js
-synth.addNewChannel();
-```
-
-### reloadSoundfont
-
-Changes the soundfont of a Synthesizer's instance.
-
-```js
-synth.reloadSoundFont(soundFontBuffer);
-```
-
-- soundFont - the soundfont to change to, an `ArrayBuffer` instance of the file.
-
-### setDrums
-Sets the given channel to a drum channel.
-```js
-synth.setDrums(channel, isDrum);
-```
-- channel - the channel to change. Usually ranges from 0 to 15, but it depends on the channel count.
-- isDrum - `boolean` indicates if the channel should be a drum channel.
-
-### Accesing controller values
-use `synth.workletProcessorChannels` to get the current values. A single channel is defined as follows:
-```js
-/**
- * @typedef {Object} WorkletProcessorChannel
- * @property {Int16Array} midiControllers - array of MIDI controller values
- * @property {boolean[]} lockedControllers - array indicating if a controller is locked
- * @property {boolean} holdPedal - indicates whether the hold pedal is active
- * @property {boolean} drumChannel - indicates whether the channel is a drum channel
- *
- * @property {Preset} preset - the channel's preset
- * @property {boolean} lockPreset - indicates whether the program on the channel is locked
- *
- * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
- * @property {Object} channelVibrato - vibrato settings for the channel
- * @property {number} channelVibrato.depth - depth of the vibrato effect (cents)
- * @property {number} channelVibrato.delay - delay before the vibrato effect starts (seconds)
- * @property {number} channelVibrato.rate - rate of the vibrato oscillation (Hz)
-
- * @property {boolean} isMuted - indicates whether the channel is muted
- * @property {WorkletVoice[]} voices - array of voices currently active on the channel
- * @property {WorkletVoice[]} sustainedVoices - array of voices that are sustained on the channel
- */
-
-```
-Note: this definition is stripped from internal values.
-
-## Sequencer
-### Initialization
-```js
-const sequencer = new Sequencer(synthesizer);
-```
-- synthesizer - a `Synthesizer` instance to play to.
-
-### loadNewSongList
-Loads a new song list.
-```js
-sequencer.loadNewSongList(parsedMidis);
-```
-- parsedMidis - an array of `MIDI` instances representing the songs to play. If there's only one, the loop will be enabled.
-
-### play
-Starts playing the sequence. If the sequence was paused, it won't change any controllers, but if it wasn't (ex. the time was changed) then it will go through all the controller changes from the start before playing. **This function does NOT modify the current playback time!**
-```js
-sequencer.play(resetTime);
-```
-- resetTime - boolean, if set to `true` then the playback will start from 0. Defaults to `false`;
-
-### pause
-Pauses the playback of the sequence.
-```js
-sequencer.pause();
-```
-
-### stop
-Stops the playback of the sequence. Currently only used internally by the `pause` function.
-```js
-sequencer.stop();
-```
-
-### nextSong
-Plays the next song in the list.
-```js
-sequencer.nextSong();
-```
-
-### previousSong
-Plays the previous song in the list.
-```js
-sequencer.previousSong();
-```
-
-### paused
-Read-only boolean, indicating that if the sequencer's playback is paused.
-```js
-if(sequencer.paused)
-{
-   console.log("Sequencer paused!");
-}
-else
-{
-   console.log("Sequencer playing or stopped!");
-}
-```
-
-### loop
-Boolean that controls if the sequencer loops.
-```js
-sequencer.loop = false; // the playback will stop after reaching the end
-```
-
-### currentTime
-Property used for changing and reading the current playback time.
-#### get
-Returns the current playback time in seconds.
-```js
-console.log("The sequences is playing for"+sequencer.currentTime+" seconds.");
-```
-#### set
-Sets the current playback time. Calls `stop` and then `play` internally.
-```js
-sequencer.currentTime = 0; // go to the start
-```
-
-### duration
-Length of the track in seconds. Equivalent of `Audio.duration`;
-```js
-console.log(`The track lasts for ${sequencer.duration} seconds!`);
-```
-
-## MIDI
-See [MIDI on SpessaSynth wiki](https://github.com/spessasus/SpessaSynth/wiki/MIDI-Class)
-
-## SoundFont2
-See [SoundFont2 on SpessaSynth wiki](https://github.com/spessasus/SpessaSynth/wiki/SoundFont2-Class)
-
-## Logging
-By default, SpessaSynth prints out a lot of stuff to console.
-Here's how you can disable it:
-```js
-// import (or require) here
-SpessaSynthLogging(enableInfo, enableWarning, enableGroup, enableTable);
-```
-All the input variables are booleans corresponding to the things SpessaSynth logs.
-- Info - all general info such as parsing soundfonts, midi files, RPN changes, etc.
-- Warnings - all messages unrecognized by the synthesizer, other warnings
-- group - the groups for parsing the soundfont and midi files.
-- table - the debug table `when enableDebugging` is set to `true` for `synth.noteOn`
+# spessasynth_core
+
+**A powerful SF2/DLS/MIDI JavaScript library. It works with any modern JS environment that supports WebAssembly.**
+
+> **TIP:**
+> Looking for an easy-to-use WebAudioAPI browser wrapper? Try [spessasynth_lib](https://github.com/spessasus/spessasynth_lib)!
+
+```shell
+npm install --save spessasynth_core
+```
+
+### [Project site (consider giving it a star!)](https://github.com/spessasus/spessasynth_core)
+
+### [Demo (using the spessasynth_lib wrapper)](https://spessasus.github.io/SpessaSynth)
+
+### [Documentation (in progress!)](https://github.com/spessasus/spessasynth_core/wiki/Home)
+
+
+> Note: This is the new heart of the SpessaSynth library, after the repository has been split.
+
+
+## Current Features
+
+### Numerous Format Support
+Supported formats list:
+- `.mid` - Standard MIDI File
+- `.kar` - Soft Karaoke MIDI File
+- `.sf2` - SoundFont2 File
+- `.sf3` - SoundFont2 Compressed File
+- `.sfogg` - SF2Pack With Vorbis Compression
+- `.dls` - Downloadable Sounds Levels 1 & 2 (as well as Mobile DLS)
+- `.rmi` - RIFF MIDI File
+- `.rmi` - RIFF MIDI File With Embedded DLS
+- `.rmi` - [RIFF MIDI File With Embedded SF2](https://github.com/spessasus/sf2-rmidi-specification)
+- `.xmf` - eXtensible Music Format
+- `.mxmf` - Mobile eXtensible Music format
+
+*With [an easy way of converting between them!](https://github.com/spessasus/spessasynth_core/wiki/Converting-Between-Formats)*
+
+### Easy Integration
+- **Modular design:** *Easy integration into other projects (load what you need)*
+- **Flexible:** *It's not just a MIDI player!*
+- **No dependencies:** *Batteries included!*
+
+### Powerful MIDI Synthesizer
+- Suitable for both **real-time** and **offline** synthesis
+- **Excellent SoundFont support:**
+  - **Full Generator Support**
+  - **Full Modulator Support:** *First (to my knowledge) JavaScript SoundFont synth with that feature!*
+  - **GeneralUserGS Compatible:** *[See more here!](https://github.com/mrbumpy409/GeneralUser-GS/blob/main/documentation/README.md)*
+  - **SoundFont3 Support:** Play compressed SoundFonts!
+  - **Experimental SF2Pack Support:** Play soundfonts compressed with BASSMIDI! (*Note: only works with vorbis compression*)
+  - **Can load very large SoundFonts:** up to 4GB!
+- **Great DLS Support:**
+  - **DLS Level 1 Support**
+  - **DLS Level 2 Support**
+  - **Mobile DLS Support**
+  - **Correct articulator support:** *Converts articulators to both modulators and generators!*
+  - **Tested and working with gm.dls!**
+  - **Correct volume:** *Properly translated to SoundFont volume!*
+  - **A-Law encoding support**
+  - **Both unsigned 8-bit and signed 16-bit sample support (24-bit theoretically supported as well!)**
+  - **Detects special articulator combinations:** *Such as vibratoLfoToPitch*
+- **Soundfont manager:** Stack multiple soundfonts!
+- **[Custom modulators for additional controllers](https://github.com/spessasus/spessasynth_core/wiki/Modulator-Class#default-modulators):** *Why not?*
+- **Unlimited channel count:** Your CPU is the limit!
+- **Excellent MIDI Standards Support:**
+  - **MIDI Controller Support:** Default supported controllers [here](https://github.com/spessasus/spessasynth_core/wiki/MIDI-Implementation#supported-controllers)
+  - **Portamento Support:** Glide the notes!
+  - **Sound Controllers:** Real-time filter and envelope control!
+  - **MIDI Tuning Standard Support:** [more info here](https://github.com/spessasus/spessasynth_core/wiki/MIDI-Implementation#midi-tuning-standard)
+  - [Full **RPN** and limited **NRPN** support](https://github.com/spessasus/spessasynth_core/wiki/MIDI-Implementation#supported-registered-parameters)
+  - Supports some [**Roland GS** and **Yamaha XG** system exclusives](https://github.com/spessasus/spessasynth_core/wiki/MIDI-Implementation#supported-system-exclusives)
+
+### Powerful and Fast MIDI Sequencer
+- **Supports MIDI formats 0, 1, and 2:** *note: format 2 support is experimental as it's very, very rare.*
+- **[Multi-Port MIDI](https://github.com/spessasus/spessasynth_core/wiki/About-Multi-Port) support:** More than 16 channels!
+- **Smart preloading:** Only preloads the samples used in the MIDI file for smooth playback *(down to key and velocity!)*
+- **Lyrics support:** Add karaoke to your program!
+- **Raw lyrics available:** Decode in any encoding! *(Kanji? No problem!)*
+- **Loop points support:** Ensures seamless loops!
+
+### Read and Write SoundFont and MIDI Files with Ease
+#### Read and write MIDI files
+  - **Smart name detection:** Handles incorrectly formatted and non-standard track names
+  - **Raw name available:** Decode in any encoding! *(Kanji? No problem!)*
+  - **Port detection during load time:** Manage ports and channels easily!
+  - **Used channels on track:** Quickly determine which channels are used
+  - **Key range detection:** Detect the key range of the MIDI
+  - **Easy MIDI editing:** Use [helper functions](https://github.com/spessasus/spessasynth_core/wiki/Writing-MIDI-Files#modifymidi) to modify the song to your needs!
+  - **Loop detection:** Automatically detects loops in MIDIs (e.g., from *Touhou Project*)
+  - **First note detection:** Skip unnecessary silence at the start by jumping to the first note!
+  - **Lyrics support:** Both regular MIDI and .kar files!
+  - **[Write MIDI files from scratch](https://github.com/spessasus/spessasynth_core/wiki/Creating-MIDI-Files)**
+  - **Easy saving:** Save with just [one function!](https://github.com/spessasus/spessasynth_core/wiki/Writing-MIDI-Files#writemidi)
+
+#### Read and write [RMID files with embedded SF2 soundfonts](https://github.com/spessasus/sf2-rmidi-specification#readme)
+  - **[Level 4](https://github.com/spessasus/sf2-rmidi-specification#level-4) compliance:** Reads and writes *everything!*
+  - **Compression and trimming support:** Reduce a MIDI file with a 1GB soundfont to **as small as 5MB**!
+  - **DLS Version support:** The original legacy format with bank offset detection!
+  - **Automatic bank shifting and validation:** Every soundfont *just works!*
+  - **Metadata support:** Add title, artist, album name and cover and more! And of course read them too! *(In any encoding!)*
+  - **Compatible with [Falcosoft Midi Player 6!](https://falcosoft.hu/softwares.html#midiplayer)**
+  - **Easy saving:** [As simple as saving a MIDI file!](https://github.com/spessasus/spessasynth_core/wiki/Writing-MIDI-Files#writermidi)
+
+#### Read and write SoundFont2 files
+  - **Easy info access:** Just an [object of strings!](https://github.com/spessasus/spessasynth_core/wiki/SoundFont2-Class#soundfontinfo)
+  - **Smart trimming:** Trim the SoundFont to only include samples used in the MIDI *(down to key and velocity!)*
+  - **sf3 conversion:** Compress SoundFont2 files to SoundFont3 with variable quality!
+  - **Easy saving:** Also just [one function!](https://github.com/spessasus/spessasynth_core/wiki/SoundFont2-Class#write)
+
+#### Read and write SoundFont3 files
+  - Same features as SoundFont2 but with now with **Ogg Vorbis compression!**
+  - **Variable compression quality:** You choose between file size and quality!
+  - **Compression preserving:** Avoid decompressing and recompressing uncompressed samples for minimal quality loss!
+
+#### Read and write DLS Level One or Two files
+  - Read DLS (DownLoadable Sounds) files as SF2 files!
+  - **Works like a normal soundfont:** *Saving it as sf2 is still [just one function!](https://github.com/spessasus/spessasynth_core/wiki/SoundFont2-Class#write)*
+  - Converts articulators to both **modulators** and **generators**!
+  - Works with both unsigned 8-bit samples and signed 16-bit samples!
+  - A-Law encoding support
+  - **Covers special generator cases:** *such as modLfoToPitch*!
+  - **Correct volume:** *looking at you, Viena and gm.sf2!*
+  - Support built right into the synthesizer!
+  - **Convert SF2 to DLS:** [with limitations](https://github.com/spessasus/spessasynth_core/wiki/DLS-Conversion-Problem)
+
+### Export MIDI as WAV
+  - Save the MIDI file as WAV audio!
+  - **Metadata support:** *Embed metadata such as title, artist, album and more!*
+  - **Cue points:** *Write MIDI loop points as cue points!*
+  - **Loop multiple times:** *Render two (or more) loops into the file for seamless transitions!*
+
+### Special Thanks
+- [FluidSynth](https://github.com/FluidSynth/fluidsynth) - for the source code that helped implement functionality and fixes
+- [Polyphone](https://www.polyphone-soundfonts.com/) - for the soundfont testing and editing tool
+- [Meltysynth](https://github.com/sinshu/meltysynth) - for the initial low-pass filter implementation
+- [RecordingBlogs](https://www.recordingblogs.com/) - for detailed explanations on MIDI messages
+- [stbvorbis.js](https://github.com/hajimehoshi/stbvorbis.js) - for the Vorbis decoder
+- [fflate](https://github.com/101arrowz/fflate) - for the MIT DEFLATE implementation
+- [foo_midi](https://github.com/stuerp/foo_midi) - for useful resources on XMF file format
+- [Falcosoft](https://falcosoft.hu) - for help with the RMIDI format
+- [Christian Collins](https://schristiancollins.com) - for various bug reports regarding the synthesizer
+- **And You!** - for checking out this project. I hope you like it :)
+
+**If you like this project, consider giving it a star. It really helps out!**
+
+# License
+Copyright © 2025 Spessasus
+Licensed under the Apache-2.0 License.
+
+#### Legal
+This project is in no way endorsed or otherwise affiliated with the MIDI Manufacturers Association,
+Creative Technology Ltd. or E-mu Systems, Inc., or any other organization mentioned.
+SoundFont® is a registered trademark of Creative Technology Ltd.
+All other trademarks are the property of their respective owners.