/[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 2021 by iliev, Fri Oct 30 16:36:20 2009 UTC revision 3054 by schoenebeck, Thu Dec 15 12:47:45 2016 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 - 2009 Christian Schoenebeck                       *   *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
7   *   Copyright (C) 2009 Grigor Iliev                                       *   *   Copyright (C) 2009 - 2015 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 27  Line 27 
27  #include "Engine.h"  #include "Engine.h"
28  #include "EngineChannel.h"  #include "EngineChannel.h"
29    
30    #define LN_10_DIV_20 0.115129254649702
31    
32  namespace LinuxSampler { namespace sfz {  namespace LinuxSampler { namespace sfz {
33    
34      Voice::Voice() {      typedef LinuxSampler::VoiceBase<EngineChannel, ::sfz::Region, Sample, DiskThread> SfzVoiceBase;
35    
36        Voice::Voice(): SfzVoiceBase(&SignalRack), SignalRack(this) {
37          pEngine     = NULL;          pEngine     = NULL;
38            bEqSupport = true;
39      }      }
40    
41      Voice::~Voice() {      Voice::~Voice() {
# Line 54  namespace LinuxSampler { namespace sfz { Line 59  namespace LinuxSampler { namespace sfz {
59          si.ChannelCount     = pSample->GetChannelCount();          si.ChannelCount     = pSample->GetChannelCount();
60          si.FrameSize        = pSample->GetFrameSize();          si.FrameSize        = pSample->GetFrameSize();
61          si.BitDepth         = (pSample->GetFrameSize() / pSample->GetChannelCount()) * 8;          si.BitDepth         = (pSample->GetFrameSize() / pSample->GetChannelCount()) * 8;
62          si.TotalFrameCount  = pSample->GetTotalFrameCount();          si.TotalFrameCount  = (uint)pSample->GetTotalFrameCount();
63    
64          si.HasLoops       = pRegion->HasLoop();          si.HasLoops       = pRegion->HasLoop();
65          si.LoopStart      = pRegion->GetLoopStart();          si.LoopStart      = pRegion->GetLoopStart();
# Line 67  namespace LinuxSampler { namespace sfz { Line 72  namespace LinuxSampler { namespace sfz {
72      Voice::RegionInfo Voice::GetRegionInfo() {      Voice::RegionInfo Voice::GetRegionInfo() {
73          RegionInfo ri;          RegionInfo ri;
74          ri.UnityNote = pRegion->pitch_keycenter;          ri.UnityNote = pRegion->pitch_keycenter;
75          ri.FineTune  = pRegion->tune;          ri.FineTune  = pRegion->tune + pRegion->transpose * 100;
76          ri.Pan       = pRegion->pan;          ri.Pan       = int(pRegion->pan * 0.63); // convert from -100..100 to -64..63
77          ri.SampleStartOffset = 0; // TODO:          ri.SampleStartOffset = pRegion->offset ? *(pRegion->offset) : 0;
78    
79          ri.EG1PreAttack        = pRegion->ampeg_start * 10;          ri.VCFEnabled    = pRegion->cutoff;
80          ri.EG1Attack           = pRegion->ampeg_attack;          switch (pRegion->fil_type) {
81          ri.EG1Hold             = pRegion->ampeg_hold;          case ::sfz::LPF_1P:
82          ri.EG1Decay1           = pRegion->ampeg_decay;              ri.VCFType = Filter::vcf_type_1p_lowpass;
83          ri.EG1Decay2           = pRegion->ampeg_decay;              break;
84          ri.EG1Sustain          = pRegion->ampeg_sustain;          case ::sfz::LPF_2P:
85          ri.EG1InfiniteSustain  = true;              ri.VCFType = Filter::vcf_type_2p_lowpass;
86          ri.EG1Release          = pRegion->ampeg_release;              break;
87            case ::sfz::LPF_4P:
88          ri.EG2PreAttack        = pRegion->fileg_start;              ri.VCFType = Filter::vcf_type_4p_lowpass;
89          ri.EG2Attack           = pRegion->fileg_attack;              break;
90          //ri.EG2Hold             = pRegion->fileg_hold; // TODO:          case ::sfz::LPF_6P:
91          ri.EG2Decay1           = pRegion->fileg_decay;              ri.VCFType = Filter::vcf_type_6p_lowpass;
92          ri.EG2Decay2           = pRegion->fileg_decay;              break;
93          ri.EG2Sustain          = pRegion->fileg_sustain;          case ::sfz::HPF_1P:
94          ri.EG2InfiniteSustain  = true;              ri.VCFType = Filter::vcf_type_1p_highpass;
95          ri.EG2Release          = pRegion->fileg_release;              break;
96            case ::sfz::HPF_2P:
97          ri.EG3Attack     = pRegion->pitcheg_attack;              ri.VCFType = Filter::vcf_type_2p_highpass;
98          ri.EG3Depth      = 0; // TODO:              break;
99          ri.VCFEnabled    = false; // TODO:          case ::sfz::HPF_4P:
100          ri.VCFType       = ::gig::vcf_type_lowpass; // TODO:              ri.VCFType = Filter::vcf_type_4p_highpass;
101          ri.VCFResonance  = 0; // TODO:              break;
102            case ::sfz::HPF_6P:
103          ri.ReleaseTriggerDecay = 0;              ri.VCFType = Filter::vcf_type_6p_highpass;
104                break;
105            case ::sfz::BPF_1P:
106            case ::sfz::BPF_2P:
107                ri.VCFType = Filter::vcf_type_2p_bandpass;
108                break;
109            case ::sfz::BRF_1P:
110            case ::sfz::BRF_2P:
111                ri.VCFType = Filter::vcf_type_2p_bandreject;
112                break;
113            case ::sfz::APF_1P:
114            case ::sfz::PKF_2P:
115            default:
116                ri.VCFEnabled = false;
117                break;
118            }
119    
120            ri.VCFResonance  = pRegion->resonance;
121    
122            // rt_decay is in dB. Precalculate a suitable value for exp in
123            // GetReleaseTriggerAttenuation: -ln(10) / 20 * rt_decay
124            ri.ReleaseTriggerDecay = -LN_10_DIV_20 * pRegion->rt_decay;
125    
126          return ri;          return ri;
127      }      }
# Line 109  namespace LinuxSampler { namespace sfz { Line 135  namespace LinuxSampler { namespace sfz {
135      }      }
136    
137      double Voice::GetSampleAttenuation() {      double Voice::GetSampleAttenuation() {
138          return 1.0; // TODO:          return exp(LN_10_DIV_20 * pRegion->volume) * pRegion->amplitude / 100;
139      }      }
140    
141      double Voice::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {      double Voice::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
142          return double(MIDIKeyVelocity) / 127.0f; // TODO:          float offset = -pRegion->amp_veltrack;
143            if (offset <= 0) offset += 100;
144            return (offset + pRegion->amp_veltrack * pRegion->amp_velcurve[MIDIKeyVelocity]) / 100;
145      }      }
146    
147      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
148          return 0.9; // TODO:          return 127.0 / MIDIKeyVelocity;
149      }      }
150    
151      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {
# Line 129  namespace LinuxSampler { namespace sfz { Line 157  namespace LinuxSampler { namespace sfz {
157          }*/ // TODO: ^^^          }*/ // TODO: ^^^
158      }      }
159    
160      void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessChannelPressureEvent(RTList<Event>::Iterator& itEvent) {
161          /*int ccvalue = itEvent->Param.CC.Value;          //TODO: ...
162          if (VCFCutoffCtrl.value == ccvalue) return;      }
         VCFCutoffCtrl.value == ccvalue;  
         if (pRegion->VCFCutoffControllerInvert)  ccvalue = 127 - ccvalue;  
         if (ccvalue < pRegion->VCFVelocityScale) ccvalue = pRegion->VCFVelocityScale;  
         float cutoff = CutoffBase * float(ccvalue);  
         if (cutoff > 127.0f) cutoff = 127.0f;  
163    
164          VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of fFinalCutoff next time      void Voice::ProcessPolyphonicKeyPressureEvent(RTList<Event>::Iterator& itEvent) {
165          fFinalCutoff = cutoff;*/ // TODO: ^^^          //TODO: ...
166      }      }
167    
168      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {
# Line 238  namespace LinuxSampler { namespace sfz { Line 261  namespace LinuxSampler { namespace sfz {
261          return eg;          return eg;
262      }      }
263    
     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;  
     }  
   
264      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {
265          /*float cutoff = pRegion->GetVelocityCutoff(MIDIKeyVelocity);          float cutoff = *pRegion->cutoff;
266          if (pRegion->VCFKeyboardTracking) {          cutoff *= RTMath::CentsToFreqRatioUnlimited(
267              cutoff *= exp((MIDIKeyVelocity - pRegion->VCFKeyboardTrackingBreakpoint) * 0.057762265f); // (ln(2) / 12)              MIDIKeyVelocity / 127.0f * pRegion->fil_veltrack +
268          }              (MIDIKey() - pRegion->fil_keycenter) * pRegion->fil_keytrack);
269          return cutoff;*/ // TODO: ^^^          return cutoff;
         return 1.0f;  
270      }      }
271    
272      float Voice::CalculateFinalCutoff(float cutoffBase) {      float Voice::CalculateFinalCutoff(float cutoffBase) {
273          /*int cvalue;          float cutoff = cutoffBase;
274          if (VCFCutoffCtrl.controller) {          if (cutoff > 0.49 * pEngine->SampleRate) cutoff = 0.49 * pEngine->SampleRate;
275              cvalue = GetSfzEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];          return cutoff;
276              if (pRegion->VCFCutoffControllerInvert) cvalue = 127 - cvalue;      }
277              // VCFVelocityScale in this case means Minimum cutoff  
278              if (cvalue < pRegion->VCFVelocityScale) cvalue = pRegion->VCFVelocityScale;      float Voice::GetReleaseTriggerAttenuation(float noteLength) {
279          }          // pow(10, -rt_decay * noteLength / 20):
280          else {          return expf(RgnInfo.ReleaseTriggerDecay * noteLength);
281              cvalue = pRegion->VCFCutoff;      }
282    
283        void Voice::ProcessGroupEvent(RTList<Event>::Iterator& itEvent) {
284            dmsg(4,("Voice %p processGroupEvents event type=%d", (void*)this, itEvent->Type));
285            if (itEvent->Type == Event::type_control_change ||
286                (Type & Voice::type_controller_triggered) ||
287                itEvent->Param.Note.Key != HostKey()) {
288                dmsg(4,("Voice %p - kill", (void*)this));
289                if (pRegion->off_mode == ::sfz::OFF_NORMAL) {
290                    // turn off the voice by entering release envelope stage
291                    EnterReleaseStage();
292                } else {
293                    // kill the voice fast
294                    SignalRack.EnterFadeOutStage();
295                }
296          }          }
         float fco = cutoffBase * float(cvalue);  
         if (fco > 127.0f) fco = 127.0f;  
   
         return fco;*/ // TODO: ^^^  
         return 127.0f;  
297      }      }
298        
299      uint8_t Voice::GetVCFCutoffCtrl() {      void Voice::SetSampleStartOffset() {
300          /*uint8_t ctrl;          if (DiskVoice && RgnInfo.SampleStartOffset > pSample->MaxOffset) {
301          switch (pRegion->VCFCutoffController) {              // The offset is applied to the RAM buffer
302              case ::gig::vcf_cutoff_ctrl_modwheel:              finalSynthesisParameters.dPos = 0;
303                  ctrl = 1;              Pos = 0;
304                  break;          } else {
305              case ::gig::vcf_cutoff_ctrl_effect1:              finalSynthesisParameters.dPos = RgnInfo.SampleStartOffset; // offset where we should start playback of sample
306                  ctrl = 12;              Pos = RgnInfo.SampleStartOffset;
                 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;  
307          }          }
   
         return ctrl;*/ // TODO: ^^^  
         return 0;  
308      }      }
309    
310      uint8_t Voice::GetVCFResonanceCtrl() {      void Voice::CalculateFadeOutCoeff(float FadeOutTime, float SampleRate) {
311          /*uint8_t ctrl;          SignalRack.CalculateFadeOutCoeff(FadeOutTime, SampleRate);
312          switch (pRegion->VCFResonanceController) {      }
313              case ::gig::vcf_res_ctrl_genpurpose3:  
314                  ctrl = 18;      int Voice::CalculatePan(uint8_t pan) {
315                  break;          // the value isn't limited to [0, 127] here, as this is done
316              case ::gig::vcf_res_ctrl_genpurpose4:          // later in SignalUnit.CalculatePan
317                  ctrl = 19;          return pan + RgnInfo.Pan;
                 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;  
318      }      }
319    
320  }} // namespace LinuxSampler::sfz  }} // namespace LinuxSampler::sfz
Legend:
Removed from v.2021  
changed lines
  Added in v.3054
  ViewVC Help
Powered by ViewVC