/[svn]/linuxsampler/trunk/src/engines/gig/Voice.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/gig/Voice.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 242 by schoenebeck, Wed Sep 15 13:59:08 2004 UTC revision 245 by schoenebeck, Sat Sep 18 14:12:36 2004 UTC
# Line 115  namespace LinuxSampler { namespace gig { Line 115  namespace LinuxSampler { namespace gig {
115              // Attributes              // Attributes
116              gig::Engine*                pEngine;            ///< Pointer to the sampler engine, to be able to access the event lists.              gig::Engine*                pEngine;            ///< Pointer to the sampler engine, to be able to access the event lists.
117              float                       Volume;             ///< Volume level of the voice              float                       Volume;             ///< Volume level of the voice
118                float                       PanLeft;
119                float                       PanRight;
120              float                       CrossfadeVolume;    ///< Current attenuation level caused by a crossfade (only if a crossfade is defined of course)              float                       CrossfadeVolume;    ///< Current attenuation level caused by a crossfade (only if a crossfade is defined of course)
121              double                      Pos;                ///< Current playback position in sample              double                      Pos;                ///< Current playback position in sample
122              double                      PitchBase;          ///< Basic pitch depth, stays the same for the whole life time of the voice              double                      PitchBase;          ///< Basic pitch depth, stays the same for the whole life time of the voice
# Line 158  namespace LinuxSampler { namespace gig { Line 160  namespace LinuxSampler { namespace gig {
160              #if ENABLE_FILTER              #if ENABLE_FILTER
161              void        CalculateBiquadParameters(uint Samples);              void        CalculateBiquadParameters(uint Samples);
162              #endif // ENABLE_FILTER              #endif // ENABLE_FILTER
163              void        Interpolate(uint Samples, sample_t* pSrc, uint Skip);              void        InterpolateNoLoop(uint Samples, sample_t* pSrc, uint Skip);
164              void        InterpolateAndLoop(uint Samples, sample_t* pSrc, uint Skip);              void        InterpolateAndLoop(uint Samples, sample_t* pSrc, uint Skip);
165              inline void InterpolateOneStep_Stereo(sample_t* pSrc, int& i, float& effective_volume, float& pitch, biquad_param_t& bq_base, biquad_param_t& bq_main) {  
166                inline void InterpolateMono(sample_t* pSrc, int& i) {
167                    InterpolateOneStep_Mono(pSrc, i,
168                                            pEngine->pSynthesisParameters[Event::destination_vca][i] * PanLeft,
169                                            pEngine->pSynthesisParameters[Event::destination_vca][i] * PanRight,
170                                            pEngine->pSynthesisParameters[Event::destination_vco][i],
171                                            pEngine->pBasicFilterParameters[i],
172                                            pEngine->pMainFilterParameters[i]);
173                }
174    
175                inline void InterpolateStereo(sample_t* pSrc, int& i) {
176                    InterpolateOneStep_Stereo(pSrc, i,
177                                              pEngine->pSynthesisParameters[Event::destination_vca][i] * PanLeft,
178                                              pEngine->pSynthesisParameters[Event::destination_vca][i] * PanRight,
179                                              pEngine->pSynthesisParameters[Event::destination_vco][i],
180                                              pEngine->pBasicFilterParameters[i],
181                                              pEngine->pMainFilterParameters[i]);
182                }
183    
184                inline void InterpolateOneStep_Stereo(sample_t* pSrc, int& i, float volume_left, float volume_right, float& pitch, biquad_param_t& bq_base, biquad_param_t& bq_main) {
185                  int   pos_int   = RTMath::DoubleToInt(this->Pos);  // integer position                  int   pos_int   = RTMath::DoubleToInt(this->Pos);  // integer position
186                  float pos_fract = this->Pos - pos_int;             // fractional part of position                  float pos_fract = this->Pos - pos_int;             // fractional part of position
187                  pos_int <<= 1;                  pos_int <<= 1;
# Line 168  namespace LinuxSampler { namespace gig { Line 189  namespace LinuxSampler { namespace gig {
189                  #if USE_LINEAR_INTERPOLATION                  #if USE_LINEAR_INTERPOLATION
190                      #if ENABLE_FILTER                      #if ENABLE_FILTER
191                          // left channel                          // left channel
192                          pEngine->pOutputLeft[i]    += this->FilterLeft.Apply(&bq_base, &bq_main, effective_volume * (pSrc[pos_int]   + pos_fract * (pSrc[pos_int+2] - pSrc[pos_int])));                          pEngine->pOutputLeft[i]    += this->FilterLeft.Apply(&bq_base, &bq_main, volume_left * (pSrc[pos_int]   + pos_fract * (pSrc[pos_int+2] - pSrc[pos_int])));
193                          // right channel                          // right channel
194                          pEngine->pOutputRight[i++] += this->FilterRight.Apply(&bq_base, &bq_main, effective_volume * (pSrc[pos_int+1] + pos_fract * (pSrc[pos_int+3] - pSrc[pos_int+1])));                          pEngine->pOutputRight[i++] += this->FilterRight.Apply(&bq_base, &bq_main, volume_right * (pSrc[pos_int+1] + pos_fract * (pSrc[pos_int+3] - pSrc[pos_int+1])));
195                      #else // no filter                      #else // no filter
196                          // left channel                          // left channel
197                          pEngine->pOutputLeft[i]    += effective_volume * (pSrc[pos_int]   + pos_fract * (pSrc[pos_int+2] - pSrc[pos_int]));                          pEngine->pOutputLeft[i]    += volume_left * (pSrc[pos_int]   + pos_fract * (pSrc[pos_int+2] - pSrc[pos_int]));
198                          // right channel                          // right channel
199                          pEngine->pOutputRight[i++] += effective_volume * (pSrc[pos_int+1] + pos_fract * (pSrc[pos_int+3] - pSrc[pos_int+1]));                          pEngine->pOutputRight[i++] += volume_right * (pSrc[pos_int+1] + pos_fract * (pSrc[pos_int+3] - pSrc[pos_int+1]));
200                      #endif // ENABLE_FILTER                      #endif // ENABLE_FILTER
201                  #else // polynomial interpolation                  #else // polynomial interpolation
202                      // calculate left channel                      // calculate left channel
# Line 187  namespace LinuxSampler { namespace gig { Line 208  namespace LinuxSampler { namespace gig {
208                      float b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;                      float b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;
209                      float c   = (x1 - xm1) * 0.5f;                      float c   = (x1 - xm1) * 0.5f;
210                      #if ENABLE_FILTER                      #if ENABLE_FILTER
211                          pEngine->pOutputLeft[i] += this->FilterLeft.Apply(&bq_base, &bq_main, effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0));                          pEngine->pOutputLeft[i] += this->FilterLeft.Apply(&bq_base, &bq_main, volume_left * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0));
212                      #else // no filter                      #else // no filter
213                          pEngine->pOutputLeft[i] += effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);                          pEngine->pOutputLeft[i] += volume_left * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);
214                      #endif // ENABLE_FILTER                      #endif // ENABLE_FILTER
215    
216                      //calculate right channel                      //calculate right channel
# Line 201  namespace LinuxSampler { namespace gig { Line 222  namespace LinuxSampler { namespace gig {
222                      b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;                      b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;
223                      c   = (x1 - xm1) * 0.5f;                      c   = (x1 - xm1) * 0.5f;
224                      #if ENABLE_FILTER                      #if ENABLE_FILTER
225                          pEngine->pOutputRight[i++] += this->FilterRight.Apply(&bq_base, &bq_main, effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0));                          pEngine->pOutputRight[i++] += this->FilterRight.Apply(&bq_base, &bq_main, volume_right * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0));
226                      #else // no filter                      #else // no filter
227                          pEngine->pOutputRight[i++] += effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);                          pEngine->pOutputRight[i++] += volume_right * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);
228                      #endif // ENABLE_FILTER                      #endif // ENABLE_FILTER
229                  #endif // USE_LINEAR_INTERPOLATION                  #endif // USE_LINEAR_INTERPOLATION
230    
231                  this->Pos += pitch;                  this->Pos += pitch;
232              }              }
233    
234              inline void InterpolateOneStep_Mono(sample_t* pSrc, int& i, float& effective_volume, float& pitch,  biquad_param_t& bq_base, biquad_param_t& bq_main) {              inline void InterpolateOneStep_Mono(sample_t* pSrc, int& i, float volume_left, float volume_right, float& pitch,  biquad_param_t& bq_base, biquad_param_t& bq_main) {
235                  int   pos_int   = RTMath::DoubleToInt(this->Pos);  // integer position                  int   pos_int   = RTMath::DoubleToInt(this->Pos);  // integer position
236                  float pos_fract = this->Pos - pos_int;             // fractional part of position                  float pos_fract = this->Pos - pos_int;             // fractional part of position
237    
238                  #if USE_LINEAR_INTERPOLATION                  #if USE_LINEAR_INTERPOLATION
239                      float sample_point  = effective_volume * (pSrc[pos_int] + pos_fract * (pSrc[pos_int+1] - pSrc[pos_int]));                      float sample_point  = pSrc[pos_int] + pos_fract * (pSrc[pos_int+1] - pSrc[pos_int]);
240                  #else // polynomial interpolation                  #else // polynomial interpolation
241                      float xm1 = pSrc[pos_int];                      float xm1 = pSrc[pos_int];
242                      float x0  = pSrc[pos_int+1];                      float x0  = pSrc[pos_int+1];
# Line 224  namespace LinuxSampler { namespace gig { Line 245  namespace LinuxSampler { namespace gig {
245                      float a   = (3.0f * (x0 - x1) - xm1 + x2) * 0.5f;                      float a   = (3.0f * (x0 - x1) - xm1 + x2) * 0.5f;
246                      float b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;                      float b   = 2.0f * x1 + xm1 - (5.0f * x0 + x2) * 0.5f;
247                      float c   = (x1 - xm1) * 0.5f;                      float c   = (x1 - xm1) * 0.5f;
248                      float sample_point = effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);                      float sample_point =  (((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0;
249                  #endif // USE_LINEAR_INTERPOLATION                  #endif // USE_LINEAR_INTERPOLATION
250    
251                  #if ENABLE_FILTER                  #if ENABLE_FILTER
252                      sample_point = this->FilterLeft.Apply(&bq_base, &bq_main, sample_point);                      sample_point = this->FilterLeft.Apply(&bq_base, &bq_main, sample_point);
253                  #endif // ENABLE_FILTER                  #endif // ENABLE_FILTER
254    
255                  pEngine->pOutputLeft[i]    += sample_point;                  pEngine->pOutputLeft[i]    += sample_point * volume_left;
256                  pEngine->pOutputRight[i++] += sample_point;                  pEngine->pOutputRight[i++] += sample_point * volume_right;
257    
258                  this->Pos += pitch;                  this->Pos += pitch;
259              }              }
Legend:
Removed from v.242  
changed lines
  Added in v.245
  ViewVC Help
Powered by ViewVC