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

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

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

revision 2176 by persson, Sun May 1 15:19:38 2011 UTC revision 2252 by iliev, Sat Aug 20 14:01:36 2011 UTC
# Line 31  Line 31 
31    
32  namespace LinuxSampler { namespace sfz {  namespace LinuxSampler { namespace sfz {
33    
34      Voice::Voice() {      typedef LinuxSampler::VoiceBase<EngineChannel, ::sfz::Region, Sample, DiskThread> SfzVoice;
35        Voice::Voice(): SignalRack(this), SfzVoice(&SignalRack) {
36          pEngine     = NULL;          pEngine     = NULL;
37      }      }
38    
# Line 71  namespace LinuxSampler { namespace sfz { Line 72  namespace LinuxSampler { namespace sfz {
72          ri.UnityNote = pRegion->pitch_keycenter;          ri.UnityNote = pRegion->pitch_keycenter;
73          ri.FineTune  = pRegion->tune + pRegion->transpose * 100;          ri.FineTune  = pRegion->tune + pRegion->transpose * 100;
74          ri.Pan       = int(pRegion->pan * 0.63); // convert from -100..100 to -64..63          ri.Pan       = int(pRegion->pan * 0.63); // convert from -100..100 to -64..63
75          ri.SampleStartOffset = 0; // TODO:          ri.SampleStartOffset = pRegion->offset ? *(pRegion->offset) : 0;
76    
         ri.EG1PreAttack        = pRegion->ampeg_start * 10;  
         ri.EG1Attack           = pRegion->ampeg_attack;  
         ri.EG1Hold             = pRegion->ampeg_hold;  
         ri.EG1Decay1           = pRegion->ampeg_decay;  
         ri.EG1Decay2           = pRegion->ampeg_decay;  
         ri.EG1Sustain          = pRegion->ampeg_sustain * 10;  
         ri.EG1InfiniteSustain  = true;  
         ri.EG1Release          = pRegion->ampeg_release;  
   
         ri.EG2PreAttack        = pRegion->fileg_start * 10;  
         ri.EG2Attack           = pRegion->fileg_attack;  
         //ri.EG2Hold             = pRegion->fileg_hold; // TODO:  
         ri.EG2Decay1           = pRegion->fileg_decay;  
         ri.EG2Decay2           = pRegion->fileg_decay;  
         ri.EG2Sustain          = pRegion->fileg_sustain * 10;  
         ri.EG2InfiniteSustain  = true;  
         ri.EG2Release          = pRegion->fileg_release;  
   
         ri.EG3Attack     = pRegion->pitcheg_attack;  
         ri.EG3Depth      = 0; // TODO:  
77          ri.VCFEnabled    = pRegion->cutoff;          ri.VCFEnabled    = pRegion->cutoff;
78          switch (pRegion->fil_type) {          switch (pRegion->fil_type) {
79          case ::sfz::LPF_1P:          case ::sfz::LPF_1P:
# Line 172  namespace LinuxSampler { namespace sfz { Line 153  namespace LinuxSampler { namespace sfz {
153          }*/ // TODO: ^^^          }*/ // TODO: ^^^
154      }      }
155    
     void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {  
         int ccvalue = itEvent->Param.CC.Value;  
         if (VCFCutoffCtrl.value == ccvalue) return;  
         VCFCutoffCtrl.value = ccvalue;  
   
         float cutoff = CutoffBase * RTMath::CentsToFreqRatioUnlimited(  
             ccvalue / 127.0f * pRegion->cutoff_oncc[VCFCutoffCtrl.controller]);  
         if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;  
   
         VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of fFinalCutoff next time  
         fFinalCutoff = cutoff;  
     }  
   
156      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {
157          /*float crossfadeVolume;          /*float crossfadeVolume;
158          switch (pRegion->AttenuationController.type) {          switch (pRegion->AttenuationController.type) {
# Line 245  namespace LinuxSampler { namespace sfz { Line 213  namespace LinuxSampler { namespace sfz {
213          return eg;          return eg;
214      }      }
215    
     void Voice::TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) {  
   
         // TODO: controller modulation  
   
         // first check if there is a v2 EG for amplitude  
         for (int i = 0 ; i < pRegion->eg.size() ; i++) {  
             if (pRegion->eg[i].amplitude > 0) {  
                 // TODO: actually use the value of the amplitude parameter  
                 pEG1 = &EG1;  
                 EG1.trigger(pRegion->eg[i], sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE, velocity);  
                 return;  
             }  
         }  
   
         // otherwise use the v1 EGADSR  
         pEG1 = &EGADSR1;  
         EGADSR1.trigger(uint(RgnInfo.EG1PreAttack),  
                         std::max(0.0, RgnInfo.EG1Attack + pRegion->ampeg_vel2attack * velrelease),  
                         std::max(0.0, RgnInfo.EG1Hold + pRegion->ampeg_vel2hold * velrelease),  
                         std::max(0.0, RgnInfo.EG1Decay1 + pRegion->ampeg_vel2decay * velrelease),  
                         uint(std::min(std::max(0.0, RgnInfo.EG1Sustain + 10 * pRegion->ampeg_vel2sustain * velrelease), 1000.0)),  
                         std::max(0.0, RgnInfo.EG1Release + pRegion->ampeg_vel2release * velrelease),  
                         sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
     }  
   
216      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {
217          /*double eg2controllervalue = 0;          /*double eg2controllervalue = 0;
218          switch (pRegion->EG2Controller.type) {          switch (pRegion->EG2Controller.type) {
# Line 306  namespace LinuxSampler { namespace sfz { Line 249  namespace LinuxSampler { namespace sfz {
249          return eg;          return eg;
250      }      }
251    
     void Voice::TriggerEG2(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) {  
   
         // TODO: the sfz filter EG should modulate cents, not hertz,  
         // so we can't use the EG or EGADSR as it is. Disable for now.  
   
         pEG2 = &EGADSR2;  
         EGADSR2.trigger(0,  
                         0,  
                         false,  
                         0,  
                         1000,  
                         0,  
                         sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
     }  
   
     void Voice::InitLFO1() {  
         /*uint16_t lfo1_internal_depth;  
         switch (pRegion->LFO1Controller) {  
             case ::gig::lfo1_ctrl_internal:  
                 lfo1_internal_depth  = pRegion->LFO1InternalDepth;  
                 pLFO1->ExtController = 0; // no external controller  
                 bLFO1Enabled         = (lfo1_internal_depth > 0);  
                 break;  
             case ::gig::lfo1_ctrl_modwheel:  
                 lfo1_internal_depth  = 0;  
                 pLFO1->ExtController = 1; // MIDI controller 1  
                 bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);  
                 break;  
             case ::gig::lfo1_ctrl_breath:  
                 lfo1_internal_depth  = 0;  
                 pLFO1->ExtController = 2; // MIDI controller 2  
                 bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);  
                 break;  
             case ::gig::lfo1_ctrl_internal_modwheel:  
                 lfo1_internal_depth  = pRegion->LFO1InternalDepth;  
                 pLFO1->ExtController = 1; // MIDI controller 1  
                 bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);  
                 break;  
             case ::gig::lfo1_ctrl_internal_breath:  
                 lfo1_internal_depth  = pRegion->LFO1InternalDepth;  
                 pLFO1->ExtController = 2; // MIDI controller 2  
                 bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);  
                 break;  
             default:  
                 lfo1_internal_depth  = 0;  
                 pLFO1->ExtController = 0; // no external controller  
                 bLFO1Enabled         = false;  
         }  
         if (bLFO1Enabled) {  
             pLFO1->trigger(pRegion->LFO1Frequency,  
                            start_level_min,  
                            lfo1_internal_depth,  
                            pRegion->LFO1ControlDepth,  
                            pRegion->LFO1FlipPhase,  
                            pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
             pLFO1->update(pLFO1->ExtController ? GetSfzEngineChannel()->ControllerTable[pLFO1->ExtController] : 0);  
         }*/ // TODO: ^^^  
         bLFO1Enabled = false;  
     }  
   
     void Voice::InitLFO2() {  
         /*uint16_t lfo2_internal_depth;  
         switch (pRegion->LFO2Controller) {  
             case ::gig::lfo2_ctrl_internal:  
                 lfo2_internal_depth  = pRegion->LFO2InternalDepth;  
                 pLFO2->ExtController = 0; // no external controller  
                 bLFO2Enabled         = (lfo2_internal_depth > 0);  
                 break;  
             case ::gig::lfo2_ctrl_modwheel:  
                 lfo2_internal_depth  = 0;  
                 pLFO2->ExtController = 1; // MIDI controller 1  
                 bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);  
                 break;  
             case ::gig::lfo2_ctrl_foot:  
                 lfo2_internal_depth  = 0;  
                 pLFO2->ExtController = 4; // MIDI controller 4  
                 bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);  
                 break;  
             case ::gig::lfo2_ctrl_internal_modwheel:  
                 lfo2_internal_depth  = pRegion->LFO2InternalDepth;  
                 pLFO2->ExtController = 1; // MIDI controller 1  
                 bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);  
                 break;  
             case ::gig::lfo2_ctrl_internal_foot:  
                 lfo2_internal_depth  = pRegion->LFO2InternalDepth;  
                 pLFO2->ExtController = 4; // MIDI controller 4  
                 bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);  
                 break;  
             default:  
                 lfo2_internal_depth  = 0;  
                 pLFO2->ExtController = 0; // no external controller  
                 bLFO2Enabled         = false;  
         }  
         if (bLFO2Enabled) {  
             pLFO2->trigger(pRegion->LFO2Frequency,  
                            start_level_max,  
                            lfo2_internal_depth,  
                            pRegion->LFO2ControlDepth,  
                            pRegion->LFO2FlipPhase,  
                            pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
             pLFO2->update(pLFO2->ExtController ? GetSfzEngineChannel()->ControllerTable[pLFO2->ExtController] : 0);  
         }*/ // TODO: ^^^  
         bLFO2Enabled = false;  
     }  
   
     void Voice::InitLFO3() {  
         /*uint16_t lfo3_internal_depth;  
         switch (pRegion->LFO3Controller) {  
             case ::gig::lfo3_ctrl_internal:  
                 lfo3_internal_depth  = pRegion->LFO3InternalDepth;  
                 pLFO3->ExtController = 0; // no external controller  
                 bLFO3Enabled         = (lfo3_internal_depth > 0);  
                 break;  
             case ::gig::lfo3_ctrl_modwheel:  
                 lfo3_internal_depth  = 0;  
                 pLFO3->ExtController = 1; // MIDI controller 1  
                 bLFO3Enabled         = (pRegion->LFO3ControlDepth > 0);  
                 break;  
             case ::gig::lfo3_ctrl_aftertouch:  
                 lfo3_internal_depth  = 0;  
                 pLFO3->ExtController = 128;  
                 bLFO3Enabled         = true;  
                 break;  
             case ::gig::lfo3_ctrl_internal_modwheel:  
                 lfo3_internal_depth  = pRegion->LFO3InternalDepth;  
                 pLFO3->ExtController = 1; // MIDI controller 1  
                 bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);  
                 break;  
             case ::gig::lfo3_ctrl_internal_aftertouch:  
                 lfo3_internal_depth  = pRegion->LFO3InternalDepth;  
                 pLFO1->ExtController = 128;  
                 bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);  
                 break;  
             default:  
                 lfo3_internal_depth  = 0;  
                 pLFO3->ExtController = 0; // no external controller  
                 bLFO3Enabled         = false;  
         }  
         if (bLFO3Enabled) {  
             pLFO3->trigger(pRegion->LFO3Frequency,  
                            start_level_mid,  
                            lfo3_internal_depth,  
                            pRegion->LFO3ControlDepth,  
                            false,  
                            pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
             pLFO3->update(pLFO3->ExtController ? GetSfzEngineChannel()->ControllerTable[pLFO3->ExtController] : 0);  
         }*/ // TODO: ^^^  
         bLFO3Enabled = false;  
     }  
   
252      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {
253          float cutoff = *pRegion->cutoff;          float cutoff = *pRegion->cutoff;
254          cutoff *= RTMath::CentsToFreqRatioUnlimited(          cutoff *= RTMath::CentsToFreqRatioUnlimited(
# Line 465  namespace LinuxSampler { namespace sfz { Line 258  namespace LinuxSampler { namespace sfz {
258      }      }
259    
260      float Voice::CalculateFinalCutoff(float cutoffBase) {      float Voice::CalculateFinalCutoff(float cutoffBase) {
261          float cutoff;          float cutoff = cutoffBase;
         if (VCFCutoffCtrl.controller) {  
             int ccvalue = GetSfzEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];  
             cutoff = CutoffBase * RTMath::CentsToFreqRatioUnlimited(  
                 ccvalue / 127.0f * pRegion->cutoff_oncc[VCFCutoffCtrl.controller]);  
         } else {  
             cutoff = cutoffBase;  
         }  
262          if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;          if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;
263          return cutoff;          return cutoff;
264      }      }
265    
     uint8_t Voice::GetVCFCutoffCtrl() {  
         // TODO: the sfz format allows several CC for the same  
         // modulation destination. The Voice interface needs to be  
         // changed to support that.  
         if (pRegion->cutoff_cc) return pRegion->cutoff_cc;  
         else if (pRegion->cutoff_chanaft) return 128;  
         return 0;  
     }  
   
     uint8_t Voice::GetVCFResonanceCtrl() {  
         /*uint8_t ctrl;  
         switch (pRegion->VCFResonanceController) {  
             case ::gig::vcf_res_ctrl_genpurpose3:  
                 ctrl = 18;  
                 break;  
             case ::gig::vcf_res_ctrl_genpurpose4:  
                 ctrl = 19;  
                 break;  
             case ::gig::vcf_res_ctrl_genpurpose5:  
                 ctrl = 80;  
                 break;  
             case ::gig::vcf_res_ctrl_genpurpose6:  
                 ctrl = 81;  
                 break;  
             case ::gig::vcf_res_ctrl_none:  
             default:  
                 ctrl = 0;  
         }  
   
         return ctrl;*/ // TODO: ^^^  
         return 0;  
     }  
   
266      float Voice::GetReleaseTriggerAttenuation(float noteLength) {      float Voice::GetReleaseTriggerAttenuation(float noteLength) {
267          // pow(10, -rt_decay * noteLength / 20):          // pow(10, -rt_decay * noteLength / 20):
268          return expf(RgnInfo.ReleaseTriggerDecay * noteLength);          return expf(RgnInfo.ReleaseTriggerDecay * noteLength);
# Line 526  namespace LinuxSampler { namespace sfz { Line 279  namespace LinuxSampler { namespace sfz {
279                  EnterReleaseStage();                  EnterReleaseStage();
280              } else {              } else {
281                  // kill the voice fast                  // kill the voice fast
282                  pEG1->enterFadeOutStage();                  SignalRack.EnterFadeOutStage();
283              }              }
284          }          }
285      }      }
286        
287        void Voice::SetSampleStartOffset() {
288            if (DiskVoice && RgnInfo.SampleStartOffset > pSample->MaxOffset) {
289                // The offset is applied to the RAM buffer
290                finalSynthesisParameters.dPos = 0;
291                Pos = 0;
292            } else {
293                finalSynthesisParameters.dPos = RgnInfo.SampleStartOffset; // offset where we should start playback of sample
294                Pos = RgnInfo.SampleStartOffset;
295            }
296        }
297    
298  }} // namespace LinuxSampler::sfz  }} // namespace LinuxSampler::sfz
Legend:
Removed from v.2176  
changed lines
  Added in v.2252
  ViewVC Help
Powered by ViewVC