/[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 614 by persson, Mon Jun 6 16:54:20 2005 UTC revision 687 by schoenebeck, Tue Jul 12 22:37:21 2005 UTC
# Line 61  namespace LinuxSampler { namespace gig { Line 61  namespace LinuxSampler { namespace gig {
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          #if CONFIG_ASM && ARCH_X86
65          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());
66          #else          #else
67          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, false);          SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, false);
# Line 117  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       *  @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 pDimRgn        - points to the dimension region 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 VoiceType      - type of this voice
125       *  @param ReleaseTriggerVoice  - if this new voice is a release trigger voice (optional, default = false)       *  @param iKeyGroup      - a value > 0 defines a key group in which this voice is member of
      *  @param VoiceStealingAllowed - wether the voice is allowed to steal voices for further subvoices  
126       *  @returns 0 on success, a value < 0 if the voice wasn't triggered       *  @returns 0 on success, a value < 0 if the voice wasn't triggered
127       *           (either due to an error or e.g. because no region is       *           (either due to an error or e.g. because no region is
128       *           defined for the given key)       *           defined for the given key)
129       */       */
130      int Voice::Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::Instrument* pInstrument, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealingAllowed) {      int Voice::Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup) {
131          this->pEngineChannel = pEngineChannel;          this->pEngineChannel = pEngineChannel;
132          if (!pInstrument) {          this->pDimRgn        = pDimRgn;
133             dmsg(1,("voice::trigger: !pInstrument\n"));  
            exit(EXIT_FAILURE);  
         }  
134          #if CONFIG_DEVMODE          #if CONFIG_DEVMODE
135          if (itNoteOnEvent->FragmentPos() > pEngine->MaxSamplesPerCycle) { // just a sanity check for debugging          if (itNoteOnEvent->FragmentPos() > pEngine->MaxSamplesPerCycle) { // just a sanity check for debugging
136              dmsg(1,("Voice::Trigger(): ERROR, TriggerDelay > Totalsamples\n"));              dmsg(1,("Voice::Trigger(): ERROR, TriggerDelay > Totalsamples\n"));
137          }          }
138          #endif // CONFIG_DEVMODE          #endif // CONFIG_DEVMODE
139    
140          Type            = type_normal;          Type            = VoiceType;
141          MIDIKey         = itNoteOnEvent->Param.Note.Key;          MIDIKey         = itNoteOnEvent->Param.Note.Key;
         pRegion         = pInstrument->GetRegion(MIDIKey);  
142          PlaybackState   = playback_state_init; // mark voice as triggered, but no audio rendered yet          PlaybackState   = playback_state_init; // mark voice as triggered, but no audio rendered yet
143          Delay           = itNoteOnEvent->FragmentPos();          Delay           = itNoteOnEvent->FragmentPos();
144          itTriggerEvent  = itNoteOnEvent;          itTriggerEvent  = itNoteOnEvent;
145          itKillEvent     = Pool<Event>::Iterator();          itKillEvent     = Pool<Event>::Iterator();
146            KeyGroup        = iKeyGroup;
147            pSample         = pDimRgn->pSample; // sample won't change until the voice is finished
148    
149          if (!pRegion) {          // calculate volume
150              dmsg(4, ("gig::Voice: No Region defined for MIDI key %d\n", MIDIKey));          const double velocityAttenuation = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity);
             return -1;  
         }  
151    
152          // only mark the first voice of a layered voice (group) to be in a          Volume = velocityAttenuation / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)
         // key group, so the layered voices won't kill each other  
         KeyGroup = (iLayer == 0 && !ReleaseTriggerVoice) ? pRegion->KeyGroup : 0;  
153    
154          // get current dimension values to select the right dimension region          Volume *= pDimRgn->SampleAttenuation;
         //FIXME: controller values for selecting the dimension region here are currently not sample accurate  
         uint DimValues[8] = { 0 };  
         for (int i = pRegion->Dimensions - 1; i >= 0; i--) {  
             switch (pRegion->pDimensionDefinitions[i].dimension) {  
                 case ::gig::dimension_samplechannel:  
                     DimValues[i] = 0; //TODO: we currently ignore this dimension  
                     break;  
                 case ::gig::dimension_layer:  
                     DimValues[i] = iLayer;  
                     break;  
                 case ::gig::dimension_velocity:  
                     DimValues[i] = itNoteOnEvent->Param.Note.Velocity;  
                     break;  
                 case ::gig::dimension_channelaftertouch:  
                     DimValues[i] = 0; //TODO: we currently ignore this dimension  
                     break;  
                 case ::gig::dimension_releasetrigger:  
                     Type = (ReleaseTriggerVoice) ? type_release_trigger : (!iLayer) ? type_release_trigger_required : type_normal;  
                     DimValues[i] = (uint) ReleaseTriggerVoice;  
                     break;  
                 case ::gig::dimension_keyboard:  
                     DimValues[i] = (uint) pEngineChannel->CurrentKeyDimension;  
                     break;  
                 case ::gig::dimension_roundrobin:  
                     DimValues[i] = (uint) pEngineChannel->pMIDIKeyInfo[MIDIKey].RoundRobinIndex; // incremented for each note on  
                     break;  
                 case ::gig::dimension_random:  
                     pEngine->RandomSeed = pEngine->RandomSeed * 1103515245 + 12345; // classic pseudo random number generator  
                     DimValues[i] = (uint) pEngine->RandomSeed >> (32 - pRegion->pDimensionDefinitions[i].bits); // highest bits are most random  
                     break;  
                 case ::gig::dimension_modwheel:  
                     DimValues[i] = pEngineChannel->ControllerTable[1];  
                     break;  
                 case ::gig::dimension_breath:  
                     DimValues[i] = pEngineChannel->ControllerTable[2];  
                     break;  
                 case ::gig::dimension_foot:  
                     DimValues[i] = pEngineChannel->ControllerTable[4];  
                     break;  
                 case ::gig::dimension_portamentotime:  
                     DimValues[i] = pEngineChannel->ControllerTable[5];  
                     break;  
                 case ::gig::dimension_effect1:  
                     DimValues[i] = pEngineChannel->ControllerTable[12];  
                     break;  
                 case ::gig::dimension_effect2:  
                     DimValues[i] = pEngineChannel->ControllerTable[13];  
                     break;  
                 case ::gig::dimension_genpurpose1:  
                     DimValues[i] = pEngineChannel->ControllerTable[16];  
                     break;  
                 case ::gig::dimension_genpurpose2:  
                     DimValues[i] = pEngineChannel->ControllerTable[17];  
                     break;  
                 case ::gig::dimension_genpurpose3:  
                     DimValues[i] = pEngineChannel->ControllerTable[18];  
                     break;  
                 case ::gig::dimension_genpurpose4:  
                     DimValues[i] = pEngineChannel->ControllerTable[19];  
                     break;  
                 case ::gig::dimension_sustainpedal:  
                     DimValues[i] = pEngineChannel->ControllerTable[64];  
                     break;  
                 case ::gig::dimension_portamento:  
                     DimValues[i] = pEngineChannel->ControllerTable[65];  
                     break;  
                 case ::gig::dimension_sostenutopedal:  
                     DimValues[i] = pEngineChannel->ControllerTable[66];  
                     break;  
                 case ::gig::dimension_softpedal:  
                     DimValues[i] = pEngineChannel->ControllerTable[67];  
                     break;  
                 case ::gig::dimension_genpurpose5:  
                     DimValues[i] = pEngineChannel->ControllerTable[80];  
                     break;  
                 case ::gig::dimension_genpurpose6:  
                     DimValues[i] = pEngineChannel->ControllerTable[81];  
                     break;  
                 case ::gig::dimension_genpurpose7:  
                     DimValues[i] = pEngineChannel->ControllerTable[82];  
                     break;  
                 case ::gig::dimension_genpurpose8:  
                     DimValues[i] = pEngineChannel->ControllerTable[83];  
                     break;  
                 case ::gig::dimension_effect1depth:  
                     DimValues[i] = pEngineChannel->ControllerTable[91];  
                     break;  
                 case ::gig::dimension_effect2depth:  
                     DimValues[i] = pEngineChannel->ControllerTable[92];  
                     break;  
                 case ::gig::dimension_effect3depth:  
                     DimValues[i] = pEngineChannel->ControllerTable[93];  
                     break;  
                 case ::gig::dimension_effect4depth:  
                     DimValues[i] = pEngineChannel->ControllerTable[94];  
                     break;  
                 case ::gig::dimension_effect5depth:  
                     DimValues[i] = pEngineChannel->ControllerTable[95];  
                     break;  
                 case ::gig::dimension_none:  
                     std::cerr << "gig::Voice::Trigger() Error: dimension=none\n" << std::flush;  
                     break;  
                 default:  
                     std::cerr << "gig::Voice::Trigger() Error: Unknown dimension\n" << std::flush;  
             }  
         }  
         pDimRgn = pRegion->GetDimensionRegionByValue(DimValues);  
155    
156          pSample = pDimRgn->pSample; // sample won't change until the voice is finished          // the volume of release triggered samples depends on note length
157          if (!pSample || !pSample->SamplesTotal) return -1; // no need to continue if sample is silent          if (Type == type_release_trigger) {
158                float noteLength = float(pEngine->FrameTime + Delay -
159                                         pEngineChannel->pMIDIKeyInfo[MIDIKey].NoteOnTime) / pEngine->SampleRate;
160                float attenuation = 1 - 0.01053 * (256 >> pDimRgn->ReleaseTriggerDecay) * noteLength;
161                if (attenuation <= 0) return -1;
162                Volume *= attenuation;
163            }
164    
165          // select channel mode (mono or stereo)          // select channel mode (mono or stereo)
166          SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);          SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);
# Line 333  namespace LinuxSampler { namespace gig { Line 226  namespace LinuxSampler { namespace gig {
226              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
227          }          }
228    
         const double velocityAttenuation = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity);  
   
         Volume = velocityAttenuation / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)  
   
         Volume *= pDimRgn->SampleAttenuation;  
   
229          // the length of the decay and release curves are dependent on the velocity          // the length of the decay and release curves are dependent on the velocity
230          const double velrelease = 1 / pDimRgn->GetVelocityRelease(itNoteOnEvent->Param.Note.Velocity);          const double velrelease = 1 / pDimRgn->GetVelocityRelease(itNoteOnEvent->Param.Note.Velocity);
231    
# Line 437  namespace LinuxSampler { namespace gig { Line 324  namespace LinuxSampler { namespace gig {
324                  case ::gig::lfo1_ctrl_internal:                  case ::gig::lfo1_ctrl_internal:
325                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
326                      pLFO1->ExtController = 0; // no external controller                      pLFO1->ExtController = 0; // no external controller
327                        bLFO1Enabled         = (lfo1_internal_depth > 0);
328                      break;                      break;
329                  case ::gig::lfo1_ctrl_modwheel:                  case ::gig::lfo1_ctrl_modwheel:
330                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
331                      pLFO1->ExtController = 1; // MIDI controller 1                      pLFO1->ExtController = 1; // MIDI controller 1
332                        bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);
333                      break;                      break;
334                  case ::gig::lfo1_ctrl_breath:                  case ::gig::lfo1_ctrl_breath:
335                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
336                      pLFO1->ExtController = 2; // MIDI controller 2                      pLFO1->ExtController = 2; // MIDI controller 2
337                        bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);
338                      break;                      break;
339                  case ::gig::lfo1_ctrl_internal_modwheel:                  case ::gig::lfo1_ctrl_internal_modwheel:
340                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
341                      pLFO1->ExtController = 1; // MIDI controller 1                      pLFO1->ExtController = 1; // MIDI controller 1
342                        bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
343                      break;                      break;
344                  case ::gig::lfo1_ctrl_internal_breath:                  case ::gig::lfo1_ctrl_internal_breath:
345                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
346                      pLFO1->ExtController = 2; // MIDI controller 2                      pLFO1->ExtController = 2; // MIDI controller 2
347                        bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
348                      break;                      break;
349                  default:                  default:
350                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
351                      pLFO1->ExtController = 0; // no external controller                      pLFO1->ExtController = 0; // no external controller
352                        bLFO1Enabled         = false;
353              }              }
354              pLFO1->Trigger(pDimRgn->LFO1Frequency,              if (bLFO1Enabled) pLFO1->Trigger(pDimRgn->LFO1Frequency,
355                            lfo1_internal_depth,                                               lfo1_internal_depth,
356                            pDimRgn->LFO1ControlDepth,                                               pDimRgn->LFO1ControlDepth,
357                            pEngineChannel->ControllerTable[pLFO1->ExtController],                                               pEngineChannel->ControllerTable[pLFO1->ExtController],
358                            pDimRgn->LFO1FlipPhase,                                               pDimRgn->LFO1FlipPhase,
359                            pEngine->SampleRate,                                               pEngine->SampleRate,
360                            Delay);                                               Delay);
361          }          }
362    
363    
# Line 475  namespace LinuxSampler { namespace gig { Line 368  namespace LinuxSampler { namespace gig {
368                  case ::gig::lfo2_ctrl_internal:                  case ::gig::lfo2_ctrl_internal:
369                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
370                      pLFO2->ExtController = 0; // no external controller                      pLFO2->ExtController = 0; // no external controller
371                        bLFO2Enabled         = (lfo2_internal_depth > 0);
372                      break;                      break;
373                  case ::gig::lfo2_ctrl_modwheel:                  case ::gig::lfo2_ctrl_modwheel:
374                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
375                      pLFO2->ExtController = 1; // MIDI controller 1                      pLFO2->ExtController = 1; // MIDI controller 1
376                        bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);
377                      break;                      break;
378                  case ::gig::lfo2_ctrl_foot:                  case ::gig::lfo2_ctrl_foot:
379                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
380                      pLFO2->ExtController = 4; // MIDI controller 4                      pLFO2->ExtController = 4; // MIDI controller 4
381                        bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);
382                      break;                      break;
383                  case ::gig::lfo2_ctrl_internal_modwheel:                  case ::gig::lfo2_ctrl_internal_modwheel:
384                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
385                      pLFO2->ExtController = 1; // MIDI controller 1                      pLFO2->ExtController = 1; // MIDI controller 1
386                        bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
387                      break;                      break;
388                  case ::gig::lfo2_ctrl_internal_foot:                  case ::gig::lfo2_ctrl_internal_foot:
389                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
390                      pLFO2->ExtController = 4; // MIDI controller 4                      pLFO2->ExtController = 4; // MIDI controller 4
391                        bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
392                      break;                      break;
393                  default:                  default:
394                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
395                      pLFO2->ExtController = 0; // no external controller                      pLFO2->ExtController = 0; // no external controller
396                        bLFO2Enabled         = false;
397              }              }
398              pLFO2->Trigger(pDimRgn->LFO2Frequency,              if (bLFO2Enabled) pLFO2->Trigger(pDimRgn->LFO2Frequency,
399                            lfo2_internal_depth,                                               lfo2_internal_depth,
400                            pDimRgn->LFO2ControlDepth,                                               pDimRgn->LFO2ControlDepth,
401                            pEngineChannel->ControllerTable[pLFO2->ExtController],                                               pEngineChannel->ControllerTable[pLFO2->ExtController],
402                            pDimRgn->LFO2FlipPhase,                                               pDimRgn->LFO2FlipPhase,
403                            pEngine->SampleRate,                                               pEngine->SampleRate,
404                            Delay);                                               Delay);
405          }          }
406    
407    
# Line 513  namespace LinuxSampler { namespace gig { Line 412  namespace LinuxSampler { namespace gig {
412                  case ::gig::lfo3_ctrl_internal:                  case ::gig::lfo3_ctrl_internal:
413                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
414                      pLFO3->ExtController = 0; // no external controller                      pLFO3->ExtController = 0; // no external controller
415                        bLFO3Enabled         = (lfo3_internal_depth > 0);
416                      break;                      break;
417                  case ::gig::lfo3_ctrl_modwheel:                  case ::gig::lfo3_ctrl_modwheel:
418                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
419                      pLFO3->ExtController = 1; // MIDI controller 1                      pLFO3->ExtController = 1; // MIDI controller 1
420                        bLFO3Enabled         = (pDimRgn->LFO3ControlDepth > 0);
421                      break;                      break;
422                  case ::gig::lfo3_ctrl_aftertouch:                  case ::gig::lfo3_ctrl_aftertouch:
423                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
424                      pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet                      pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet
425                        bLFO3Enabled         = false; // see TODO comment in line above
426                      break;                      break;
427                  case ::gig::lfo3_ctrl_internal_modwheel:                  case ::gig::lfo3_ctrl_internal_modwheel:
428                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
429                      pLFO3->ExtController = 1; // MIDI controller 1                      pLFO3->ExtController = 1; // MIDI controller 1
430                        bLFO3Enabled         = (lfo3_internal_depth > 0 || pDimRgn->LFO3ControlDepth > 0);
431                      break;                      break;
432                  case ::gig::lfo3_ctrl_internal_aftertouch:                  case ::gig::lfo3_ctrl_internal_aftertouch:
433                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
434                      pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet                      pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet
435                        bLFO3Enabled         = (lfo3_internal_depth > 0 /*|| pDimRgn->LFO3ControlDepth > 0*/); // see TODO comment in line above
436                      break;                      break;
437                  default:                  default:
438                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
439                      pLFO3->ExtController = 0; // no external controller                      pLFO3->ExtController = 0; // no external controller
440                        bLFO3Enabled         = false;
441              }              }
442              pLFO3->Trigger(pDimRgn->LFO3Frequency,              if (bLFO3Enabled) pLFO3->Trigger(pDimRgn->LFO3Frequency,
443                            lfo3_internal_depth,                                               lfo3_internal_depth,
444                            pDimRgn->LFO3ControlDepth,                                               pDimRgn->LFO3ControlDepth,
445                            pEngineChannel->ControllerTable[pLFO3->ExtController],                                               pEngineChannel->ControllerTable[pLFO3->ExtController],
446                            false,                                               false,
447                            pEngine->SampleRate,                                               pEngine->SampleRate,
448                            Delay);                                               Delay);
449          }          }
450    
451    
# Line 683  namespace LinuxSampler { namespace gig { Line 588  namespace LinuxSampler { namespace gig {
588              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
589              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
590          }          }
591          pLFO1->Process(Samples);          if (bLFO1Enabled) pLFO1->Process(Samples);
592          pLFO2->Process(Samples);          if (bLFO2Enabled) pLFO2->Process(Samples);
593          if (pLFO3->Process(Samples)) { // if pitch LFO modulation is active          if (bLFO3Enabled) {
594              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);              if (pLFO3->Process(Samples)) { // if pitch LFO modulation is active
595              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);                  SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
596                    SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
597                }
598          }          }
599    
600          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))
Legend:
Removed from v.614  
changed lines
  Added in v.687
  ViewVC Help
Powered by ViewVC