spessasynth_core 1.1.3 → 1.1.5

package/src/utils/xg_hacks.js

@@ -0,0 +1,193 @@
+import { SpessaSynthInfo } from "./loggin.js";
+import { consoleColors } from "./other.js";
+import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+
+export const XG_SFX_VOICE = 64;
+
+const GM2_DEFAULT_BANK = 121;
+
+/**
+ * @param sys {SynthSystem}
+ * @returns {number}
+ */
+export function getDefaultBank(sys)
+{
+    return sys === "gm2" ? GM2_DEFAULT_BANK : 0;
+}
+
+/**
+ * @param bankNr {number}
+ * @returns {boolean}
+ */
+export function isXGDrums(bankNr)
+{
+    return bankNr === 120 || bankNr === 126 || bankNr === 127;
+}
+
+/**
+ * @param bank {number}
+ * @returns {boolean}
+ */
+export function isValidXGMSB(bank)
+{
+    return isXGDrums(bank) || bank === XG_SFX_VOICE || bank === GM2_DEFAULT_BANK;
+}
+
+/**
+ * Bank select hacks abstracted here
+ * @param bankBefore {number} the current bank number
+ * @param bank {number} the cc change bank number
+ * @param system {SynthSystem} MIDI system
+ * @param isLSB {boolean} is bank LSB?
+ * @param isDrums {boolean} is drum channel?
+ * @param channelNumber {number} channel number
+ * @returns {{
+ *     newBank: number,
+ *     drumsStatus: 0|1|2
+ * }} 0 - unchanged, 1 - OFF, 2 - ON
+ */
+export function parseBankSelect(bankBefore, bank, system, isLSB, isDrums, channelNumber)
+{
+    // 64 means SFX in MSB, so it is allowed
+    let out = bankBefore;
+    let drumsStatus = 0;
+    if (isLSB)
+    {
+        if (isSystemXG(system))
+        {
+            if (!isValidXGMSB(bank))
+            {
+                out = bank;
+            }
+        }
+        else if (system === "gm2")
+        {
+            out = bank;
+        }
+    }
+    else
+    {
+        let canSetBankSelect = true;
+        switch (system)
+        {
+            case "gm":
+                // gm ignores bank select
+                SpessaSynthInfo(
+                    `%cIgnoring the Bank Select (${bank}), as the synth is in GM mode.`,
+                    consoleColors.info
+                );
+                canSetBankSelect = false;
+                break;
+            
+            case "xg":
+                canSetBankSelect = isValidXGMSB(bank);
+                // for xg, if msb is 120, 126 or 127, then it's drums
+                if (isXGDrums(bank))
+                {
+                    drumsStatus = 2;
+                }
+                else
+                {
+                    // drums shall not be disabled on channel 9
+                    if (channelNumber % 16 !== DEFAULT_PERCUSSION)
+                    {
+                        drumsStatus = 1;
+                    }
+                }
+                break;
+            
+            case "gm2":
+                if (bank === 120)
+                {
+                    drumsStatus = 2;
+                }
+                else
+                {
+                    if (channelNumber % 16 !== DEFAULT_PERCUSSION)
+                    {
+                        drumsStatus = 1;
+                    }
+                }
+        }
+        
+        if (isDrums)
+        {
+            // 128 for percussion channel
+            bank = 128;
+        }
+        if (bank === 128 && !isDrums)
+        {
+            // if a channel is not for percussion, default to bank current
+            bank = bankBefore;
+        }
+        if (canSetBankSelect)
+        {
+            out = bank;
+        }
+    }
+    return {
+        newBank: out,
+        drumsStatus: drumsStatus
+    };
+}
+
+
+/**
+ * Chooses a bank number according to spessasynth logic
+ * That is:
+ * for GS, bank MSB if not drum, otherwise 128
+ * for XG: bank MSB if drum and MSB is valid, 128 othewise, bank MSB if it is SFX voice, LSB otherwise
+ * @param msb {number}
+ * @param lsb {number}
+ * @param isDrums {boolean}
+ * @param isXG {boolean}
+ * @returns {number}
+ */
+export function chooseBank(msb, lsb, isDrums, isXG)
+{
+    if (isXG)
+    {
+        if (isDrums)
+        {
+            if (isXGDrums(msb))
+            {
+                return msb;
+            }
+            else
+            {
+                return 128;
+            }
+        }
+        else
+        {
+            // check for SFX
+            if (isValidXGMSB(msb))
+            {
+                return msb;
+            }
+            // if lsb is 0 and msb is not, use that
+            if (lsb === 0 && msb !== 0)
+            {
+                return msb;
+            }
+            if (!isValidXGMSB(lsb))
+            {
+                return lsb;
+            }
+            return 0;
+        }
+    }
+    else
+    {
+        return isDrums ? 128 : msb;
+    }
+}
+
+/**
+ * @param system {SynthSystem}
+ * @returns boolean
+ */
+export function isSystemXG(system)
+{
+    return system === "gm2" || system === "xg";
+}

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,10 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
-      <option name="processCode" value="true" />
-      <option name="processLiterals" value="true" />
-      <option name="processComments" value="true" />
-    </inspection_tool>
-  </profile>
-</component>

package/.idea/jsLibraryMappings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptLibraryMappings">
-    <includedPredefinedLibrary name="Node.js Core" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/spessasynth_core.iml" filepath="$PROJECT_DIR$/.idea/spessasynth_core.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/spessasynth_core.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

package/spessasynth_core/midi_parser/README.md

@@ -1,3 +0,0 @@
-## 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.

package/spessasynth_core/midi_parser/midi_loader.js

@@ -1,386 +0,0 @@
-import { dataBytesAmount, getChannel, messageTypes, MidiMessage } from './midi_message.js'
-import {ShiftableByteArray} from "../utils/shiftable_array.js";
-import {
-    readByte,
-    readBytesAsString,
-    readBytesAsUintBigEndian,
-    readVariableLengthQuantity
-} from "../utils/byte_functions.js";
-import { arrayToHexString, consoleColors, formatTitle } from '../utils/other.js'
-import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.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.
- */
-export class MIDI{
-    /**
-     * Parses a given midi file
-     * @param arrayBuffer {Buffer}
-     * @param fileName {string} optional, replaces the decoded title if empty
-     */
-    constructor(arrayBuffer, fileName="") {
-        SpessaSynthGroupCollapsed(`%cParsing MIDI File...`, consoleColors.info);
-
-        const fileByteArray = new ShiftableByteArray(arrayBuffer);
-        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
-        const format = readBytesAsUintBigEndian(headerChunk.data, 2);
-        // tracks count
-        this.tracksAmount = readBytesAsUintBigEndian(headerChunk.data, 2);
-        // time division
-        this.timeDivision = readBytesAsUintBigEndian(headerChunk.data, 2);
-
-        const decoder = new TextDecoder('shift-jis');
-
-        // read the copyright
-        this.copyright = "";
-
-        /**
-         * Contains all the tempo changes in the file. (Ordered from last to first)
-         * @type {{
-         *     ticks: number,
-         *     tempo: number
-         * }[]}
-         */
-        this.tempoChanges = [{ticks: 0, tempo: 120}];
-
-        let loopStart = null;
-        let loopEnd = null;
-
-        this.lastVoiceEventTick = 0;
-
-        /**
-         * Midi port numbers for each tracks
-         * @type {number[]}
-         */
-        this.midiPorts = [];
-
-        /**
-         * Read all the tracks
-         * @type {MidiMessage[][]}
-         */
-        this.tracks = [];
-        for(let i = 0; i < this.tracksAmount; i++)
-        {
-            /**
-             * @type {MidiMessage[]}
-             */
-            const track = [];
-            const trackChunk = this.readMIDIChunk(fileByteArray);
-            this.midiPorts.push(0)
-
-            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(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 if(!runningByte && 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, just use that
-                    statusByte = readByte(trackChunk.data);
-                }
-                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 = readByte(trackChunk.data);
-                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
-                        break;
-                    case -3:
-                        // sysex
-                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
-                        break;
-                    default:
-                        // voice message
-                        // get the midi message length
-                        if(totalTicks > this.lastVoiceEventTick)
-                        {
-                            this.lastVoiceEventTick = totalTicks;
-                        }
-                        eventDataLength = dataBytesAmount[statusByte >> 4];
-                        break;
-                }
-
-                // put the event data into the array
-                const eventData = new ShiftableByteArray(eventDataLength);
-                const messageData = trackChunk.data.slice(trackChunk.data.currentIndex, trackChunk.data.currentIndex + eventDataLength);
-                trackChunk.data.currentIndex += eventDataLength;
-                eventData.set(messageData, 0);
-
-                runningByte = statusByte;
-
-                const message = new MidiMessage(totalTicks, statusByte, eventData);
-                track.push(message);
-
-                // check for tempo change
-                if(statusByte === messageTypes.setTempo)
-                {
-                    this.tempoChanges.push({
-                        ticks: totalTicks,
-                        tempo: 60000000 / readBytesAsUintBigEndian(messageData, 3)
-                    });
-                }
-                else
-                // check for loop start (Marker "start")
-
-                if(statusByte === messageTypes.marker)
-                {
-                    const text = readBytesAsString(eventData, eventData.length).trim().toLowerCase();
-                    switch (text)
-                    {
-                        default:
-                            break;
-
-                        case "start":
-                        case "loopstart":
-                            loopStart = totalTicks;
-                            break;
-
-                        case "loopend":
-                            loopEnd = totalTicks;
-                    }
-                    eventData.currentIndex = 0;
-
-                }
-                else
-                // check for loop (CC 2/4)
-                if((statusByte & 0xF0) === messageTypes.controllerChange)
-                {
-                    switch(eventData[0])
-                    {
-                        case 2:
-                        case 116:
-                            loopStart = totalTicks;
-                            break;
-
-                        case 4:
-                        case 117:
-                            if(loopEnd === null)
-                            {
-                                loopEnd = totalTicks;
-                            }
-                            else
-                            {
-                                // this controller has occured more than once, this means that it doesn't indicate the loop
-                                loopEnd = 0;
-                            }
-                            break;
-                    }
-                }
-                else
-                // check for midi port
-                if(statusByte === messageTypes.midiPort)
-                {
-                    this.midiPorts[i] = eventData[0];
-                }
-                else
-                // check for copyright
-                if(statusByte === messageTypes.copyright)
-                {
-                    this.copyright += decoder.decode(eventData) + "\n";
-                }
-
-                // check for embedded copyright (roland SC display sysex) http://www.bandtrax.com.au/sysex.htm
-                if(statusByte === messageTypes.systemExclusive)
-                {
-                    // header goes like this: 41 10 45 12 10 00 00
-                    if(arrayToHexString(messageData.slice(0, 7)).trim() === "41 10 45 12 10 00 00")
-                    {
-                        const decoded = decoder.decode(messageData.slice(7, messageData.length - 3)) + "\n";
-                        this.copyright += decoded;
-                        SpessaSynthInfo(`%cDecoded Roland SC message! %c${decoded}`,
-                            consoleColors.recognized,
-                            consoleColors.value)
-                    }
-                }
-            }
-            this.tracks.push(track);
-            SpessaSynthInfo(`%cParsed %c${this.tracks.length}%c / %c${this.tracksAmount}`,
-                consoleColors.info,
-                consoleColors.value,
-                consoleColors.info,
-                consoleColors.value);
-        }
-
-        //this.lastVoiceEventTick = Math.max(...this.tracks.map(track =>
-        //track[track.length - 1].ticks));
-        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(`%cMIDI file parsed. Total tick time: %c${this.lastVoiceEventTick}`,
-            consoleColors.info,
-            consoleColors.recognized);
-        SpessaSynthGroupEnd();
-        
-        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};
-
-        // get track name
-        this.midiName = "";
-
-        // midi name
-        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.systemExclusive
-            ) === undefined)
-            {
-                let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
-                if(name)
-                {
-                    this.midiName = decoder.decode(name.messageData);
-                }
-            }
-        }
-        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.midiName = decoder.decode(name.messageData);
-            }
-        }
-
-        this.fileName = fileName;
-
-        // if midiName is "", use the file name
-        if(this.midiName.trim().length === 0 && fileName.length > 0)
-        {
-            this.midiName = formatTitle(fileName);
-        }
-
-        // reverse the tempo changes
-        this.tempoChanges.reverse();
-
-        /**
-         * The total playback time, in seconds
-         * @type {number}
-         */
-        this.duration = this._ticksToSeconds(this.lastVoiceEventTick);
-    }
-
-    /**
-     * @param fileByteArray {ShiftableByteArray}
-     * @returns {{type: string, size: number, data: ShiftableByteArray}}
-     */
-    readMIDIChunk(fileByteArray)
-    {
-        const chunk = {};
-        // type
-        chunk.type = readBytesAsString(fileByteArray, 4);
-        // size
-        chunk.size = readBytesAsUintBigEndian(fileByteArray, 4);
-        // data
-        chunk.data = new ShiftableByteArray(chunk.size);
-        const dataSlice = fileByteArray.slice(fileByteArray.currentIndex, fileByteArray.currentIndex + chunk.size);
-        chunk.data.set(dataSlice, 0);
-        fileByteArray.currentIndex += chunk.size;
-        return chunk;
-    }
-
-
-    /**
-     * Coverts ticks to time in seconds
-     * @param ticks {number}
-     * @returns {number}
-     * @private
-     */
-    _ticksToSeconds(ticks)
-    {
-        if (ticks <= 0) {
-            return 0;
-        }
-
-        // find the last tempo change that has occured
-        let tempo = this.tempoChanges.find(v => v.ticks < ticks);
-
-        let timeSinceLastTempo = ticks - tempo.ticks;
-        return this._ticksToSeconds(ticks - timeSinceLastTempo) + (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
-    }
-}