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

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

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

revision 332 by senkov, Sat Jan 1 03:06:06 2005 UTC revision 425 by persson, Sat Mar 5 07:27:48 2005 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6     *   Copyright (C) 2005 Christian Schoenebeck                              *
7   *                                                                         *   *                                                                         *
8   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 58  namespace LinuxSampler { namespace gig { Line 59  namespace LinuxSampler { namespace gig {
59          pLFO2  = NULL;          pLFO2  = NULL;
60          pLFO3  = NULL;          pLFO3  = NULL;
61          KeyGroup = 0;          KeyGroup = 0;
62          SynthesisMode = 0; //Set all mode bits to 0 first          SynthesisMode = 0; // set all mode bits to 0 first
   
63          // select synthesis implementation (currently either pure C++ or MMX+SSE(1))          // select synthesis implementation (currently either pure C++ or MMX+SSE(1))
64            #if ARCH_X86
65          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());
66            #else
67            SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, false);
68            #endif
69          SYNTHESIS_MODE_SET_PROFILING(SynthesisMode, true);          SYNTHESIS_MODE_SET_PROFILING(SynthesisMode, true);
70    
71            FilterLeft.Reset();
72            FilterRight.Reset();
73      }      }
74    
75      Voice::~Voice() {      Voice::~Voice() {
# Line 110  namespace LinuxSampler { namespace gig { Line 117  namespace LinuxSampler { namespace gig {
117       *  Initializes and triggers the voice, a disk stream will be launched if       *  Initializes and triggers the voice, a disk stream will be launched if
118       *  needed.       *  needed.
119       *       *
120         *  @param pEngineChannel      - engine channel on which this voice was ordered
121       *  @param itNoteOnEvent       - event that caused triggering of this voice       *  @param itNoteOnEvent       - event that caused triggering of this voice
122       *  @param PitchBend           - MIDI detune factor (-8192 ... +8191)       *  @param PitchBend           - MIDI detune factor (-8192 ... +8191)
123       *  @param pInstrument         - points to the loaded instrument which provides sample wave(s) and articulation data       *  @param pInstrument         - points to the loaded instrument which provides sample wave(s) and articulation data
124       *  @param iLayer              - layer number this voice refers to (only if this is a layered sound of course)       *  @param iLayer              - layer number this voice refers to (only if this is a layered sound of course)
125       *  @param ReleaseTriggerVoice - if this new voice is a release trigger voice (optional, default = false)       *  @param ReleaseTriggerVoice - if this new voice is a release trigger voice (optional, default = false)
126       *  @param VoiceStealing       - wether the voice is allowed to steal voices for further subvoices       *  @param VoiceStealing       - wether the voice is allowed to steal voices for further subvoices
127       *  @returns 0 on success, a value < 0 if something failed       *  @returns 0 on success, a value < 0 if the voice wasn't triggered
128         *           (either due to an error or e.g. because no region is
129         *           defined for the given key)
130       */       */
131      int Voice::Trigger(Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::Instrument* pInstrument, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing) {      int Voice::Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::Instrument* pInstrument, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing) {
132            this->pEngineChannel = pEngineChannel;
133          if (!pInstrument) {          if (!pInstrument) {
134             dmsg(1,("voice::trigger: !pInstrument\n"));             dmsg(1,("voice::trigger: !pInstrument\n"));
135             exit(EXIT_FAILURE);             exit(EXIT_FAILURE);
# Line 137  namespace LinuxSampler { namespace gig { Line 148  namespace LinuxSampler { namespace gig {
148          itChildVoice    = Pool<Voice>::Iterator();          itChildVoice    = Pool<Voice>::Iterator();
149    
150          if (!pRegion) {          if (!pRegion) {
151              std::cerr << "gig::Voice: No Region defined for MIDI key " << MIDIKey << std::endl << std::flush;              dmsg(4, ("gig::Voice: No Region defined for MIDI key %d\n", MIDIKey));
             KillImmediately();  
152              return -1;              return -1;
153          }          }
154    
# Line 146  namespace LinuxSampler { namespace gig { Line 156  namespace LinuxSampler { namespace gig {
156    
157          // get current dimension values to select the right dimension region          // get current dimension values to select the right dimension region
158          //FIXME: controller values for selecting the dimension region here are currently not sample accurate          //FIXME: controller values for selecting the dimension region here are currently not sample accurate
159          uint DimValues[5] = {0,0,0,0,0};          uint DimValues[8] = { 0 };
160          for (int i = pRegion->Dimensions - 1; i >= 0; i--) {          for (int i = pRegion->Dimensions - 1; i >= 0; i--) {
161              switch (pRegion->pDimensionDefinitions[i].dimension) {              switch (pRegion->pDimensionDefinitions[i].dimension) {
162                  case ::gig::dimension_samplechannel:                  case ::gig::dimension_samplechannel:
# Line 157  namespace LinuxSampler { namespace gig { Line 167  namespace LinuxSampler { namespace gig {
167                      // if this is the 1st layer then spawn further voices for all the other layers                      // if this is the 1st layer then spawn further voices for all the other layers
168                      if (iLayer == 0)                      if (iLayer == 0)
169                          for (int iNewLayer = 1; iNewLayer < pRegion->pDimensionDefinitions[i].zones; iNewLayer++)                          for (int iNewLayer = 1; iNewLayer < pRegion->pDimensionDefinitions[i].zones; iNewLayer++)
170                              itChildVoice = pEngine->LaunchVoice(itNoteOnEvent, iNewLayer, ReleaseTriggerVoice, VoiceStealing);                              itChildVoice = pEngine->LaunchVoice(pEngineChannel, itNoteOnEvent, iNewLayer, ReleaseTriggerVoice, VoiceStealing);
171                      break;                      break;
172                  case ::gig::dimension_velocity:                  case ::gig::dimension_velocity:
173                      DimValues[i] = itNoteOnEvent->Param.Note.Velocity;                      DimValues[i] = itNoteOnEvent->Param.Note.Velocity;
# Line 170  namespace LinuxSampler { namespace gig { Line 180  namespace LinuxSampler { namespace gig {
180                      DimValues[i] = (uint) ReleaseTriggerVoice;                      DimValues[i] = (uint) ReleaseTriggerVoice;
181                      break;                      break;
182                  case ::gig::dimension_keyboard:                  case ::gig::dimension_keyboard:
183                      DimValues[i] = (uint) itNoteOnEvent->Param.Note.Key;                      DimValues[i] = (uint) pEngineChannel->CurrentKeyDimension;
184                      break;                      break;
185                  case ::gig::dimension_modwheel:                  case ::gig::dimension_modwheel:
186                      DimValues[i] = pEngine->ControllerTable[1];                      DimValues[i] = pEngineChannel->ControllerTable[1];
187                      break;                      break;
188                  case ::gig::dimension_breath:                  case ::gig::dimension_breath:
189                      DimValues[i] = pEngine->ControllerTable[2];                      DimValues[i] = pEngineChannel->ControllerTable[2];
190                      break;                      break;
191                  case ::gig::dimension_foot:                  case ::gig::dimension_foot:
192                      DimValues[i] = pEngine->ControllerTable[4];                      DimValues[i] = pEngineChannel->ControllerTable[4];
193                      break;                      break;
194                  case ::gig::dimension_portamentotime:                  case ::gig::dimension_portamentotime:
195                      DimValues[i] = pEngine->ControllerTable[5];                      DimValues[i] = pEngineChannel->ControllerTable[5];
196                      break;                      break;
197                  case ::gig::dimension_effect1:                  case ::gig::dimension_effect1:
198                      DimValues[i] = pEngine->ControllerTable[12];                      DimValues[i] = pEngineChannel->ControllerTable[12];
199                      break;                      break;
200                  case ::gig::dimension_effect2:                  case ::gig::dimension_effect2:
201                      DimValues[i] = pEngine->ControllerTable[13];                      DimValues[i] = pEngineChannel->ControllerTable[13];
202                      break;                      break;
203                  case ::gig::dimension_genpurpose1:                  case ::gig::dimension_genpurpose1:
204                      DimValues[i] = pEngine->ControllerTable[16];                      DimValues[i] = pEngineChannel->ControllerTable[16];
205                      break;                      break;
206                  case ::gig::dimension_genpurpose2:                  case ::gig::dimension_genpurpose2:
207                      DimValues[i] = pEngine->ControllerTable[17];                      DimValues[i] = pEngineChannel->ControllerTable[17];
208                      break;                      break;
209                  case ::gig::dimension_genpurpose3:                  case ::gig::dimension_genpurpose3:
210                      DimValues[i] = pEngine->ControllerTable[18];                      DimValues[i] = pEngineChannel->ControllerTable[18];
211                      break;                      break;
212                  case ::gig::dimension_genpurpose4:                  case ::gig::dimension_genpurpose4:
213                      DimValues[i] = pEngine->ControllerTable[19];                      DimValues[i] = pEngineChannel->ControllerTable[19];
214                      break;                      break;
215                  case ::gig::dimension_sustainpedal:                  case ::gig::dimension_sustainpedal:
216                      DimValues[i] = pEngine->ControllerTable[64];                      DimValues[i] = pEngineChannel->ControllerTable[64];
217                      break;                      break;
218                  case ::gig::dimension_portamento:                  case ::gig::dimension_portamento:
219                      DimValues[i] = pEngine->ControllerTable[65];                      DimValues[i] = pEngineChannel->ControllerTable[65];
220                      break;                      break;
221                  case ::gig::dimension_sostenutopedal:                  case ::gig::dimension_sostenutopedal:
222                      DimValues[i] = pEngine->ControllerTable[66];                      DimValues[i] = pEngineChannel->ControllerTable[66];
223                      break;                      break;
224                  case ::gig::dimension_softpedal:                  case ::gig::dimension_softpedal:
225                      DimValues[i] = pEngine->ControllerTable[67];                      DimValues[i] = pEngineChannel->ControllerTable[67];
226                      break;                      break;
227                  case ::gig::dimension_genpurpose5:                  case ::gig::dimension_genpurpose5:
228                      DimValues[i] = pEngine->ControllerTable[80];                      DimValues[i] = pEngineChannel->ControllerTable[80];
229                      break;                      break;
230                  case ::gig::dimension_genpurpose6:                  case ::gig::dimension_genpurpose6:
231                      DimValues[i] = pEngine->ControllerTable[81];                      DimValues[i] = pEngineChannel->ControllerTable[81];
232                      break;                      break;
233                  case ::gig::dimension_genpurpose7:                  case ::gig::dimension_genpurpose7:
234                      DimValues[i] = pEngine->ControllerTable[82];                      DimValues[i] = pEngineChannel->ControllerTable[82];
235                      break;                      break;
236                  case ::gig::dimension_genpurpose8:                  case ::gig::dimension_genpurpose8:
237                      DimValues[i] = pEngine->ControllerTable[83];                      DimValues[i] = pEngineChannel->ControllerTable[83];
238                      break;                      break;
239                  case ::gig::dimension_effect1depth:                  case ::gig::dimension_effect1depth:
240                      DimValues[i] = pEngine->ControllerTable[91];                      DimValues[i] = pEngineChannel->ControllerTable[91];
241                      break;                      break;
242                  case ::gig::dimension_effect2depth:                  case ::gig::dimension_effect2depth:
243                      DimValues[i] = pEngine->ControllerTable[92];                      DimValues[i] = pEngineChannel->ControllerTable[92];
244                      break;                      break;
245                  case ::gig::dimension_effect3depth:                  case ::gig::dimension_effect3depth:
246                      DimValues[i] = pEngine->ControllerTable[93];                      DimValues[i] = pEngineChannel->ControllerTable[93];
247                      break;                      break;
248                  case ::gig::dimension_effect4depth:                  case ::gig::dimension_effect4depth:
249                      DimValues[i] = pEngine->ControllerTable[94];                      DimValues[i] = pEngineChannel->ControllerTable[94];
250                      break;                      break;
251                  case ::gig::dimension_effect5depth:                  case ::gig::dimension_effect5depth:
252                      DimValues[i] = pEngine->ControllerTable[95];                      DimValues[i] = pEngineChannel->ControllerTable[95];
253                      break;                      break;
254                  case ::gig::dimension_none:                  case ::gig::dimension_none:
255                      std::cerr << "gig::Voice::Trigger() Error: dimension=none\n" << std::flush;                      std::cerr << "gig::Voice::Trigger() Error: dimension=none\n" << std::flush;
# Line 248  namespace LinuxSampler { namespace gig { Line 258  namespace LinuxSampler { namespace gig {
258                      std::cerr << "gig::Voice::Trigger() Error: Unknown dimension\n" << std::flush;                      std::cerr << "gig::Voice::Trigger() Error: Unknown dimension\n" << std::flush;
259              }              }
260          }          }
261          pDimRgn = pRegion->GetDimensionRegionByValue(DimValues[4],DimValues[3],DimValues[2],DimValues[1],DimValues[0]);          pDimRgn = pRegion->GetDimensionRegionByValue(DimValues);
262    
263          pSample = pDimRgn->pSample; // sample won't change until the voice is finished          pSample = pDimRgn->pSample; // sample won't change until the voice is finished
264            if (!pSample || !pSample->SamplesTotal) return -1; // no need to continue if sample is silent
265    
266          // select channel mode (mono or stereo)          // select channel mode (mono or stereo)
267          SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);          SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);
# Line 264  namespace LinuxSampler { namespace gig { Line 275  namespace LinuxSampler { namespace gig {
275                  CrossfadeVolume = CrossfadeAttenuation(itNoteOnEvent->Param.Note.Velocity);                  CrossfadeVolume = CrossfadeAttenuation(itNoteOnEvent->Param.Note.Velocity);
276                  break;                  break;
277              case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate              case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate
278                  CrossfadeVolume = CrossfadeAttenuation(pEngine->ControllerTable[pDimRgn->AttenuationController.controller_number]);                  CrossfadeVolume = CrossfadeAttenuation(pEngineChannel->ControllerTable[pDimRgn->AttenuationController.controller_number]);
279                  break;                  break;
280              case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined              case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined
281              default:              default:
# Line 310  namespace LinuxSampler { namespace gig { Line 321  namespace LinuxSampler { namespace gig {
321    
322          // calculate initial pitch value          // calculate initial pitch value
323          {          {
324              double pitchbasecents = pDimRgn->FineTune * 10 + (int) pEngine->ScaleTuning[MIDIKey % 12];              double pitchbasecents = pDimRgn->FineTune + (int) pEngine->ScaleTuning[MIDIKey % 12];
325              if (pDimRgn->PitchTrack) pitchbasecents += (MIDIKey - (int) pDimRgn->UnityNote) * 100;              if (pDimRgn->PitchTrack) pitchbasecents += (MIDIKey - (int) pDimRgn->UnityNote) * 100;
326              this->PitchBase = RTMath::CentsToFreqRatio(pitchbasecents) * (double(pSample->SamplesPerSecond) / double(pEngine->pAudioOutputDevice->SampleRate()));              this->PitchBase = RTMath::CentsToFreqRatio(pitchbasecents) * (double(pSample->SamplesPerSecond) / double(pEngine->pAudioOutputDevice->SampleRate()));
327              this->PitchBend = RTMath::CentsToFreqRatio(((double) PitchBend / 8192.0) * 200.0); // pitchbend wheel +-2 semitones = 200 cents              this->PitchBend = RTMath::CentsToFreqRatio(((double) PitchBend / 8192.0) * 200.0); // pitchbend wheel +-2 semitones = 200 cents
# Line 318  namespace LinuxSampler { namespace gig { Line 329  namespace LinuxSampler { namespace gig {
329    
330          Volume = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity) / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)          Volume = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity) / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)
331    
332            Volume *= pDimRgn->SampleAttenuation;
333    
334          // setup EG 1 (VCA EG)          // setup EG 1 (VCA EG)
335          {          {
336              // get current value of EG1 controller              // get current value of EG1 controller
# Line 333  namespace LinuxSampler { namespace gig { Line 346  namespace LinuxSampler { namespace gig {
346                      eg1controllervalue = itNoteOnEvent->Param.Note.Velocity;                      eg1controllervalue = itNoteOnEvent->Param.Note.Velocity;
347                      break;                      break;
348                  case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller                  case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller
349                      eg1controllervalue = pEngine->ControllerTable[pDimRgn->EG1Controller.controller_number];                      eg1controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG1Controller.controller_number];
350                      break;                      break;
351              }              }
352              if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;              if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;
# Line 352  namespace LinuxSampler { namespace gig { Line 365  namespace LinuxSampler { namespace gig {
365                            pDimRgn->EG1InfiniteSustain,                            pDimRgn->EG1InfiniteSustain,
366                            pDimRgn->EG1Sustain,                            pDimRgn->EG1Sustain,
367                            pDimRgn->EG1Release + eg1release,                            pDimRgn->EG1Release + eg1release,
368                            Delay);                            // the SSE synthesis implementation requires
369                              // the vca start to be 16 byte aligned
370                              SYNTHESIS_MODE_GET_IMPLEMENTATION(SynthesisMode) ?
371                              Delay & 0xfffffffc : Delay);
372          }          }
373    
374    
# Line 371  namespace LinuxSampler { namespace gig { Line 387  namespace LinuxSampler { namespace gig {
387                      eg2controllervalue = itNoteOnEvent->Param.Note.Velocity;                      eg2controllervalue = itNoteOnEvent->Param.Note.Velocity;
388                      break;                      break;
389                  case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller                  case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller
390                      eg2controllervalue = pEngine->ControllerTable[pDimRgn->EG2Controller.controller_number];                      eg2controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG2Controller.controller_number];
391                      break;                      break;
392              }              }
393              if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;              if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;
# Line 432  namespace LinuxSampler { namespace gig { Line 448  namespace LinuxSampler { namespace gig {
448              pLFO1->Trigger(pDimRgn->LFO1Frequency,              pLFO1->Trigger(pDimRgn->LFO1Frequency,
449                            lfo1_internal_depth,                            lfo1_internal_depth,
450                            pDimRgn->LFO1ControlDepth,                            pDimRgn->LFO1ControlDepth,
451                            pEngine->ControllerTable[pLFO1->ExtController],                            pEngineChannel->ControllerTable[pLFO1->ExtController],
452                            pDimRgn->LFO1FlipPhase,                            pDimRgn->LFO1FlipPhase,
453                            pEngine->SampleRate,                            pEngine->SampleRate,
454                            Delay);                            Delay);
# Line 470  namespace LinuxSampler { namespace gig { Line 486  namespace LinuxSampler { namespace gig {
486              pLFO2->Trigger(pDimRgn->LFO2Frequency,              pLFO2->Trigger(pDimRgn->LFO2Frequency,
487                            lfo2_internal_depth,                            lfo2_internal_depth,
488                            pDimRgn->LFO2ControlDepth,                            pDimRgn->LFO2ControlDepth,
489                            pEngine->ControllerTable[pLFO2->ExtController],                            pEngineChannel->ControllerTable[pLFO2->ExtController],
490                            pDimRgn->LFO2FlipPhase,                            pDimRgn->LFO2FlipPhase,
491                            pEngine->SampleRate,                            pEngine->SampleRate,
492                            Delay);                            Delay);
# Line 508  namespace LinuxSampler { namespace gig { Line 524  namespace LinuxSampler { namespace gig {
524              pLFO3->Trigger(pDimRgn->LFO3Frequency,              pLFO3->Trigger(pDimRgn->LFO3Frequency,
525                            lfo3_internal_depth,                            lfo3_internal_depth,
526                            pDimRgn->LFO3ControlDepth,                            pDimRgn->LFO3ControlDepth,
527                            pEngine->ControllerTable[pLFO3->ExtController],                            pEngineChannel->ControllerTable[pLFO3->ExtController],
528                            false,                            false,
529                            pEngine->SampleRate,                            pEngine->SampleRate,
530                            Delay);                            Delay);
# Line 516  namespace LinuxSampler { namespace gig { Line 532  namespace LinuxSampler { namespace gig {
532    
533    
534          #if FORCE_FILTER_USAGE          #if FORCE_FILTER_USAGE
535          SYNTHESIS_MODE_SET_FILTER(SynthesisMode, true);          const bool bUseFilter = true;
536          #else // use filter only if instrument file told so          #else // use filter only if instrument file told so
537          SYNTHESIS_MODE_SET_FILTER(SynthesisMode, pDimRgn->VCFEnabled);          const bool bUseFilter = pDimRgn->VCFEnabled;
538          #endif // FORCE_FILTER_USAGE          #endif // FORCE_FILTER_USAGE
539          if (pDimRgn->VCFEnabled) {          SYNTHESIS_MODE_SET_FILTER(SynthesisMode, bUseFilter);
540            if (bUseFilter) {
541              #ifdef OVERRIDE_FILTER_CUTOFF_CTRL              #ifdef OVERRIDE_FILTER_CUTOFF_CTRL
542              VCFCutoffCtrl.controller = OVERRIDE_FILTER_CUTOFF_CTRL;              VCFCutoffCtrl.controller = OVERRIDE_FILTER_CUTOFF_CTRL;
543              #else // use the one defined in the instrument file              #else // use the one defined in the instrument file
# Line 590  namespace LinuxSampler { namespace gig { Line 607  namespace LinuxSampler { namespace gig {
607              FilterRight.SetType(OVERRIDE_FILTER_TYPE);              FilterRight.SetType(OVERRIDE_FILTER_TYPE);
608              #endif // OVERRIDE_FILTER_TYPE              #endif // OVERRIDE_FILTER_TYPE
609    
610              VCFCutoffCtrl.value    = pEngine->ControllerTable[VCFCutoffCtrl.controller];              VCFCutoffCtrl.value    = pEngineChannel->ControllerTable[VCFCutoffCtrl.controller];
611              VCFResonanceCtrl.value = pEngine->ControllerTable[VCFResonanceCtrl.controller];              VCFResonanceCtrl.value = pEngineChannel->ControllerTable[VCFResonanceCtrl.controller];
612    
613              // calculate cutoff frequency              // calculate cutoff frequency
614              float cutoff = (!VCFCutoffCtrl.controller)              float cutoff = (!VCFCutoffCtrl.controller)
# Line 638  namespace LinuxSampler { namespace gig { Line 655  namespace LinuxSampler { namespace gig {
655    
656          // Reset the synthesis parameter matrix          // Reset the synthesis parameter matrix
657    
658          pEngine->ResetSynthesisParameters(Event::destination_vca, this->Volume * this->CrossfadeVolume * pEngine->GlobalVolume);          pEngine->ResetSynthesisParameters(Event::destination_vca, this->Volume * this->CrossfadeVolume * pEngineChannel->GlobalVolume);
659          pEngine->ResetSynthesisParameters(Event::destination_vco, this->PitchBase);          pEngine->ResetSynthesisParameters(Event::destination_vco, this->PitchBase);
660          pEngine->ResetSynthesisParameters(Event::destination_vcfc, VCFCutoffCtrl.fvalue);          pEngine->ResetSynthesisParameters(Event::destination_vcfc, VCFCutoffCtrl.fvalue);
661          pEngine->ResetSynthesisParameters(Event::destination_vcfr, VCFResonanceCtrl.fvalue);          pEngine->ResetSynthesisParameters(Event::destination_vcfr, VCFResonanceCtrl.fvalue);
# Line 647  namespace LinuxSampler { namespace gig { Line 664  namespace LinuxSampler { namespace gig {
664          ProcessEvents(Samples);          ProcessEvents(Samples);
665    
666          // Let all modulators write their parameter changes to the synthesis parameter matrix for the current audio fragment          // Let all modulators write their parameter changes to the synthesis parameter matrix for the current audio fragment
667          pEG1->Process(Samples, pEngine->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend, itKillEvent);          pEG1->Process(Samples, pEngineChannel->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend, itKillEvent);
668          pEG2->Process(Samples, pEngine->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend);          pEG2->Process(Samples, pEngineChannel->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend);
669          if (pEG3->Process(Samples)) { // if pitch EG is active          if (pEG3->Process(Samples)) { // if pitch EG is active
670              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
671              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
# Line 661  namespace LinuxSampler { namespace gig { Line 678  namespace LinuxSampler { namespace gig {
678          }          }
679    
680          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))
681                  CalculateBiquadParameters(Samples); // calculate the final biquad filter parameters              CalculateBiquadParameters(Samples); // calculate the final biquad filter parameters
682    
683          switch (this->PlaybackState) {          switch (this->PlaybackState) {
684    
# Line 862  namespace LinuxSampler { namespace gig { Line 879  namespace LinuxSampler { namespace gig {
879    
880                  crossfadevolume = CrossfadeAttenuation(itVCAEvent->Param.CC.Value);                  crossfadevolume = CrossfadeAttenuation(itVCAEvent->Param.CC.Value);
881    
882                  float effective_volume = crossfadevolume * this->Volume * pEngine->GlobalVolume;                  float effective_volume = crossfadevolume * this->Volume * pEngineChannel->GlobalVolume;
883    
884                  // apply volume value to the volume parameter sequence                  // apply volume value to the volume parameter sequence
885                  for (uint i = itVCAEvent->FragmentPos(); i < end; i++) {                  for (uint i = itVCAEvent->FragmentPos(); i < end; i++) {
# Line 942  namespace LinuxSampler { namespace gig { Line 959  namespace LinuxSampler { namespace gig {
959          biquad_param_t bqmain;          biquad_param_t bqmain;
960          float prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][0];          float prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][0];
961          float prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][0];          float prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][0];
962          FilterLeft.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);          FilterLeft.SetParameters( &bqbase, &bqmain, prev_cutoff + FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
963          FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);          FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff + FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
964          pEngine->pBasicFilterParameters[0] = bqbase;          pEngine->pBasicFilterParameters[0] = bqbase;
965          pEngine->pMainFilterParameters[0]  = bqmain;          pEngine->pMainFilterParameters[0]  = bqmain;
966    
# Line 956  namespace LinuxSampler { namespace gig { Line 973  namespace LinuxSampler { namespace gig {
973                  {                  {
974                      prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][i];                      prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][i];
975                      prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][i];                      prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][i];
976                      FilterLeft.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);                      FilterLeft.SetParameters( &bqbase, &bqmain, prev_cutoff + FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
977                      FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);                      FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff + FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
978                  }                  }
979              }              }
980    

Legend:
Removed from v.332  
changed lines
  Added in v.425

  ViewVC Help
Powered by ViewVC