spessasynth_lib 3.24.13 → 3.24.15

package/synthetizer/worklet_system/README.md

@@ -1,4 +1,4 @@
-## This the worklet system synthesis folder.
+## This is the worklet system synthesis folder.
 
 The code here is responsible for a single midi channel, synthesizing the sound to it.
 
@@ -6,7 +6,7 @@ The code here is responsible for a single midi channel, synthesizing the sound t
 - `worklet_utilities` contains the various digital signal processing functions such as the wavetable oscillator, low
   pass filter, etc.
 
-For those interested, the `voice_control.js` contains the actual DSP synthesis code.
+For those interested, `render_voice.js` file contains the actual DSP synthesis code.
 
 `minify_processor.js` uses esbuild to minify the processor code. Importing this instead of `worklet_processor.js` is
 recommended.

package/synthetizer/worklet_system/main_processor.js

@@ -2,54 +2,31 @@ import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE, VOICE_CAP } from "../synthetize
 import { WorkletSequencer } from "../../sequencer/worklet_sequencer/worklet_sequencer.js";
 import { SpessaSynthInfo } from "../../utils/loggin.js";
 import { consoleColors } from "../../utils/other.js";
-import { releaseVoice, renderVoice, voiceKilling } from "./worklet_methods/voice_control.js";
+import { voiceKilling } from "./worklet_methods/stopping_notes/voice_killing.js";
 import { ALL_CHANNELS_OR_DIFFERENT_ACTION, returnMessageType } from "./message_protocol/worklet_message.js";
 import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 import { VOLUME_ENVELOPE_SMOOTHING_FACTOR } from "./worklet_utilities/volume_envelope.js";
 import { handleMessage } from "./message_protocol/handle_message.js";
 import { callEvent, sendChannelProperties } from "./message_protocol/message_sending.js";
 import { systemExclusive } from "./worklet_methods/system_exclusive.js";
-import { noteOn } from "./worklet_methods/note_on.js";
-import { killNote, noteOff, stopAll, stopAllChannels } from "./worklet_methods/note_off.js";
-import {
-    channelPressure,
-    pitchWheel,
-    polyPressure,
-    setChannelTuning,
-    setChannelTuningSemitones,
-    setMasterTuning,
-    setModulationDepth,
-    setOctaveTuning,
-    transposeAllChannels,
-    transposeChannel
-} from "./worklet_methods/tuning_control.js";
-import {
-    controllerChange,
-    muteChannel,
-    setMasterGain,
-    setMasterPan,
-    setMIDIVolume
-} from "./worklet_methods/controller_control.js";
-import { disableAndLockGSNRPN, setVibrato } from "./worklet_methods/vibrato_control.js";
-import { dataEntryCoarse, dataEntryFine } from "./worklet_methods/data_entry.js";
-import { createWorkletChannel } from "./worklet_utilities/worklet_processor_channel.js";
-import { resetAllControllers, resetControllers, resetParameters } from "./worklet_methods/reset_controllers.js";
-import {
-    clearSoundFont,
-    getPreset,
-    programChange,
-    reloadSoundFont,
-    sendPresetList,
-    setDrums,
-    setEmbeddedSoundFont,
-    setPreset
-} from "./worklet_methods/program_control.js";
-import { applySynthesizerSnapshot, sendSynthesizerSnapshot } from "./snapshot/snapshot.js";
+import { setMasterGain, setMasterPan, setMIDIVolume } from "./worklet_methods/controller_control/master_parameters.js";
+import { resetAllControllers } from "./worklet_methods/controller_control/reset_controllers.js";
 import { WorkletSoundfontManager } from "./worklet_methods/worklet_soundfont_manager/worklet_soundfont_manager.js";
 import { interpolationTypes } from "./worklet_utilities/wavetable_oscillator.js";
 import { WorkletKeyModifierManager } from "./worklet_methods/worklet_key_modifier.js";
 import { getWorkletVoices } from "./worklet_utilities/worklet_voice.js";
-import { PAN_SMOOTHING_FACTOR, panVoice } from "./worklet_utilities/stereo_panner.js";
+import { PAN_SMOOTHING_FACTOR } from "./worklet_utilities/stereo_panner.js";
+import { stopAllChannels } from "./worklet_methods/stopping_notes/stop_all_channels.js";
+import { setEmbeddedSoundFont } from "./worklet_methods/soundfont_management/set_embedded_sound_font.js";
+import { reloadSoundFont } from "./worklet_methods/soundfont_management/reload_sound_font.js";
+import { clearSoundFont } from "./worklet_methods/soundfont_management/clear_sound_font.js";
+import { sendPresetList } from "./worklet_methods/soundfont_management/send_preset_list.js";
+import { getPreset } from "./worklet_methods/soundfont_management/get_preset.js";
+import { transposeAllChannels } from "./worklet_methods/tuning_control/transpose_all_channels.js";
+import { setMasterTuning } from "./worklet_methods/tuning_control/set_master_tuning.js";
+import { sendSynthesizerSnapshot } from "./snapshot/send_synthesizer_snapshot.js";
+import { applySynthesizerSnapshot } from "./snapshot/apply_synthesizer_snapshot.js";
+import { createWorkletChannel } from "./worklet_methods/create_worklet_channel.js";
 
 
 /**
@@ -334,43 +311,39 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
                 return;
             }
             let outputIndex;
-            let outputLeft;
-            let outputRight;
-            let reverbChannels;
-            let chorusChannels;
+            let outputL;
+            let outputR;
+            let reverbL;
+            let reverbR;
+            let chorusL;
+            let chorusR;
             if (this.oneOutputMode)
             {
                 // first output only
                 const output = outputs[0];
                 // reverb and chorus are disabled. 32 output channels: two for each midi channel
                 outputIndex = (index % 16) * 2;
-                outputLeft = output[outputIndex];
-                outputRight = output[outputIndex + 1];
+                outputL = output[outputIndex];
+                outputR = output[outputIndex + 1];
             }
             else
             {
                 // 2 first outputs are reverb and chorus, others are for channels
                 outputIndex = (index % this._outputsAmount) + 2;
-                outputLeft = outputs[outputIndex][0];
-                outputRight = outputs[outputIndex][1];
-                reverbChannels = outputs[0];
-                chorusChannels = outputs[1];
+                outputL = outputs[outputIndex][0];
+                outputR = outputs[outputIndex][1];
+                reverbL = outputs[0][0];
+                reverbR = outputs[0][1];
+                chorusL = outputs[1][0];
+                chorusR = outputs[1][1];
             }
             
             // for every voice, render it
-            channel.voices = channel.voices.filter(v =>
-            {
-                // render voice
-                this.renderVoice(
-                    channel,
-                    v,
-                    outputLeft, outputRight,
-                    reverbChannels,
-                    chorusChannels
-                );
-                
-                return !v.finished;
-            });
+            channel.renderAudio(
+                outputL, outputR,
+                reverbL, reverbR,
+                chorusL, chorusR
+            );
             
             totalCurrentVoices += channel.voices.length;
         });
@@ -403,12 +376,81 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         this.soundfontManager.destroyManager();
         delete this.soundfontManager;
     }
+    
+    /**
+     * @param channel {number}
+     * @param controllerNumber {number}
+     * @param controllerValue {number}
+     * @param force {boolean}
+     */
+    controllerChange(channel, controllerNumber, controllerValue, force = false)
+    {
+        this.workletProcessorChannels[channel].controllerChange(controllerNumber, controllerValue, force);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @param velocity {number}
+     * @param enableDebug {boolean}
+     * @param sendEvent {boolean}
+     */
+    noteOn(channel, midiNote, velocity, enableDebug = false, sendEvent = true)
+    {
+        this.workletProcessorChannels[channel].noteOn(midiNote, velocity, enableDebug, sendEvent);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     */
+    noteOff(channel, midiNote)
+    {
+        this.workletProcessorChannels[channel].noteOff(midiNote);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @param pressure {number}
+     */
+    polyPressure(channel, midiNote, pressure)
+    {
+        this.workletProcessorChannels[channel].polyPressure(midiNote, pressure);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param pressure {number}
+     */
+    channelPressure(channel, pressure)
+    {
+        this.workletProcessorChannels[channel].channelPressure(pressure);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param MSB {number}
+     * @param LSB {number}
+     */
+    pitchWheel(channel, MSB, LSB)
+    {
+        this.workletProcessorChannels[channel].pitchWheel(MSB, LSB);
+    }
+    
+    /**
+     * @param channel {number}
+     * @param programNumber {number}
+     * @param userChange {boolean}
+     */
+    programChange(channel, programNumber, userChange = false)
+    {
+        this.workletProcessorChannels[channel].programChange(programNumber, userChange);
+    }
 }
 
 // include other methods
 // voice related
-SpessaSynthProcessor.prototype.renderVoice = renderVoice;
-SpessaSynthProcessor.prototype.releaseVoice = releaseVoice;
 SpessaSynthProcessor.prototype.voiceKilling = voiceKilling;
 SpessaSynthProcessor.prototype.getWorkletVoices = getWorkletVoices;
 
@@ -420,30 +462,10 @@ SpessaSynthProcessor.prototype.callEvent = callEvent;
 // system-exclusive related
 SpessaSynthProcessor.prototype.systemExclusive = systemExclusive;
 
-// note messages related
-SpessaSynthProcessor.prototype.noteOn = noteOn;
-SpessaSynthProcessor.prototype.noteOff = noteOff;
-SpessaSynthProcessor.prototype.polyPressure = polyPressure;
-SpessaSynthProcessor.prototype.killNote = killNote;
-SpessaSynthProcessor.prototype.stopAll = stopAll;
-SpessaSynthProcessor.prototype.stopAllChannels = stopAllChannels;
-SpessaSynthProcessor.prototype.muteChannel = muteChannel;
-
-// custom vibrato related
-SpessaSynthProcessor.prototype.setVibrato = setVibrato;
-SpessaSynthProcessor.prototype.disableAndLockGSNRPN = disableAndLockGSNRPN;
-
-// data entry related
-SpessaSynthProcessor.prototype.dataEntryCoarse = dataEntryCoarse;
-SpessaSynthProcessor.prototype.dataEntryFine = dataEntryFine;
-
 // channel related
+SpessaSynthProcessor.prototype.stopAllChannels = stopAllChannels;
 SpessaSynthProcessor.prototype.createWorkletChannel = createWorkletChannel;
-SpessaSynthProcessor.prototype.controllerChange = controllerChange;
-SpessaSynthProcessor.prototype.channelPressure = channelPressure;
 SpessaSynthProcessor.prototype.resetAllControllers = resetAllControllers;
-SpessaSynthProcessor.prototype.resetControllers = resetControllers;
-SpessaSynthProcessor.prototype.resetParameters = resetParameters;
 
 // master parameter related
 SpessaSynthProcessor.prototype.setMasterGain = setMasterGain;
@@ -452,19 +474,10 @@ SpessaSynthProcessor.prototype.setMIDIVolume = setMIDIVolume;
 
 // tuning related
 SpessaSynthProcessor.prototype.transposeAllChannels = transposeAllChannels;
-SpessaSynthProcessor.prototype.transposeChannel = transposeChannel;
-SpessaSynthProcessor.prototype.setChannelTuning = setChannelTuning;
-SpessaSynthProcessor.prototype.setChannelTuningSemitones = setChannelTuningSemitones;
 SpessaSynthProcessor.prototype.setMasterTuning = setMasterTuning;
-SpessaSynthProcessor.prototype.setModulationDepth = setModulationDepth;
-SpessaSynthProcessor.prototype.pitchWheel = pitchWheel;
-SpessaSynthProcessor.prototype.setOctaveTuning = setOctaveTuning;
 
 // program related
-SpessaSynthProcessor.prototype.programChange = programChange;
 SpessaSynthProcessor.prototype.getPreset = getPreset;
-SpessaSynthProcessor.prototype.setPreset = setPreset;
-SpessaSynthProcessor.prototype.setDrums = setDrums;
 SpessaSynthProcessor.prototype.reloadSoundFont = reloadSoundFont;
 SpessaSynthProcessor.prototype.clearSoundFont = clearSoundFont;
 SpessaSynthProcessor.prototype.setEmbeddedSoundFont = setEmbeddedSoundFont;
@@ -474,6 +487,4 @@ SpessaSynthProcessor.prototype.sendPresetList = sendPresetList;
 SpessaSynthProcessor.prototype.sendSynthesizerSnapshot = sendSynthesizerSnapshot;
 SpessaSynthProcessor.prototype.applySynthesizerSnapshot = applySynthesizerSnapshot;
 
-SpessaSynthProcessor.prototype.panVoice = panVoice;
-
 export { SpessaSynthProcessor };

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -17,27 +17,32 @@ export function handleMessage(message)
     /**
      * @type {WorkletProcessorChannel}
      */
-    let channelObject = {};
+    let channelObject;
     if (channel >= 0)
     {
         channelObject = this.workletProcessorChannels[channel];
+        if (channelObject === undefined)
+        {
+            SpessaSynthWarn(`Trying to access channel ${channel} which does not exist... ignoring!`);
+            return;
+        }
     }
     switch (message.messageType)
     {
         case workletMessageType.noteOn:
-            this.noteOn(channel, data[0], data[1], data[2]);
+            channelObject.noteOn(...data);
             break;
         
         case workletMessageType.noteOff:
-            this.noteOff(channel, data);
+            channelObject.noteOff(data);
             break;
         
         case workletMessageType.pitchWheel:
-            this.pitchWheel(channel, data[0], data[1]);
+            channelObject.pitchWheel(...data);
             break;
         
         case workletMessageType.ccChange:
-            this.controllerChange(channel, data[0], data[1], data[2]);
+            channelObject.controllerChange(...data);
             break;
         
         case workletMessageType.customcCcChange:
@@ -46,7 +51,7 @@ export function handleMessage(message)
             break;
         
         case workletMessageType.killNote:
-            this.killNote(channel, data);
+            channelObject.killNote(data);
             break;
         
         case workletMessageType.programChange:
@@ -54,11 +59,11 @@ export function handleMessage(message)
             break;
         
         case workletMessageType.channelPressure:
-            this.channelPressure(channel, data);
+            channelObject.channelPressure(data);
             break;
         
         case workletMessageType.polyPressure:
-            this.polyPressure(channel, data[0], data[1]);
+            channelObject.polyPressure(...data);
             break;
         
         case workletMessageType.ccReset:
@@ -68,7 +73,7 @@ export function handleMessage(message)
             }
             else
             {
-                this.resetControllers(channel);
+                channelObject.resetControllers();
             }
             break;
         
@@ -83,21 +88,21 @@ export function handleMessage(message)
                 {
                     if (data.rate === -1)
                     {
-                        this.disableAndLockGSNRPN(i);
+                        channelObject.disableAndLockGSNRPN();
                     }
                     else
                     {
-                        this.setVibrato(i, data.depth, data.rate, data.delay);
+                        channelObject.setVibrato(data.depth, data.rate, data.delay);
                     }
                 }
             }
             else if (data.rate === -1)
             {
-                this.disableAndLockGSNRPN(channel);
+                channelObject.disableAndLockGSNRPN();
             }
             else
             {
-                this.setVibrato(channel, data.depth, data.rate, data.delay);
+                channelObject.setVibrato(data.depth, data.rate, data.delay);
             }
             break;
         
@@ -108,7 +113,7 @@ export function handleMessage(message)
             }
             else
             {
-                this.stopAll(channel, data === 1);
+                channelObject.stopAllNotes(data === 1);
             }
             break;
         
@@ -117,7 +122,7 @@ export function handleMessage(message)
             break;
         
         case workletMessageType.muteChannel:
-            this.muteChannel(channel, data);
+            channelObject.muteChannel(data);
             break;
         
         case workletMessageType.addNewChannel:
@@ -155,7 +160,7 @@ export function handleMessage(message)
             break;
         
         case workletMessageType.setDrums:
-            this.setDrums(channel, data);
+            channelObject.setDrums(data);
             break;
         
         case workletMessageType.transpose:
@@ -165,7 +170,7 @@ export function handleMessage(message)
             }
             else
             {
-                this.transposeChannel(channel, data[0], data[1]);
+                channelObject.transposeChannel(data[0], data[1]);
             }
             break;
         

package/synthetizer/worklet_system/message_protocol/worklet_message.js

@@ -81,6 +81,7 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  *     messageType: workletMessageType,
  *     messageData: (
  *     number[]
+ *     |undefined
  *     |boolean[]
  *     |WorkletVoice[]
  *     |number
@@ -111,7 +112,7 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  * 1 - event call                   -> {eventName<string>, eventData:<the event's data>}
  * 2 - reported current time        -> currentTime<number>
  * 3 - sequencer specific           -> [messageType<WorkletSequencerReturnMessageType> messageData<any>] note: refer to sequencer_message.js
- * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to snapshot.js
+ * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to synthesizer_snapshot.js
  * 5 - ready                        -> (no data)
  * 6 - soundfontError               -> errorMessage<string>
  * 7 - idenfity                     -> version<string>

package/synthetizer/worklet_system/snapshot/apply_synthesizer_snapshot.js

@@ -0,0 +1,14 @@
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
+import { SynthesizerSnapshot } from "./synthesizer_snapshot.js";
+
+/**
+ * Applies the snapshot to the synth
+ * @param snapshot {SynthesizerSnapshot}
+ * @this {SpessaSynthProcessor}
+ */
+export function applySynthesizerSnapshot(snapshot)
+{
+    SynthesizerSnapshot.applySnapshot(this, snapshot);
+    SpessaSynthInfo("%cFinished applying snapshot!", consoleColors.info);
+}

package/synthetizer/worklet_system/snapshot/channel_snapshot.js

@@ -0,0 +1,166 @@
+/**
+ * Represents a snapshot of a single channel's state in the synthesizer.
+ */
+export class ChannelSnapshot
+{
+    /**
+     * The channel's MIDI program number.
+     * @type {number}
+     */
+    program;
+    
+    /**
+     * The channel's bank number.
+     * @type {number}
+     */
+    bank;
+    
+    /**
+     * The name of the patch currently loaded in the channel.
+     * @type {string}
+     */
+    patchName;
+    
+    /**
+     * Indicates whether the channel's program change is disabled.
+     * @type {boolean}
+     */
+    lockPreset;
+    
+    /**
+     * The array of all MIDI controllers (in 14-bit values) with the modulator sources at the end.
+     * @type {Int16Array}
+     */
+    midiControllers;
+    
+    /**
+     * An array of booleans, indicating if the controller with a current index is locked.
+     * @type {boolean[]}
+     */
+    lockedControllers;
+    
+    /**
+     * Array of custom (not SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+     * @type {Float32Array}
+     */
+    customControllers;
+    
+    /**
+     * Indicates whether the channel vibrato is locked.
+     * @type {boolean}
+     */
+    lockVibrato;
+    
+    /**
+     * The channel's vibrato settings.
+     * @type {Object}
+     * @property {number} depth - Vibrato depth, in gain.
+     * @property {number} delay - Vibrato delay from note on in seconds.
+     * @property {number} rate - Vibrato rate in Hz.
+     */
+    channelVibrato;
+    
+    /**
+     * Key shift for the channel.
+     * @type {number}
+     */
+    channelTransposeKeyShift;
+    
+    /**
+     * The channel's octave tuning in cents.
+     * @type {Int8Array}
+     */
+    channelOctaveTuning;
+    
+    /**
+     * Tuning of individual keys in cents.
+     * @type {Int16Array}
+     */
+    keyCentTuning;
+    
+    /**
+     * Indicates whether the channel is muted.
+     * @type {boolean}
+     */
+    isMuted;
+    
+    /**
+     * Overrides velocity if greater than 0, otherwise disabled.
+     * @type {number}
+     */
+    velocityOverride;
+    
+    /**
+     * Indicates whether the channel is a drum channel.
+     * @type {boolean}
+     */
+    drumChannel;
+    
+    /**
+     * Creates a snapshot of a single channel's state in the synthesizer.
+     * @param workletProcessor {SpessaSynthProcessor}
+     * @param channelNumber {number}
+     * @returns {ChannelSnapshot}
+     */
+    static getChannelSnapshot(workletProcessor, channelNumber)
+    {
+        const channelObject = workletProcessor.workletProcessorChannels[channelNumber];
+        const channelSnapshot = new ChannelSnapshot();
+        // program data
+        channelSnapshot.program = channelObject.preset.program;
+        channelSnapshot.bank = channelObject.getBankSelect();
+        channelSnapshot.lockPreset = channelObject.lockPreset;
+        channelSnapshot.patchName = channelObject.preset.presetName;
+        
+        // controller data
+        channelSnapshot.midiControllers = channelObject.midiControllers;
+        channelSnapshot.lockedControllers = channelObject.lockedControllers;
+        channelSnapshot.customControllers = channelObject.customControllers;
+        
+        // vibrato data
+        channelSnapshot.channelVibrato = channelObject.channelVibrato;
+        channelSnapshot.lockVibrato = channelObject.lockGSNRPNParams;
+        
+        // tuning and transpose data
+        channelSnapshot.channelTransposeKeyShift = channelObject.channelTransposeKeyShift;
+        channelSnapshot.channelOctaveTuning = channelObject.channelOctaveTuning;
+        channelSnapshot.keyCentTuning = channelObject.keyCentTuning;
+        
+        // other data
+        channelSnapshot.isMuted = channelObject.isMuted;
+        channelSnapshot.velocityOverride = channelObject.velocityOverride;
+        channelSnapshot.drumChannel = channelObject.drumChannel;
+        return channelSnapshot;
+    }
+    
+    /**
+     * Applies the snapshot to the specified channel.
+     * @param workletProcessor {SpessaSynthProcessor}
+     * @param channelNumber {number}
+     * @param channelSnapshot {ChannelSnapshot}
+     */
+    static applyChannelSnapshot(workletProcessor, channelNumber, channelSnapshot)
+    {
+        const channelObject = workletProcessor.workletProcessorChannels[channelNumber];
+        channelObject.muteChannel(channelSnapshot.isMuted);
+        channelObject.setDrums(channelSnapshot.drumChannel);
+        
+        // restore controllers
+        channelObject.midiControllers = channelSnapshot.midiControllers;
+        channelObject.lockedControllers = channelSnapshot.lockedControllers;
+        channelObject.customControllers = channelSnapshot.customControllers;
+        
+        // restore vibrato and transpose
+        channelObject.channelVibrato = channelSnapshot.channelVibrato;
+        channelObject.lockGSNRPNParams = channelSnapshot.lockVibrato;
+        channelObject.channelTransposeKeyShift = channelSnapshot.channelTransposeKeyShift;
+        channelObject.channelOctaveTuning = channelSnapshot.channelOctaveTuning;
+        channelObject.velocityOverride = channelSnapshot.velocityOverride;
+        
+        // restore preset and lock
+        channelObject.lockPreset = false;
+        channelObject.setBankSelect(channelSnapshot.bank);
+        channelObject.programChange(channelSnapshot.program);
+        channelObject.lockPreset = channelSnapshot.lockPreset;
+    }
+}

package/synthetizer/worklet_system/snapshot/send_synthesizer_snapshot.js

@@ -0,0 +1,14 @@
+import { returnMessageType } from "../message_protocol/worklet_message.js";
+import { SynthesizerSnapshot } from "./synthesizer_snapshot.js";
+
+/**
+ * sends a snapshot of the current controller values of the synth (used to copy that data to OfflineAudioContext when rendering)
+ * @this {SpessaSynthProcessor}
+ */
+export function sendSynthesizerSnapshot()
+{
+    this.post({
+        messageType: returnMessageType.synthesizerSnapshot,
+        messageData: SynthesizerSnapshot.createSynthesizerSnapshot(this)
+    });
+}