spessoplayer 0.5.0

package/README.md

@@ -0,0 +1,29 @@
+# spessoplayer
+
+## Description
+
+This is a midi player/converter that uses the spessasynth_core package for maximum compatibility while also providing functionality
+
+## Installation
+
+```bash
+$ npm install --global spessoplayer
+```
+
+You'll be prompted if you want to install ffmpeg (convertion of files) and SoX (effects) using your current package manager,
+
+it is recommended to install both (they weigh *~10.2* MB combined)
+
+## Basic usage
+
+For printing to stdout:
+```bash
+$ spessoplayer midi.mid soundfont.sf2 -
+```
+
+For writing to file:
+```bash
+$ spessoplayer midi.mid soundfont.sf2 out.wav
+```
+
+for a more comprehensive look at all the options go to [COMMAND-LINE-OPTIONS](./COMMAND-LINE-OPTIONS.md)

package/audioBuffer.mjs

@@ -0,0 +1,284 @@
+/*
+  Copyright (C) 2025  unixatch
+
+    it under the terms of the GNU General Public License as published by
+    This program is free software: you can redistribute it and/or modify
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with spessoplayer.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import {
+  IndexedByteArray,
+  DEFAULT_WAV_WRITE_OPTIONS
+} from "spessasynth_core"
+// This section is identical to what's inside spessasynth_core but not being exported, that's why it's here
+function fillWithDefaults(obj, defObj) {
+  return {
+    ...defObj,
+    ...obj ?? {}
+  };
+}
+function writeBinaryStringIndexed(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);
+  }
+  if (padLength > string.length) {
+    for (let i = 0; i < padLength - string.length; i++) {
+      outArray[outArray.currentIndex++] = 0;
+    }
+  }
+  return outArray;
+}
+function writeLittleEndianIndexed(dataArray, number, byteTarget) {
+  for (let i = 0; i < byteTarget; i++) {
+    dataArray[dataArray.currentIndex++] = number >> i * 8 & 255;
+  }
+}
+function writeRIFFChunkParts(header, chunks, isList = false) {
+  let dataOffset = 8;
+  let headerWritten = header;
+  const dataLength = chunks.reduce((len, c) => c.length + len, 0);
+  let writtenSize = dataLength;
+  if (isList) {
+    dataOffset += 4;
+    writtenSize += 4;
+    headerWritten = "LIST";
+  }
+  let finalSize = dataOffset + dataLength;
+  if (finalSize % 2 !== 0) {
+    finalSize++;
+  }
+  const outArray = new IndexedByteArray(finalSize);
+  writeBinaryStringIndexed(outArray, headerWritten);
+  writeDword(outArray, writtenSize);
+  if (isList) {
+    writeBinaryStringIndexed(outArray, header);
+  }
+  chunks.forEach((c) => {
+    outArray.set(c, dataOffset);
+    dataOffset += c.length;
+  });
+  return outArray;
+}
+function writeRIFFChunkRaw(header, data, addZeroByte = false, isList = false) {
+  if (header.length !== 4) {
+    throw new Error(`Invalid header length: ${header}`);
+  }
+  let dataStartOffset = 8;
+  let headerWritten = header;
+  let dataLength = data.length;
+  if (addZeroByte) {
+    dataLength++;
+  }
+  let writtenSize = dataLength;
+  if (isList) {
+    dataStartOffset += 4;
+    writtenSize += 4;
+    headerWritten = "LIST";
+  }
+  let finalSize = dataStartOffset + dataLength;
+  if (finalSize % 2 !== 0) {
+    finalSize++;
+  }
+  const outArray = new IndexedByteArray(finalSize);
+  writeBinaryStringIndexed(outArray, headerWritten);
+  writeDword(outArray, writtenSize);
+  if (isList) {
+    writeBinaryStringIndexed(outArray, header);
+  }
+  outArray.set(data, dataStartOffset);
+  return outArray;
+}
+
+/**
+ * WAV Header Generator
+ * @param {Object} audioData - An object that contains infos about the audio
+ * @param {Number} audioData.length - Audio length in samples, essentially the sample count
+ * @param {Number} audioData.numChannels - How many channels the audio has
+ * @param {Number} sampleRate - Sample rate of the audio
+ * @param {Object} options - Optional, adds loop timestamps and more
+ * @returns {Uint8Array} the wav header
+ */
+function getWavHeader({ length, numChannels }, sampleRate, options = DEFAULT_WAV_WRITE_OPTIONS) {
+  const bytesPerSample = 2;
+  const fullOptions = fillWithDefaults(options, DEFAULT_WAV_WRITE_OPTIONS);
+  const loop = fullOptions.loop;
+  const metadata = fullOptions.metadata;
+  let infoChunk = new IndexedByteArray(0);
+  const infoOn = Object.keys(metadata).length > 0;
+  if (infoOn) {
+    const encoder = new TextEncoder();
+    const infoChunks = [
+      writeRIFFChunkRaw(
+        "ICMT",
+        encoder.encode("Created with SpessaSynth"),
+        true
+      )
+    ];
+    if (metadata.artist) {
+      infoChunks.push(
+        writeRIFFChunkRaw("IART", encoder.encode(metadata.artist), true)
+      );
+    }
+    if (metadata.album) {
+      infoChunks.push(
+        writeRIFFChunkRaw("IPRD", encoder.encode(metadata.album), true)
+      );
+    }
+    if (metadata.genre) {
+      infoChunks.push(
+        writeRIFFChunkRaw("IGNR", encoder.encode(metadata.genre), true)
+      );
+    }
+    if (metadata.title) {
+      infoChunks.push(
+        writeRIFFChunkRaw("INAM", encoder.encode(metadata.title), true)
+      );
+    }
+    infoChunk = writeRIFFChunkParts("INFO", infoChunks, true);
+  }
+  let cueChunk = new IndexedByteArray(0);
+  const cueOn = loop?.end !== undefined && loop?.start !== undefined;
+  if (cueOn) {
+    const loopStartSamples = Math.floor(loop.start * sampleRate);
+    const loopEndSamples = Math.floor(loop.end * sampleRate);
+    const cueStart = new IndexedByteArray(24);
+    writeLittleEndianIndexed(cueStart, 0, 4);
+    writeLittleEndianIndexed(cueStart, 0, 4);
+    writeBinaryStringIndexed(cueStart, "data");
+    writeLittleEndianIndexed(cueStart, 0, 4);
+    writeLittleEndianIndexed(cueStart, 0, 4);
+    writeLittleEndianIndexed(cueStart, loopStartSamples, 4);
+    const cueEnd = new IndexedByteArray(24);
+    writeLittleEndianIndexed(cueEnd, 1, 4);
+    writeLittleEndianIndexed(cueEnd, 0, 4);
+    writeBinaryStringIndexed(cueEnd, "data");
+    writeLittleEndianIndexed(cueEnd, 0, 4);
+    writeLittleEndianIndexed(cueEnd, 0, 4);
+    writeLittleEndianIndexed(cueEnd, loopEndSamples, 4);
+    cueChunk = writeRIFFChunkParts("cue ", [
+      new IndexedByteArray([2, 0, 0, 0]),
+      // Cue points count
+      cueStart,
+      cueEnd
+    ]);
+  }
+  const headerSize = 44;
+  const dataSize = length * numChannels * bytesPerSample;
+  const fileSize = headerSize + dataSize + infoChunk.length + cueChunk.length - 8;
+  const header = new Uint8Array(headerSize);
+  header.set([82, 73, 70, 70], 0);
+  header.set(
+    new Uint8Array([
+      fileSize & 255,
+      fileSize >> 8 & 255,
+      fileSize >> 16 & 255,
+      fileSize >> 24 & 255
+    ]),
+    4
+  );
+  header.set([87, 65, 86, 69], 8);
+  header.set([102, 109, 116, 32], 12);
+  header.set([16, 0, 0, 0], 16);
+  header.set([1, 0], 20);
+  header.set([numChannels & 255, numChannels >> 8], 22);
+  header.set(
+    new Uint8Array([
+      sampleRate & 255,
+      sampleRate >> 8 & 255,
+      sampleRate >> 16 & 255,
+      sampleRate >> 24 & 255
+    ]),
+    24
+  );
+  const byteRate = sampleRate * numChannels * bytesPerSample;
+  header.set(
+    new Uint8Array([
+      byteRate & 255,
+      byteRate >> 8 & 255,
+      byteRate >> 16 & 255,
+      byteRate >> 24 & 255
+    ]),
+    28
+  );
+  header.set([numChannels * bytesPerSample, 0], 32);
+  header.set([16, 0], 34);
+  header.set([100, 97, 116, 97], 36);
+  header.set(
+    new Uint8Array([
+      dataSize & 255,
+      dataSize >> 8 & 255,
+      dataSize >> 16 & 255,
+      dataSize >> 24 & 255
+    ]),
+    40
+  );
+  return header;
+}
+
+/**
+ * Translates to PCM data
+ * @param {Array} audioData - An array that contains the audio buffers
+ * @param {Number} sampleRate - Sample rate of the audio
+ * @param {Object} options - Optional, adds loop timestamps and more
+ * @returns {Uint8Array} the translated data
+ */
+function getData(audioData, sampleRate, options = DEFAULT_WAV_WRITE_OPTIONS) {
+  const length = audioData[0].length;
+  const numChannels = audioData.length;
+  const fullOptions = fillWithDefaults(options, DEFAULT_WAV_WRITE_OPTIONS);
+  const headerSize = 44;
+  const bytesPerSample = 2;
+
+  const dataSize = length * numChannels * bytesPerSample;
+  const fileSize = dataSize;
+  
+  const Data = new Uint8Array(fileSize);
+  let offset = 0;
+  // Volume
+  let multiplier = 32767;
+  /*if (fullOptions.normalizeAudio) {
+    const numSamples = audioData[0].length;
+    let maxAbsValue = 0;
+    for (let ch = 0; ch < numChannels; ch++) {
+      const data = audioData[ch];
+      
+      for (let i = 0; i < numSamples; i++) {
+        const sample = Math.abs(data[i]);
+        if (sample > maxAbsValue) {
+          maxAbsValue = sample;
+        }
+      }
+    }
+    multiplier = maxAbsValue > 0 
+      ? 32767 / maxAbsValue 
+      : 1;
+  }*/
+  for (let i = 0; i < length; i++) {
+    audioData.forEach((d) => {
+      const sample = Math.min(32767, Math.max(-32768, d[i] * multiplier));
+      Data[offset++] = sample & 255;
+      Data[offset++] = sample >> 8 & 255;
+    });
+  }
+  return Data;
+}
+
+
+export { 
+  getWavHeader,
+  getData
+}