envelope.cpp

   1 /*
   2   ZynAddSubFX - a software synthesizer
   3
   4   Envelope.C - Envelope implementation
   5   Copyright (C) 2002-2005 Nasca Octavian Paul
   6   Author: Nasca Octavian Paul
   7
   8   This program is free software; you can redistribute it and/or modify
   9   it under the terms of version 2 of the GNU General Public License
  10   as published by the Free Software Foundation.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License (version 2) for more details.
  16
  17   You should have received a copy of the GNU General Public License (version 2)
  18   along with this program; if not, write to the Free Software Foundation,
  19   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20
  21 */
  22
  23 #include <math.h>
  24
  25 #include "globals.h"
  26 #include "envelope_parameters.h"
  27 #include "envelope.h"
  28
  29 void
  30 Envelope::init(
  31   float sample_rate,
  32   EnvelopeParams * parameters_ptr,
  33   float basefreq)
  34 {
  35   int i;
  36   float buffer_duration;
  37
  38   envpoints = parameters_ptr->Penvpoints;
  39
  40   if (envpoints > MAX_ENVELOPE_POINTS)
  41   {
  42     envpoints = MAX_ENVELOPE_POINTS;
  43   }
  44
  45   envsustain = (parameters_ptr->Penvsustain == 0) ? -1 : parameters_ptr->Penvsustain;
  46   m_forced_release = parameters_ptr->m_forced_release;
  47   m_stretch = pow(440.0 / basefreq, parameters_ptr->m_stretch / 64.0);
  48   m_linear = parameters_ptr->m_linear;
  49
  50   buffer_duration = SOUND_BUFFER_SIZE / sample_rate;
  51
  52   for (i = 0 ; i < MAX_ENVELOPE_POINTS ; i++)
  53   {
  54     float tmp = parameters_ptr->getdt(i) / 1000.0 * m_stretch;
  55     if (tmp > buffer_duration)
  56     {
  57       envdt[i] = buffer_duration / tmp;
  58     }
  59     else
  60     {
  61       envdt[i] = 2.0;             // any value larger than 1
  62     }
  63
  64     envval[i] = parameters_ptr->m_values[i];
  65   }
  66
  67   envdt[0] = 1.0;
  68
  69   currentpoint = 1; // the envelope starts from 1
  70   m_key_released = false;
  71   t = 0.0;
  72   m_finished = false;
  73   inct = envdt[1];
  74   envoutval = 0.0;
  75 }
  76
  77 Envelope::Envelope()
  78 {
  79 }
  80
  81 Envelope::~Envelope()
  82 {
  83 }
  84
  85 /*
  86  * Relase the key (note envelope)
  87  */
  88 void
  89 Envelope::relasekey()
  90 {
  91   if (m_key_released)
  92   {
  93     return;
  94   }
  95
  96   m_key_released = true;
  97
  98   if (m_forced_release)
  99   {
 100     t = 0.0;
 101   }
 102 }
 103
 104 /*
 105  * Envelope Output
 106  */
 107 float
 108 Envelope::envout()
 109 {
 110   float out;
 111
 112   if (m_finished)               // if the envelope is finished
 113   {
 114     envoutval = envval[envpoints - 1];
 115     return envoutval;
 116   }
 117
 118   if ((currentpoint == envsustain + 1) && !m_key_released) // if it is sustaining now
 119   {
 120     envoutval = envval[envsustain];
 121     return envoutval;
 122   }
 123
 124   if (m_key_released && m_forced_release) // do the forced release
 125   {
 126     int tmp = (envsustain < 0) ? (envpoints - 1) : (envsustain + 1); // if there is no sustain point, use the last point for release
 127
 128     if (envdt[tmp] < 0.00000001)
 129     {
 130       out = envval[tmp];
 131     }
 132     else
 133     {
 134       out = envoutval + (envval[tmp] - envoutval) * t;
 135     }
 136
 137     t += envdt[tmp] * m_stretch;
 138
 139     if (t >= 1.0)
 140     {
 141       currentpoint = envsustain + 2;
 142       m_forced_release = false;
 143       t = 0.0;
 144       inct = envdt[currentpoint];
 145       if (currentpoint >= envpoints || envsustain < 0)
 146       {
 147         m_finished = true;
 148       }
 149     }
 150
 151     return out;
 152   }
 153
 154   if (inct >= 1.0)
 155   {
 156     out = envval[currentpoint];
 157   }
 158   else
 159   {
 160     out = envval[currentpoint - 1] + (envval[currentpoint] - envval[currentpoint - 1]) * t;
 161   }
 162
 163   t += inct;
 164
 165   if (t >= 1.0)
 166   {
 167     if (currentpoint >= envpoints - 1)
 168     {
 169       m_finished = true;
 170     }
 171     else
 172     {
 173       currentpoint++;
 174     }
 175
 176     t = 0.0;
 177
 178     inct = envdt[currentpoint];
 179   }
 180
 181   envoutval = out;
 182
 183   return out;
 184 }
 185
 186 /*
 187  * Envelope Output (dB)
 188  */
 189 float
 190 Envelope::envout_dB()
 191 {
 192   float out;
 193
 194   if (m_linear)
 195   {
 196     return envout();
 197   }
 198
 199   // first point is always lineary interpolated
 200   if (currentpoint == 1 &&
 201       (!m_key_released || !m_forced_release))
 202   {
 203     float v1 = dB2rap(envval[0]);
 204     float v2 = dB2rap(envval[1]);
 205     out = v1 + (v2 - v1) * t;
 206
 207     t += inct;
 208
 209     if (t >= 1.0)
 210     {
 211       t = 0.0;
 212       inct = envdt[2];
 213       currentpoint++;
 214       out = v2;
 215     }
 216
 217     if (out > 0.001)
 218     {
 219       envoutval=rap2dB(out);
 220     }
 221     else
 222     {
 223       envoutval=-40.0;
 224     }
 225   }
 226   else
 227   {
 228     out = dB2rap(envout());
 229   }
 230
 231   return out;
 232 }
 233
 234 bool
 235 Envelope::finished()
 236 {
 237   return m_finished;
 238 }