spessasynth_lib 0.0.1

package/package/utils/byte_functions/string.js

@@ -0,0 +1,97 @@
+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)
+            {
+                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)
+        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}
+ * @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/package/utils/byte_functions/variable_length_quantity.js

@@ -0,0 +1,37 @@
+/**
+ * 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/package/utils/encode_vorbis.js

@@ -0,0 +1,30 @@
+import { libvorbis } from '../externals/libvorbis/OggVorbisEncoder.min.js'
+
+/**
+ * @typedef {function} EncodeVorbisFunction
+ * @param channelAudioData {Float32Array[]}
+ * @param sampleRate {number}
+ * @param channels {number}
+ * @param quality {number} -0.1 to 1
+ * @returns {Uint8Array}
+ */
+export function encodeVorbis(channelAudioData, channels,  sampleRate, quality)
+{
+    // https://github.com/higuma/ogg-vorbis-encoder-js
+    //libvorbis.init();
+    const encoder = new libvorbis.OggVorbisEncoder(sampleRate, channels, quality);
+    encoder.encode(channelAudioData);
+    /**
+     * @type {Uint8Array[]}
+     */
+    const arrs = encoder.finish();
+    const outLen = arrs.reduce((l, c) => l + c.length, 0);
+    const out = new Uint8Array(outLen);
+    let offset = 0;
+    for(const a of arrs)
+    {
+        out.set(a, offset);
+        offset += a.length;
+    }
+    return out;
+}

package/package/utils/indexed_array.js

@@ -0,0 +1,41 @@
+/**
+ * indexed_array.js
+ * purpose: exteds Uint8Array with a currentIndex property
+ */
+
+export class IndexedByteArray extends Uint8Array
+{
+    /**
+     * Creates a new instance of an Uint8Array with a currentIndex property
+     * @param args {any} same as for Uint8Array
+     */
+    constructor(args)
+    {
+        super(args);
+        this.currentIndex = 0;
+    }
+
+    /**
+     * The current index of the array
+     * @type {number}
+     */
+    currentIndex;
+}
+
+
+/**
+ * @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/package/utils/loggin.js

@@ -0,0 +1,79 @@
+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();
+    }
+}

package/package/utils/other.js

@@ -0,0 +1,54 @@
+/**
+ * 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(".rmi", "")
+        .replaceAll("_", " ");
+}
+
+/**
+ * Does what it says
+ * @param arr {number[]}
+ * @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;
+}
+
+export const consoleColors = {
+    warn: "color: orange;",
+    unrecognized: "color: red;",
+    info: "color: aqua;",
+    recognized: "color: lime",
+    value: "color: yellow; background-color: black;"
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "spessasynth_lib",
+  "version": "0.0.1",
+  "description": "No compromise SoundFont and MIDI library and player",
+  "browser": "index.js",
+  "types": "@types/index.d.ts",
+  "type": "module",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/spessasus/SpessaSynth.git"
+  },
+  "keywords": [
+    "soundfont",
+    "synthesizer",
+    "synth",
+    "sf2",
+    "sf3",
+    "midi",
+    "midi-player",
+    "web-audio-api",
+    "web-midi-api",
+    "player",
+    "soundfont2",
+    "soundfont3"
+  ],
+  "author": {
+    "name": "spessasus",
+    "email": "spesekspesek@gmail.com",
+    "url": "https://github.com/spessasus"
+  },
+  "license": "(MIT AND Apache-2.0)",
+  "bugs": {
+    "url": "https://github.com/spessasus/SpessaSynth/issues",
+    "email": "spesekspesek@gmail.com"
+  },
+  "homepage": "https://github.com/spessasus/SpessaSynth#readme"
+}