spessasynth_core 3.26.34 → 3.26.36

package/package.json

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

package/src/soundfont/basic_soundfont/basic_instrument.js

@@ -1,5 +1,6 @@
 import { BasicGlobalZone } from "./basic_global_zone.js";
 import { BasicInstrumentZone } from "./basic_instrument_zone.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
 
 export class BasicInstrument
 {
@@ -64,7 +65,8 @@ export class BasicInstrument
         const index = this.linkedPresets.indexOf(preset);
         if (index < 0)
         {
-            throw new Error(`Cannot unlink ${preset.presetName} from ${this.instrumentName}: not linked.`);
+            SpessaSynthWarn(`Cannot unlink ${preset.presetName} from ${this.instrumentName}: not linked.`);
+            return;
         }
         this.linkedPresets.splice(index, 1);
         this.instrumentZones.forEach(z => z.useCount--);
@@ -87,7 +89,7 @@ export class BasicInstrument
     {
         if (this.useCount > 0)
         {
-            throw new Error(`Cannot delete an instrument that has ${this.useCount} usages.`);
+            throw new Error(`Cannot delete an instrument that is used by: ${this.linkedPresets.map(p => p.presetName)}.`);
         }
         this.instrumentZones.forEach(z => z.deleteZone());
         this.instrumentZones.length = 0;

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -20,11 +20,10 @@ export const sampleTypes = {
 };
 
 /**
- * @typedef {function} EncodeVorbisFunction
- * @param channelAudioData {Float32Array[]}
+ * @typedef {function} SampleEncodingFunction
+ * @async
+ * @param audioData {Float32Array}
  * @param sampleRate {number}
- * @param channels {number}
- * @param quality {number} -0.1 to 1
  * @returns {Uint8Array}
  */
 
@@ -106,7 +105,7 @@ export class BasicSample
      * Indicates if the data was overriden, so it cannot be copied back unchanged
      * @type {boolean}
      */
-    dataOverriden = false;
+    dataOverriden = true;
     
     /**
      * The basic representation of a sample
@@ -163,7 +162,7 @@ export class BasicSample
      * @return {Uint8Array} either s16 or vorbis data
      * @virtual
      */
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.isCompressed && allowVorbis && !this.dataOverriden)
         {
@@ -190,10 +189,9 @@ export class BasicSample
     }
     
     /**
-     * @param quality {number}
-     * @param encodeVorbis {EncodeVorbisFunction}
+     * @param encodeVorbis {SampleEncodingFunction}
      */
-    compressSample(quality, encodeVorbis)
+    async compressSample(encodeVorbis)
     {
         // no need to compress
         if (this.isCompressed)
@@ -210,12 +208,12 @@ export class BasicSample
                 this.resampleData(RESAMPLE_RATE);
                 audioData = this.getAudioData();
             }
-            const compressed = encodeVorbis([audioData], 1, this.sampleRate, quality);
+            const compressed = await encodeVorbis(audioData, this.sampleRate);
             this.setCompressedData(compressed);
         }
         catch (e)
         {
-            SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`);
+            SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`, e);
             delete this.compressedData;
             // flag as uncompressed
             this.isCompressed = false;
@@ -251,7 +249,7 @@ export class BasicSample
     {
         if (this.useCount > 0)
         {
-            throw new Error(`Cannot delete sample that has ${this.useCount} usages.`);
+            throw new Error(`Cannot delete sample used by: ${this.linkedInstruments.map(i => i.instrumentName)}.`);
         }
         this.unlinkSample();
     }
@@ -312,7 +310,8 @@ export class BasicSample
         const index = this.linkedInstruments.indexOf(instrument);
         if (index < 0)
         {
-            throw new Error(`Cannot unlink ${instrument.instrumentName} from ${this.sampleName}: not linked.`);
+            SpessaSynthWarn(`Cannot unlink ${instrument.instrumentName} from ${this.sampleName}: not linked.`);
+            return;
         }
         this.linkedInstruments.splice(index, 1);
     }

package/src/soundfont/basic_soundfont/basic_soundbank.js

@@ -148,9 +148,9 @@ class BasicSoundBank
     
     /**
      * Creates a simple soundfont with one saw wave preset.
-     * @returns {ArrayBufferLike}
+     * @returns {Promise<ArrayBufferLike>}
      */
-    static getDummySoundfontFile()
+    static async getDummySoundfontFile()
     {
         const font = new BasicSoundBank();
         const sample = new BasicSample(
@@ -162,11 +162,12 @@ class BasicSoundBank
             0,
             127
         );
-        sample.sampleData = new Float32Array(128);
+        const sampleData = new Float32Array(128);
         for (let i = 0; i < 128; i++)
         {
-            sample.sampleData[i] = (i / 128) * 2 - 1;
+            sampleData[i] = (i / 128) * 2 - 1;
         }
+        sample.setAudioData(sampleData);
         font.addSamples(sample);
         
         const gZone = new BasicGlobalZone();
@@ -201,7 +202,8 @@ class BasicSoundBank
         font.soundFontInfo["isng"] = "E-mu 10K2";
         font.soundFontInfo["INAM"] = "Dummy";
         font.flush();
-        return font.write().buffer;
+        const f = await font.write();
+        return f.buffer;
     }
     
     /**
@@ -252,7 +254,6 @@ class BasicSoundBank
         if (sample.isCompressed)
         {
             newSample.setCompressedData(sample.compressedData.slice());
-            console.log(sample.compressedData.length);
         }
         else
         {

package/src/soundfont/basic_soundfont/write_dls/write_dls.js

@@ -6,14 +6,30 @@ import { getStringBytes } from "../../../utils/byte_functions/string.js";
 import { writeWavePool } from "./wvpl.js";
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
 import { consoleColors } from "../../../utils/other.js";
+import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
+
+/**
+ * @typedef {Object} DLSWriteOptions
+ * @property {ProgressFunction|undefined} progressFunction - a function to show progress for writing large banks. It can be undefined.
+ */
+
+
+/**
+ * @type {DLSWriteOptions}
+ */
+const DEFAULT_DLS_OPTIONS = {
+    progressFunction: undefined
+};
 
 /**
  * Write the soundfont as a .dls file. Experimental
  * @this {BasicSoundBank}
+ * @param {DLSWriteOptions|undefined} options - options for writing the file.
  * @returns {Uint8Array}
  */
-export function writeDLS()
+export async function writeDLS(options = DEFAULT_DLS_OPTIONS)
 {
+    options = fillWithDefaults(options, DEFAULT_DLS_OPTIONS);
     SpessaSynthGroupCollapsed(
         "%cSaving DLS...",
         consoleColors.info
@@ -40,7 +56,7 @@ export function writeDLS()
         "%cWriting WAVE samples...",
         consoleColors.info
     );
-    const wavepool = writeWavePool.apply(this);
+    const wavepool = await writeWavePool.call(this, options.progressFunction);
     const wvpl = wavepool.data;
     const ptblOffsets = wavepool.indexes;
     SpessaSynthInfo("%cSucceeded!", consoleColors.recognized);

package/src/soundfont/basic_soundfont/write_dls/wvpl.js

@@ -3,22 +3,27 @@ import { writeRIFFChunkParts } from "../riff_chunk.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {{data: IndexedByteArray, indexes: number[] }}
+ * @param {ProgressFunction|undefined} progressFunction
+ * @returns {Promise<{data: IndexedByteArray, indexes: number[] }>}
  */
-export function writeWavePool()
+export async function writeWavePool(progressFunction)
 {
     let currentIndex = 0;
     const offsets = [];
     /**
      * @type {IndexedByteArray[]}
      */
-    const samples = this.samples.map(s =>
+    const samples = [];
+    let written = 0;
+    for (const s of this.samples)
     {
         const out = writeDLSSample(s);
+        await progressFunction?.(s.sampleName, written, this.samples.length);
         offsets.push(currentIndex);
         currentIndex += out.length;
-        return out;
-    });
+        samples.push(out);
+        written++;
+    }
     return {
         data: writeRIFFChunkParts(
             "wvpl",

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

@@ -1,8 +1,8 @@
-import { SpessaSynthInfo } from "../../../utils/loggin.js";
-import { consoleColors } from "../../../utils/other.js";
 import { IndexedByteArray } from "../../../utils/indexed_array.js";
 import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
 import { writeLittleEndian } from "../../../utils/byte_functions/little_endian.js";
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
 
 /*
 Sdta structure:
@@ -26,25 +26,45 @@ const SDTA_TO_DATA_OFFSET =
  * @param smplStartOffsets {number[]}
  * @param smplEndOffsets {number[]}
  * @param compress {boolean}
- * @param quality {number}
- * @param vorbisFunc {EncodeVorbisFunction}
+ * @param decompress {boolean}
+ * @param vorbisFunc {SampleEncodingFunction}
+ * @param progressFunc {ProgressFunction|undefined}
  * @returns {Uint8Array}
  */
-export function getSDTA(smplStartOffsets, smplEndOffsets, compress, quality, vorbisFunc)
+export async function getSDTA(smplStartOffsets,
+                              smplEndOffsets,
+                              compress,
+                              decompress,
+                              vorbisFunc,
+                              progressFunc
+)
 {
     // write smpl: write int16 data of each sample linearly
     // get size (calling getAudioData twice doesn't matter since it gets cached)
+    let writtenCount = 0;
     let smplChunkSize = 0;
-    const sampleDatas = this.samples.map((s, i) =>
+    const sampleDatas = [];
+    
+    // linear async is faster here as the writing function usually uses a single wasm instance
+    for (const s of this.samples)
     {
         if (compress)
         {
-            s.compressSample(quality, vorbisFunc);
+            await s.compressSample(vorbisFunc);
+        }
+        if (decompress)
+        {
+            s.setAudioData(s.getAudioData());
         }
+        
         // raw data: either copy s16le or encoded vorbis or encode manually if overridden
-        const r = s.getRawData();
+        // use set timeout so the thread doesn't die
+        const r = s.getRawData(true);
+        writtenCount++;
+        progressFunc?.(s.sampleName, writtenCount, this.samples.length);
+        
         SpessaSynthInfo(
-            `%cEncoded sample %c${i}. ${s.sampleName}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`,
+            `%cEncoded sample %c${writtenCount}. ${s.sampleName}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`,
             consoleColors.info,
             consoleColors.recognized,
             consoleColors.info,
@@ -53,15 +73,16 @@ export function getSDTA(smplStartOffsets, smplEndOffsets, compress, quality, vor
             s.isCompressed ? consoleColors.recognized : consoleColors.unrecognized,
             consoleColors.info
         );
+        
         /* 6.1 Sample Data Format in the smpl Sub-chunk
         Each sample is followed by a minimum of forty-six zero
         valued sample data points. These zero valued data points are necessary to guarantee that any reasonable upward pitch shift
         using any reasonable interpolator can loop on zero data at the end of the sound.
         This doesn't apply to sf3 tho
          */
-        smplChunkSize += r.length + (s.isCompressed ? 0 : 92); // 92 = 46 sample data points
-        return r;
-    });
+        smplChunkSize += r.length + (s.isCompressed ? 0 : 92);
+        sampleDatas.push(r);
+    }
     
     if (smplChunkSize % 2 !== 0)
     {

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

@@ -16,16 +16,25 @@ import { writeLittleEndian, writeWord } from "../../../utils/byte_functions/litt
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
 import { MOD_BYTE_SIZE } from "../modulator.js";
 import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
+
+/**
+ * @typedef {function} ProgressFunction
+ * @param {string} sampleName - the written sample name.
+ * @param {number} sampleIndex - the sample's index.
+ * @param {number} sampleCount - the total sample count for progress displaying.
+ */
+
 /**
  * @typedef {Object} SoundFont2WriteOptions
- * @property {boolean|undefined} compress - if the soundfont should be compressed with the Ogg Vorbis codec
- * @property {number|undefined} compressionQuality - the vorbis compression quality, from -0.1 to 1
- * @property {EncodeVorbisFunction|undefined} compressionFunction -
- * the encode vorbis function. Can be undefined if not compressed.
+ * @property {boolean|undefined} compress - if the soundfont should be compressed with a given function.
+ * @property {SampleEncodingFunction|undefined} compressionFunction -
+ * the encode vorbis function. It can be undefined if not compressed.
+ * @property {ProgressFunction|undefined} progressFunction - a function to show progress for writing large banks. It can be undefined.
  * @property {boolean|undefined} writeDefaultModulators - if the DMOD chunk should be written.
  * Recommended.
  * @property {boolean|undefined} writeExtendedLimits - if the xdta chunk should be written to allow virtually infinite parameters.
  * Recommended.
+ * @property {boolean|undefined} decompress - if an sf3 bank should be decompressed back to sf2. Not recommended.
  */
 
 
@@ -43,8 +52,10 @@ const DEFAULT_WRITE_OPTIONS = {
     compress: false,
     compressionQuality: 0.5,
     compressionFunction: undefined,
+    progressFunction: undefined,
     writeDefaultModulators: true,
-    writeExtendedLimits: true
+    writeExtendedLimits: true,
+    decompress: false
 };
 
 /**
@@ -53,14 +64,18 @@ const DEFAULT_WRITE_OPTIONS = {
  * @param {SoundFont2WriteOptions} options
  * @returns {Uint8Array}
  */
-export function write(options = DEFAULT_WRITE_OPTIONS)
+export async function write(options = DEFAULT_WRITE_OPTIONS)
 {
     options = fillWithDefaults(options, DEFAULT_WRITE_OPTIONS);
-    if (options.compress)
+    if (options?.compress)
     {
-        if (typeof options.compressionFunction !== "function")
+        if (typeof options?.compressionFunction !== "function")
         {
-            throw new TypeError("No compression function supplied but compression enabled.");
+            throw new Error("No compression function supplied but compression enabled.");
+        }
+        if (options?.decompress)
+        {
+            throw new Error("Decompressed and compressed at the same time.");
         }
     }
     SpessaSynthGroupCollapsed(
@@ -88,6 +103,10 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
     {
         this.soundFontInfo["ifil"] = "3.0"; // set version to 3
     }
+    if (options?.decompress)
+    {
+        this.soundFontInfo["ifil"] = "2.4"; // set version to 2.04
+    }
     
     if (options?.writeDefaultModulators)
     {
@@ -152,13 +171,14 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
     // write sdta
     const smplStartOffsets = [];
     const smplEndOffsets = [];
-    const sdtaChunk = getSDTA.call(
+    const sdtaChunk = await getSDTA.call(
         this,
         smplStartOffsets,
         smplEndOffsets,
-        options?.compress,
-        options?.compressionQuality ?? 0.5,
-        options.compressionFunction
+        options.compress,
+        options.decompress,
+        options?.compressionFunction,
+        options?.progressFunction
     );
     
     SpessaSynthInfo(

package/src/soundfont/dls/dls_sample.js

@@ -175,6 +175,7 @@ export class DLSSample extends BasicSample
             loopEnd
         );
         this.sampleDbAttenuation = sampleDbAttenuation;
+        this.dataOverriden = false;
         /**
          * @type {IndexedByteArray}
          */
@@ -221,11 +222,11 @@ export class DLSSample extends BasicSample
         super.setAudioData(audioData);
     }
     
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.dataOverriden || this.isCompressed)
         {
-            return super.getRawData();
+            return super.getRawData(allowVorbis);
         }
         if (this.wFormatTag === W_FORMAT_TAG.PCM && this.bytesPerSample === 2)
         {

package/src/soundfont/read_sf2/samples.js

@@ -22,21 +22,10 @@ export class SoundFontSample extends BasicSample
     linkedSampleIndex;
     
     /**
-     * The handle to the core sf2 file for dynamic sample reading
+     * The sliced sample from the smpl chunk
      * @type {Uint8Array}
      */
-    sf2FileArrayHandle;
-    
-    /**
-     * Start index of the sample in the file byte array
-     * @type {number}
-     */
-    s16leStart = 0;
-    /**
-     * End index of the sample in the file byte array
-     * @type {number}
-     */
-    s16leEnd = 0;
+    s16leData;
     
     /**
      * Creates a sample
@@ -83,6 +72,7 @@ export class SoundFontSample extends BasicSample
             sampleLoopStartIndex - (sampleStartIndex / 2),
             sampleLoopEndIndex - (sampleStartIndex / 2)
         );
+        this.dataOverriden = false;
         this.isCompressed = compressed;
         this.sampleName = sampleName;
         // in bytes
@@ -116,13 +106,15 @@ export class SoundFontSample extends BasicSample
                     this.startByteOffset / 2,
                     this.endByteOffset / 2
                 );
+                this.dataOverriden = true;
             }
             else
             {
                 // regular sf2 s16le
-                this.s16leStart = smplStart + this.startByteOffset;
-                this.s16leEnd = smplStart + this.endByteOffset;
-                this.sf2FileArrayHandle = sampleDataArray;
+                this.s16leData = sampleDataArray.slice(
+                    smplStart + this.startByteOffset,
+                    smplStart + this.endByteOffset
+                );
             }
             
         }
@@ -189,7 +181,7 @@ export class SoundFontSample extends BasicSample
         // read the sample data
         let audioData = new Float32Array(byteLength / 2);
         let convertedSigned16 = new Int16Array(
-            this.sf2FileArrayHandle.buffer.slice(this.s16leStart, this.s16leEnd)
+            this.s16leData.buffer
         );
         
         // convert to float
@@ -207,15 +199,15 @@ export class SoundFontSample extends BasicSample
      * @param allowVorbis
      * @returns {Uint8Array}
      */
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.dataOverriden || this.compressedData)
         {
             // return vorbis or encode manually
-            return super.getRawData();
+            return super.getRawData(allowVorbis);
         }
         // copy the smpl directly
-        return this.sf2FileArrayHandle.slice(this.s16leStart, this.s16leEnd);
+        return this.s16leData;
     }
 }
 

package/src/synthetizer/audio_engine/engine_components/midi_audio_channel.js

@@ -166,7 +166,7 @@ class MidiAudioChannel
     
     /**
      * The preset currently assigned to the channel.
-     * @type {BasicPreset}
+     * @type {?BasicPreset}
      */
     preset = undefined;
     
@@ -364,7 +364,6 @@ class MidiAudioChannel
         {
             return;
         }
-        delete this.preset;
         this.preset = preset;
     }
     
@@ -464,7 +463,7 @@ class MidiAudioChannel
             isDrum: this.drumChannel,
             transposition: this.channelTransposeKeyShift + this.customControllers[customControllers.channelTransposeFine] / 100,
             bank: this.sentBank,
-            program: this.preset.program
+            program: this.preset?.program
         };
         this.synth?.onChannelPropertyChange?.(data, this.channelNumber);
     }

package/src/synthetizer/audio_engine/engine_components/voice.js

@@ -491,7 +491,14 @@ export function getVoices(channel, midiNote, velocity, realKey)
     const overridePatch = this.keyModifierManager.hasOverridePatch(channel, midiNote);
     
     let bank = channelObject.getBankSelect();
-    let program = channelObject.preset.program;
+    
+    let preset = channelObject.preset;
+    if (!preset)
+    {
+        SpessaSynthWarn(`No preset for channel ${channel}!`);
+        return [];
+    }
+    let program = preset.program;
     if (overridePatch)
     {
         const override = this.keyModifierManager.getPatch(channel, midiNote);
@@ -507,7 +514,6 @@ export function getVoices(channel, midiNote, velocity, realKey)
     }
     
     // not cached...
-    let preset = channelObject.preset;
     if (overridePatch)
     {
         preset = this.getPreset(bank, program);

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

@@ -29,13 +29,17 @@ export function resetAllControllers(log = true)
     this.setSystem(DEFAULT_SYNTH_MODE);
     for (let channelNumber = 0; channelNumber < this.midiAudioChannels.length; channelNumber++)
     {
-        this.midiAudioChannels[channelNumber].resetControllers();
-        
         /**
          * @type {MidiAudioChannel}
          **/
         const ch = this.midiAudioChannels[channelNumber];
         
+        ch.resetControllers();
+        // safety net
+        if (!ch.preset)
+        {
+            continue;
+        }
         // if preset is unlocked, switch to non-drums and call event
         if (!ch.lockPreset)
         {
@@ -67,11 +71,11 @@ export function resetAllControllers(log = true)
             });
         }
         
-        const presetBank = ch.preset.bank;
+        const presetBank = ch.preset?.bank;
         // call program change
         this.callEvent("programchange", {
             channel: channelNumber,
-            program: ch.preset.program,
+            program: ch.preset?.program,
             bank: presetBank
         });
         

package/src/synthetizer/audio_engine/engine_methods/note_on.js

@@ -4,6 +4,7 @@ import { customControllers } from "../engine_components/controller_tables.js";
 import { Modulator } from "../../../soundfont/basic_soundfont/modulator.js";
 import { GENERATOR_OVERRIDE_NO_CHANGE_VALUE } from "../../synth_constants.js";
 import { generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
+import { SpessaSynthWarn } from "../../../utils/loggin.js";
 
 /**
  * sends a "MIDI Note on message"
@@ -29,6 +30,12 @@ export function noteOn(midiNote, velocity)
         return;
     }
     
+    if (!this.preset)
+    {
+        SpessaSynthWarn(`No preset for channel ${this.channelNumber}!`);
+        return;
+    }
+    
     const realKey = midiNote + this.channelTransposeKeyShift + this.customControllers[customControllers.channelKeyShift];
     let internalMidiNote = realKey;
     
@@ -36,7 +43,7 @@ export function noteOn(midiNote, velocity)
     {
         return;
     }
-    const program = this.preset.program;
+    const program = this.preset?.program;
     const tune = this.synth.tunings[program]?.[realKey]?.midiNote;
     if (tune >= 0)
     {

package/src/synthetizer/audio_engine/engine_methods/program_change.js

@@ -1,3 +1,6 @@
+import { SpessaSynthWarn } from "../../../utils/loggin.js";
+import { BasicPreset } from "../../../soundfont/basic_soundfont/basic_preset.js";
+
 /**
  * executes a program change
  * @param programNumber {number}
@@ -14,7 +17,13 @@ export function programChange(programNumber)
     
     const isXG = this.isXGChannel;
     const p = this.synth.soundfontManager.getPreset(bank, programNumber, isXG);
-    const preset = p.preset;
+    let preset = p.preset;
+    if (!preset)
+    {
+        SpessaSynthWarn("No presets! Using empty fallback.");
+        preset = new BasicPreset(this.synth.soundfontManager.soundfontList[0].soundfont);
+        preset.presetName = "SPESSA EMPTY FALLBACK PRESET";
+    }
     this.setPreset(preset);
     this.sentBank = Math.min(128, preset.bank + p.bankOffset);
     this.synth.callEvent("programchange", {

package/src/synthetizer/audio_engine/engine_methods/render_voice.js

@@ -66,7 +66,7 @@ export function renderVoice(
     let semitones = voice.modulatedGenerators[generatorTypes.coarseTune];  // soundfont coarse tuning
     
     // midi tuning standard
-    const tuning = this.synth.tunings[this.preset.program]?.[voice.realKey];
+    const tuning = this.synth.tunings[this.preset?.program]?.[voice.realKey];
     if (tuning !== undefined && tuning?.midiNote >= 0)
     {
         // override key