spessasynth_core 3.26.23 → 3.26.25

package/index.js

@@ -19,7 +19,7 @@ import { SynthesizerSnapshot } from "./src/synthetizer/audio_engine/snapshot/syn
 import { ChannelSnapshot } from "./src/synthetizer/audio_engine/snapshot/channel_snapshot.js";
 
 import { BasicSoundBank } from "./src/soundfont/basic_soundfont/basic_soundbank.js";
-import { BasicSample } from "./src/soundfont/basic_soundfont/basic_sample.js";
+import { BasicSample, sampleTypes } from "./src/soundfont/basic_soundfont/basic_sample.js";
 import { BasicPresetZone } from "./src/soundfont/basic_soundfont/basic_preset_zone.js";
 import { BasicInstrument } from "./src/soundfont/basic_soundfont/basic_instrument.js";
 import { BasicPreset } from "./src/soundfont/basic_soundfont/basic_preset.js";
@@ -103,6 +103,7 @@ export {
     generatorTypes,
     DLSSources,
     DLSDestinations,
+    sampleTypes,
     
     
     // MIDI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_core",
-  "version": "3.26.23",
+  "version": "3.26.25",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "main": "index.js",
   "type": "module",

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -8,6 +8,21 @@ import { SpessaSynthWarn } from "../../utils/loggin.js";
 // should be reasonable for most cases
 const RESAMPLE_RATE = 48000;
 
+/**
+ * @enum {number}
+ */
+export const sampleTypes = {
+    monoSample: 1,
+    rightSample: 2,
+    leftSample: 4,
+    linkedSample: 8,
+    romMonoSample: 32769,
+    romRightSample: 32770,
+    romLeftSample: 32772,
+    romLinkedSample: 32776
+};
+
+
 /**
  * @typedef {function} EncodeVorbisFunction
  * @param channelAudioData {Float32Array[]}
@@ -45,14 +60,14 @@ export class BasicSample
     samplePitchCorrection;
     
     /**
-     * Sample link, currently unused here
-     * @type {number}
+     * Linked sample, unused if mono
+     * @type {BasicSample|undefined}
      */
-    sampleLink;
+    linkedSample;
     
     /**
-     * Type of the sample, currently only used for SF3
-     * @type {number}
+     * The type of the sample, it can indicate an SF3 sample
+     * @type {sampleTypes|number}
      */
     sampleType;
     
@@ -97,8 +112,7 @@ export class BasicSample
      * @param sampleRate {number} The sample's rate in Hz
      * @param samplePitch {number} The sample's pitch as a MIDI note number
      * @param samplePitchCorrection {number} The sample's pitch correction in cents
-     * @param sampleLink {number} The sample's link, currently unused
-     * @param sampleType {number} The sample's type, an enum
+     * @param sampleType {sampleTypes|number} The sample's type, an enum that can indicate SF3
      * @param loopStart {number} The sample's loop start relative to the sample start in sample points
      * @param loopEnd {number} The sample's loop end relative to the sample start in sample points
      */
@@ -107,7 +121,6 @@ export class BasicSample
         sampleRate,
         samplePitch,
         samplePitchCorrection,
-        sampleLink,
         sampleType,
         loopStart,
         loopEnd
@@ -117,12 +130,21 @@ export class BasicSample
         this.sampleRate = sampleRate;
         this.samplePitch = samplePitch;
         this.samplePitchCorrection = samplePitchCorrection;
-        this.sampleLink = sampleLink;
-        this.sampleType = sampleType;
         this.sampleLoopStartIndex = loopStart;
         this.sampleLoopEndIndex = loopEnd;
-        // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
-        this.isCompressed = (sampleType & 0x10) > 0;
+        this.setSampleType(sampleType);
+    }
+    
+    /**
+     * If the sample is linked to another sample
+     * @returns {boolean}
+     */
+    get isLinked()
+    {
+        return !this.isCompressed &&
+            (this.sampleType === sampleTypes.rightSample ||
+                this.sampleType === sampleTypes.leftSample ||
+                this.sampleType === sampleTypes.linkedSample);
     }
     
     /**
@@ -189,20 +211,88 @@ export class BasicSample
             }
             this.compressedData = encodeVorbis([audioData], 1, this.sampleRate, quality);
             // flag as compressed
-            this.sampleType |= 0x10;
-            this.isCompressed = true;
+            this.setSampleType(this.sampleType | 0x10);
         }
         catch (e)
         {
             SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`);
-            this.isCompressed = false;
             this.compressedData = undefined;
             // flag as uncompressed
-            this.sampleType &= 0xEF;
+            this.setSampleType(this.sampleType & 0xEF);
+        }
+        
+    }
+    
+    /**
+     * @param type {sampleTypes|number}
+     */
+    setSampleType(type)
+    {
+        this.sampleType = type;
+        // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
+        this.isCompressed = (type & 0x10) > 0;
+        if (!this.isLinked)
+        {
+            // unlink the other sample
+            if (this.linkedSample)
+            {
+                this.linkedSample.linkedSample = undefined;
+                this.linkedSample.sampleType = type;
+            }
+            
+            this.linkedSample = undefined;
+        }
+        if ((type & 0x8000) > 0 && this.linkedSample)
+        {
+            throw new Error("ROM samples cannot be linked.");
         }
         
     }
     
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Unlinks a sample link
+     */
+    unlinkSample()
+    {
+        this.setSampleType(sampleTypes.monoSample);
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Links a stereo sample
+     * @param sample {BasicSample}
+     * @param type {sampleTypes}
+     */
+    setLinkedSample(sample, type)
+    {
+        if (this.isCompressed)
+        {
+            throw new Error("Cannot link a compressed sample.");
+        }
+        this.linkedSample = sample;
+        sample.linkedSample = this;
+        if (type === sampleTypes.leftSample)
+        {
+            this.setSampleType(sampleTypes.leftSample);
+            sample.setSampleType(sampleTypes.rightSample);
+        }
+        else if (type === sampleTypes.rightSample)
+        {
+            this.setSampleType(sampleTypes.rightSample);
+            sample.setSampleType(sampleTypes.leftSample);
+        }
+        else if (type === sampleTypes.linkedSample)
+        {
+            this.setSampleType(sampleTypes.linkedSample);
+            sample.setSampleType(sampleTypes.linkedSample);
+        }
+        else
+        {
+            throw new Error("Invalid sample type: " + type);
+        }
+    }
+    
     /**
      * @param instrument {BasicInstrument}
      */
@@ -226,6 +316,7 @@ export class BasicSample
     
     /**
      * @returns {Float32Array}
+     * @virtual
      */
     getAudioData()
     {
@@ -239,6 +330,7 @@ export class BasicSample
     // noinspection JSUnusedGlobalSymbols
     /**
      * @param audioData {Float32Array}
+     * @virtual
      */
     setAudioData(audioData)
     {

package/src/soundfont/basic_soundfont/write_sf2/shdr.js

@@ -40,7 +40,8 @@ export function getSHDR(smplStartOffsets, smplEndOffsets)
         shdrData[shdrData.currentIndex++] = sample.samplePitch;
         shdrData[shdrData.currentIndex++] = sample.samplePitchCorrection;
         // sample link
-        writeWord(shdrData, sample.sampleLink);
+        const sampleLinkIndex = this.samples.indexOf(sample.linkedSample);
+        writeWord(shdrData, Math.max(0, sampleLinkIndex));
         // sample type: write raw because we simply copy compressed samples
         writeWord(shdrData, sample.sampleType);
     });

package/src/soundfont/basic_soundfont/write_sf2/write.js

@@ -37,7 +37,7 @@ const DEFAULT_WRITE_OPTIONS = {
 };
 
 /**
- * Write the soundfont as an .sf2 file. This method is DESTRUCTIVE
+ * Write the soundfont as an .sf2 file
  * @this {BasicSoundBank}
  * @param {SoundFont2WriteOptions} options
  * @returns {Uint8Array}

package/src/soundfont/dls/dls_sample.js

@@ -52,6 +52,14 @@ export class DLSSample extends BasicSample
         return this.sampleData;
     }
     
+    /**
+     * @param audioData {Float32Array}
+     */
+    setAudioData(audioData)
+    {
+        super.setAudioData(audioData);
+    }
+    
     getRawData()
     {
         if (this.isCompressed)

package/src/soundfont/read_sf2/samples.js

@@ -8,6 +8,12 @@ import { BasicSample } from "../basic_soundfont/basic_sample.js";
 
 export class SoundFontSample extends BasicSample
 {
+    /**
+     * Linked sample index for retrieving linked samples in sf2
+     * @type {number}
+     */
+    linkedSampleIndex;
+    
     /**
      * Creates a sample
      * @param sampleName {string}
@@ -18,7 +24,7 @@ export class SoundFontSample extends BasicSample
      * @param sampleRate {number}
      * @param samplePitch {number}
      * @param samplePitchCorrection {number}
-     * @param sampleLink {number}
+     * @param linkedSampleIndex {number}
      * @param sampleType {number}
      * @param smplArr {IndexedByteArray|Float32Array}
      * @param sampleIndex {number} initial sample index when loading the sfont
@@ -34,7 +40,7 @@ export class SoundFontSample extends BasicSample
         sampleRate,
         samplePitch,
         samplePitchCorrection,
-        sampleLink,
+        linkedSampleIndex,
         sampleType,
         smplArr,
         sampleIndex,
@@ -46,7 +52,6 @@ export class SoundFontSample extends BasicSample
             sampleRate,
             samplePitch,
             samplePitchCorrection,
-            sampleLink,
             sampleType,
             sampleLoopStartIndex - (sampleStartIndex / 2),
             sampleLoopEndIndex - (sampleStartIndex / 2)
@@ -69,6 +74,19 @@ export class SoundFontSample extends BasicSample
             this.sampleLength = 99999999; // set to 999,999 before we decode it
         }
         this.isDataRaw = isDataRaw;
+        this.linkedSampleIndex = linkedSampleIndex;
+    }
+    
+    /**
+     * @param samplesArray {BasicSample[]}
+     */
+    getLinkedSample(samplesArray)
+    {
+        if (this.isCompressed || this.linkedSample || !this.isLinked)
+        {
+            return;
+        }
+        this.setLinkedSample(samplesArray[this.linkedSampleIndex], this.sampleType);
     }
     
     /**
@@ -135,6 +153,16 @@ export class SoundFontSample extends BasicSample
         }
     }
     
+    /**
+     * @param audioData {Float32Array}
+     */
+    setAudioData(audioData)
+    {
+        super.setAudioData(audioData);
+        this.isSampleLoaded = true;
+        this.isDataRaw = false;
+    }
+    
     /**
      * Loads the audio data and stores it for reuse
      * @returns {Float32Array} The audioData
@@ -237,6 +265,10 @@ export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = t
     }
     // remove EOS
     samples.pop();
+    
+    // link samples
+    samples.forEach(s => s.getLinkedSample(samples));
+    
     return samples;
 }
 

package/src/synthetizer/audio_engine/engine_methods/controller_control/reset_controllers.js

@@ -102,6 +102,16 @@ export function resetAllControllers(log = true)
                 LSB: lsb
             });
         }
+        
+        // restore channel pressure
+        if (this.midiAudioChannels[channelNumber].lockedControllers[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] === false)
+        {
+            const val = this.midiAudioChannels[channelNumber].midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] >> 7;
+            this.callEvent("channelpressure", {
+                channel: channelNumber,
+                pressure: val
+            });
+        }
     }
     this.tunings = [];
     this.tunings = [];