voice.h

Go to the documentation of this file.

/* FluidSynth - A Software Synthesizer
 *
 * Copyright (C) 2003  Peter Hanappe and others.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307, USA
 */

#ifndef _FLUID_VOICE_H
#define _FLUID_VOICE_H

#include "fluid.h"
#include "gen.h"

namespace FluidS {

#define NO_CHANNEL             0xff

enum fluid_voice_status {
    FLUID_VOICE_OFF,
    FLUID_VOICE_ON,
    FLUID_VOICE_SUSTAINED
      };

/*
 * envelope data
 */
struct fluid_env_data_t {
    unsigned int count;     // sample count
    float coeff;
    float incr;
    float min;
    float max;
      };

/* Indices for envelope tables */
enum fluid_voice_envelope_index_t {
    FLUID_VOICE_ENVDELAY,
    FLUID_VOICE_ENVATTACK,
    FLUID_VOICE_ENVHOLD,
    FLUID_VOICE_ENVDECAY,
    FLUID_VOICE_ENVSUSTAIN,
    FLUID_VOICE_ENVRELEASE,
    FLUID_VOICE_ENVFINISHED,
    FLUID_VOICE_ENVLAST
      };

//---------------------------------------------------------
//   Voice
//---------------------------------------------------------

class Voice
      {
      static float interp_coeff_linear[FLUID_INTERP_MAX][2];
      static float interp_coeff[FLUID_INTERP_MAX][4];
      static float sinc_table7[FLUID_INTERP_MAX][7];

      Fluid* _fluid;
      double _noteTuning;             // +/- in midicent

      //keeps number of frames that are now in cache
      //Cached frames are the frames that are calculated in terms of DSP (digital sound processing) and interpolated.
      unsigned _cachedFrames = 0;
      //Keeps number of the initially cached frames. It's used to calculate actual shift in cache arrays for setting cache to output stream.
      unsigned _initialCacheFrames = 0;
      //Cache arrays keep actual calculated data after applying effects. Its size is twice bigger than framesBuffer (2 channels).
      std::vector<float> _cacheOut;
      std::vector<float> _cacheReverb;
      std::vector<float> _cacheChorus;
            
      /*
       / Applies effects to the calculated interpolation and put frames to output containers.
       / @startBufIdx is used to specify start index of interpolation data array that is used to put data to frames array.
       / @count specifies how many frames should be calculated. Note, size of output arrays must be twice bigger, than @count.
      */
      void effects(int startBufIdx, int count, float* out, float* effect1, float* effect2);
            
      /*
       / Generates DSP data required for sound interpolation. @frames defines number of available frames to generate sound envelope.
       / Note, the minimal viable number of frames is NUM_FRAMES_DELAY. That is why we need all that stuff with caching. Using bluetooth or some specific hardware leads to less number of frames and silence.
      */
      bool generateDataForDSPChain(unsigned frames);
            
      /*
       / Generates sound data from calculated DSP data. Resulting data is stored in @dsp_buf.
       / The data is generated for @n frames. Note, number of generated frames can be less than @n.
       */
      std::tuple<unsigned, bool> interpolateGeneratedDSPData(unsigned n);

public:
    unsigned int id;                // the id is incremented for every new noteon.
                            // it's used for noteoff's
    unsigned char status;
    unsigned char chan;             // the channel number, quick access for channel messages
    unsigned char key;              // the key, quick access for noteoff
    unsigned char vel;              // the velocity

    Channel* channel;
    Generator gen[GEN_LAST];
    Mod mod[FLUID_NUM_MOD];

    int mod_count;
    bool has_looped;                /* Flag that is set as soon as the first loop is completed. */
    Sample* sample;
    int check_sample_sanity_flag;   /* Flag that initiates, that sample-related parameters
                               have to be checked. */
    unsigned int ticks;

    float amp;                       /* the linear amplitude */
    Phase phase;                     // the phase of the sample wave

    // Temporary variables used in write()
    float phase_incr;         /* the phase increment for the next 64 samples */
      qreal amp_incr;       /* amplitude increment value */
      std::vector<float> dsp_buf;         /* buffer to store interpolated sample data to */

    /* basic parameters */
    float pitch;              /* the pitch in midicents */
    float attenuation;        /* the attenuation in centibels */
    float min_attenuation_cB; /* Estimate on the smallest possible attenuation
                              * during the lifetime of the voice */
    float root_pitch, root_pitch_hz;

    /* sample and loop start and end points (offset in sample memory).  */
    int start;
    int end;
    int loopstart;
    int loopend;

    /* vol env */
    fluid_env_data_t volenv_data[FLUID_VOICE_ENVLAST];
    unsigned int volenv_count;
    int volenv_section;
   std::map<int, qreal> Sample2AmpInc;
    float volenv_val;
    float amplitude_that_reaches_noise_floor_nonloop;
    float amplitude_that_reaches_noise_floor_loop;
   int positionToTurnOff; // this is the sample accurate position where the sample reaches the noise floor

    /* mod env */
    fluid_env_data_t modenv_data[FLUID_VOICE_ENVLAST];
    unsigned int modenv_count;
    int modenv_section;
    float modenv_val;         /* the value of the modulation envelope */
    float modenv_to_fc;
    float modenv_to_pitch;

    /* mod lfo */
    float modlfo_val;          /* the value of the modulation LFO */
    unsigned int modlfo_delay;       /* the delay of the lfo in samples */
   unsigned int modlfo_pos;
   unsigned int modlfo_dur; // duration in samples
   float modlfo_to_fc;
    float modlfo_to_pitch;
    float modlfo_to_vol;

    /* vib lfo */
    float viblfo_val;        /* the value of the vibrato LFO */
    unsigned int viblfo_delay;      /* the delay of the lfo in samples */
    float viblfo_incr;       /* the lfo frequency is converted to a per-buffer increment */
    float viblfo_to_pitch;

    /* resonant filter */
    float fres;              /* the resonance frequency, in cents (not absolute cents) */
    float last_fres;         /* Current resonance frequency of the IIR filter */
    /* Serves as a flag: A deviation between fres and last_fres */
    /* indicates, that the filter has to be recalculated. */
    float q_lin;             /* the q-factor on a linear scale */
    float filter_gain;       /* Gain correction factor, depends on q */
    float hist1, hist2;      /* Sample history for the IIR filter */
    int filter_startup;             /* Flag: If set, the filter will be set directly.
                       Else it changes smoothly. */

    /* filter coefficients */
    /* The coefficients are normalized to a0. */
    /* b0 and b2 are identical => b02 */
    float b02;              /* b0 / a0 */
    float b1;              /* b1 / a0 */
    float a1;              /* a0 / a0 */
    float a2;              /* a1 / a0 */

    float b02_incr;
    float b1_incr;
    float a1_incr;
    float a2_incr;
    int filter_coeff_incr_count;

    /* pan */
    float pan;
    float amp_left;
    float amp_right;

    /* reverb */
    float reverb_send;
    float amp_reverb;

    /* chorus */
    float chorus_send;
    float amp_chorus;

    /* interpolation method, as in fluid_interp in fluidsynth.h */
    int interp_method;

    /* for debugging */
    int debug;
    double ref;

   public:
      Voice(Fluid*);
      Channel* get_channel() const    { return channel; }
      void voice_start();
      void off();
      void init(Sample*, Channel*, int key, int vel, unsigned id, double tuning);
      void gen_incr(int i, float val);
      void gen_set(int i, float val);
      float gen_get(int gen);
      unsigned int get_id() const { return id; }
      bool isPlaying()            { return ((status == FLUID_VOICE_ON) || (status == FLUID_VOICE_SUSTAINED)); }
      void set_param(int gen, float nrpn_value, int abs);

      // Update all the synthesis parameters, which depend on generator
      // 'gen'. This is only necessary after changing a generator of an
      // already operating voice.  Most applications will not need this
      // function.

      void update_param(int gen);

      double GEN(int n) { return gen[n].val + gen[n].mod + gen[n].nrpn; }

      void modulate_all();
      void modulate(bool _cc, int _ctrl);
      float get_lower_boundary_for_attenuation();
      void check_sample_sanity();
      void noteoff();
      void kill_excl();
      int calculate_hold_decay_frames(int gen_base, int gen_key2base, int is_decay);
      void calculate_gen_pitch();

      /* A voice is 'ON', if it has not yet received a noteoff
       * event. Sending a noteoff event will advance the envelopes to
       * section 5 (release).
       */
      bool RELEASED() const    { return chan == NO_CHANNEL; }
      bool SUSTAINED() const   { return status == FLUID_VOICE_SUSTAINED; }
      bool PLAYING() const     { return (status == FLUID_VOICE_ON) || (status == FLUID_VOICE_SUSTAINED); }
      bool ON() const          { return (status == FLUID_VOICE_ON) && (volenv_section < FLUID_VOICE_ENVRELEASE); }
      int SAMPLEMODE() const   { return ((int)gen[GEN_SAMPLEMODE].val); }

      void calcVolEnv(int n, fluid_env_data_t *env_data);
      void write(unsigned n, float* out, float* reverb, float* chorus);
      void add_mod(const Mod* mod, int mode);

      static void dsp_float_config();
      bool updateAmpInc(unsigned int &nextNewAmpInc, std::map<int, qreal>::iterator &curSample2AmpInc, qreal &dsp_amp_incr, unsigned int &dsp_i);
      int dsp_float_interpolate_none(unsigned);
      int dsp_float_interpolate_linear(unsigned);
      int dsp_float_interpolate_4th_order(unsigned);
      int dsp_float_interpolate_7th_order(unsigned);
      };
}


#endif /* _FLUID_VOICE_H */