spessasynth_lib 3.22.7 → 3.22.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.22.7",
+  "version": "3.22.9",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/soundfont/basic_soundfont/generator.js

@@ -106,7 +106,7 @@ generatorLimits[generatorTypes.freqVibLFO] = { min: -16000, max: 4500, def: 0 };
 generatorLimits[generatorTypes.delayModEnv] = { min: -32768, max: 5000, def: -32768 }; // -32768 indicates instant phase, this is done to prevent click at the start of filter modenv
 generatorLimits[generatorTypes.attackModEnv] = { min: -32768, max: 8000, def: -32768 };
 generatorLimits[generatorTypes.holdModEnv] = { min: -12000, max: 5000, def: -12000 };
-generatorLimits[generatorTypes.decayModEnv] = { min: -7200, max: 8000, def: -12000 };   // min is set to -7200 to prevent lowpass clicks
+generatorLimits[generatorTypes.decayModEnv] = { min: -12000, max: 8000, def: -12000 };
 generatorLimits[generatorTypes.sustainModEnv] = { min: 0, max: 1000, def: 0 };
 generatorLimits[generatorTypes.releaseModEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 to prevent lowpass clicks
 // keynum to mod env

package/soundfont/dls/articulator_converter.js

@@ -4,6 +4,7 @@ import { midiControllers } from "../../midi_parser/midi_message.js";
 import { DLSDestinations } from "./dls_destinations.js";
 
 import { generatorTypes } from "../basic_soundfont/generator.js";
+import { consoleColors } from "../../utils/other.js";
 
 /**
  * @param source {number}
@@ -174,6 +175,48 @@ function checkForSpecialDLSCombo(source, destination)
     }
 }
 
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param value {number}
+ * @param transform {number}
+ */
+function modulatorConverterDebug(
+    source,
+    control,
+    destination,
+    value,
+    transform
+)
+{
+    const type = Object.keys(DLSDestinations).find(k => DLSDestinations[k] === destination);
+    const srcType = Object.keys(DLSSources).find(k => DLSSources[k] === source);
+    const ctrlType = Object.keys(DLSSources).find(k => DLSSources[k] === control);
+    const typeString = type ? type : destination.toString(16);
+    const srcString = srcType ? srcType : source.toString(16);
+    const ctrlString = ctrlType ? ctrlType : control.toString(16);
+    console.debug(
+        `%cAttempting to convert the following DLS Articulator to SF2 Modulator:
+        Source: %c${srcString}%c
+        Control: %c${ctrlString}%c
+        Destination: %c${typeString}%c
+        Amount: %c${value}%c
+        Transform: %c${transform}%c...`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info
+    );
+}
+
 /**
  * @param source {number}
  * @param control {number}
@@ -202,6 +245,7 @@ export function getSF2ModulatorFromArticulator(
     let sf2Source;
     let swapSources = false;
     let isSourceNoController = false;
+    let newValue = value;
     if (specialDestination === undefined)
     {
         // determine destination
@@ -217,7 +261,7 @@ export function getSF2ModulatorFromArticulator(
         destinationGenerator = sf2GenDestination;
         if (sf2GenDestination.newAmount !== undefined)
         {
-            value = sf2GenDestination.newAmount;
+            newValue = sf2GenDestination.newAmount;
             destinationGenerator = sf2GenDestination.gen;
         }
         sf2Source = getSF2SourceFromDLS(source);
@@ -263,10 +307,22 @@ export function getSF2ModulatorFromArticulator(
         }
         const sourceIsBipolar = (transform >> 14) & 1;
         let sourceIsNegative = (transform >> 15) & 1;
-        // special case: for attenuation, invert source
+        // special case: for attenuation, invert source (dls gain is the opposite of sf2 attenuation)
         if (destinationGenerator === generatorTypes.initialAttenuation)
         {
-            sourceIsNegative = !sourceIsNegative;
+            // modulatorConverterDebug(
+            //     source,
+            //     control,
+            //     destination,
+            //     value,
+            //     transform
+            // );
+            // invert only if the actual transform value is not negative.
+            // if it is, it's already inverted
+            if (value > 0)
+            {
+                sourceIsNegative = !sourceIsNegative;
+            }
         }
         sourceEnumFinal = getModSourceEnum(
             sourceTransform,
@@ -301,7 +357,7 @@ export function getSF2ModulatorFromArticulator(
         secSrcEnum: secSourceEnumFinal,
         dest: destinationGenerator,
         transform: 0x0,
-        amt: value
+        amt: newValue
     });
     
 }

package/soundfont/dls/read_articulation.js

@@ -7,47 +7,6 @@ import { consoleColors } from "../../utils/other.js";
 import { Generator, generatorTypes } from "../basic_soundfont/generator.js";
 import { Modulator } from "../basic_soundfont/modulator.js";
 
-/**
- * @param source {number}
- * @param control {number}
- * @param destination {number}
- * @param value {number}
- * @param transform {number}
- */
-function modulatorConverterDebug(
-    source,
-    control,
-    destination,
-    value,
-    transform
-)
-{
-    const type = Object.keys(DLSDestinations).find(k => DLSDestinations[k] === destination);
-    const srcType = Object.keys(DLSSources).find(k => DLSSources[k] === source);
-    const ctrlType = Object.keys(DLSSources).find(k => DLSSources[k] === control);
-    const typeString = type ? type : destination.toString(16);
-    const srcString = srcType ? srcType : source.toString(16);
-    const ctrlString = ctrlType ? ctrlType : control.toString(16);
-    SpessaSynthInfo(
-        `%cAttempting to convert the following DLS Articulator to SF2 Modulator:
-        Source: %c${srcString}%c
-        Control: %c${ctrlString}%c
-        Destination: %c${typeString}%c
-        Amount: %c${value}%c
-        Transform: %c${transform}%c...`,
-        consoleColors.info,
-        consoleColors.recognized,
-        consoleColors.info,
-        consoleColors.recognized,
-        consoleColors.info,
-        consoleColors.recognized,
-        consoleColors.info,
-        consoleColors.recognized,
-        consoleColors.info,
-        consoleColors.recognized,
-        consoleColors.info
-    );
-}
 
 /**
  * Reads the articulator chunk
@@ -80,7 +39,6 @@ export function readArticulation(chunk, disableVibrato)
         const scale = readLittleEndian(artData, 4) | 0;
         const value = scale >> 16; // convert it to 16 bit as soundfont uses that
         
-        // modulatorConverterDebug(source, control, destination, value, transform);
         // interpret this somehow...
         // if source and control are both zero, it's a generator
         if (source === 0 && control === 0 && transform === 0)

package/soundfont/dls/read_samples.js

@@ -10,6 +10,102 @@ 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 -32768 to 32767
+    }
+    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}
@@ -43,10 +139,6 @@ export function readDLSSamples(waveListChunk)
         }
         // https://github.com/tpn/winsdk-10/blob/9b69fd26ac0c7d0b83d378dba01080e93349c2ed/Include/10.0.14393.0/shared/mmreg.h#L2108
         const waveFormat = readLittleEndian(fmtChunk.chunkData, 2);
-        if (waveFormat !== 1)
-        {
-            throw new Error(`Only PCM format in WAVE is supported. Fmt reports ${waveFormat}`);
-        }
         const channelsAmount = readLittleEndian(fmtChunk.chunkData, 2);
         if (channelsAmount !== 1)
         {
@@ -61,48 +153,30 @@ export function readDLSSamples(waveListChunk)
         const wBitsPerSample = readLittleEndian(fmtChunk.chunkData, 2);
         const bytesPerSample = wBitsPerSample / 8;
         
-        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 (wBitsPerSample === 8)
-        {
-            normalizationFactor = 255; // For 8-bit normalize from 0-255
-            isUnsigned = true;
-        }
-        else
-        {
-            normalizationFactor = maxSampleValue; // For 16-bit normalize from -32768 to 32767
-        }
         // 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!");
         }
-        const sampleLength = dataChunk.size / bytesPerSample;
-        const sampleData = new Float32Array(sampleLength);
-        for (let i = 0; i < sampleData.length; i++)
+        let sampleData;
+        switch (waveFormat)
         {
-            // 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;
-            }
+            default:
+                failed = true;
+                sampleData = new Float32Array(dataChunk.size / bytesPerSample);
+                break;
+            //throw new Error(`Unsupported WAVE format. Fmt reports ${waveFormat}`);
+            
+            case W_FORMAT_TAG.PCM:
+                sampleData = readPCM(dataChunk, bytesPerSample);
+                break;
+            
+            case W_FORMAT_TAG.ALAW:
+                sampleData = readALAW(dataChunk, bytesPerSample);
+                break;
+            
         }
         
         // sane defaults
@@ -162,13 +236,18 @@ export function readDLSSamples(waveListChunk)
             }
         }
         
+        if (failed)
+        {
+            console.error(`Failed to load '${sampleName}': Unsupported format: (${waveFormat})`);
+        }
+        
         this.samples.push(new DLSSample(
             sampleName,
             sampleRate,
             sampleKey,
             samplePitch,
             sampleLoopStart,
-            sampleLength,
+            sampleData.length,
             sampleData,
             sampleDbAttenuation
         ));