spessasynth_core 3.26.24 → 3.26.26

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.24",
+  "version": "3.26.26",
   "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
+     * @type {sampleTypes}
      */
     sampleType;
     
@@ -69,7 +84,7 @@ export class BasicSample
     sampleLoopEndIndex;
     
     /**
-     * Indicates if the sample is compressed
+     * Indicates if the sample is compressed using vorbis SF3
      * @type {boolean}
      */
     isCompressed;
@@ -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,20 @@ 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.sampleType = sampleType;
+    }
+    
+    /**
+     * If the sample is linked to another sample
+     * @returns {boolean}
+     */
+    get isLinked()
+    {
+        return this.sampleType === sampleTypes.rightSample ||
+            this.sampleType === sampleTypes.leftSample ||
+            this.sampleType === sampleTypes.linkedSample;
     }
     
     /**
@@ -189,20 +210,82 @@ 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;
+        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)
+        {
+            throw new Error("ROM samples are not supported.");
+        }
+        
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Unlinks a sample link
+     */
+    unlinkSample()
+    {
+        this.setSampleType(sampleTypes.monoSample);
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Links a stereo sample
+     * @param sample {BasicSample} the sample to link to
+     * @param type {sampleTypes} either left, right or linked
+     */
+    setLinkedSample(sample, type)
+    {
+        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}
      */

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

@@ -2,6 +2,7 @@ import { IndexedByteArray } from "../../../utils/indexed_array.js";
 import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
 import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
 import { RiffChunk, writeRIFFChunk } from "../riff_chunk.js";
+import { SF3_BIT_FLIT } from "../../read_sf2/samples.js";
 
 /**
  * @this {BasicSoundBank}
@@ -40,9 +41,15 @@ export function getSHDR(smplStartOffsets, smplEndOffsets)
         shdrData[shdrData.currentIndex++] = sample.samplePitch;
         shdrData[shdrData.currentIndex++] = sample.samplePitchCorrection;
         // sample link
-        writeWord(shdrData, sample.sampleLink);
-        // sample type: write raw because we simply copy compressed samples
-        writeWord(shdrData, sample.sampleType);
+        const sampleLinkIndex = this.samples.indexOf(sample.linkedSample);
+        writeWord(shdrData, Math.max(0, sampleLinkIndex));
+        // sample type: add byte if compressed
+        let type = sample.sampleType;
+        if (sample.isCompressed)
+        {
+            type |= SF3_BIT_FLIT;
+        }
+        writeWord(shdrData, type);
     });
     
     // write EOS and zero everything else

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/read_sf2/samples.js

@@ -6,8 +6,16 @@ import { SpessaSynthWarn } from "../../utils/loggin.js";
 import { readBytesAsString } from "../../utils/byte_functions/string.js";
 import { BasicSample } from "../basic_soundfont/basic_sample.js";
 
+export const SF3_BIT_FLIT = 0x10;
+
 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 +26,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,23 +42,28 @@ export class SoundFontSample extends BasicSample
         sampleRate,
         samplePitch,
         samplePitchCorrection,
-        sampleLink,
+        linkedSampleIndex,
         sampleType,
         smplArr,
         sampleIndex,
         isDataRaw
     )
     {
+        // read sf3
+        // https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format
+        const compressed = (sampleType & SF3_BIT_FLIT) > 0;
+        // remove the compression flag
+        sampleType &= ~SF3_BIT_FLIT;
         super(
             sampleName,
             sampleRate,
             samplePitch,
             samplePitchCorrection,
-            sampleLink,
             sampleType,
             sampleLoopStartIndex - (sampleStartIndex / 2),
             sampleLoopEndIndex - (sampleStartIndex / 2)
         );
+        this.isCompressed = compressed;
         this.sampleName = sampleName;
         // in bytes
         this.sampleStartIndex = sampleStartIndex;
@@ -69,6 +82,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.linkedSample || !this.isLinked)
+        {
+            return;
+        }
+        this.setLinkedSample(samplesArray[this.linkedSampleIndex], this.sampleType);
     }
     
     /**
@@ -247,6 +273,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 = [];