开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluid_voice.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：73k
源码类别：

midi

开发平台：

C/C++

fluid_voice.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  21. #include "fluidsynth_priv.h"
  22. #include "fluid_voice.h"
  23. #include "fluid_mod.h"
  24. #include "fluid_chan.h"
  25. #include "fluid_conv.h"
  26. #include "fluid_synth.h"
  27. #include "fluid_sys.h"
  28. #include "fluid_sfont.h"
  30. /* used for filter turn off optimization - if filter cutoff is above the
  31.    specified value and filter q is below the other value, turn filter off */
  32. #define FLUID_MAX_AUDIBLE_FILTER_FC 19000.0f
  33. #define FLUID_MIN_AUDIBLE_FILTER_Q 1.2f
  35. /* Smallest amplitude that can be perceived (full scale is +/- 0.5)
  36.  * 16 bits => 96+4=100 dB dynamic range => 0.00001
  37.  * 0.00001 * 2 is approximately 0.00003 :)
  38.  */
  39. #define FLUID_NOISE_FLOOR 0.00003
  41. /* these should be the absolute minimum that FluidSynth can deal with */
  42. #define FLUID_MIN_LOOP_SIZE 2
  43. #define FLUID_MIN_LOOP_PAD 0
  45. /* min vol envelope release (to stop clicks) in SoundFont timecents */
  46. #define FLUID_MIN_VOLENVRELEASE -7200.0f /* ~16ms */
  48. static int fluid_voice_calculate_runtime_synthesis_parameters(fluid_voice_t* voice);
  49. static int calculate_hold_decay_buffers(fluid_voice_t* voice, int gen_base,
  50.                                         int gen_key2base, int is_decay);
  51. static inline void fluid_voice_filter (fluid_voice_t *voice);
  52. static fluid_real_t
  53. fluid_voice_get_lower_boundary_for_attenuation(fluid_voice_t* voice);
  54. static void fluid_voice_check_sample_sanity(fluid_voice_t* voice);
  56. /*
  57.  * new_fluid_voice
  58.  */
  59. fluid_voice_t*
  60. new_fluid_voice(fluid_real_t output_rate)
  61. {
  62.   fluid_voice_t* voice;
  63.   voice = FLUID_NEW(fluid_voice_t);
  64.   if (voice == NULL) {
  65.     FLUID_LOG(FLUID_ERR, "Out of memory");
  66.     return NULL;
  67.   }
  68.   voice->status = FLUID_VOICE_CLEAN;
  69.   voice->chan = NO_CHANNEL;
  70.   voice->key = 0;
  71.   voice->vel = 0;
  72.   voice->channel = NULL;
  73.   voice->sample = NULL;
  74.   voice->output_rate = output_rate;
  76.   /* The 'sustain' and 'finished' segments of the volume / modulation
  77.    * envelope are constant. They are never affected by any modulator
  78.    * or generator. Therefore it is enough to initialize them once
  79.    * during the lifetime of the synth.
  80.    */
  81.   voice->volenv_data[FLUID_VOICE_ENVSUSTAIN].count = 0xffffffff;
  82.   voice->volenv_data[FLUID_VOICE_ENVSUSTAIN].coeff = 1.0f;
  83.   voice->volenv_data[FLUID_VOICE_ENVSUSTAIN].incr = 0.0f;
  84.   voice->volenv_data[FLUID_VOICE_ENVSUSTAIN].min = -1.0f;
  85.   voice->volenv_data[FLUID_VOICE_ENVSUSTAIN].max = 2.0f;
  87.   voice->volenv_data[FLUID_VOICE_ENVFINISHED].count = 0xffffffff;
  88.   voice->volenv_data[FLUID_VOICE_ENVFINISHED].coeff = 0.0f;
  89.   voice->volenv_data[FLUID_VOICE_ENVFINISHED].incr = 0.0f;
  90.   voice->volenv_data[FLUID_VOICE_ENVFINISHED].min = -1.0f;
  91.   voice->volenv_data[FLUID_VOICE_ENVFINISHED].max = 1.0f;
  93.   voice->modenv_data[FLUID_VOICE_ENVSUSTAIN].count = 0xffffffff;
  94.   voice->modenv_data[FLUID_VOICE_ENVSUSTAIN].coeff = 1.0f;
  95.   voice->modenv_data[FLUID_VOICE_ENVSUSTAIN].incr = 0.0f;
  96.   voice->modenv_data[FLUID_VOICE_ENVSUSTAIN].min = -1.0f;
  97.   voice->modenv_data[FLUID_VOICE_ENVSUSTAIN].max = 2.0f;
  99.   voice->modenv_data[FLUID_VOICE_ENVFINISHED].count = 0xffffffff;
  100.   voice->modenv_data[FLUID_VOICE_ENVFINISHED].coeff = 0.0f;
  101.   voice->modenv_data[FLUID_VOICE_ENVFINISHED].incr = 0.0f;
  102.   voice->modenv_data[FLUID_VOICE_ENVFINISHED].min = -1.0f;
  103.   voice->modenv_data[FLUID_VOICE_ENVFINISHED].max = 1.0f;
  105.   return voice;
  106. }
  108. /*
  109.  * delete_fluid_voice
  110.  */
  111. int
  112. delete_fluid_voice(fluid_voice_t* voice)
  113. {
  114.   if (voice == NULL) {
  115.     return FLUID_OK;
  116.   }
  117.   FLUID_FREE(voice);
  118.   return FLUID_OK;
  119. }
  121. /* fluid_voice_init
  122.  *
  123.  * Initialize the synthesis process
  124.  */
  125. int
  126. fluid_voice_init(fluid_voice_t* voice, fluid_sample_t* sample,
  127.  fluid_channel_t* channel, int key, int vel, unsigned int id,
  128.  unsigned int start_time, fluid_real_t gain)
  129. {
  130.   /* Note: The voice parameters will be initialized later, when the
  131.    * generators have been retrieved from the sound font. Here, only
  132.    * the 'working memory' of the voice (position in envelopes, history
  133.    * of IIR filters, position in sample etc) is initialized. */
  136.   voice->id = id;
  137.   voice->chan = fluid_channel_get_num(channel);
  138.   voice->key = (unsigned char) key;
  139.   voice->vel = (unsigned char) vel;
  140.   voice->channel = channel;
  141.   voice->mod_count = 0;
  142.   voice->sample = sample;
  143.   voice->start_time = start_time;
  144.   voice->ticks = 0;
  145.   voice->noteoff_ticks = 0;
  146.   voice->debug = 0;
  147.   voice->has_looped = 0; /* Will be set during voice_write when the 2nd loop point is reached */
  148.   voice->last_fres = -1; /* The filter coefficients have to be calculated later in the DSP loop. */
  149.   voice->filter_startup = 1; /* Set the filter immediately, don't fade between old and new settings */
  150.   voice->interp_method = fluid_channel_get_interp_method(voice->channel);
  152.   /* vol env initialization */
  153.   voice->volenv_count = 0;
  154.   voice->volenv_section = 0;
  155.   voice->volenv_val = 0.0f;
  156.   voice->amp = 0.0f; /* The last value of the volume envelope, used to
  157.                         calculate the volume increment during
  158.                         processing */
  160.   /* mod env initialization*/
  161.   voice->modenv_count = 0;
  162.   voice->modenv_section = 0;
  163.   voice->modenv_val = 0.0f;
  165.   /* mod lfo */
  166.   voice->modlfo_val = 0.0;/* Fixme: Retrieve from any other existing
  167.                              voice on this channel to keep LFOs in
  168.                              unison? */
  170.   /* vib lfo */
  171.   voice->viblfo_val = 0.0f; /* Fixme: See mod lfo */
  173.   /* Clear sample history in filter */
  174.   voice->hist1 = 0;
  175.   voice->hist2 = 0;
  177.   /* Set all the generators to their default value, according to SF
  178.    * 2.01 section 8.1.3 (page 48). The value of NRPN messages are
  179.    * copied from the channel to the voice's generators. The sound font
  180.    * loader overwrites them. The generator values are later converted
  181.    * into voice parameters in
  182.    * fluid_voice_calculate_runtime_synthesis_parameters.  */
  183.   fluid_gen_init(&voice->gen[0], channel);
  185.   voice->synth_gain = gain;
  186.   /* avoid division by zero later*/
  187.   if (voice->synth_gain < 0.0000001){
  188.     voice->synth_gain = 0.0000001;
  189.   }
  191.   /* For a looped sample, this value will be overwritten as soon as the
  192.    * loop parameters are initialized (they may depend on modulators).
  193.    * This value can be kept, it is a worst-case estimate.
  194.    */
  196.   voice->amplitude_that_reaches_noise_floor_nonloop = FLUID_NOISE_FLOOR / voice->synth_gain;
  197.   voice->amplitude_that_reaches_noise_floor_loop = FLUID_NOISE_FLOOR / voice->synth_gain;
  199.   /* Increment the reference count of the sample to prevent the
  200.      unloading of the soundfont while this voice is playing. */
  201.   fluid_sample_incr_ref(voice->sample);
  203.   return FLUID_OK;
  204. }
  206. /**
  207.  * Set the value of a generator.
  208.  * @param voice Voice instance
  209.  * @param i Generator ID (#fluid_gen_type)
  210.  * @param val Generator value
  211.  */
  212. void
  213. fluid_voice_gen_set(fluid_voice_t* voice, int i, float val)
  214. {
  215.   voice->gen[i].val = val;
  216.   voice->gen[i].flags = GEN_SET;
  217. }
  219. /**
  220.  * Offset the value of a generator.
  221.  * @param voice Voice instance
  222.  * @param i Generator ID (#fluid_gen_type)
  223.  * @param val Value to add to the existing value
  224.  */
  225. void
  226. fluid_voice_gen_incr(fluid_voice_t* voice, int i, float val)
  227. {
  228.   voice->gen[i].val += val;
  229.   voice->gen[i].flags = GEN_SET;
  230. }
  232. /**
  233.  * Get the value of a generator.
  234.  * @param voice Voice instance
  235.  * @param gen Generator ID (#fluid_gen_type)
  236.  * @return Current generator value
  237.  */
  238. float
  239. fluid_voice_gen_get(fluid_voice_t* voice, int gen)
  240. {
  241.   return voice->gen[gen].val;
  242. }
  244. fluid_real_t fluid_voice_gen_value(fluid_voice_t* voice, int num)
  245. {
  246. /* This is an extension to the SoundFont standard. More
  247.  * documentation is available at the fluid_synth_set_gen2()
  248.  * function. */
  249. if (voice->gen[num].flags == GEN_ABS_NRPN) {
  250. return (fluid_real_t) voice->gen[num].nrpn;
  251. } else {
  252. return (fluid_real_t) (voice->gen[num].val + voice->gen[num].mod + voice->gen[num].nrpn);
  253. }
  254. }
  257. /**
  258.  * Synthesize a voice to a buffer.
  259.  *
  260.  * @param voice Voice to synthesize
  261.  * @param dsp_buf Audio buffer to synthesize to (#FLUID_BUFSIZE in length)
  262.  * @return Count of samples written to dsp_buf (can be 0)
  263.  *
  264.  * Panning, reverb and chorus are processed separately. The dsp interpolation
  265.  * routine is in (fluid_dsp_float.c).
  266.  */
  267. int
  268. fluid_voice_write (fluid_voice_t* voice, fluid_real_t *dsp_buf)
  269. {
  270.   fluid_real_t fres;
  271.   fluid_real_t target_amp; /* target amplitude */
  272.   fluid_env_data_t* env_data;
  273.   fluid_real_t x;
  274.   int count = 0;
  276.   /* Other routines (such as fluid_voice_effects) use the last dsp_buf assigned */
  277.   voice->dsp_buf = dsp_buf;
  278.   voice->dsp_buf_count = 0;
  280.   /******************* sample **********************/
  282.   if (voice->sample == NULL)
  283.   {
  284.     fluid_voice_off(voice);
  285.     return 0;
  286.   }
  288.   if (voice->noteoff_ticks != 0 && voice->ticks >= voice->noteoff_ticks) 
  289.   {
  290.     fluid_voice_noteoff(voice);
  291.   }
  293.   fluid_check_fpe ("voice_write startup");
  295.   /* Range checking for sample- and loop-related parameters
  296.    * Initial phase is calculated here*/
  297.   fluid_voice_check_sample_sanity (voice);
  299.   /******************* vol env **********************/
  301.   env_data = &voice->volenv_data[voice->volenv_section];
  303.   /* skip to the next section of the envelope if necessary */
  304.   while (voice->volenv_count >= env_data->count)
  305.   {
  306.     // If we're switching envelope stages from decay to sustain, force the value to be the end value of the previous stage
  307.     if (env_data && voice->volenv_section == FLUID_VOICE_ENVDECAY)
  308.       voice->volenv_val = env_data->min * env_data->coeff;
  310.     env_data = &voice->volenv_data[++voice->volenv_section];
  311.     voice->volenv_count = 0;
  312.   }
  314.   /* calculate the envelope value and check for valid range */
  315.   x = env_data->coeff * voice->volenv_val + env_data->incr;
  316.   if (x < env_data->min)
  317.   {
  318.     x = env_data->min;
  319.     voice->volenv_section++;
  320.     voice->volenv_count = 0;
  321.   }
  322.   else if (x > env_data->max)
  323.   {
  324.     x = env_data->max;
  325.     voice->volenv_section++;
  326.     voice->volenv_count = 0;
  327.   }
  329.   voice->volenv_val = x;
  330.   voice->volenv_count++;
  332.   if (voice->volenv_section == FLUID_VOICE_ENVFINISHED)
  333.   {
  334.     fluid_profile (FLUID_PROF_VOICE_RELEASE, voice->ref);
  335.     fluid_voice_off (voice);
  336.     return 0;
  337.   }
  339.   fluid_check_fpe ("voice_write vol env");
  341.   /******************* mod env **********************/
  343.   env_data = &voice->modenv_data[voice->modenv_section];
  345.   /* skip to the next section of the envelope if necessary */
  346.   while (voice->modenv_count >= env_data->count)
  347.   {
  348.     env_data = &voice->modenv_data[++voice->modenv_section];
  349.     voice->modenv_count = 0;
  350.   }
  352.   /* calculate the envelope value and check for valid range */
  353.   x = env_data->coeff * voice->modenv_val + env_data->incr;
  355.   if (x < env_data->min)
  356.   {
  357.     x = env_data->min;
  358.     voice->modenv_section++;
  359.     voice->modenv_count = 0;
  360.   }
  361.   else if (x > env_data->max)
  362.   {
  363.     x = env_data->max;
  364.     voice->modenv_section++;
  365.     voice->modenv_count = 0;
  366.   }
  368.   voice->modenv_val = x;
  369.   voice->modenv_count++;
  370.   fluid_check_fpe ("voice_write mod env");
  372.   /******************* mod lfo **********************/
  374.   if (voice->ticks >= voice->modlfo_delay)
  375.   {
  376.     voice->modlfo_val += voice->modlfo_incr;
  377.   
  378.     if (voice->modlfo_val > 1.0)
  379.     {
  380.       voice->modlfo_incr = -voice->modlfo_incr;
  381.       voice->modlfo_val = (fluid_real_t) 2.0 - voice->modlfo_val;
  382.     }
  383.     else if (voice->modlfo_val < -1.0)
  384.     {
  385.       voice->modlfo_incr = -voice->modlfo_incr;
  386.       voice->modlfo_val = (fluid_real_t) -2.0 - voice->modlfo_val;
  387.     }
  388.   }
  389.   
  390.   fluid_check_fpe ("voice_write mod LFO");
  392.   /******************* vib lfo **********************/
  394.   if (voice->ticks >= voice->viblfo_delay)
  395.   {
  396.     voice->viblfo_val += voice->viblfo_incr;
  398.     if (voice->viblfo_val > (fluid_real_t) 1.0)
  399.     {
  400.       voice->viblfo_incr = -voice->viblfo_incr;
  401.       voice->viblfo_val = (fluid_real_t) 2.0 - voice->viblfo_val;
  402.     }
  403.     else if (voice->viblfo_val < -1.0)
  404.     {
  405.       voice->viblfo_incr = -voice->viblfo_incr;
  406.       voice->viblfo_val = (fluid_real_t) -2.0 - voice->viblfo_val;
  407.     }
  408.   }
  410.   fluid_check_fpe ("voice_write Vib LFO");
  412.   /******************* amplitude **********************/
  414.   /* calculate final amplitude
  415.    * - initial gain
  416.    * - amplitude envelope
  417.    */
  419.   if (voice->volenv_section == FLUID_VOICE_ENVDELAY)
  420.     goto post_process; /* The volume amplitude is in hold phase. No sound is produced. */
  422.   if (voice->volenv_section == FLUID_VOICE_ENVATTACK)
  423.   {
  424.     /* the envelope is in the attack section: ramp linearly to max value.
  425.      * A positive modlfo_to_vol should increase volume (negative attenuation).
  426.      */
  427.     target_amp = fluid_atten2amp (voice->attenuation)
  428.       * fluid_cb2amp (voice->modlfo_val * -voice->modlfo_to_vol)
  429.       * voice->volenv_val;
  430.   }
  431.   else
  432.   {
  433.     fluid_real_t amplitude_that_reaches_noise_floor;
  434.     fluid_real_t amp_max;
  436.     target_amp = fluid_atten2amp (voice->attenuation)
  437.       * fluid_cb2amp (960.0f * (1.0f - voice->volenv_val)
  438.       + voice->modlfo_val * -voice->modlfo_to_vol);
  440.     /* We turn off a voice, if the volume has dropped low enough. */
  442.     /* A voice can be turned off, when an estimate for the volume
  443.      * (upper bound) falls below that volume, that will drop the
  444.      * sample below the noise floor.
  445.      */
  447.     /* If the loop amplitude is known, we can use it if the voice loop is within
  448.      * the sample loop
  449.      */
  451.     /* Is the playing pointer already in the loop? */
  452.     if (voice->has_looped)
  453.       amplitude_that_reaches_noise_floor = voice->amplitude_that_reaches_noise_floor_loop;
  454.     else
  455.       amplitude_that_reaches_noise_floor = voice->amplitude_that_reaches_noise_floor_nonloop;
  457.     /* voice->attenuation_min is a lower boundary for the attenuation
  458.      * now and in the future (possibly 0 in the worst case).  Now the
  459.      * amplitude of sample and volenv cannot exceed amp_max (since
  460.      * volenv_val can only drop):
  461.      */
  463.     amp_max = fluid_atten2amp (voice->min_attenuation_cB) * voice->volenv_val;
  465.     /* And if amp_max is already smaller than the known amplitude,
  466.      * which will attenuate the sample below the noise floor, then we
  467.      * can safely turn off the voice. Duh. */
  468.     if (amp_max < amplitude_that_reaches_noise_floor)
  469.     {
  470.       fluid_profile (FLUID_PROF_VOICE_RELEASE, voice->ref);
  471.       fluid_voice_off (voice);
  472.       goto post_process;
  473.     }
  474.   }
  476.   /* Volume increment to go from voice->amp to target_amp in FLUID_BUFSIZE steps */
  477.   voice->amp_incr = (target_amp - voice->amp) / FLUID_BUFSIZE;
  479.   fluid_check_fpe ("voice_write amplitude calculation");
  481.   /* no volume and not changing? - No need to process */
  482.   if ((voice->amp == 0.0f) && (voice->amp_incr == 0.0f))
  483.     goto post_process;
  485.   /* Calculate the number of samples, that the DSP loop advances
  486.    * through the original waveform with each step in the output
  487.    * buffer. It is the ratio between the frequencies of original
  488.    * waveform and output waveform.*/
  489.   voice->phase_incr = fluid_ct2hz_real
  490.     (voice->pitch + voice->modlfo_val * voice->modlfo_to_pitch
  491.      + voice->viblfo_val * voice->viblfo_to_pitch
  492.      + voice->modenv_val * voice->modenv_to_pitch) / voice->root_pitch_hz;
  494.   fluid_check_fpe ("voice_write phase calculation");
  496.   /* if phase_incr is not advancing, set it to the minimum fraction value (prevent stuckage) */
  497.   if (voice->phase_incr == 0) voice->phase_incr = 1;
  499.   /*************** resonant filter ******************/
  501.   /* calculate the frequency of the resonant filter in Hz */
  502.   fres = fluid_ct2hz(voice->fres
  503.      + voice->modlfo_val * voice->modlfo_to_fc
  504.      + voice->modenv_val * voice->modenv_to_fc);
  506.   /* FIXME - Still potential for a click during turn on, can we interpolate
  507.      between 20khz cutoff and 0 Q? */
  509.   /* I removed the optimization of turning the filter off when the
  510.    * resonance frequence is above the maximum frequency. Instead, the
  511.    * filter frequency is set to a maximum of 0.45 times the sampling
  512.    * rate. For a 44100 kHz sampling rate, this amounts to 19845
  513.    * Hz. The reason is that there were problems with anti-aliasing when the
  514.    * synthesizer was run at lower sampling rates. Thanks to Stephan
  515.    * Tassart for pointing me to this bug. By turning the filter on and
  516.    * clipping the maximum filter frequency at 0.45*srate, the filter
  517.    * is used as an anti-aliasing filter. */
  519.   if (fres > 0.45f * voice->output_rate)
  520.     fres = 0.45f * voice->output_rate;
  521.   else if (fres < 5)
  522.     fres = 5;
  524.   /* if filter enabled and there is a significant frequency change.. */
  525.   if ((abs (fres - voice->last_fres) > 0.01))
  526.   {
  527.     /* The filter coefficients have to be recalculated (filter
  528.     * parameters have changed). Recalculation for various reasons is
  529.     * forced by setting last_fres to -1.  The flag filter_startup
  530.     * indicates, that the DSP loop runs for the first time, in this
  531.     * case, the filter is set directly, instead of smoothly fading
  532.     * between old and new settings.
  533.     *
  534.     * Those equations from Robert Bristow-Johnson's `Cookbook
  535.     * formulae for audio EQ biquad filter coefficients', obtained
  536.     * from Harmony-central.com / Computer / Programming. They are
  537.     * the result of the bilinear transform on an analogue filter
  538.     * prototype. To quote, `BLT frequency warping has been taken
  539.     * into account for both significant frequency relocation and for
  540.     * bandwidth readjustment'. */
  542.    fluid_real_t omega = (fluid_real_t) (2.0 * M_PI * (fres / ((float) voice->output_rate)));
  543.    fluid_real_t sin_coeff = (fluid_real_t) sin(omega);
  544.    fluid_real_t cos_coeff = (fluid_real_t) cos(omega);
  545.    fluid_real_t alpha_coeff = sin_coeff / (2.0f * voice->q_lin);
  546.    fluid_real_t a0_inv = 1.0f / (1.0f + alpha_coeff);
  548.    /* Calculate the filter coefficients. All coefficients are
  549.     * normalized by a0. Think of `a1' as `a1/a0'.
  550.     *
  551.     * Here a couple of multiplications are saved by reusing common expressions.
  552.     * The original equations should be:
  553.     *  voice->b0=(1.-cos_coeff)*a0_inv*0.5*voice->filter_gain;
  554.     *  voice->b1=(1.-cos_coeff)*a0_inv*voice->filter_gain;
  555.     *  voice->b2=(1.-cos_coeff)*a0_inv*0.5*voice->filter_gain; */
  557.    fluid_real_t a1_temp = -2.0f * cos_coeff * a0_inv;
  558.    fluid_real_t a2_temp = (1.0f - alpha_coeff) * a0_inv;
  559.    fluid_real_t b1_temp = (1.0f - cos_coeff) * a0_inv * voice->filter_gain;
  560.    /* both b0 -and- b2 */
  561.    fluid_real_t b02_temp = b1_temp * 0.5f;
  563.    if (voice->filter_startup)
  564.    {
  565.      /* The filter is calculated, because the voice was started up.
  566.       * In this case set the filter coefficients without delay.
  567.       */
  568.      voice->a1 = a1_temp;
  569.      voice->a2 = a2_temp;
  570.      voice->b02 = b02_temp;
  571.      voice->b1 = b1_temp;
  572.      voice->filter_coeff_incr_count = 0;
  573.      voice->filter_startup = 0;
  574. //       printf("Setting initial filter coefficients.n");
  575.    }
  576.    else
  577.    {
  579.       /* The filter frequency is changed.  Calculate an increment
  580.        * factor, so that the new setting is reached after one buffer
  581.        * length. x_incr is added to the current value FLUID_BUFSIZE
  582.        * times. The length is arbitrarily chosen. Longer than one
  583.        * buffer will sacrifice some performance, though.  Note: If
  584.        * the filter is still too 'grainy', then increase this number
  585.        * at will.
  586.        */
  588. #define FILTER_TRANSITION_SAMPLES (FLUID_BUFSIZE)
  590.       voice->a1_incr = (a1_temp - voice->a1) / FILTER_TRANSITION_SAMPLES;
  591.       voice->a2_incr = (a2_temp - voice->a2) / FILTER_TRANSITION_SAMPLES;
  592.       voice->b02_incr = (b02_temp - voice->b02) / FILTER_TRANSITION_SAMPLES;
  593.       voice->b1_incr = (b1_temp - voice->b1) / FILTER_TRANSITION_SAMPLES;
  594.       /* Have to add the increments filter_coeff_incr_count times. */
  595.       voice->filter_coeff_incr_count = FILTER_TRANSITION_SAMPLES;
  596.     }
  597.     voice->last_fres = fres;
  598.     fluid_check_fpe ("voice_write filter calculation");
  599.   }
  602.   fluid_check_fpe ("voice_write DSP coefficients");
  604.   /*********************** run the dsp chain ************************
  605.    * The sample is mixed with the output buffer.
  606.    * The buffer has to be filled from 0 to FLUID_BUFSIZE-1.
  607.    * Depending on the position in the loop and the loop size, this
  608.    * may require several runs. */
  610.   switch (voice->interp_method)
  611.   {
  612.     case FLUID_INTERP_NONE:
  613.       count = fluid_dsp_float_interpolate_none (voice);
  614.       break;
  615.     case FLUID_INTERP_LINEAR:
  616.       count = fluid_dsp_float_interpolate_linear (voice);
  617.       break;
  618.     case FLUID_INTERP_4THORDER:
  619.     default:
  620.       count = fluid_dsp_float_interpolate_4th_order (voice);
  621.       break;
  622.     case FLUID_INTERP_7THORDER:
  623.       count = fluid_dsp_float_interpolate_7th_order (voice);
  624.       break;
  625.   }
  627.   fluid_check_fpe ("voice_write interpolation");
  629.   voice->dsp_buf_count = count;
  631.   /* Apply filter */
  632.   if (count > 0) fluid_voice_filter (voice);
  634.   /* turn off voice if short count (sample ended and not looping) */
  635.   if (count < FLUID_BUFSIZE)
  636.   {
  637.       fluid_profile(FLUID_PROF_VOICE_RELEASE, voice->ref);
  638.       fluid_voice_off(voice);
  639.   }
  641.  post_process:
  642.   voice->ticks += FLUID_BUFSIZE;
  643.   fluid_check_fpe ("voice_write postprocess");
  644.   return count;
  645. }
  648. /**
  649.  * Applies a lowpass filter with variable cutoff frequency and quality factor.
  650.  * @param voice Voice to apply filter to
  651.  * @param count Count of samples in voice->dsp_buf
  652.  */
  653. /*
  654.  * Variable description:
  655.  * - dsp_buf: Pointer to the synthesized audio data
  656.  * - dsp_a1, dsp_a2, dsp_b0, dsp_b1, dsp_b2: Filter coefficients
  657.  * - voice holds the voice structure
  658.  *
  659.  * A couple of variables are used internally, their results are discarded:
  660.  * - dsp_i: Index through the output buffer
  661.  * - dsp_phase_fractional: The fractional part of dsp_phase
  662.  * - dsp_coeff: A table of four coefficients, depending on the fractional phase.
  663.  *              Used to interpolate between samples.
  664.  * - dsp_process_buffer: Holds the processed signal between stages
  665.  * - dsp_centernode: delay line for the IIR filter
  666.  * - dsp_hist1: same
  667.  * - dsp_hist2: same
  668.  */
  669. static inline void
  670. fluid_voice_filter (fluid_voice_t *voice)
  671. {
  672.   /* IIR filter sample history */
  673.   fluid_real_t dsp_hist1 = voice->hist1;
  674.   fluid_real_t dsp_hist2 = voice->hist2;
  676.   /* IIR filter coefficients */
  677.   fluid_real_t dsp_a1 = voice->a1;
  678.   fluid_real_t dsp_a2 = voice->a2;
  679.   fluid_real_t dsp_b02 = voice->b02;
  680.   fluid_real_t dsp_b1 = voice->b1;
  681.   fluid_real_t dsp_a1_incr = voice->a1_incr;
  682.   fluid_real_t dsp_a2_incr = voice->a2_incr;
  683.   fluid_real_t dsp_b02_incr = voice->b02_incr;
  684.   fluid_real_t dsp_b1_incr = voice->b1_incr;
  685.   int dsp_filter_coeff_incr_count = voice->filter_coeff_incr_count;
  687.   fluid_real_t *dsp_buf = voice->dsp_buf;
  689.   fluid_real_t dsp_centernode;
  690.   int count = voice->dsp_buf_count;
  691.   int dsp_i;
  693.   /* filter (implement the voice filter according to SoundFont standard) */
  695.   /* Check for denormal number (too close to zero). */
  696.   if (fabs (dsp_hist1) < 1e-20) dsp_hist1 = 0.0f;  /* FIXME JMG - Is this even needed? */
  698.   /* Two versions of the filter loop. One, while the filter is
  699.   * changing towards its new setting. The other, if the filter
  700.   * doesn't change.
  701.   */
  703.   if (dsp_filter_coeff_incr_count > 0)
  704.   {
  705.     /* Increment is added to each filter coefficient filter_coeff_incr_count times. */
  706.     for (dsp_i = 0; dsp_i < count; dsp_i++)
  707.     {
  708.       /* The filter is implemented in Direct-II form. */
  709.       dsp_centernode = dsp_buf[dsp_i] - dsp_a1 * dsp_hist1 - dsp_a2 * dsp_hist2;
  710.       dsp_buf[dsp_i] = dsp_b02 * (dsp_centernode + dsp_hist2) + dsp_b1 * dsp_hist1;
  711.       dsp_hist2 = dsp_hist1;
  712.       dsp_hist1 = dsp_centernode;
  714.       if (dsp_filter_coeff_incr_count-- > 0)
  715.       {
  716. dsp_a1 += dsp_a1_incr;
  717. dsp_a2 += dsp_a2_incr;
  718. dsp_b02 += dsp_b02_incr;
  719. dsp_b1 += dsp_b1_incr;
  720.       }
  721.     } /* for dsp_i */
  722.   }
  723.   else /* The filter parameters are constant.  This is duplicated to save time. */
  724.   {
  725.     for (dsp_i = 0; dsp_i < count; dsp_i++)
  726.     { /* The filter is implemented in Direct-II form. */
  727.       dsp_centernode = dsp_buf[dsp_i] - dsp_a1 * dsp_hist1 - dsp_a2 * dsp_hist2;
  728.       dsp_buf[dsp_i] = dsp_b02 * (dsp_centernode + dsp_hist2) + dsp_b1 * dsp_hist1;
  729.       dsp_hist2 = dsp_hist1;
  730.       dsp_hist1 = dsp_centernode;
  731.     }
  732.   }
  734.   voice->hist1 = dsp_hist1;
  735.   voice->hist2 = dsp_hist2;
  736.   voice->a1 = dsp_a1;
  737.   voice->a2 = dsp_a2;
  738.   voice->b02 = dsp_b02;
  739.   voice->b1 = dsp_b1;
  740.   voice->filter_coeff_incr_count = dsp_filter_coeff_incr_count;
  742.   fluid_check_fpe ("voice_filter");
  743. }
  745. /**
  746.  * Mix voice data to left/right (panning), reverb and chorus buffers.
  747.  * @param voice Voice to mix
  748.  * @param left_buf Left audio buffer
  749.  * @param right_buf Right audio buffer
  750.  * @param reverb_buf Reverb buffer
  751.  * @param chorus_buf Chorus buffer
  752.  *
  753.  * NOTE: Uses voice->dsp_buf and voice->dsp_buf_count which were assigned
  754.  * by fluid_voice_write().  This is therefore meant to be called only after
  755.  * that function.
  756.  */
  757. void
  758. fluid_voice_mix (fluid_voice_t *voice,
  759.  fluid_real_t* left_buf, fluid_real_t* right_buf,
  760.  fluid_real_t* reverb_buf, fluid_real_t* chorus_buf)
  761. {
  762.   fluid_real_t *dsp_buf = voice->dsp_buf;
  763.   int count = voice->dsp_buf_count;
  764.   int dsp_i;
  765.   float v;
  767.   /* pan (Copy the signal to the left and right output buffer) The voice
  768.    * panning generator has a range of -500 .. 500.  If it is centered,
  769.    * it's close to 0.  voice->amp_left and voice->amp_right are then the
  770.    * same, and we can save one multiplication per voice and sample.
  771.    */
  772.   if ((-0.5 < voice->pan) && (voice->pan < 0.5))
  773.   {
  774.     /* The voice is centered. Use voice->amp_left twice. */
  775.     for (dsp_i = 0; dsp_i < count; dsp_i++)
  776.     {
  777.       v = voice->amp_left * dsp_buf[dsp_i];
  778.       left_buf[dsp_i] += v;
  779.       right_buf[dsp_i] += v;
  780.     }
  781.   }
  782.   else /* The voice is not centered. Stereo samples have one side zero. */
  783.   {
  784.     if (voice->amp_left != 0.0)
  785.     {
  786.       for (dsp_i = 0; dsp_i < count; dsp_i++)
  787. left_buf[dsp_i] += voice->amp_left * dsp_buf[dsp_i];
  788.     }
  790.     if (voice->amp_right != 0.0)
  791.     {
  792.       for (dsp_i = 0; dsp_i < count; dsp_i++)
  793. right_buf[dsp_i] += voice->amp_right * dsp_buf[dsp_i];
  794.     }
  795.   }
  797.   /* reverb send. Buffer may be NULL. */
  798.   if ((reverb_buf != NULL) && (voice->amp_reverb != 0.0))
  799.   {
  800.     for (dsp_i = 0; dsp_i < count; dsp_i++)
  801.       reverb_buf[dsp_i] += voice->amp_reverb * dsp_buf[dsp_i];
  802.   }
  804.   /* chorus send. Buffer may be NULL. */
  805.   if ((chorus_buf != NULL) && (voice->amp_chorus != 0))
  806.   {
  807.     for (dsp_i = 0; dsp_i < count; dsp_i++)
  808.       chorus_buf[dsp_i] += voice->amp_chorus * dsp_buf[dsp_i];
  809.   }
  811.   fluid_check_fpe ("voice_mix");
  812. }
  814. /*
  815.  * fluid_voice_start
  816.  */
  817. void fluid_voice_start(fluid_voice_t* voice)
  818. {
  819.   /* The maximum volume of the loop is calculated and cached once for each
  820.    * sample with its nominal loop settings. This happens, when the sample is used
  821.    * for the first time.*/
  823.   fluid_voice_calculate_runtime_synthesis_parameters(voice);
  825.   /* Force setting of the phase at the first DSP loop run
  826.    * This cannot be done earlier, because it depends on modulators.*/
  827.   voice->check_sample_sanity_flag=FLUID_SAMPLESANITY_STARTUP;
  829.   voice->ref = fluid_profile_ref();
  831.   voice->status = FLUID_VOICE_ON;
  833.   /* Increment voice count atomically, for non-synth thread read access */
  834.   fluid_atomic_int_add (&voice->channel->synth->active_voice_count, 1);
  835. }
  837. void 
  838. fluid_voice_calculate_gen_pitch(fluid_voice_t* voice)
  839. {
  840.   fluid_tuning_t* tuning;
  841.   fluid_real_t x;
  843.   /* The GEN_PITCH is a hack to fit the pitch bend controller into the
  844.    * modulator paradigm.  Now the nominal pitch of the key is set.
  845.    * Note about SCALETUNE: SF2.01 8.1.3 says, that this generator is a
  846.    * non-realtime parameter. So we don't allow modulation (as opposed
  847.    * to _GEN(voice, GEN_SCALETUNE) When the scale tuning is varied,
  848.    * one key remains fixed. Here C3 (MIDI number 60) is used.
  849.    */
  850.   if (fluid_channel_has_tuning(voice->channel)) {
  851.     tuning = fluid_channel_get_tuning (voice->channel);
  852.     x = fluid_tuning_get_pitch (tuning, (int)(voice->root_pitch / 100.0f));
  853.     voice->gen[GEN_PITCH].val = voice->gen[GEN_SCALETUNE].val / 100.0f *
  854.       (fluid_tuning_get_pitch (tuning, voice->key) - x) + x;
  855.   } else {
  856.     voice->gen[GEN_PITCH].val = voice->gen[GEN_SCALETUNE].val
  857.       * (voice->key - voice->root_pitch / 100.0f) + voice->root_pitch;
  858.   }
  859. }
  861. /*
  862.  * fluid_voice_calculate_runtime_synthesis_parameters
  863.  *
  864.  * in this function we calculate the values of all the parameters. the
  865.  * parameters are converted to their most useful unit for the DSP
  866.  * algorithm, for example, number of samples instead of
  867.  * timecents. Some parameters keep their "perceptual" unit and
  868.  * conversion will be done in the DSP function. This is the case, for
  869.  * example, for the pitch since it is modulated by the controllers in
  870.  * cents. */
  871. static int
  872. fluid_voice_calculate_runtime_synthesis_parameters(fluid_voice_t* voice)
  873. {
  874.   int i;
  876.   int list_of_generators_to_initialize[35] = {
  877.     GEN_STARTADDROFS,                    /* SF2.01 page 48 #0   */
  878.     GEN_ENDADDROFS,                      /*                #1   */
  879.     GEN_STARTLOOPADDROFS,                /*                #2   */
  880.     GEN_ENDLOOPADDROFS,                  /*                #3   */
  881.     /* GEN_STARTADDRCOARSEOFS see comment below [1]        #4   */
  882.     GEN_MODLFOTOPITCH,                   /*                #5   */
  883.     GEN_VIBLFOTOPITCH,                   /*                #6   */
  884.     GEN_MODENVTOPITCH,                   /*                #7   */
  885.     GEN_FILTERFC,                        /*                #8   */
  886.     GEN_FILTERQ,                         /*                #9   */
  887.     GEN_MODLFOTOFILTERFC,                /*                #10  */
  888.     GEN_MODENVTOFILTERFC,                /*                #11  */
  889.     /* GEN_ENDADDRCOARSEOFS [1]                            #12  */
  890.     GEN_MODLFOTOVOL,                     /*                #13  */
  891.     /* not defined                                         #14  */
  892.     GEN_CHORUSSEND,                      /*                #15  */
  893.     GEN_REVERBSEND,                      /*                #16  */
  894.     GEN_PAN,                             /*                #17  */
  895.     /* not defined                                         #18  */
  896.     /* not defined                                         #19  */
  897.     /* not defined                                         #20  */
  898.     GEN_MODLFODELAY,                     /*                #21  */
  899.     GEN_MODLFOFREQ,                      /*                #22  */
  900.     GEN_VIBLFODELAY,                     /*                #23  */
  901.     GEN_VIBLFOFREQ,                      /*                #24  */
  902.     GEN_MODENVDELAY,                     /*                #25  */
  903.     GEN_MODENVATTACK,                    /*                #26  */
  904.     GEN_MODENVHOLD,                      /*                #27  */
  905.     GEN_MODENVDECAY,                     /*                #28  */
  906.     /* GEN_MODENVSUSTAIN [1]                               #29  */
  907.     GEN_MODENVRELEASE,                   /*                #30  */
  908.     /* GEN_KEYTOMODENVHOLD [1]                             #31  */
  909.     /* GEN_KEYTOMODENVDECAY [1]                            #32  */
  910.     GEN_VOLENVDELAY,                     /*                #33  */
  911.     GEN_VOLENVATTACK,                    /*                #34  */
  912.     GEN_VOLENVHOLD,                      /*                #35  */
  913.     GEN_VOLENVDECAY,                     /*                #36  */
  914.     /* GEN_VOLENVSUSTAIN [1]                               #37  */
  915.     GEN_VOLENVRELEASE,                   /*                #38  */
  916.     /* GEN_KEYTOVOLENVHOLD [1]                             #39  */
  917.     /* GEN_KEYTOVOLENVDECAY [1]                            #40  */
  918.     /* GEN_STARTLOOPADDRCOARSEOFS [1]                      #45  */
  919.     GEN_KEYNUM,                          /*                #46  */
  920.     GEN_VELOCITY,                        /*                #47  */
  921.     GEN_ATTENUATION,                     /*                #48  */
  922.     /* GEN_ENDLOOPADDRCOARSEOFS [1]                        #50  */
  923.     /* GEN_COARSETUNE           [1]                        #51  */
  924.     /* GEN_FINETUNE             [1]                        #52  */
  925.     GEN_OVERRIDEROOTKEY,                 /*                #58  */
  926.     GEN_PITCH,                           /*                ---  */
  927.     -1};                                 /* end-of-list marker  */
  929.   /* When the voice is made ready for the synthesis process, a lot of
  930.    * voice-internal parameters have to be calculated.
  931.    *
  932.    * At this point, the sound font has already set the -nominal- value
  933.    * for all generators (excluding GEN_PITCH). Most generators can be
  934.    * modulated - they include a nominal value and an offset (which
  935.    * changes with velocity, note number, channel parameters like
  936.    * aftertouch, mod wheel...) Now this offset will be calculated as
  937.    * follows:
  938.    *
  939.    *  - Process each modulator once.
  940.    *  - Calculate its output value.
  941.    *  - Find the target generator.
  942.    *  - Add the output value to the modulation value of the generator.
  943.    *
  944.    * Note: The generators have been initialized with
  945.    * fluid_gen_set_default_values.
  946.    */
  948.   for (i = 0; i < voice->mod_count; i++) {
  949.     fluid_mod_t* mod = &voice->mod[i];
  950.     fluid_real_t modval = fluid_mod_get_value(mod, voice->channel, voice);
  951.     int dest_gen_index = mod->dest;
  952.     fluid_gen_t* dest_gen = &voice->gen[dest_gen_index];
  953.     dest_gen->mod += modval;
  954.     /*      fluid_dump_modulator(mod); */
  955.   }
  957.   /* Now the generators are initialized, nominal and modulation value.
  958.    * The voice parameters (which depend on generators) are calculated
  959.    * with fluid_voice_update_param. Processing the list of generator
  960.    * changes will calculate each voice parameter once.
  961.    *
  962.    * Note [1]: Some voice parameters depend on several generators. For
  963.    * example, the pitch depends on GEN_COARSETUNE, GEN_FINETUNE and
  964.    * GEN_PITCH.  voice->pitch.  Unnecessary recalculation is avoided
  965.    * by removing all but one generator from the list of voice
  966.    * parameters.  Same with GEN_XXX and GEN_XXXCOARSE: the
  967.    * initialisation list contains only GEN_XXX.
  968.    */
  970.   /* Calculate the voice parameter(s) dependent on each generator. */
  971.   for (i = 0; list_of_generators_to_initialize[i] != -1; i++) {
  972.     fluid_voice_update_param(voice, list_of_generators_to_initialize[i]);
  973.   }
  975.   /* Make an estimate on how loud this voice can get at any time (attenuation). */
  976.   voice->min_attenuation_cB = fluid_voice_get_lower_boundary_for_attenuation(voice);
  978.   return FLUID_OK;
  979. }
  981. /*
  982.  * calculate_hold_decay_buffers
  983.  */
  984. static int
  985. calculate_hold_decay_buffers(fluid_voice_t* voice, int gen_base,
  986.                              int gen_key2base, int is_decay)
  987. {
  988.   /* Purpose:
  989.    *
  990.    * Returns the number of DSP loops, that correspond to the hold
  991.    * (is_decay=0) or decay (is_decay=1) time.
  992.    * gen_base=GEN_VOLENVHOLD, GEN_VOLENVDECAY, GEN_MODENVHOLD,
  993.    * GEN_MODENVDECAY gen_key2base=GEN_KEYTOVOLENVHOLD,
  994.    * GEN_KEYTOVOLENVDECAY, GEN_KEYTOMODENVHOLD, GEN_KEYTOMODENVDECAY
  995.    */
  997.   fluid_real_t timecents;
  998.   fluid_real_t seconds;
  999.   int buffers;
  1001.   /* SF2.01 section 8.4.3 # 31, 32, 39, 40
  1002.    * GEN_KEYTOxxxENVxxx uses key 60 as 'origin'.
  1003.    * The unit of the generator is timecents per key number.
  1004.    * If KEYTOxxxENVxxx is 100, a key one octave over key 60 (72)
  1005.    * will cause (60-72)*100=-1200 timecents of time variation.
  1006.    * The time is cut in half.
  1007.    */
  1008.   timecents = (_GEN(voice, gen_base) + _GEN(voice, gen_key2base) * (60.0 - voice->key));
  1010.   /* Range checking */
  1011.   if (is_decay){
  1012.     /* SF 2.01 section 8.1.3 # 28, 36 */
  1013.     if (timecents > 8000.0) {
  1014.       timecents = 8000.0;
  1015.     }
  1016.   } else {
  1017.     /* SF 2.01 section 8.1.3 # 27, 35 */
  1018.     if (timecents > 5000) {
  1019.       timecents = 5000.0;
  1020.     }
  1021.     /* SF 2.01 section 8.1.2 # 27, 35:
  1022.      * The most negative number indicates no hold time
  1023.      */
  1024.     if (timecents <= -32768.) {
  1025.       return 0;
  1026.     }
  1027.   }
  1028.   /* SF 2.01 section 8.1.3 # 27, 28, 35, 36 */
  1029.   if (timecents < -12000.0) {
  1030.     timecents = -12000.0;
  1031.   }
  1033.   seconds = fluid_tc2sec(timecents);
  1034.   /* Each DSP loop processes FLUID_BUFSIZE samples. */
  1036.   /* round to next full number of buffers */
  1037.   buffers = (int)(((fluid_real_t)voice->output_rate * seconds)
  1038.   / (fluid_real_t)FLUID_BUFSIZE
  1039.   +0.5);
  1041.   return buffers;
  1042. }
  1044. /*
  1045.  * The value of a generator (gen) has changed.  (The different
  1046.  * generators are listed in fluidsynth.h, or in SF2.01 page 48-49)
  1047.  * Now the dependent 'voice' parameters are calculated.
  1048.  *
  1049.  * fluid_voice_update_param can be called during the setup of the
  1050.  * voice (to calculate the initial value for a voice parameter), or
  1051.  * during its operation (a generator has been changed due to
  1052.  * real-time parameter modifications like pitch-bend).
  1053.  *
  1054.  * Note: The generator holds three values: The base value .val, an
  1055.  * offset caused by modulators .mod, and an offset caused by the
  1056.  * NRPN system. _GEN(voice, generator_enumerator) returns the sum
  1057.  * of all three.
  1058.  */
  1059. /**
  1060.  * Update all the synthesis parameters, which depend on generator a gen.
  1061.  * @param voice Voice instance
  1062.  * @param gen Generator id (#fluid_gen_type)
  1063.  *
  1064.  * This is only necessary after changing a generator of an already operating voice.
  1065.  * Most applications will not need this function.
  1066.  */
  1067. void
  1068. fluid_voice_update_param(fluid_voice_t* voice, int gen)
  1069. {
  1070.   double q_dB;
  1071.   fluid_real_t x;
  1072.   fluid_real_t y;
  1073.   unsigned int count;
  1074.   // Alternate attenuation scale used by EMU10K1 cards when setting the attenuation at the preset or instrument level within the SoundFont bank.
  1075.   static const float ALT_ATTENUATION_SCALE = 0.4;
  1077.   switch (gen) {
  1079.   case GEN_PAN:
  1080.     /* range checking is done in the fluid_pan function */
  1081.     voice->pan = _GEN(voice, GEN_PAN);
  1082.     voice->amp_left = fluid_pan(voice->pan, 1) * voice->synth_gain / 32768.0f;
  1083.     voice->amp_right = fluid_pan(voice->pan, 0) * voice->synth_gain / 32768.0f;
  1084.     break;
  1086.   case GEN_ATTENUATION:
  1087.     voice->attenuation = ((fluid_real_t)(voice)->gen[GEN_ATTENUATION].val*ALT_ATTENUATION_SCALE) +
  1088.     (fluid_real_t)(voice)->gen[GEN_ATTENUATION].mod + (fluid_real_t)(voice)->gen[GEN_ATTENUATION].nrpn;
  1090.     /* Range: SF2.01 section 8.1.3 # 48
  1091.      * Motivation for range checking:
  1092.      * OHPiano.SF2 sets initial attenuation to a whooping -96 dB */
  1093.     fluid_clip(voice->attenuation, 0.0, 1440.0);
  1094.     break;
  1096.     /* The pitch is calculated from three different generators.
  1097.      * Read comment in fluidsynth.h about GEN_PITCH.
  1098.      */
  1099.   case GEN_PITCH:
  1100.   case GEN_COARSETUNE:
  1101.   case GEN_FINETUNE:
  1102.     /* The testing for allowed range is done in 'fluid_ct2hz' */
  1103.     voice->pitch = (_GEN(voice, GEN_PITCH)
  1104.     + 100.0f * _GEN(voice, GEN_COARSETUNE)
  1105.     + _GEN(voice, GEN_FINETUNE));
  1106.     break;
  1108.   case GEN_REVERBSEND:
  1109.     /* The generator unit is 'tenths of a percent'. */
  1110.     voice->reverb_send = _GEN(voice, GEN_REVERBSEND) / 1000.0f;
  1111.     fluid_clip(voice->reverb_send, 0.0, 1.0);
  1112.     voice->amp_reverb = voice->reverb_send * voice->synth_gain / 32768.0f;
  1113.     break;
  1115.   case GEN_CHORUSSEND:
  1116.     /* The generator unit is 'tenths of a percent'. */
  1117.     voice->chorus_send = _GEN(voice, GEN_CHORUSSEND) / 1000.0f;
  1118.     fluid_clip(voice->chorus_send, 0.0, 1.0);
  1119.     voice->amp_chorus = voice->chorus_send * voice->synth_gain / 32768.0f;
  1120.     break;
  1122.   case GEN_OVERRIDEROOTKEY:
  1123.     /* This is a non-realtime parameter. Therefore the .mod part of the generator
  1124.      * can be neglected.
  1125.      * NOTE: origpitch sets MIDI root note while pitchadj is a fine tuning amount
  1126.      * which offsets the original rate.  This means that the fine tuning is
  1127.      * inverted with respect to the root note (so subtract it, not add).
  1128.      */
  1129.     if (voice->gen[GEN_OVERRIDEROOTKEY].val > -1) {   //FIXME: use flag instead of -1
  1130.       voice->root_pitch = voice->gen[GEN_OVERRIDEROOTKEY].val * 100.0f
  1131. - voice->sample->pitchadj;
  1132.     } else {
  1133.       voice->root_pitch = voice->sample->origpitch * 100.0f - voice->sample->pitchadj;
  1134.     }
  1135.     voice->root_pitch_hz = fluid_ct2hz(voice->root_pitch);
  1136.     if (voice->sample != NULL) {
  1137.       voice->root_pitch_hz *= (fluid_real_t) voice->output_rate / voice->sample->samplerate;
  1138.     }
  1139.     /* voice->pitch depends on voice->root_pitch, so calculate voice->pitch now */
  1140.     fluid_voice_calculate_gen_pitch(voice);
  1141.     break;
  1143.   case GEN_FILTERFC:
  1144.     /* The resonance frequency is converted from absolute cents to
  1145.      * midicents .val and .mod are both used, this permits real-time
  1146.      * modulation.  The allowed range is tested in the 'fluid_ct2hz'
  1147.      * function [PH,20021214]
  1148.      */
  1149.     voice->fres = _GEN(voice, GEN_FILTERFC);
  1151.     /* The synthesis loop will have to recalculate the filter
  1152.      * coefficients. */
  1153.     voice->last_fres = -1.0f;
  1154.     break;
  1156.   case GEN_FILTERQ:
  1157.     /* The generator contains 'centibels' (1/10 dB) => divide by 10 to
  1158.      * obtain dB */
  1159.     q_dB = _GEN(voice, GEN_FILTERQ) / 10.0f;
  1161.     /* Range: SF2.01 section 8.1.3 # 8 (convert from cB to dB => /10) */
  1162.     fluid_clip(q_dB, 0.0f, 96.0f);
  1164.     /* Short version: Modify the Q definition in a way, that a Q of 0
  1165.      * dB leads to no resonance hump in the freq. response.
  1166.      *
  1167.      * Long version: From SF2.01, page 39, item 9 (initialFilterQ):
  1168.      * "The gain at the cutoff frequency may be less than zero when
  1169.      * zero is specified".  Assume q_dB=0 / q_lin=1: If we would leave
  1170.      * q as it is, then this results in a 3 dB hump slightly below
  1171.      * fc. At fc, the gain is exactly the DC gain (0 dB).  What is
  1172.      * (probably) meant here is that the filter does not show a
  1173.      * resonance hump for q_dB=0. In this case, the corresponding
  1174.      * q_lin is 1/sqrt(2)=0.707.  The filter should have 3 dB of
  1175.      * attenuation at fc now.  In this case Q_dB is the height of the
  1176.      * resonance peak not over the DC gain, but over the frequency
  1177.      * response of a non-resonant filter.  This idea is implemented as
  1178.      * follows: */
  1179.     q_dB -= 3.01f;
  1181.     /* The 'sound font' Q is defined in dB. The filter needs a linear
  1182.        q. Convert. */
  1183.     voice->q_lin = (fluid_real_t) (pow(10.0f, q_dB / 20.0f));
  1185.     /* SF 2.01 page 59:
  1186.      *
  1187.      *  The SoundFont specs ask for a gain reduction equal to half the
  1188.      *  height of the resonance peak (Q).  For example, for a 10 dB
  1189.      *  resonance peak, the gain is reduced by 5 dB.  This is done by
  1190.      *  multiplying the total gain with sqrt(1/Q).  `Sqrt' divides dB
  1191.      *  by 2 (100 lin = 40 dB, 10 lin = 20 dB, 3.16 lin = 10 dB etc)
  1192.      *  The gain is later factored into the 'b' coefficients
  1193.      *  (numerator of the filter equation).  This gain factor depends
  1194.      *  only on Q, so this is the right place to calculate it.
  1195.      */
  1196.     voice->filter_gain = (fluid_real_t) (1.0 / sqrt(voice->q_lin));
  1198.     /* The synthesis loop will have to recalculate the filter coefficients. */
  1199.     voice->last_fres = -1.;
  1200.     break;
  1202.   case GEN_MODLFOTOPITCH:
  1203.     voice->modlfo_to_pitch = _GEN(voice, GEN_MODLFOTOPITCH);
  1204.     fluid_clip(voice->modlfo_to_pitch, -12000.0, 12000.0);
  1205.     break;
  1207.   case GEN_MODLFOTOVOL:
  1208.     voice->modlfo_to_vol = _GEN(voice, GEN_MODLFOTOVOL);
  1209.     fluid_clip(voice->modlfo_to_vol, -960.0, 960.0);
  1210.     break;
  1212.   case GEN_MODLFOTOFILTERFC:
  1213.     voice->modlfo_to_fc = _GEN(voice, GEN_MODLFOTOFILTERFC);
  1214.     fluid_clip(voice->modlfo_to_fc, -12000, 12000);
  1215.     break;
  1217.   case GEN_MODLFODELAY:
  1218.     x = _GEN(voice, GEN_MODLFODELAY);
  1219.     fluid_clip(x, -12000.0f, 5000.0f);
  1220.     voice->modlfo_delay = (unsigned int) (voice->output_rate * fluid_tc2sec_delay(x));
  1221.     break;
  1223.   case GEN_MODLFOFREQ:
  1224.     /* - the frequency is converted into a delta value, per buffer of FLUID_BUFSIZE samples
  1225.      * - the delay into a sample delay
  1226.      */
  1227.     x = _GEN(voice, GEN_MODLFOFREQ);
  1228.     fluid_clip(x, -16000.0f, 4500.0f);
  1229.     voice->modlfo_incr = (4.0f * FLUID_BUFSIZE * fluid_act2hz(x) / voice->output_rate);
  1230.     break;
  1232.   case GEN_VIBLFOFREQ:
  1233.     /* vib lfo
  1234.      *
  1235.      * - the frequency is converted into a delta value, per buffer of FLUID_BUFSIZE samples
  1236.      * - the delay into a sample delay
  1237.      */
  1238.     x = _GEN(voice, GEN_VIBLFOFREQ);
  1239.     fluid_clip(x, -16000.0f, 4500.0f);
  1240.     voice->viblfo_incr = (4.0f * FLUID_BUFSIZE * fluid_act2hz(x) / voice->output_rate);
  1241.     break;
  1243.   case GEN_VIBLFODELAY:
  1244.     x = _GEN(voice,GEN_VIBLFODELAY);
  1245.     fluid_clip(x, -12000.0f, 5000.0f);
  1246.     voice->viblfo_delay = (unsigned int) (voice->output_rate * fluid_tc2sec_delay(x));
  1247.     break;
  1249.   case GEN_VIBLFOTOPITCH:
  1250.     voice->viblfo_to_pitch = _GEN(voice, GEN_VIBLFOTOPITCH);
  1251.     fluid_clip(voice->viblfo_to_pitch, -12000.0, 12000.0);
  1252.     break;
  1254.   case GEN_KEYNUM:
  1255.     /* GEN_KEYNUM: SF2.01 page 46, item 46
  1256.      *
  1257.      * If this generator is active, it forces the key number to its
  1258.      * value.  Non-realtime controller.
  1259.      *
  1260.      * There is a flag, which should indicate, whether a generator is
  1261.      * enabled or not.  But here we rely on the default value of -1.
  1262.      * */
  1263.     x = _GEN(voice, GEN_KEYNUM);
  1264.     if (x >= 0){
  1265.       voice->key = x;
  1266.     }
  1267.     break;
  1269.   case GEN_VELOCITY:
  1270.     /* GEN_VELOCITY: SF2.01 page 46, item 47
  1271.      *
  1272.      * If this generator is active, it forces the velocity to its
  1273.      * value. Non-realtime controller.
  1274.      *
  1275.      * There is a flag, which should indicate, whether a generator is
  1276.      * enabled or not. But here we rely on the default value of -1.  */
  1277.     x = _GEN(voice, GEN_VELOCITY);
  1278.     if (x > 0) {
  1279.       voice->vel = x;
  1280.     }
  1281.     break;
  1283.   case GEN_MODENVTOPITCH:
  1284.     voice->modenv_to_pitch = _GEN(voice, GEN_MODENVTOPITCH);
  1285.     fluid_clip(voice->modenv_to_pitch, -12000.0, 12000.0);
  1286.     break;
  1288.   case GEN_MODENVTOFILTERFC:
  1289.     voice->modenv_to_fc = _GEN(voice,GEN_MODENVTOFILTERFC);
  1291.     /* Range: SF2.01 section 8.1.3 # 1
  1292.      * Motivation for range checking:
  1293.      * Filter is reported to make funny noises now and then
  1294.      */
  1295.     fluid_clip(voice->modenv_to_fc, -12000.0, 12000.0);
  1296.     break;
  1299.     /* sample start and ends points
  1300.      *
  1301.      * Range checking is initiated via the
  1302.      * voice->check_sample_sanity flag,
  1303.      * because it is impossible to check here:
  1304.      * During the voice setup, all modulators are processed, while
  1305.      * the voice is inactive. Therefore, illegal settings may
  1306.      * occur during the setup (for example: First move the loop
  1307.      * end point ahead of the loop start point => invalid, then
  1308.      * move the loop start point forward => valid again.
  1309.      */
  1310.   case GEN_STARTADDROFS:              /* SF2.01 section 8.1.3 # 0 */
  1311.   case GEN_STARTADDRCOARSEOFS:        /* SF2.01 section 8.1.3 # 4 */
  1312.     if (voice->sample != NULL) {
  1313.       voice->start = (voice->sample->start
  1314.      + (int) _GEN(voice, GEN_STARTADDROFS)
  1315.      + 32768 * (int) _GEN(voice, GEN_STARTADDRCOARSEOFS));
  1316.       voice->check_sample_sanity_flag = FLUID_SAMPLESANITY_CHECK;
  1317.     }
  1318.     break;
  1319.   case GEN_ENDADDROFS:                 /* SF2.01 section 8.1.3 # 1 */
  1320.   case GEN_ENDADDRCOARSEOFS:           /* SF2.01 section 8.1.3 # 12 */
  1321.     if (voice->sample != NULL) {
  1322.       voice->end = (voice->sample->end
  1323.    + (int) _GEN(voice, GEN_ENDADDROFS)
  1324.    + 32768 * (int) _GEN(voice, GEN_ENDADDRCOARSEOFS));
  1325.       voice->check_sample_sanity_flag = FLUID_SAMPLESANITY_CHECK;
  1326.     }
  1327.     break;
  1328.   case GEN_STARTLOOPADDROFS:           /* SF2.01 section 8.1.3 # 2 */
  1329.   case GEN_STARTLOOPADDRCOARSEOFS:     /* SF2.01 section 8.1.3 # 45 */
  1330.     if (voice->sample != NULL) {
  1331.       voice->loopstart = (voice->sample->loopstart
  1332.   + (int) _GEN(voice, GEN_STARTLOOPADDROFS)
  1333.   + 32768 * (int) _GEN(voice, GEN_STARTLOOPADDRCOARSEOFS));
  1334.       voice->check_sample_sanity_flag = FLUID_SAMPLESANITY_CHECK;
  1335.     }
  1336.     break;
  1338.   case GEN_ENDLOOPADDROFS:             /* SF2.01 section 8.1.3 # 3 */
  1339.   case GEN_ENDLOOPADDRCOARSEOFS:       /* SF2.01 section 8.1.3 # 50 */
  1340.     if (voice->sample != NULL) {
  1341.       voice->loopend = (voice->sample->loopend
  1342. + (int) _GEN(voice, GEN_ENDLOOPADDROFS)
  1343. + 32768 * (int) _GEN(voice, GEN_ENDLOOPADDRCOARSEOFS));
  1344.       voice->check_sample_sanity_flag = FLUID_SAMPLESANITY_CHECK;
  1345.     }
  1346.     break;
  1348.     /* Conversion functions differ in range limit */
  1349. #define NUM_BUFFERS_DELAY(_v)   (unsigned int) (voice->output_rate * fluid_tc2sec_delay(_v) / FLUID_BUFSIZE)
  1350. #define NUM_BUFFERS_ATTACK(_v)  (unsigned int) (voice->output_rate * fluid_tc2sec_attack(_v) / FLUID_BUFSIZE)
  1351. #define NUM_BUFFERS_RELEASE(_v) (unsigned int) (voice->output_rate * fluid_tc2sec_release(_v) / FLUID_BUFSIZE)
  1353.     /* volume envelope
  1354.      *
  1355.      * - delay and hold times are converted to absolute number of samples
  1356.      * - sustain is converted to its absolute value
  1357.      * - attack, decay and release are converted to their increment per sample
  1358.      */
  1359.   case GEN_VOLENVDELAY:                /* SF2.01 section 8.1.3 # 33 */
  1360.     x = _GEN(voice, GEN_VOLENVDELAY);
  1361.     fluid_clip(x, -12000.0f, 5000.0f);
  1362.     count = NUM_BUFFERS_DELAY(x);
  1363.     voice->volenv_data[FLUID_VOICE_ENVDELAY].count = count;
  1364.     voice->volenv_data[FLUID_VOICE_ENVDELAY].coeff = 0.0f;
  1365.     voice->volenv_data[FLUID_VOICE_ENVDELAY].incr = 0.0f;
  1366.     voice->volenv_data[FLUID_VOICE_ENVDELAY].min = -1.0f;
  1367.     voice->volenv_data[FLUID_VOICE_ENVDELAY].max = 1.0f;
  1368.     break;
  1370.   case GEN_VOLENVATTACK:               /* SF2.01 section 8.1.3 # 34 */
  1371.     x = _GEN(voice, GEN_VOLENVATTACK);
  1372.     fluid_clip(x, -12000.0f, 8000.0f);
  1373.     count = 1 + NUM_BUFFERS_ATTACK(x);
  1374.     voice->volenv_data[FLUID_VOICE_ENVATTACK].count = count;
  1375.     voice->volenv_data[FLUID_VOICE_ENVATTACK].coeff = 1.0f;
  1376.     voice->volenv_data[FLUID_VOICE_ENVATTACK].incr = count ? 1.0f / count : 0.0f;
  1377.     voice->volenv_data[FLUID_VOICE_ENVATTACK].min = -1.0f;
  1378.     voice->volenv_data[FLUID_VOICE_ENVATTACK].max = 1.0f;
  1379.     break;
  1381.   case GEN_VOLENVHOLD:                 /* SF2.01 section 8.1.3 # 35 */
  1382.   case GEN_KEYTOVOLENVHOLD:            /* SF2.01 section 8.1.3 # 39 */
  1383.     count = calculate_hold_decay_buffers(voice, GEN_VOLENVHOLD, GEN_KEYTOVOLENVHOLD, 0); /* 0 means: hold */
  1384.     voice->volenv_data[FLUID_VOICE_ENVHOLD].count = count;
  1385.     voice->volenv_data[FLUID_VOICE_ENVHOLD].coeff = 1.0f;
  1386.     voice->volenv_data[FLUID_VOICE_ENVHOLD].incr = 0.0f;
  1387.     voice->volenv_data[FLUID_VOICE_ENVHOLD].min = -1.0f;
  1388.     voice->volenv_data[FLUID_VOICE_ENVHOLD].max = 2.0f;
  1389.     break;
  1391.   case GEN_VOLENVDECAY:               /* SF2.01 section 8.1.3 # 36 */
  1392.   case GEN_VOLENVSUSTAIN:             /* SF2.01 section 8.1.3 # 37 */
  1393.   case GEN_KEYTOVOLENVDECAY:          /* SF2.01 section 8.1.3 # 40 */
  1394.     y = 1.0f - 0.001f * _GEN(voice, GEN_VOLENVSUSTAIN);
  1395.     fluid_clip(y, 0.0f, 1.0f);
  1396.     count = calculate_hold_decay_buffers(voice, GEN_VOLENVDECAY, GEN_KEYTOVOLENVDECAY, 1); /* 1 for decay */
  1397.     voice->volenv_data[FLUID_VOICE_ENVDECAY].count = count;
  1398.     voice->volenv_data[FLUID_VOICE_ENVDECAY].coeff = 1.0f;
  1399.     voice->volenv_data[FLUID_VOICE_ENVDECAY].incr = count ? -1.0f / count : 0.0f;
  1400.     voice->volenv_data[FLUID_VOICE_ENVDECAY].min = y;
  1401.     voice->volenv_data[FLUID_VOICE_ENVDECAY].max = 2.0f;
  1402.     break;
  1404.   case GEN_VOLENVRELEASE:             /* SF2.01 section 8.1.3 # 38 */
  1405.     x = _GEN(voice, GEN_VOLENVRELEASE);
  1406.     fluid_clip(x, FLUID_MIN_VOLENVRELEASE, 8000.0f);
  1407.     count = 1 + NUM_BUFFERS_RELEASE(x);
  1408.     voice->volenv_data[FLUID_VOICE_ENVRELEASE].count = count;
  1409.     voice->volenv_data[FLUID_VOICE_ENVRELEASE].coeff = 1.0f;
  1410.     voice->volenv_data[FLUID_VOICE_ENVRELEASE].incr = count ? -1.0f / count : 0.0f;
  1411.     voice->volenv_data[FLUID_VOICE_ENVRELEASE].min = 0.0f;
  1412.     voice->volenv_data[FLUID_VOICE_ENVRELEASE].max = 1.0f;
  1413.     break;
  1415.     /* Modulation envelope */
  1416.   case GEN_MODENVDELAY:               /* SF2.01 section 8.1.3 # 25 */
  1417.     x = _GEN(voice, GEN_MODENVDELAY);
  1418.     fluid_clip(x, -12000.0f, 5000.0f);
  1419.     voice->modenv_data[FLUID_VOICE_ENVDELAY].count = NUM_BUFFERS_DELAY(x);
  1420.     voice->modenv_data[FLUID_VOICE_ENVDELAY].coeff = 0.0f;
  1421.     voice->modenv_data[FLUID_VOICE_ENVDELAY].incr = 0.0f;
  1422.     voice->modenv_data[FLUID_VOICE_ENVDELAY].min = -1.0f;
  1423.     voice->modenv_data[FLUID_VOICE_ENVDELAY].max = 1.0f;
  1424.     break;
  1426.   case GEN_MODENVATTACK:               /* SF2.01 section 8.1.3 # 26 */
  1427.     x = _GEN(voice, GEN_MODENVATTACK);
  1428.     fluid_clip(x, -12000.0f, 8000.0f);
  1429.     count = 1 + NUM_BUFFERS_ATTACK(x);
  1430.     voice->modenv_data[FLUID_VOICE_ENVATTACK].count = count;
  1431.     voice->modenv_data[FLUID_VOICE_ENVATTACK].coeff = 1.0f;
  1432.     voice->modenv_data[FLUID_VOICE_ENVATTACK].incr = count ? 1.0f / count : 0.0f;
  1433.     voice->modenv_data[FLUID_VOICE_ENVATTACK].min = -1.0f;
  1434.     voice->modenv_data[FLUID_VOICE_ENVATTACK].max = 1.0f;
  1435.     break;
  1437.   case GEN_MODENVHOLD:               /* SF2.01 section 8.1.3 # 27 */
  1438.   case GEN_KEYTOMODENVHOLD:          /* SF2.01 section 8.1.3 # 31 */
  1439.     count = calculate_hold_decay_buffers(voice, GEN_MODENVHOLD, GEN_KEYTOMODENVHOLD, 0); /* 1 means: hold */
  1440.     voice->modenv_data[FLUID_VOICE_ENVHOLD].count = count;
  1441.     voice->modenv_data[FLUID_VOICE_ENVHOLD].coeff = 1.0f;
  1442.     voice->modenv_data[FLUID_VOICE_ENVHOLD].incr = 0.0f;
  1443.     voice->modenv_data[FLUID_VOICE_ENVHOLD].min = -1.0f;
  1444.     voice->modenv_data[FLUID_VOICE_ENVHOLD].max = 2.0f;
  1445.     break;
  1447.   case GEN_MODENVDECAY:                                   /* SF 2.01 section 8.1.3 # 28 */
  1448.   case GEN_MODENVSUSTAIN:                                 /* SF 2.01 section 8.1.3 # 29 */
  1449.   case GEN_KEYTOMODENVDECAY:                              /* SF 2.01 section 8.1.3 # 32 */
  1450.     count = calculate_hold_decay_buffers(voice, GEN_MODENVDECAY, GEN_KEYTOMODENVDECAY, 1); /* 1 for decay */
  1451.     y = 1.0f - 0.001f * _GEN(voice, GEN_MODENVSUSTAIN);
  1452.     fluid_clip(y, 0.0f, 1.0f);
  1453.     voice->modenv_data[FLUID_VOICE_ENVDECAY].count = count;
  1454.     voice->modenv_data[FLUID_VOICE_ENVDECAY].coeff = 1.0f;
  1455.     voice->modenv_data[FLUID_VOICE_ENVDECAY].incr = count ? -1.0f / count : 0.0f;
  1456.     voice->modenv_data[FLUID_VOICE_ENVDECAY].min = y;
  1457.     voice->modenv_data[FLUID_VOICE_ENVDECAY].max = 2.0f;
  1458.     break;
  1460.   case GEN_MODENVRELEASE:                                  /* SF 2.01 section 8.1.3 # 30 */
  1461.     x = _GEN(voice, GEN_MODENVRELEASE);
  1462.     fluid_clip(x, -12000.0f, 8000.0f);
  1463.     count = 1 + NUM_BUFFERS_RELEASE(x);
  1464.     voice->modenv_data[FLUID_VOICE_ENVRELEASE].count = count;
  1465.     voice->modenv_data[FLUID_VOICE_ENVRELEASE].coeff = 1.0f;
  1466.     voice->modenv_data[FLUID_VOICE_ENVRELEASE].incr = count ? -1.0f / count : 0.0;
  1467.     voice->modenv_data[FLUID_VOICE_ENVRELEASE].min = 0.0f;
  1468.     voice->modenv_data[FLUID_VOICE_ENVRELEASE].max = 2.0f;
  1469.     break;
  1471.   } /* switch gen */
  1472. }
  1474. /**
  1475.  * Recalculate voice parameters for a given control.
  1476.  * @param voice the synthesis voice
  1477.  * @param cc flag to distinguish between a continous control and a channel control (pitch bend, ...)
  1478.  * @param ctrl the control number
  1479.  *
  1480.  * In this implementation, I want to make sure that all controllers
  1481.  * are event based: the parameter values of the DSP algorithm should
  1482.  * only be updates when a controller event arrived and not at every
  1483.  * iteration of the audio cycle (which would probably be feasible if
  1484.  * the synth was made in silicon).
  1485.  *
  1486.  * The update is done in three steps:
  1487.  *
  1488.  * - first, we look for all the modulators that have the changed
  1489.  * controller as a source. This will yield a list of generators that
  1490.  * will be changed because of the controller event.
  1491.  *
  1492.  * - For every changed generator, calculate its new value. This is the
  1493.  * sum of its original value plus the values of al the attached
  1494.  * modulators.
  1495.  *
  1496.  * - For every changed generator, convert its value to the correct
  1497.  * unit of the corresponding DSP parameter
  1498.  */
  1499. int fluid_voice_modulate(fluid_voice_t* voice, int cc, int ctrl)
  1500. {
  1501.   int i, k;
  1502.   fluid_mod_t* mod;
  1503.   int gen;
  1504.   fluid_real_t modval;
  1506. /*    printf("Chan=%d, CC=%d, Src=%d, Val=%dn", voice->channel->channum, cc, ctrl, val); */
  1508.   for (i = 0; i < voice->mod_count; i++) {
  1510.     mod = &voice->mod[i];
  1512.     /* step 1: find all the modulators that have the changed controller
  1513.      * as input source. */
  1514.     if (fluid_mod_has_source(mod, cc, ctrl)) {
  1516.       gen = fluid_mod_get_dest(mod);
  1517.       modval = 0.0;
  1519.       /* step 2: for every changed modulator, calculate the modulation
  1520.        * value of its associated generator */
  1521.       for (k = 0; k < voice->mod_count; k++) {
  1522. if (fluid_mod_has_dest(&voice->mod[k], gen)) {
  1523.   modval += fluid_mod_get_value(&voice->mod[k], voice->channel, voice);
  1524. }
  1525.       }
  1527.       fluid_gen_set_mod(&voice->gen[gen], modval);
  1529.       /* step 3: now that we have the new value of the generator,
  1530.        * recalculate the parameter values that are derived from the
  1531.        * generator */
  1532.       fluid_voice_update_param(voice, gen);
  1533.     }
  1534.   }
  1535.   return FLUID_OK;
  1536. }
  1538. /**
  1539.  * Update all the modulators. This function is called after a
  1540.  * ALL_CTRL_OFF MIDI message has been received (CC 121).
  1541.  *
  1542.  */
  1543. int fluid_voice_modulate_all(fluid_voice_t* voice)
  1544. {
  1545.   fluid_mod_t* mod;
  1546.   int i, k, gen;
  1547.   fluid_real_t modval;
  1549.   /* Loop through all the modulators.
  1551.      FIXME: we should loop through the set of generators instead of
  1552.      the set of modulators. We risk to call 'fluid_voice_update_param'
  1553.      several times for the same generator if several modulators have
  1554.      that generator as destination. It's not an error, just a wast of
  1555.      energy (think polution, global warming, unhappy musicians,
  1556.      ...) */
  1558.   for (i = 0; i < voice->mod_count; i++) {
  1560.     mod = &voice->mod[i];
  1561.     gen = fluid_mod_get_dest(mod);
  1562.     modval = 0.0;
  1564.     /* Accumulate the modulation values of all the modulators with
  1565.      * destination generator 'gen' */
  1566.     for (k = 0; k < voice->mod_count; k++) {
  1567.       if (fluid_mod_has_dest(&voice->mod[k], gen)) {
  1568. modval += fluid_mod_get_value(&voice->mod[k], voice->channel, voice);
  1569.       }
  1570.     }
  1572.     fluid_gen_set_mod(&voice->gen[gen], modval);
  1574.     /* Update the parameter values that are depend on the generator
  1575.      * 'gen' */
  1576.     fluid_voice_update_param(voice, gen);
  1577.   }
  1579.   return FLUID_OK;
  1580. }
  1582. /*
  1583.  * fluid_voice_noteoff
  1584.  */
  1585. int
  1586. fluid_voice_noteoff(fluid_voice_t* voice)
  1587. {
  1588.   unsigned int at_tick;
  1590.   fluid_profile(FLUID_PROF_VOICE_NOTE, voice->ref);
  1592.   at_tick = fluid_channel_get_min_note_length_ticks (voice->channel);
  1594.   if (at_tick > voice->ticks) {
  1595.     /* Delay noteoff */
  1596.     voice->noteoff_ticks = at_tick;
  1597.     return FLUID_OK;
  1598.   }
  1599.   voice->noteoff_ticks = 0;
  1601.   if (voice->channel && fluid_channel_sustained(voice->channel)) {
  1602.     voice->status = FLUID_VOICE_SUSTAINED;
  1603.   } else {
  1604.     if (voice->volenv_section == FLUID_VOICE_ENVATTACK) {
  1605.       /* A voice is turned off during the attack section of the volume
  1606.        * envelope.  The attack section ramps up linearly with
  1607.        * amplitude. The other sections use logarithmic scaling. Calculate new
  1608.        * volenv_val to achieve equievalent amplitude during the release phase
  1609.        * for seamless volume transition.
  1610.        */
  1611.       if (voice->volenv_val > 0){
  1612. fluid_real_t lfo = voice->modlfo_val * -voice->modlfo_to_vol;
  1613.         fluid_real_t amp = voice->volenv_val * pow (10.0, lfo / -200);
  1614.         fluid_real_t env_value = - ((-200 * log (amp) / log (10.0) - lfo) / 960.0 - 1);
  1615. fluid_clip (env_value, 0.0, 1.0);
  1616.         voice->volenv_val = env_value;
  1617.       }
  1618.     }
  1619.     voice->volenv_section = FLUID_VOICE_ENVRELEASE;
  1620.     voice->volenv_count = 0;
  1621.     voice->modenv_section = FLUID_VOICE_ENVRELEASE;
  1622.     voice->modenv_count = 0;
  1623.   }
  1625.   return FLUID_OK;
  1626. }
  1628. /*
  1629.  * fluid_voice_kill_excl
  1630.  *
  1631.  * Percussion sounds can be mutually exclusive: for example, a 'closed
  1632.  * hihat' sound will terminate an 'open hihat' sound ringing at the
  1633.  * same time. This behaviour is modeled using 'exclusive classes',
  1634.  * turning on a voice with an exclusive class other than 0 will kill
  1635.  * all other voices having that exclusive class within the same preset
  1636.  * or channel.  fluid_voice_kill_excl gets called, when 'voice' is to
  1637.  * be killed for that reason.
  1638.  */
  1639. int
  1640. fluid_voice_kill_excl(fluid_voice_t* voice){
  1642.   if (!_PLAYING(voice)) {
  1643.     return FLUID_OK;
  1644.   }
  1646.   /* Turn off the exclusive class information for this voice,
  1647.      so that it doesn't get killed twice
  1648.   */
  1649.   fluid_voice_gen_set(voice, GEN_EXCLUSIVECLASS, 0);
  1651.   /* If the voice is not yet in release state, put it into release state */
  1652.   if (voice->volenv_section != FLUID_VOICE_ENVRELEASE){
  1653.     voice->volenv_section = FLUID_VOICE_ENVRELEASE;
  1654.     voice->volenv_count = 0;
  1655.     voice->modenv_section = FLUID_VOICE_ENVRELEASE;
  1656.     voice->modenv_count = 0;
  1657.   }
  1659.   /* Speed up the volume envelope */
  1660.   /* The value was found through listening tests with hi-hat samples. */
  1661.   fluid_voice_gen_set(voice, GEN_VOLENVRELEASE, -200);
  1662.   fluid_voice_update_param(voice, GEN_VOLENVRELEASE);
  1664.   /* Speed up the modulation envelope */
  1665.   fluid_voice_gen_set(voice, GEN_MODENVRELEASE, -200);
  1666.   fluid_voice_update_param(voice, GEN_MODENVRELEASE);
  1668.   return FLUID_OK;
  1669. }
  1671. /*
  1672.  * fluid_voice_off
  1673.  *
  1674.  * Purpose:
  1675.  * Turns off a voice, meaning that it is not processed
  1676.  * anymore by the DSP loop.
  1677.  */
  1678. int
  1679. fluid_voice_off(fluid_voice_t* voice)
  1680. {
  1681.   fluid_profile(FLUID_PROF_VOICE_RELEASE, voice->ref);
  1683.   voice->chan = NO_CHANNEL;
  1684.   voice->volenv_section = FLUID_VOICE_ENVFINISHED;
  1685.   voice->volenv_count = 0;
  1686.   voice->modenv_section = FLUID_VOICE_ENVFINISHED;
  1687.   voice->modenv_count = 0;
  1688.   voice->status = FLUID_VOICE_OFF;
  1690.   /* Decrement the reference count of the sample. */
  1691.   if (voice->sample) {
  1692.     fluid_sample_decr_ref(voice->sample);
  1693.     voice->sample = NULL;
  1694.   }
  1696.   /* Decrement voice count atomically, for non-synth thread read access */
  1697.   fluid_atomic_int_add (&voice->channel->synth->active_voice_count, -1);
  1699.   return FLUID_OK;
  1700. }
  1702. /**
  1703.  * Adds a modulator to the voice.
  1704.  * @param voice Voice instance
  1705.  * @param mod Modulator info (copied)
  1706.  * @param mode Determines how to handle an existing identical modulator
  1707.  *   #FLUID_VOICE_ADD to add (offset) the modulator amounts,
  1708.  *   #FLUID_VOICE_OVERWRITE to replace the modulator,
  1709.  *   #FLUID_VOICE_DEFAULT when adding a default modulator - no duplicate should
  1710.  *   exist so don't check.
  1711.  */
  1712. void
  1713. fluid_voice_add_mod(fluid_voice_t* voice, fluid_mod_t* mod, int mode)
  1714. {
  1715.   int i;
  1717.   /*
  1718.    * Some soundfonts come with a huge number of non-standard
  1719.    * controllers, because they have been designed for one particular
  1720.    * sound card.  Discard them, maybe print a warning.
  1721.    */
  1723.   if (((mod->flags1 & FLUID_MOD_CC) == 0)
  1724.       && ((mod->src1 != 0)          /* SF2.01 section 8.2.1: Constant value */
  1725.   && (mod->src1 != 2)       /* Note-on velocity */
  1726.   && (mod->src1 != 3)       /* Note-on key number */
  1727.   && (mod->src1 != 10)      /* Poly pressure */
  1728.   && (mod->src1 != 13)      /* Channel pressure */
  1729.   && (mod->src1 != 14)      /* Pitch wheel */
  1730.   && (mod->src1 != 16))) {  /* Pitch wheel sensitivity */
  1731.     FLUID_LOG(FLUID_WARN, "Ignoring invalid controller, using non-CC source %i.", mod->src1);
  1732.     return;
  1733.   }
  1735.   if (mode == FLUID_VOICE_ADD) {
  1737.     /* if identical modulator exists, add them */
  1738.     for (i = 0; i < voice->mod_count; i++) {
  1739.       if (fluid_mod_test_identity(&voice->mod[i], mod)) {
  1740. // printf("Adding modulator...n");
  1741. voice->mod[i].amount += mod->amount;
  1742. return;
  1743.       }
  1744.     }
  1746.   } else if (mode == FLUID_VOICE_OVERWRITE) {
  1748.     /* if identical modulator exists, replace it (only the amount has to be changed) */
  1749.     for (i = 0; i < voice->mod_count; i++) {
  1750.       if (fluid_mod_test_identity(&voice->mod[i], mod)) {
  1751. // printf("Replacing modulator...amount is %fn",mod->amount);
  1752. voice->mod[i].amount = mod->amount;
  1753. return;
  1754.       }
  1755.     }
  1756.   }
  1758.   /* Add a new modulator (No existing modulator to add / overwrite).
  1759.      Also, default modulators (FLUID_VOICE_DEFAULT) are added without
  1760.      checking, if the same modulator already exists. */
  1761.   if (voice->mod_count < FLUID_NUM_MOD) {
  1762.     fluid_mod_clone(&voice->mod[voice->mod_count++], mod);
  1763.   }
  1764. }
  1766. /**
  1767.  * Get the unique ID of the noteon-event.
  1768.  * @param voice Voice instance
  1769.  * @return Note on unique ID
  1770.  *
  1771.  * A SoundFont loader may store the voice processes it has created for
  1772.  * real-time control during the operation of a voice (for example: parameter
  1773.  * changes in SoundFont editor). The synth uses a pool of voices, which are
  1774.  * 'recycled' and never deallocated.
  1775.  *
  1776.  * Before modifying an existing voice, check
  1777.  * - that its state is still 'playing'
  1778.  * - that the ID is still the same
  1779.  *
  1780.  * Otherwise the voice has finished playing.
  1781.  */
  1782. unsigned int fluid_voice_get_id(fluid_voice_t* voice)
  1783. {
  1784.   return voice->id;
  1785. }
  1787. /**
  1788.  * Check if a voice is still playing.
  1789.  * @param voice Voice instance
  1790.  * @return TRUE if playing, FALSE otherwise
  1791.  */
  1792. int fluid_voice_is_playing(fluid_voice_t* voice)
  1793. {
  1794.   return _PLAYING(voice);
  1795. }
  1797. /*
  1798.  * fluid_voice_get_lower_boundary_for_attenuation
  1799.  *
  1800.  * Purpose:
  1801.  *
  1802.  * A lower boundary for the attenuation (as in 'the minimum
  1803.  * attenuation of this voice, with volume pedals, modulators
  1804.  * etc. resulting in minimum attenuation, cannot fall below x cB) is
  1805.  * calculated.  This has to be called during fluid_voice_init, after
  1806.  * all modulators have been run on the voice once.  Also,
  1807.  * voice->attenuation has to be initialized.
  1808.  */
  1809. static fluid_real_t
  1810. fluid_voice_get_lower_boundary_for_attenuation(fluid_voice_t* voice)
  1811. {
  1812.   int i;
  1813.   fluid_mod_t* mod;
  1814.   fluid_real_t possible_att_reduction_cB=0;
  1815.   fluid_real_t lower_bound;
  1817.   for (i = 0; i < voice->mod_count; i++) {
  1818.     mod = &voice->mod[i];
  1820.     /* Modulator has attenuation as target and can change over time? */
  1821.     if ((mod->dest == GEN_ATTENUATION)
  1822. && ((mod->flags1 & FLUID_MOD_CC) || (mod->flags2 & FLUID_MOD_CC))) {
  1824.       fluid_real_t current_val = fluid_mod_get_value(mod, voice->channel, voice);
  1825.       fluid_real_t v = fabs(mod->amount);
  1827.       if ((mod->src1 == FLUID_MOD_PITCHWHEEL)
  1828.   || (mod->flags1 & FLUID_MOD_BIPOLAR)
  1829.   || (mod->flags2 & FLUID_MOD_BIPOLAR)
  1830.   || (mod->amount < 0)) {
  1831. /* Can this modulator produce a negative contribution? */
  1832. v *= -1.0;
  1833.       } else {
  1834. /* No negative value possible. But still, the minimum contribution is 0. */
  1835. v = 0;
  1836.       }
  1838.       /* For example:
  1839.        * - current_val=100
  1840.        * - min_val=-4000
  1841.        * - possible_att_reduction_cB += 4100
  1842.        */
  1843.       if (current_val > v){
  1844. possible_att_reduction_cB += (current_val - v);
  1845.       }
  1846.     }
  1847.   }
  1849.   lower_bound = voice->attenuation-possible_att_reduction_cB;
  1851.   /* SF2.01 specs do not allow negative attenuation */
  1852.   if (lower_bound < 0) {
  1853.     lower_bound = 0;
  1854.   }
  1855.   return lower_bound;
  1856. }
  1859. /* Purpose:
  1860.  *
  1861.  * Make sure, that sample start / end point and loop points are in
  1862.  * proper order. When starting up, calculate the initial phase.
  1863.  */
  1864. static void
  1865. fluid_voice_check_sample_sanity(fluid_voice_t* voice)
  1866. {
  1867.     int min_index_nonloop=(int) voice->sample->start;
  1868.     int max_index_nonloop=(int) voice->sample->end;
  1870.     /* make sure we have enough samples surrounding the loop */
  1871.     int min_index_loop=(int) voice->sample->start + FLUID_MIN_LOOP_PAD;
  1872.     int max_index_loop=(int) voice->sample->end - FLUID_MIN_LOOP_PAD + 1; /* 'end' is last valid sample, loopend can be + 1 */
  1873.     fluid_check_fpe("voice_check_sample_sanity start");
  1875.     if (!voice->check_sample_sanity_flag){
  1876. return;
  1877.     }
  1879. #if 0
  1880.     printf("Sample from %i to %in",voice->sample->start, voice->sample->end);
  1881.     printf("Sample loop from %i %in",voice->sample->loopstart, voice->sample->loopend);
  1882.     printf("Playback from %i to %in", voice->start, voice->end);
  1883.     printf("Playback loop from %i to %in",voice->loopstart, voice->loopend);
  1884. #endif
  1886.     /* Keep the start point within the sample data */
  1887.     if (voice->start < min_index_nonloop){
  1888. voice->start = min_index_nonloop;
  1889.     } else if (voice->start > max_index_nonloop){
  1890. voice->start = max_index_nonloop;
  1891.     }
  1893.     /* Keep the end point within the sample data */
  1894.     if (voice->end < min_index_nonloop){
  1895.       voice->end = min_index_nonloop;
  1896.     } else if (voice->end > max_index_nonloop){
  1897.       voice->end = max_index_nonloop;
  1898.     }
  1900.     /* Keep start and end point in the right order */
  1901.     if (voice->start > voice->end){
  1902. int temp = voice->start;
  1903. voice->start = voice->end;
  1904. voice->end = temp;
  1905. /*FLUID_LOG(FLUID_DBG, "Loop / sample sanity check: Changing order of start / end points!"); */
  1906.     }
  1908.     /* Zero length? */
  1909.     if (voice->start == voice->end){
  1910. fluid_voice_off(voice);
  1911. return;
  1912.     }
  1914.     if ((_SAMPLEMODE(voice) == FLUID_LOOP_UNTIL_RELEASE)
  1915. || (_SAMPLEMODE(voice) == FLUID_LOOP_DURING_RELEASE)) {
  1916. /* Keep the loop start point within the sample data */
  1917. if (voice->loopstart < min_index_loop){
  1918.     voice->loopstart = min_index_loop;
  1919.       } else if (voice->loopstart > max_index_loop){
  1920. voice->loopstart = max_index_loop;
  1921.       }
  1923.       /* Keep the loop end point within the sample data */
  1924.       if (voice->loopend < min_index_loop){
  1925. voice->loopend = min_index_loop;
  1926.       } else if (voice->loopend > max_index_loop){
  1927. voice->loopend = max_index_loop;
  1928.       }
  1930.       /* Keep loop start and end point in the right order */
  1931.       if (voice->loopstart > voice->loopend){
  1932. int temp = voice->loopstart;
  1933. voice->loopstart = voice->loopend;
  1934. voice->loopend = temp;
  1935. /*FLUID_LOG(FLUID_DBG, "Loop / sample sanity check: Changing order of loop points!"); */
  1936.       }
  1938.       /* Loop too short? Then don't loop. */
  1939.       if (voice->loopend < voice->loopstart + FLUID_MIN_LOOP_SIZE){
  1940.   voice->gen[GEN_SAMPLEMODE].val = FLUID_UNLOOPED;
  1941.       }
  1943.       /* The loop points may have changed. Obtain a new estimate for the loop volume. */
  1944.       /* Is the voice loop within the sample loop? */
  1945.       if ((int)voice->loopstart >= (int)voice->sample->loopstart
  1946.   && (int)voice->loopend <= (int)voice->sample->loopend){
  1947. /* Is there a valid peak amplitude available for the loop? */
  1948. if (voice->sample->amplitude_that_reaches_noise_floor_is_valid){
  1949.   voice->amplitude_that_reaches_noise_floor_loop=voice->sample->amplitude_that_reaches_noise_floor / voice->synth_gain;
  1950. } else {
  1951.   /* Worst case */
  1952.   voice->amplitude_that_reaches_noise_floor_loop=voice->amplitude_that_reaches_noise_floor_nonloop;
  1953. };
  1954.       };
  1956.     } /* if sample mode is looped */
  1958.     /* Run startup specific code (only once, when the voice is started) */
  1959.     if (voice->check_sample_sanity_flag & FLUID_SAMPLESANITY_STARTUP){
  1960.       if (max_index_loop - min_index_loop < FLUID_MIN_LOOP_SIZE){
  1961.         if ((_SAMPLEMODE(voice) == FLUID_LOOP_UNTIL_RELEASE)
  1962.     || (_SAMPLEMODE(voice) == FLUID_LOOP_DURING_RELEASE)){
  1963.   voice->gen[GEN_SAMPLEMODE].val = FLUID_UNLOOPED;
  1964. }
  1965.       }
  1967.       /* Set the initial phase of the voice (using the result from the
  1968.  start offset modulators). */
  1969.       fluid_phase_set_int(voice->phase, voice->start);
  1970.     } /* if startup */
  1972.     /* Is this voice run in loop mode, or does it run straight to the
  1973.        end of the waveform data? */
  1974.     if (((_SAMPLEMODE(voice) == FLUID_LOOP_UNTIL_RELEASE) && (voice->volenv_section < FLUID_VOICE_ENVRELEASE))
  1975. || (_SAMPLEMODE(voice) == FLUID_LOOP_DURING_RELEASE)) {
  1976.       /* Yes, it will loop as soon as it reaches the loop point.  In
  1977.        * this case we must prevent, that the playback pointer (phase)
  1978.        * happens to end up beyond the 2nd loop point, because the
  1979.        * point has moved.  The DSP algorithm is unable to cope with
  1980.        * that situation.  So if the phase is beyond the 2nd loop
  1981.        * point, set it to the start of the loop. No way to avoid some
  1982.        * noise here.  Note: If the sample pointer ends up -before the
  1983.        * first loop point- instead, then the DSP loop will just play
  1984.        * the sample, enter the loop and proceed as expected => no
  1985.        * actions required.
  1986.        */
  1987.       int index_in_sample = fluid_phase_index(voice->phase);
  1988.       if (index_in_sample >= voice->loopend){
  1989. /* FLUID_LOG(FLUID_DBG, "Loop / sample sanity check: Phase after 2nd loop point!"); */
  1990. fluid_phase_set_int(voice->phase, voice->loopstart);
  1991.       }
  1992.     }
  1993. /*    FLUID_LOG(FLUID_DBG, "Loop / sample sanity check: Sample from %i to %i, loop from %i to %i", voice->start, voice->end, voice->loopstart, voice->loopend); */
  1995.     /* Sample sanity has been assured. Don't check again, until some
  1996.        sample parameter is changed by modulation. */
  1997.     voice->check_sample_sanity_flag=0;
  1998. #if 0
  1999.     printf("Sane? playback loop from %i to %in", voice->loopstart, voice->loopend);
  2000. #endif
  2001.     fluid_check_fpe("voice_check_sample_sanity");
  2002. }
  2005. int fluid_voice_set_param(fluid_voice_t* voice, int gen, fluid_real_t nrpn_value, int abs)
  2006. {
  2007.   voice->gen[gen].nrpn = nrpn_value;
  2008.   voice->gen[gen].flags = (abs)? GEN_ABS_NRPN : GEN_SET;
  2009.   fluid_voice_update_param(voice, gen);
  2010.   return FLUID_OK;
  2011. }
  2013. int fluid_voice_set_gain(fluid_voice_t* voice, fluid_real_t gain)
  2014. {
  2015.   /* avoid division by zero*/
  2016.   if (gain < 0.0000001){
  2017.     gain = 0.0000001;
  2018.   }
  2020.   voice->synth_gain = gain;
  2021.   voice->amp_left = fluid_pan(voice->pan, 1) * gain / 32768.0f;
  2022.   voice->amp_right = fluid_pan(voice->pan, 0) * gain / 32768.0f;
  2023.   voice->amp_reverb = voice->reverb_send * gain / 32768.0f;
  2024.   voice->amp_chorus = voice->chorus_send * gain / 32768.0f;
  2026.   return FLUID_OK;
  2027. }
  2029. /* - Scan the loop
  2030.  * - determine the peak level
  2031.  * - Calculate, what factor will make the loop inaudible
  2032.  * - Store in sample
  2033.  */
  2034. /**
  2035.  * Calculate the peak volume of a sample for voice off optimization.
  2036.  * @param s Sample to optimize
  2037.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  2038.  *
  2039.  * If the peak volume during the loop is known, then the voice can
  2040.  * be released earlier during the release phase. Otherwise, the
  2041.  * voice will operate (inaudibly), until the envelope is at the
  2042.  * nominal turnoff point.  So it's a good idea to call
  2043.  * fluid_voice_optimize_sample() on each sample once.
  2044.  */
  2045. int
  2046. fluid_voice_optimize_sample(fluid_sample_t* s)
  2047. {
  2048.   signed short peak_max = 0;
  2049.   signed short peak_min = 0;
  2050.   signed short peak;
  2051.   fluid_real_t normalized_amplitude_during_loop;
  2052.   double result;
  2053.   int i;
  2055.   /* ignore ROM and other(?) invalid samples */
  2056.   if (!s->valid) return (FLUID_OK);
  2058.   if (!s->amplitude_that_reaches_noise_floor_is_valid){ /* Only once */
  2059.     /* Scan the loop */
  2060.     for (i = (int)s->loopstart; i < (int) s->loopend; i ++){
  2061.       signed short val = s->data[i];
  2062.       if (val > peak_max) {
  2063. peak_max = val;
  2064.       } else if (val < peak_min) {
  2065. peak_min = val;
  2066.       }
  2067.     }
  2069.     /* Determine the peak level */
  2070.     if (peak_max >- peak_min){
  2071.       peak = peak_max;
  2072.     } else {
  2073.       peak =- peak_min;
  2074.     };
  2075.     if (peak == 0){
  2076.       /* Avoid division by zero */
  2077.       peak = 1;
  2078.     };
  2080.     /* Calculate what factor will make the loop inaudible
  2081.      * For example: Take a peak of 3277 (10 % of 32768).  The
  2082.      * normalized amplitude is 0.1 (10 % of 32768).  An amplitude
  2083.      * factor of 0.0001 (as opposed to the default 0.00001) will
  2084.      * drop this sample to the noise floor.
  2085.      */
  2087.     /* 16 bits => 96+4=100 dB dynamic range => 0.00001 */
  2088.     normalized_amplitude_during_loop = ((fluid_real_t)peak)/32768.;
  2089.     result = FLUID_NOISE_FLOOR / normalized_amplitude_during_loop;
  2091.     /* Store in sample */
  2092.     s->amplitude_that_reaches_noise_floor = (double)result;
  2093.     s->amplitude_that_reaches_noise_floor_is_valid = 1;
  2094. #if 0
  2095.     printf("Sample peak detection: factor %fn", (double)result);
  2096. #endif
  2097.   };
  2098.   return FLUID_OK;
  2099. }