spessasynth_core 1.1.2 → 1.1.4

package/src/soundfont/dls/read_samples.js

@@ -0,0 +1,270 @@
+import { findRIFFListType, readRIFFChunk } from "../basic_soundfont/riff_chunk.js";
+import { readBytesAsString } from "../../utils/byte_functions/string.js";
+import {
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+    SpessaSynthWarn
+} from "../../utils/loggin.js";
+import { consoleColors } from "../../utils/other.js";
+import { readLittleEndian, signedInt16 } from "../../utils/byte_functions/little_endian.js";
+import { DLSSample } from "./dls_sample.js";
+
+const W_FORMAT_TAG = {
+    PCM: 0x01,
+    ALAW: 0x6
+};
+
+/**
+ * @param dataChunk {RiffChunk}
+ * @param bytesPerSample {number}
+ * @returns {Float32Array}
+ */
+function readPCM(dataChunk, bytesPerSample)
+{
+    const maxSampleValue = Math.pow(2, bytesPerSample * 8 - 1); // Max value for the sample
+    const maxUnsigned = Math.pow(2, bytesPerSample * 8);
+    
+    let normalizationFactor;
+    let isUnsigned = false;
+    
+    if (bytesPerSample === 1)
+    {
+        normalizationFactor = 255; // For 8-bit normalize from 0-255
+        isUnsigned = true;
+    }
+    else
+    {
+        normalizationFactor = maxSampleValue; // For 16-bit normalize from -32,768 to 32,767
+    }
+    const sampleLength = dataChunk.size / bytesPerSample;
+    const sampleData = new Float32Array(sampleLength);
+    for (let i = 0; i < sampleData.length; i++)
+    {
+        // read
+        let sample = readLittleEndian(dataChunk.chunkData, bytesPerSample);
+        // turn into signed
+        if (isUnsigned)
+        {
+            // normalize unsigned 8-bit sample
+            sampleData[i] = (sample / normalizationFactor) - 0.5;
+        }
+        else
+        {
+            // normalize signed 16-bit sample
+            if (sample >= maxSampleValue)
+            {
+                sample -= maxUnsigned;
+            }
+            sampleData[i] = sample / normalizationFactor;
+        }
+    }
+    return sampleData;
+}
+
+/**
+ * @param dataChunk {RiffChunk}
+ * @param bytesPerSample {number}
+ * @returns {Float32Array}
+ */
+function readALAW(dataChunk, bytesPerSample)
+{
+    const sampleLength = dataChunk.size / bytesPerSample;
+    const sampleData = new Float32Array(sampleLength);
+    for (let i = 0; i < sampleData.length; i++)
+    {
+        // read
+        const input = readLittleEndian(dataChunk.chunkData, bytesPerSample);
+        
+        // https://en.wikipedia.org/wiki/G.711#A-law
+        // re-toggle toggled bits
+        let sample = input ^ 0x55;
+        
+        // remove sign bit
+        sample &= 0x7F;
+        
+        // extract exponent
+        let exponent = sample >> 4;
+        // extract mantissa
+        let mantissa = sample & 0xF;
+        if (exponent > 0)
+        {
+            mantissa += 16; // add leading '1', if exponent > 0
+        }
+        
+        mantissa = (mantissa << 4) + 0x8;
+        if (exponent > 1)
+        {
+            mantissa = mantissa << (exponent - 1);
+        }
+        
+        const s16sample = input > 127 ? mantissa : -mantissa;
+        
+        // convert to float
+        sampleData[i] = s16sample / 32678;
+    }
+    return sampleData;
+}
+
+/**
+ * @this {DLSSoundFont}
+ * @param waveListChunk {RiffChunk}
+ */
+export function readDLSSamples(waveListChunk)
+{
+    SpessaSynthGroupCollapsed(
+        "%cLoading Wave samples...",
+        consoleColors.recognized
+    );
+    let sampleID = 0;
+    while (waveListChunk.chunkData.currentIndex < waveListChunk.chunkData.length)
+    {
+        const waveChunk = readRIFFChunk(waveListChunk.chunkData);
+        this.verifyHeader(waveChunk, "LIST");
+        this.verifyText(readBytesAsString(waveChunk.chunkData, 4), "wave");
+        
+        /**
+         * @type {RiffChunk[]}
+         */
+        const waveChunks = [];
+        while (waveChunk.chunkData.currentIndex < waveChunk.chunkData.length)
+        {
+            waveChunks.push(readRIFFChunk(waveChunk.chunkData));
+        }
+        
+        const fmtChunk = waveChunks.find(c => c.header === "fmt ");
+        if (!fmtChunk)
+        {
+            throw new Error("No fmt chunk in the wave file!");
+        }
+        // https://github.com/tpn/winsdk-10/blob/9b69fd26ac0c7d0b83d378dba01080e93349c2ed/Include/10.0.14393.0/shared/mmreg.h#L2108
+        const waveFormat = readLittleEndian(fmtChunk.chunkData, 2);
+        const channelsAmount = readLittleEndian(fmtChunk.chunkData, 2);
+        if (channelsAmount !== 1)
+        {
+            throw new Error(`Only mono samples are supported. Fmt reports ${channelsAmount} channels`);
+        }
+        const sampleRate = readLittleEndian(fmtChunk.chunkData, 4);
+        // skip avg bytes
+        readLittleEndian(fmtChunk.chunkData, 4);
+        // blockAlign
+        readLittleEndian(fmtChunk.chunkData, 2);
+        // it's bits per sample because one channel
+        const wBitsPerSample = readLittleEndian(fmtChunk.chunkData, 2);
+        const bytesPerSample = wBitsPerSample / 8;
+        
+        // read the data
+        let failed = false;
+        const dataChunk = waveChunks.find(c => c.header === "data");
+        if (!dataChunk)
+        {
+            this.parsingError("No data chunk in the WAVE chunk!");
+        }
+        let sampleData;
+        switch (waveFormat)
+        {
+            default:
+                failed = true;
+                sampleData = new Float32Array(dataChunk.size / bytesPerSample);
+                break;
+            
+            case W_FORMAT_TAG.PCM:
+                sampleData = readPCM(dataChunk, bytesPerSample);
+                break;
+            
+            case W_FORMAT_TAG.ALAW:
+                sampleData = readALAW(dataChunk, bytesPerSample);
+                break;
+            
+        }
+        
+        // read sample name
+        const waveInfo = findRIFFListType(waveChunks, "INFO");
+        let sampleName = `Unnamed ${sampleID}`;
+        if (waveInfo)
+        {
+            let infoChunk = readRIFFChunk(waveInfo.chunkData);
+            while (infoChunk.header !== "INAM" && waveInfo.chunkData.currentIndex < waveInfo.chunkData.length)
+            {
+                infoChunk = readRIFFChunk(waveInfo.chunkData);
+            }
+            if (infoChunk.header === "INAM")
+            {
+                sampleName = readBytesAsString(infoChunk.chunkData, infoChunk.size).trim();
+            }
+        }
+        
+        // correct defaults
+        let sampleKey = 60;
+        let samplePitch = 0;
+        let sampleLoopStart = 0;
+        let sampleLoopEnd = sampleData.length - 1;
+        let sampleDbAttenuation = 0;
+        
+        // read wsmp
+        const wsmpChunk = waveChunks.find(c => c.header === "wsmp");
+        if (wsmpChunk)
+        {
+            // skip cbsize
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            sampleKey = readLittleEndian(wsmpChunk.chunkData, 2);
+            // section 1.14.2: Each relative pitch unit represents 1/65536 cents.
+            // but that doesn't seem true for this one: it's just cents.
+            samplePitch = signedInt16(
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++],
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++]
+            );
+            
+            // pitch correction: convert hundreds to the root key
+            const samplePitchSemitones = Math.trunc(samplePitch / 100);
+            sampleKey += samplePitchSemitones;
+            samplePitch -= samplePitchSemitones * 100;
+            
+            
+            // gain is applied it manually here (literally multiplying the samples)
+            const gainCorrection = readLittleEndian(wsmpChunk.chunkData, 4);
+            // convert to signed and turn into decibels
+            sampleDbAttenuation = (gainCorrection | 0) / -655360;
+            // no idea about ful options
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            const loopsAmount = readLittleEndian(wsmpChunk.chunkData, 4);
+            if (loopsAmount === 1)
+            {
+                // skip size and type
+                readLittleEndian(wsmpChunk.chunkData, 8);
+                sampleLoopStart = readLittleEndian(wsmpChunk.chunkData, 4);
+                const loopSize = readLittleEndian(wsmpChunk.chunkData, 4);
+                sampleLoopEnd = sampleLoopStart + loopSize;
+            }
+        }
+        else
+        {
+            SpessaSynthWarn("No wsmp chunk in wave... using sane defaults.");
+        }
+        
+        if (failed)
+        {
+            console.error(`Failed to load '${sampleName}': Unsupported format: (${waveFormat})`);
+        }
+        
+        this.samples.push(new DLSSample(
+            sampleName,
+            sampleRate,
+            sampleKey,
+            samplePitch,
+            sampleLoopStart,
+            sampleLoopEnd,
+            sampleData,
+            sampleDbAttenuation
+        ));
+        
+        
+        sampleID++;
+        SpessaSynthInfo(
+            `%cLoaded sample %c${sampleName}`,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    SpessaSynthGroupEnd();
+}

package/src/soundfont/load_soundfont.js

@@ -0,0 +1,21 @@
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { readBytesAsString } from "../utils/byte_functions/string.js";
+import { DLSSoundFont } from "./dls/dls_soundfont.js";
+import { SoundFont2 } from "./read_sf2/soundfont.js";
+
+/**
+ * Loads a soundfont file
+ * @param buffer {ArrayBuffer}
+ * @returns {BasicSoundBank}
+ */
+export function loadSoundFont(buffer)
+{
+    const check = buffer.slice(8, 12);
+    const a = new IndexedByteArray(check);
+    const id = readBytesAsString(a, 4, undefined, false).toLowerCase();
+    if (id === "dls ")
+    {
+        return new DLSSoundFont(buffer);
+    }
+    return new SoundFont2(buffer, false);
+}

package/src/soundfont/read_sf2/generators.js

@@ -0,0 +1,46 @@
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { signedInt16 } from "../../utils/byte_functions/little_endian.js";
+import { Generator } from "../basic_soundfont/generator.js";
+
+
+export class ReadGenerator extends Generator
+{
+    /**
+     * Creates a generator
+     * @param dataArray {IndexedByteArray}
+     */
+    constructor(dataArray)
+    {
+        super();
+        // 4 bytes:
+        // type, type, type, value
+        const i = dataArray.currentIndex;
+        /**
+         * @type {generatorTypes|number}
+         */
+        this.generatorType = (dataArray[i + 1] << 8) | dataArray[i];
+        this.generatorValue = signedInt16(dataArray[i + 2], dataArray[i + 3]);
+        dataArray.currentIndex += 4;
+    }
+}
+
+/**
+ * Reads the generator read
+ * @param generatorChunk {RiffChunk}
+ * @returns {Generator[]}
+ */
+export function readGenerators(generatorChunk)
+{
+    let gens = [];
+    while (generatorChunk.chunkData.length > generatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new ReadGenerator(generatorChunk.chunkData));
+    }
+    if (gens.length > 1)
+    {
+        // remove terminal
+        gens.pop();
+    }
+    return gens;
+}

package/{spessasynth_core/soundfont/chunk → src/soundfont/read_sf2}/instruments.js

@@ -1,27 +1,28 @@
-import {RiffChunk} from "./riff_chunk.js";
-import {InstrumentZone} from "./zones.js";
-import {readBytesAsString, readBytesAsUintLittleEndian} from "../../utils/byte_functions.js";
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { InstrumentZone } from "./zones.js";
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { readBytesAsString } from "../../utils/byte_functions/string.js";
+import { BasicInstrument } from "../basic_soundfont/basic_instrument.js";
 
 /**
  * instrument.js
  * purpose: parses soundfont instrument and stores them as a class
  */
 
-export class Instrument{
+export class Instrument extends BasicInstrument
+{
     /**
      * Creates an instrument
      * @param instrumentChunk {RiffChunk}
      */
-    constructor(instrumentChunk) {
+    constructor(instrumentChunk)
+    {
+        super();
         this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
-        this.instrumentZoneIndex = readBytesAsUintLittleEndian(instrumentChunk.chunkData, 2);
+        this.instrumentZoneIndex = readLittleEndian(instrumentChunk.chunkData, 2);
         this.instrumentZonesAmount = 0;
-        /**
-         * @type {InstrumentZone[]}
-         */
-        this.instrumentZones = [];
     }
-
+    
     /**
      * Loads all the instrument zones, given the amount
      * @param amount {number}
@@ -30,7 +31,7 @@ export class Instrument{
     getInstrumentZones(amount, zones)
     {
         this.instrumentZonesAmount = amount;
-        for(let i = this.instrumentZoneIndex; i < this.instrumentZonesAmount + this.instrumentZoneIndex; i++)
+        for (let i = this.instrumentZoneIndex; i < this.instrumentZonesAmount + this.instrumentZoneIndex; i++)
         {
             this.instrumentZones.push(zones[i]);
         }
@@ -46,15 +47,20 @@ export class Instrument{
 export function readInstruments(instrumentChunk, instrumentZones)
 {
     let instruments = [];
-    while(instrumentChunk.chunkData.length > instrumentChunk.chunkData.currentIndex)
+    while (instrumentChunk.chunkData.length > instrumentChunk.chunkData.currentIndex)
     {
         let instrument = new Instrument(instrumentChunk);
-        if(instruments.length > 0)
+        if (instruments.length > 0)
         {
             let instrumentsAmount = instrument.instrumentZoneIndex - instruments[instruments.length - 1].instrumentZoneIndex;
             instruments[instruments.length - 1].getInstrumentZones(instrumentsAmount, instrumentZones);
         }
         instruments.push(instrument);
     }
+    if (instruments.length > 1)
+    {
+        // remove EOI
+        instruments.pop();
+    }
     return instruments;
 }

package/src/soundfont/read_sf2/modulators.js

@@ -0,0 +1,36 @@
+import { readLittleEndian, signedInt16 } from "../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { Modulator } from "../basic_soundfont/modulator.js";
+
+
+export class ReadModulator extends Modulator
+{
+    /**
+     * Creates a modulator
+     * @param dataArray {IndexedByteArray}
+     */
+    constructor(dataArray)
+    {
+        const srcEnum = readLittleEndian(dataArray, 2);
+        const destination = readLittleEndian(dataArray, 2);
+        const amount = signedInt16(dataArray[dataArray.currentIndex++], dataArray[dataArray.currentIndex++]);
+        const secSrcEnum = readLittleEndian(dataArray, 2);
+        const transformType = readLittleEndian(dataArray, 2);
+        super(srcEnum, secSrcEnum, destination, amount, transformType);
+    }
+}
+
+/**
+ * Reads the modulator read
+ * @param modulatorChunk {RiffChunk}
+ * @returns {Modulator[]}
+ */
+export function readModulators(modulatorChunk)
+{
+    let gens = [];
+    while (modulatorChunk.chunkData.length > modulatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new ReadModulator(modulatorChunk.chunkData));
+    }
+    return gens;
+}

package/src/soundfont/read_sf2/presets.js

@@ -0,0 +1,80 @@
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { PresetZone } from "./zones.js";
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { readBytesAsString } from "../../utils/byte_functions/string.js";
+import { BasicPreset } from "../basic_soundfont/basic_preset.js";
+
+/**
+ * parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
+ */
+
+export class Preset extends BasicPreset
+{
+    /**
+     * Creates a preset
+     * @param presetChunk {RiffChunk}
+     * @param sf2 {BasicSoundBank}
+     */
+    constructor(presetChunk, sf2)
+    {
+        super(sf2);
+        this.presetName = readBytesAsString(presetChunk.chunkData, 20)
+            .trim()
+            .replace(/\d{3}:\d{3}/, ""); // remove those pesky "000:001"
+        
+        this.program = readLittleEndian(presetChunk.chunkData, 2);
+        this.bank = readLittleEndian(presetChunk.chunkData, 2);
+        this.presetZoneStartIndex = readLittleEndian(presetChunk.chunkData, 2);
+        
+        // read the dword
+        this.library = readLittleEndian(presetChunk.chunkData, 4);
+        this.genre = readLittleEndian(presetChunk.chunkData, 4);
+        this.morphology = readLittleEndian(presetChunk.chunkData, 4);
+        this.presetZonesAmount = 0;
+    }
+    
+    /**
+     * Loads all the preset zones, given the amount
+     * @param amount {number}
+     * @param zones {PresetZone[]}
+     */
+    getPresetZones(amount, zones)
+    {
+        this.presetZonesAmount = amount;
+        for (let i = this.presetZoneStartIndex; i < this.presetZonesAmount + this.presetZoneStartIndex; i++)
+        {
+            this.presetZones.push(zones[i]);
+        }
+    }
+}
+
+/**
+ * Reads the presets
+ * @param presetChunk {RiffChunk}
+ * @param presetZones {PresetZone[]}
+ * @param sf2 {BasicSoundBank}
+ * @returns {Preset[]}
+ */
+export function readPresets(presetChunk, presetZones, sf2)
+{
+    /**
+     * @type {Preset[]}
+     */
+    let presets = [];
+    while (presetChunk.chunkData.length > presetChunk.chunkData.currentIndex)
+    {
+        let preset = new Preset(presetChunk, sf2);
+        if (presets.length > 0)
+        {
+            let presetZonesAmount = preset.presetZoneStartIndex - presets[presets.length - 1].presetZoneStartIndex;
+            presets[presets.length - 1].getPresetZones(presetZonesAmount, presetZones);
+        }
+        presets.push(preset);
+    }
+    // remove EOP
+    if (presets.length > 1)
+    {
+        presets.pop();
+    }
+    return presets;
+}