/[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 2086 by persson, Sun Apr 25 12:51:30 2010 UTC revision 2224 by iliev, Mon Aug 1 19:08:09 2011 UTC
# Line 4  Line 4 
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 - 2008 Christian Schoenebeck                       *   *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
7   *   Copyright (C) 2009 - 2010 Christian Schoenebeck and Grigor Iliev      *   *   Copyright (C) 2009 - 2011 Christian Schoenebeck and Grigor Iliev      *
8   *                                                                         *   *                                                                         *
9   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
10   *   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 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;
   
         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;  
76    
77          ri.EG2PreAttack        = pRegion->fileg_start * 10;          ri.EG2PreAttack        = pRegion->fileg_start * 10;
78          ri.EG2Attack           = pRegion->fileg_attack;          ri.EG2Attack           = pRegion->fileg_attack;
# Line 93  namespace LinuxSampler { namespace sfz { Line 85  namespace LinuxSampler { namespace sfz {
85    
86          ri.EG3Attack     = pRegion->pitcheg_attack;          ri.EG3Attack     = pRegion->pitcheg_attack;
87          ri.EG3Depth      = 0; // TODO:          ri.EG3Depth      = 0; // TODO:
88          ri.VCFEnabled    = false; // TODO:          ri.VCFEnabled    = pRegion->cutoff;
89          ri.VCFType       = ::gig::vcf_type_lowpass; // TODO:          switch (pRegion->fil_type) {
90          ri.VCFResonance  = 0; // TODO:          case ::sfz::LPF_1P:
91                ri.VCFType = Filter::vcf_type_1p_lowpass;
92                break;
93            case ::sfz::LPF_2P:
94                ri.VCFType = Filter::vcf_type_2p_lowpass;
95                break;
96            case ::sfz::LPF_4P:
97                ri.VCFType = Filter::vcf_type_4p_lowpass;
98                break;
99            case ::sfz::LPF_6P:
100                ri.VCFType = Filter::vcf_type_6p_lowpass;
101                break;
102            case ::sfz::HPF_1P:
103                ri.VCFType = Filter::vcf_type_1p_highpass;
104                break;
105            case ::sfz::HPF_2P:
106                ri.VCFType = Filter::vcf_type_2p_highpass;
107                break;
108            case ::sfz::HPF_4P:
109                ri.VCFType = Filter::vcf_type_4p_highpass;
110                break;
111            case ::sfz::HPF_6P:
112                ri.VCFType = Filter::vcf_type_6p_highpass;
113                break;
114            case ::sfz::BPF_1P:
115            case ::sfz::BPF_2P:
116                ri.VCFType = Filter::vcf_type_2p_bandpass;
117                break;
118            case ::sfz::BRF_1P:
119            case ::sfz::BRF_2P:
120                ri.VCFType = Filter::vcf_type_2p_bandreject;
121                break;
122            case ::sfz::APF_1P:
123            case ::sfz::PKF_2P:
124            default:
125                ri.VCFEnabled = false;
126                break;
127            }
128    
129            ri.VCFResonance  = pRegion->resonance;
130    
131          // rt_decay is in dB. Precalculate a suitable value for exp in          // rt_decay is in dB. Precalculate a suitable value for exp in
132          // GetReleaseTriggerAttenuation: -ln(10) / 20 * rt_decay          // GetReleaseTriggerAttenuation: -ln(10) / 20 * rt_decay
# Line 121  namespace LinuxSampler { namespace sfz { Line 152  namespace LinuxSampler { namespace sfz {
152      }      }
153    
154      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
155          return 0.9; // TODO:          return 127.0 / MIDIKeyVelocity;
156      }      }
157    
158      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {
# Line 134  namespace LinuxSampler { namespace sfz { Line 165  namespace LinuxSampler { namespace sfz {
165      }      }
166    
167      void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {
168          /*int ccvalue = itEvent->Param.CC.Value;          int ccvalue = itEvent->Param.CC.Value;
169          if (VCFCutoffCtrl.value == ccvalue) return;          if (VCFCutoffCtrl.value == ccvalue) return;
170          VCFCutoffCtrl.value == ccvalue;          VCFCutoffCtrl.value = ccvalue;
171          if (pRegion->VCFCutoffControllerInvert)  ccvalue = 127 - ccvalue;  
172          if (ccvalue < pRegion->VCFVelocityScale) ccvalue = pRegion->VCFVelocityScale;          float cutoff = CutoffBase * RTMath::CentsToFreqRatioUnlimited(
173          float cutoff = CutoffBase * float(ccvalue);              ccvalue / 127.0f * pRegion->cutoff_oncc[VCFCutoffCtrl.controller]);
174          if (cutoff > 127.0f) cutoff = 127.0f;          if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;
175    
176          VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of fFinalCutoff next time          VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of fFinalCutoff next time
177          fFinalCutoff = cutoff;*/ // TODO: ^^^          fFinalCutoff = cutoff;
178      }      }
179    
180      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {
# Line 206  namespace LinuxSampler { namespace sfz { Line 237  namespace LinuxSampler { namespace sfz {
237          return eg;          return eg;
238      }      }
239    
240      void Voice::TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) {      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {
   
         // 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),  
                         RgnInfo.EG1Attack,  
                         RgnInfo.EG1Hold,  
                         RgnInfo.EG1Decay1,  
                         uint(RgnInfo.EG1Sustain),  
                         RgnInfo.EG1Release,  
                         sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
      }  
   
      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {  
241          /*double eg2controllervalue = 0;          /*double eg2controllervalue = 0;
242          switch (pRegion->EG2Controller.type) {          switch (pRegion->EG2Controller.type) {
243              case ::gig::eg2_ctrl_t::type_none: // no controller defined              case ::gig::eg2_ctrl_t::type_none: // no controller defined
# Line 267  namespace LinuxSampler { namespace sfz { Line 273  namespace LinuxSampler { namespace sfz {
273          return eg;          return eg;
274      }      }
275    
     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;  
     }  
   
276      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {
277          /*float cutoff = pRegion->GetVelocityCutoff(MIDIKeyVelocity);          float cutoff = *pRegion->cutoff;
278          if (pRegion->VCFKeyboardTracking) {          cutoff *= RTMath::CentsToFreqRatioUnlimited(
279              cutoff *= exp((MIDIKeyVelocity - pRegion->VCFKeyboardTrackingBreakpoint) * 0.057762265f); // (ln(2) / 12)              MIDIKeyVelocity / 127.0f * pRegion->fil_veltrack +
280          }              (MIDIKey - pRegion->fil_keycenter) * pRegion->fil_keytrack);
281          return cutoff;*/ // TODO: ^^^          return cutoff;
         return 1.0f;  
282      }      }
283    
284      float Voice::CalculateFinalCutoff(float cutoffBase) {      float Voice::CalculateFinalCutoff(float cutoffBase) {
285          /*int cvalue;          float cutoff;
286          if (VCFCutoffCtrl.controller) {          if (VCFCutoffCtrl.controller) {
287              cvalue = GetSfzEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];              int ccvalue = GetSfzEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];
288              if (pRegion->VCFCutoffControllerInvert) cvalue = 127 - cvalue;              cutoff = CutoffBase * RTMath::CentsToFreqRatioUnlimited(
289              // VCFVelocityScale in this case means Minimum cutoff                  ccvalue / 127.0f * pRegion->cutoff_oncc[VCFCutoffCtrl.controller]);
290              if (cvalue < pRegion->VCFVelocityScale) cvalue = pRegion->VCFVelocityScale;          } else {
291                cutoff = cutoffBase;
292          }          }
293          else {          if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;
294              cvalue = pRegion->VCFCutoff;          return cutoff;
         }  
         float fco = cutoffBase * float(cvalue);  
         if (fco > 127.0f) fco = 127.0f;  
   
         return fco;*/ // TODO: ^^^  
         return 127.0f;  
295      }      }
296    
297      uint8_t Voice::GetVCFCutoffCtrl() {      uint8_t Voice::GetVCFCutoffCtrl() {
298          /*uint8_t ctrl;          // TODO: the sfz format allows several CC for the same
299          switch (pRegion->VCFCutoffController) {          // modulation destination. The Voice interface needs to be
300              case ::gig::vcf_cutoff_ctrl_modwheel:          // changed to support that.
301                  ctrl = 1;          if (pRegion->cutoff_cc) return pRegion->cutoff_cc;
302                  break;          else if (pRegion->cutoff_chanaft) return 128;
             case ::gig::vcf_cutoff_ctrl_effect1:  
                 ctrl = 12;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_effect2:  
                 ctrl = 13;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_breath:  
                 ctrl = 2;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_foot:  
                 ctrl = 4;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_sustainpedal:  
                 ctrl = 64;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_softpedal:  
                 ctrl = 67;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_genpurpose7:  
                 ctrl = 82;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_genpurpose8:  
                 ctrl = 83;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_aftertouch:  
                 ctrl = 128;  
                 break;  
             case ::gig::vcf_cutoff_ctrl_none:  
             default:  
                 ctrl = 0;  
                 break;  
         }  
   
         return ctrl;*/ // TODO: ^^^  
303          return 0;          return 0;
304      }      }
305    
# Line 501  namespace LinuxSampler { namespace sfz { Line 332  namespace LinuxSampler { namespace sfz {
332          return expf(RgnInfo.ReleaseTriggerDecay * noteLength);          return expf(RgnInfo.ReleaseTriggerDecay * noteLength);
333      }      }
334    
335        void Voice::ProcessGroupEvent(RTList<Event>::Iterator& itEvent) {
336            dmsg(4,("Voice %x processGroupEvents event type=%d", this, itEvent->Type));
337            if (itEvent->Type == Event::type_control_change ||
338                (Type & Voice::type_controller_triggered) ||
339                itEvent->Param.Note.Key != MIDIKey) {
340                dmsg(4,("Voice %x - kill", this));
341                if (pRegion->off_mode == ::sfz::OFF_NORMAL) {
342                    // turn off the voice by entering release envelope stage
343                    EnterReleaseStage();
344                } else {
345                    // kill the voice fast
346                    SignalRack.EnterFadeOutStage();
347                }
348            }
349        }
350        
351        void Voice::SetSampleStartOffset() {
352            if (DiskVoice && RgnInfo.SampleStartOffset > pSample->MaxOffset) {
353                // The offset is applied to the RAM buffer
354                finalSynthesisParameters.dPos = 0;
355                Pos = 0;
356            } else {
357                finalSynthesisParameters.dPos = RgnInfo.SampleStartOffset; // offset where we should start playback of sample
358                Pos = RgnInfo.SampleStartOffset;
359            }
360        }
361    
362  }} // namespace LinuxSampler::sfz  }} // namespace LinuxSampler::sfz
Legend:
Removed from v.2086  
changed lines
  Added in v.2224
  ViewVC Help
Powered by ViewVC