spessasynth_core 1.1.3 → 1.1.5

package/src/utils/byte_functions/string.js

@@ -0,0 +1,107 @@
+import { IndexedByteArray } from "../indexed_array.js";
+
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param bytes {number}
+ * @param encoding {string} the textElement encoding
+ * @param trimEnd {boolean} if we should trim once we reach an invalid byte
+ * @returns {string}
+ */
+export function readBytesAsString(dataArray, bytes, encoding = undefined, trimEnd = true)
+{
+    if (!encoding)
+    {
+        let finished = false;
+        let string = "";
+        for (let i = 0; i < bytes; i++)
+        {
+            let byte = dataArray[dataArray.currentIndex++];
+            if (finished)
+            {
+                continue;
+            }
+            if ((byte < 32 || byte > 127) && byte !== 10) // 10 is "\n"
+            {
+                if (trimEnd)
+                {
+                    finished = true;
+                    continue;
+                }
+                else
+                {
+                    if (byte === 0)
+                    {
+                        finished = true;
+                        continue;
+                    }
+                }
+            }
+            string += String.fromCharCode(byte);
+        }
+        return string;
+    }
+    else
+    {
+        let byteBuffer = dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + bytes);
+        dataArray.currentIndex += bytes;
+        let decoder = new TextDecoder(encoding.replace(/[^\x20-\x7E]/g, ""));
+        return decoder.decode(byteBuffer.buffer);
+    }
+}
+
+/**
+ * @param string {string}
+ * @param padLength {number}
+ * @returns {IndexedByteArray}
+ */
+export function getStringBytes(string, padLength = 0)
+{
+    let len = string.length;
+    if (padLength > 0)
+    {
+        len = padLength;
+    }
+    const arr = new IndexedByteArray(len);
+    writeStringAsBytes(arr, string, padLength);
+    return arr;
+}
+
+/**
+ * @param string {string}
+ * @returns {IndexedByteArray}
+ */
+export function getStringBytesZero(string)
+{
+    return getStringBytes(string, string.length + 1);
+}
+
+/**
+ * @param string {string}
+ * @param outArray {IndexedByteArray}
+ * @param padLength {number}
+ * @returns {IndexedByteArray} modified IN PLACE
+ */
+export function writeStringAsBytes(outArray, string, padLength = 0)
+{
+    if (padLength > 0)
+    {
+        if (string.length > padLength)
+        {
+            string = string.slice(0, padLength);
+        }
+    }
+    for (let i = 0; i < string.length; i++)
+    {
+        outArray[outArray.currentIndex++] = string.charCodeAt(i);
+    }
+    
+    // pad with zeros if needed
+    if (padLength > string.length)
+    {
+        for (let i = 0; i < padLength - string.length; i++)
+        {
+            outArray[outArray.currentIndex++] = 0;
+        }
+    }
+    return outArray;
+}

package/src/utils/byte_functions/variable_length_quantity.js

@@ -0,0 +1,42 @@
+/**
+ * Reads VLQ From a MIDI byte array
+ * @param MIDIbyteArray {IndexedByteArray}
+ * @returns {number}
+ */
+export function readVariableLengthQuantity(MIDIbyteArray)
+{
+    let out = 0;
+    while (MIDIbyteArray)
+    {
+        const byte = MIDIbyteArray[MIDIbyteArray.currentIndex++];
+        // extract the first 7 bytes
+        out = (out << 7) | (byte & 127);
+        
+        // if the last byte isn't 1, stop reading
+        if ((byte >> 7) !== 1)
+        {
+            break;
+        }
+    }
+    return out;
+}
+
+/**
+ * Write a VLQ from a number to a byte array
+ * @param number {number}
+ * @returns {number[]}
+ */
+export function writeVariableLengthQuantity(number)
+{
+    // Add the first byte
+    let bytes = [number & 127];
+    number >>= 7;
+    
+    // Continue processing the remaining bytes
+    while (number > 0)
+    {
+        bytes.unshift((number & 127) | 128);
+        number >>= 7;
+    }
+    return bytes;
+}

package/src/utils/fill_with_defaults.js

@@ -0,0 +1,21 @@
+/**
+ * Fills the object with default values
+ * @param obj {Object}
+ * @param defObj {Object}
+ * @returns {Object}
+ */
+export function fillWithDefaults(obj, defObj)
+{
+    if (obj === undefined)
+    {
+        obj = {};
+    }
+    for (const key in defObj)
+    {
+        if (defObj.hasOwnProperty(key) && !(key in obj))
+        {
+            obj[key] = defObj[key];
+        }
+    }
+    return obj;
+}

package/src/utils/indexed_array.js

@@ -0,0 +1,52 @@
+/**
+ * indexed_array.js
+ * purpose: exteds Uint8Array with a currentIndex property
+ */
+
+export class IndexedByteArray extends Uint8Array
+{
+    /**
+     * The current index of the array
+     * @type {number}
+     */
+    currentIndex = 0;
+    
+    /**
+     * Creates a new instance of an Uint8Array with a currentIndex property
+     * @param args {any} same as for Uint8Array
+     */
+    constructor(args)
+    {
+        super(args);
+    }
+    
+    /**
+     * @param start {number?}
+     * @param end {number?}
+     * @returns {IndexedByteArray}
+     */
+    slice(start, end)
+    {
+        const a = super.slice(start, end);
+        a.currentIndex = 0;
+        return a;
+    }
+}
+
+
+/**
+ * @param arrs {(IndexedByteArray|Uint8Array)[]}
+ * @returns {IndexedByteArray|Uint8Array}
+ */
+export function combineArrays(arrs)
+{
+    const length = arrs.reduce((sum, current) => sum + current.length, 0);
+    const newArr = new IndexedByteArray(length);
+    let offset = 0;
+    for (const arr of arrs)
+    {
+        newArr.set(arr, offset);
+        offset += arr.length;
+    }
+    return newArr;
+}

package/{spessasynth_core → src}/utils/loggin.js

@@ -1,79 +1,71 @@
-let ENABLE_INFO = true;
-let ENABLE_WARN = true;
-let ENABLE_GROUP = true;
-let ENABLE_TABLE = true;
-
-/**
- * Enables or disables looging
- * @param enableInfo {boolean} - enables info
- * @param enableWarn {boolean} - enables warning
- * @param enableGroup {boolean} - enables groups
- * @param enableTable {boolean} - enables tables
- */
-export function SpessaSynthLogging(enableInfo, enableWarn, enableGroup, enableTable)
-{
-    ENABLE_INFO = enableInfo;
-    ENABLE_WARN = enableWarn;
-    ENABLE_GROUP = enableGroup;
-    ENABLE_TABLE = enableTable;
-}
-
-/**
- * @param message {...any}
- */
-export function SpessaSynthInfo(...message)
-{
-    if(ENABLE_INFO)
-    {
-        console.info(...message);
-    }
-}
-
-/**
- * @param message {...any}
- */
-export function SpessaSynthWarn(...message)
-{
-    if(ENABLE_WARN)
-    {
-        console.warn(...message);
-    }
-}
-
-export function SpessaSynthTable(...args)
-{
-    if(ENABLE_TABLE)
-    {
-        console.table(...args);
-    }
-}
-
-/**
- * @param message {...any} the message
- */
-export function SpessaSynthGroup(...message)
-{
-    if(ENABLE_GROUP)
-    {
-        console.group(...message);
-    }
-}
-
-/**
- * @param message {...any} the message
- */
-export function SpessaSynthGroupCollapsed(...message)
-{
-    if(ENABLE_GROUP)
-    {
-        console.groupCollapsed(...message);
-    }
-}
-
-export function SpessaSynthGroupEnd()
-{
-    if(ENABLE_GROUP)
-    {
-        console.groupEnd();
-    }
+let ENABLE_INFO = false;
+let ENABLE_WARN = true;
+let ENABLE_GROUP = false;
+let ENABLE_TABLE = true;
+
+/**
+ * Enables or disables looging
+ * @param enableInfo {boolean} - enables info
+ * @param enableWarn {boolean} - enables warning
+ * @param enableGroup {boolean} - enables groups
+ * @param enableTable {boolean} - enables tables
+ */
+export function SpessaSynthLogging(enableInfo, enableWarn, enableGroup, enableTable)
+{
+    ENABLE_INFO = enableInfo;
+    ENABLE_WARN = enableWarn;
+    ENABLE_GROUP = enableGroup;
+    ENABLE_TABLE = enableTable;
+}
+
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthInfo(...message)
+{
+    if (ENABLE_INFO)
+    {
+        console.info(...message);
+    }
+}
+
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthWarn(...message)
+{
+    if (ENABLE_WARN)
+    {
+        console.warn(...message);
+    }
+}
+
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroup(...message)
+{
+    if (ENABLE_GROUP)
+    {
+        console.group(...message);
+    }
+}
+
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroupCollapsed(...message)
+{
+    if (ENABLE_GROUP)
+    {
+        console.groupCollapsed(...message);
+    }
+}
+
+export function SpessaSynthGroupEnd()
+{
+    if (ENABLE_GROUP)
+    {
+        console.groupEnd();
+    }
 }

package/src/utils/other.js

@@ -0,0 +1,92 @@
+/**
+ * other.js
+ * purpose: contains some useful functions that don't belong in any specific category
+ */
+
+/**
+ * Formats the given seconds to nice readable time
+ * @param totalSeconds {number} time in seconds
+ * @return {{seconds: number, minutes: number, time: string}}
+ */
+export function formatTime(totalSeconds)
+{
+    totalSeconds = Math.floor(totalSeconds);
+    let minutes = Math.floor(totalSeconds / 60);
+    let seconds = Math.round(totalSeconds - (minutes * 60));
+    return {
+        "minutes": minutes,
+        "seconds": seconds,
+        "time": `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`
+    };
+}
+
+/**
+ * @param fileName {string}
+ * @returns {string}
+ */
+export function formatTitle(fileName)
+{
+    return fileName
+        .trim()
+        .replaceAll(".mid", "")
+        .replaceAll(".kar", "")
+        .replaceAll(".rmi", "")
+        .replaceAll(".xmf", "")
+        .replaceAll(".mxmf", "")
+        .replaceAll("_", " ")
+        .trim();
+}
+
+/**
+ * Does what it says
+ * @param arr {number[]|Uint8Array}
+ * @returns {string}
+ */
+export function arrayToHexString(arr)
+{
+    let hexString = "";
+    
+    for (let i = 0; i < arr.length; i++)
+    {
+        const hex = arr[i].toString(16).padStart(2, "0").toUpperCase();
+        hexString += hex;
+        hexString += " ";
+    }
+    
+    return hexString;
+}
+
+/**
+ * @param eventData {Uint8Array}
+ * @returns {Uint8Array}
+ */
+export function sanitizeKarLyrics(eventData)
+{
+    // for KAR files:
+    // https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
+    // "/" is the newline character
+    // "\" is also the newline character
+    // "\" ASCII code is 92
+    // "/" ASCII code is 47
+    // newline ASCII code is 10
+    const sanitized = [];
+    for (let byte of eventData)
+    {
+        if (byte === 47 || byte === 92)
+        {
+            byte = 10;
+        }
+        sanitized.push(byte);
+    }
+    return new Uint8Array(sanitized);
+}
+
+export const consoleColors = {
+    warn: "color: orange;",
+    unrecognized: "color: red;",
+    info: "color: aqua;",
+    recognized: "color: lime",
+    value: "color: yellow; background-color: black;"
+};
+
+

package/src/utils/sysex_detector.js

@@ -0,0 +1,58 @@
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isXGOn(e)
+{
+    return e.messageData[0] === 0x43 && // Yamaha
+        e.messageData[2] === 0x4C &&    // XG ON
+        e.messageData[5] === 0x7E &&
+        e.messageData[6] === 0x00;
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGSDrumsOn(e)
+{
+    return e.messageData[0] === 0x41 &&     // roland
+        e.messageData[2] === 0x42 &&        // GS
+        e.messageData[3] === 0x12 &&        // GS
+        e.messageData[4] === 0x40 &&        // system parameter
+        (e.messageData[5] & 0x10) !== 0 &&  // part parameter
+        e.messageData[6] === 0x15;          // drum pars
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGSOn(e)
+{
+    return e.messageData[0] === 0x41  // roland
+        && e.messageData[2] === 0x42  // GS
+        && e.messageData[6] === 0x7F; // Mode set
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGMOn(e)
+{
+    return e.messageData[0] === 0x7E  // non realtime
+        && e.messageData[2] === 0x09  // gm system
+        && e.messageData[3] === 0x01; // gm1
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGM2On(e)
+{
+    return e.messageData[0] === 0x7E  // non realtime
+        && e.messageData[2] === 0x09  // gm system
+        && e.messageData[3] === 0x03; // gm2
+}