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

Annotation of /linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2224 - (hide annotations) (download)
Mon Aug 1 19:08:09 2011 UTC (12 years, 7 months ago) by iliev
File size: 15668 byte(s)
* implemented opcode pitchlfo_depthccN

1 iliev 2218 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5     * Copyright (C) 2011 Grigor Iliev *
6     * *
7     * This program is free software; you can redistribute it and/or modify *
8     * it under the terms of the GNU General Public License as published by *
9     * the Free Software Foundation; either version 2 of the License, or *
10     * (at your option) any later version. *
11     * *
12     * This program is distributed in the hope that it will be useful, *
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15     * GNU General Public License for more details. *
16     * *
17     * You should have received a copy of the GNU General Public License *
18     * along with this program; if not, write to the Free Software *
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20     * MA 02111-1307 USA *
21     ***************************************************************************/
22    
23     #include "SfzSignalUnitRack.h"
24     #include "Voice.h"
25 iliev 2221 #include <SF.h>
26 iliev 2218
27     namespace LinuxSampler { namespace sfz {
28    
29     SfzSignalUnit::SfzSignalUnit(SfzSignalUnitRack* rack): SignalUnit(rack), pVoice(rack->pVoice) {
30    
31     }
32    
33     double SfzSignalUnit::GetSampleRate() {
34     return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
35     }
36    
37    
38     void EGv1Unit::Trigger() {
39     ::sfz::Region* const pRegion = pVoice->pRegion;
40 iliev 2220
41 iliev 2218 // the length of the decay and release curves are dependent on the velocity
42     const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
43    
44 iliev 2220 // set the delay trigger
45     uiDelayTrigger = (pRegion->ampeg_delay + pRegion->ampeg_vel2delay * velrelease) * GetSampleRate();
46    
47 iliev 2218 EG.trigger(uint(pRegion->ampeg_start * 10),
48     std::max(0.0, pRegion->ampeg_attack + pRegion->ampeg_vel2attack * velrelease),
49     std::max(0.0, pRegion->ampeg_hold + pRegion->ampeg_vel2hold * velrelease),
50     std::max(0.0, pRegion->ampeg_decay + pRegion->ampeg_vel2decay * velrelease),
51     uint(std::min(std::max(0.0, 10 * (pRegion->ampeg_sustain + pRegion->ampeg_vel2sustain * velrelease)), 1000.0)),
52     std::max(0.0, pRegion->ampeg_release + pRegion->ampeg_vel2release * velrelease),
53     GetSampleRate());
54     }
55    
56 iliev 2220
57 iliev 2218 void EGv2Unit::Trigger() {
58     EG.trigger(*pEGInfo, GetSampleRate(), pVoice->MIDIVelocity);
59     }
60 iliev 2219
61 iliev 2220
62     void PitchEGUnit::Trigger() {
63     ::sfz::Region* const pRegion = pVoice->pRegion;
64     depth = pRegion->pitcheg_depth;
65    
66     // the length of the decay and release curves are dependent on the velocity
67     const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
68 iliev 2218
69 iliev 2220 // set the delay trigger
70     uiDelayTrigger = (pRegion->pitcheg_delay + pRegion->pitcheg_vel2delay * velrelease) * GetSampleRate();
71    
72     EG.trigger(uint(pRegion->pitcheg_start * 10),
73     std::max(0.0, pRegion->pitcheg_attack + pRegion->pitcheg_vel2attack * velrelease),
74     std::max(0.0, pRegion->pitcheg_hold + pRegion->pitcheg_vel2hold * velrelease),
75     std::max(0.0, pRegion->pitcheg_decay + pRegion->pitcheg_vel2decay * velrelease),
76     uint(std::min(std::max(0.0, 10 * (pRegion->pitcheg_sustain + pRegion->pitcheg_vel2sustain * velrelease)), 1000.0)),
77     std::max(0.0, pRegion->pitcheg_release + pRegion->pitcheg_vel2release * velrelease),
78     GetSampleRate());
79     }
80    
81 iliev 2222
82     void FilEGUnit::Trigger() {
83     ::sfz::Region* const pRegion = pVoice->pRegion;
84     depth = pRegion->fileg_depth;
85    
86     // the length of the decay and release curves are dependent on the velocity
87     const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
88 iliev 2220
89 iliev 2222 // set the delay trigger
90     uiDelayTrigger = (pRegion->fileg_delay + pRegion->fileg_vel2delay * velrelease) * GetSampleRate();
91    
92     EG.trigger(uint(pRegion->fileg_start * 10),
93     std::max(0.0, pRegion->fileg_attack + pRegion->fileg_vel2attack * velrelease),
94     std::max(0.0, pRegion->fileg_hold + pRegion->fileg_vel2hold * velrelease),
95     std::max(0.0, pRegion->fileg_decay + pRegion->fileg_vel2decay * velrelease),
96     uint(std::min(std::max(0.0, 10 * (pRegion->fileg_sustain + pRegion->fileg_vel2sustain * velrelease)), 1000.0)),
97     std::max(0.0, pRegion->fileg_release + pRegion->fileg_vel2release * velrelease),
98     GetSampleRate());
99     }
100    
101    
102 iliev 2219 void LFOUnit::Increment() {
103     if (DelayStage()) return;
104    
105     SignalUnit::Increment();
106    
107 iliev 2223 Level = pLFO->Render();
108 iliev 2219 }
109    
110     void LFOUnit::Trigger() {
111     //reset
112     Level = 0;
113    
114     // set the delay trigger
115 iliev 2220 uiDelayTrigger = pLfoInfo->delay * GetSampleRate();
116 iliev 2219 }
117    
118 iliev 2221 void LFOv1Unit::Trigger() {
119     LFOUnit::Trigger();
120    
121     lfo.trigger (
122     pLfoInfo->freq,
123     start_level_mid,
124     1, 0, false, GetSampleRate()
125     );
126     lfo.update(0);
127     }
128    
129 iliev 2223
130     LFOv2Unit::LFOv2Unit(SfzSignalUnitRack* rack)
131     : LFOUnit(rack), lfos(8), lfo0(1200.0f), lfo1(1200.0f), lfo2(1200.0f),
132     lfo3(1200.0f), lfo4(1200.0f), lfo5(1200.0f), lfo6(1200.0f), lfo7(1200.0f)
133     {
134     lfos.add(&lfo0);
135     lfos.add(&lfo1);
136     lfos.add(&lfo2);
137     lfos.add(&lfo3);
138     lfos.add(&lfo4);
139     lfos.add(&lfo5);
140     lfos.add(&lfo6);
141     lfos.add(&lfo7);
142     }
143    
144 iliev 2219 void LFOv2Unit::Trigger() {
145     LFOUnit::Trigger();
146    
147 iliev 2223 if (pLfoInfo->wave < 0 || pLfoInfo->wave >= lfos.size()) pLFO = &lfo0;
148     else pLFO = lfos[pLfoInfo->wave];
149    
150     pLFO->Trigger (
151 iliev 2219 pLfoInfo->freq,
152     start_level_mid,
153     1, 0, false, GetSampleRate()
154     );
155 iliev 2223 pLFO->Update(0);
156 iliev 2219 }
157 iliev 2221
158     void AmpLFOUnit::Trigger() {
159     ::sfz::Region* const pRegion = pVoice->pRegion;
160     pLfoInfo->delay = pRegion->amplfo_delay;
161     pLfoInfo->freq = pRegion->amplfo_freq;
162     pLfoInfo->volume = pRegion->amplfo_depth;
163    
164     LFOv1Unit::Trigger();
165     }
166    
167     void PitchLFOUnit::Trigger() {
168     ::sfz::Region* const pRegion = pVoice->pRegion;
169     pLfoInfo->delay = pRegion->pitchlfo_delay;
170     pLfoInfo->freq = pRegion->pitchlfo_freq;
171     pLfoInfo->pitch = pRegion->pitchlfo_depth;
172    
173     LFOv1Unit::Trigger();
174     }
175    
176     void FilLFOUnit::Trigger() {
177     ::sfz::Region* const pRegion = pVoice->pRegion;
178     pLfoInfo->delay = pRegion->fillfo_delay;
179     pLfoInfo->freq = pRegion->fillfo_freq;
180     pLfoInfo->cutoff = pRegion->fillfo_depth;
181    
182     LFOv1Unit::Trigger();
183     }
184 iliev 2224
185     CCUnit::CCUnit(SfzSignalUnitRack* rack): CCSignalUnit(rack) { }
186    
187     void CCUnit::Trigger() {
188     for (int i = 0; i < Ctrls.size(); i++) {
189     Ctrls[i].Value = pVoice->GetControllerValue(Ctrls[i].Controller);
190     }
191     CCSignalUnit::Trigger();
192     }
193    
194     void CCUnit::SetCCs(::sfz::Array<int>& cc) {
195     RemoveAllCCs();
196     for (int i = 0; i < 128; i++) {
197     if (cc[i] != 0) AddCC(i, cc[i]);
198     }
199     }
200 iliev 2218
201 iliev 2219
202 iliev 2218 EndpointUnit::EndpointUnit(SfzSignalUnitRack* rack): EndpointSignalUnit(rack) {
203    
204     }
205    
206     SfzSignalUnitRack* const EndpointUnit::GetRack() {
207     return static_cast<SfzSignalUnitRack* const>(pRack);
208     }
209    
210     void EndpointUnit::Trigger() {
211    
212     }
213    
214     bool EndpointUnit::Active() {
215     if (GetRack()->suVolEG.Active()) return true;
216    
217     bool b = false;
218     for (int i = 0; i < GetRack()->volEGs.size(); i++) {
219     if (GetRack()->volEGs[i]->Active()) { b = true; break; }
220     }
221    
222     return b;
223     }
224    
225     float EndpointUnit::GetVolume() {
226     float vol = GetRack()->suVolEG.Active() ? GetRack()->suVolEG.GetLevel() : 0;
227    
228     for (int i = 0; i < GetRack()->volEGs.size(); i++) {
229     EGv2Unit* eg = GetRack()->volEGs[i];
230     if (!eg->Active()) continue;
231     vol += eg->GetLevel() * (eg->pEGInfo->amplitude / 100.0f);
232     }
233    
234 iliev 2221 AmpLFOUnit* u = &(GetRack()->suAmpLFO);
235     vol *= u->Active() ? ::sf2::ToRatio((u->GetLevel() * u->pLfoInfo->volume) * 10.0) : 1;
236    
237 iliev 2218 return vol;
238     }
239    
240     float EndpointUnit::GetFilterCutoff() {
241 iliev 2221 float val;
242 iliev 2219
243 iliev 2221 FilLFOUnit* u = &(GetRack()->suFilLFO);
244     val = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->pLfoInfo->cutoff) : 1;
245    
246 iliev 2222 FilEGUnit* u2 = &(GetRack()->suFilEG);
247     val *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * u2->depth) : 1;
248    
249 iliev 2219 for (int i = 0; i < GetRack()->filLFOs.size(); i++) {
250     LFOv2Unit* lfo = GetRack()->filLFOs[i];
251     if (!lfo->Active()) continue;
252    
253     float f = lfo->GetLevel() * lfo->pLfoInfo->cutoff;
254     val *= RTMath::CentsToFreqRatioUnlimited(f);
255     }
256    
257     return val;
258 iliev 2218 }
259    
260     float EndpointUnit::GetPitch() {
261 iliev 2221 double p;
262 iliev 2220 EGv1Unit* u = &(GetRack()->suPitchEG);
263 iliev 2221 p = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->depth) : 1;
264    
265     PitchLFOUnit* u2 = &(GetRack()->suPitchLFO);
266 iliev 2224 CCSignalUnit* u3 = &(GetRack()->suPitchLFO.suDepthCC);
267     float f = u3->Active() ? u3->GetLevel() : 0;
268     p *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * (u2->pLfoInfo->pitch + f)) : 1;
269 iliev 2221 return p;
270 iliev 2218 }
271    
272     float EndpointUnit::GetResonance() {
273 iliev 2219 float val = 0;
274    
275     for (int i = 0; i < GetRack()->resLFOs.size(); i++) {
276     LFOv2Unit* lfo = GetRack()->resLFOs[i];
277     if (!lfo->Active()) continue;
278    
279     val += lfo->GetLevel() * lfo->pLfoInfo->resonance;
280     }
281    
282     return val;
283 iliev 2218 }
284    
285 iliev 2219 float EndpointUnit::GetPan() {
286     float pan = 0;
287    
288     for (int i = 0; i < GetRack()->panLFOs.size(); i++) {
289     LFOv2Unit* lfo = GetRack()->panLFOs[i];
290     if (!lfo->Active()) continue;
291    
292     pan += lfo->GetLevel() * lfo->pLfoInfo->pan;
293     }
294    
295     if(pan < -100) return -100;
296     if(pan > 100) return 100;
297    
298     return pan;
299     }
300 iliev 2218
301 iliev 2219
302 iliev 2218 SfzSignalUnitRack::SfzSignalUnitRack(Voice* voice)
303 iliev 2222 : SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this), suFilEG(this), suPitchEG(this),
304 iliev 2219 EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount),
305 iliev 2221 suAmpLFO(this), suPitchLFO(this), suFilLFO(this),
306 iliev 2219 LFOs(maxLfoCount), filLFOs(maxLfoCount), resLFOs(maxLfoCount), panLFOs(maxLfoCount)
307 iliev 2218 {
308 iliev 2222 suEndpoint.pVoice = suVolEG.pVoice = suFilEG.pVoice = suPitchEG.pVoice = voice;
309 iliev 2221 suAmpLFO.pVoice = suPitchLFO.pVoice = suFilLFO.pVoice = voice;
310 iliev 2224 suPitchLFO.suDepthCC.pVoice = voice;
311 iliev 2218
312     for (int i = 0; i < EGs.capacity(); i++) {
313     EGs[i] = new EGv2Unit(this);
314     EGs[i]->pVoice = voice;
315     }
316 iliev 2219
317     for (int i = 0; i < LFOs.capacity(); i++) {
318     LFOs[i] = new LFOv2Unit(this);
319     LFOs[i]->pVoice = voice;
320     }
321 iliev 2218 }
322    
323     SfzSignalUnitRack::~SfzSignalUnitRack() {
324 iliev 2219 for (int i = 0; i < EGs.capacity(); i++) {
325 iliev 2218 delete EGs[i]; EGs[i] = NULL;
326     }
327 iliev 2219
328     for (int i = 0; i < LFOs.capacity(); i++) {
329     delete LFOs[i]; LFOs[i] = NULL;
330     }
331 iliev 2218 }
332    
333     void SfzSignalUnitRack::Trigger() {
334     EGs.clear();
335     volEGs.clear();
336     pitchEGs.clear();
337    
338 iliev 2219 LFOs.clear();
339     filLFOs.clear();
340     resLFOs.clear();
341     panLFOs.clear();
342    
343 iliev 2218 ::sfz::Region* const pRegion = pVoice->pRegion;
344    
345 iliev 2219 for (int i = 0; i < pRegion->eg.size(); i++) {
346 iliev 2218 if (pRegion->eg[i].node.size() == 0) continue;
347    
348     if(EGs.size() < EGs.capacity()) {
349     EGv2Unit eg(this);
350     eg.pEGInfo = &(pRegion->eg[i]);
351     EGs.increment()->Copy(eg);
352     } else { std::cerr << "Maximum number of EGs reached!" << std::endl; break; }
353    
354     if (pRegion->eg[i].amplitude > 0) {
355     if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
356     else std::cerr << "Maximum number of EGs reached!" << std::endl;
357     }
358     }
359    
360     if (pRegion->ampeg_sustain == -1) {
361     if (volEGs.size() > 0) pRegion->ampeg_sustain = 0;
362     else pRegion->ampeg_sustain = 100;
363     }
364    
365 iliev 2219 // LFO
366     for (int i = 0; i < pRegion->lfos.size(); i++) {
367     if (pRegion->lfos[i].freq == -1) continue; // Not initialized
368    
369     if(LFOs.size() < LFOs.capacity()) {
370     LFOv2Unit lfo(this);
371     lfo.pLfoInfo = &(pRegion->lfos[i]);
372     LFOs.increment()->Copy(lfo);
373     } else { std::cerr << "Maximum number of LFOs reached!" << std::endl; break; }
374    
375     if (pRegion->lfos[i].cutoff != 0) {
376     if(filLFOs.size() < filLFOs.capacity()) filLFOs.add(LFOs[LFOs.size() - 1]);
377     else std::cerr << "Maximum number of LFOs reached!" << std::endl;
378     }
379    
380     if (pRegion->lfos[i].resonance != 0) {
381     if(resLFOs.size() < resLFOs.capacity()) resLFOs.add(LFOs[LFOs.size() - 1]);
382     else std::cerr << "Maximum number of LFOs reached!" << std::endl;
383     }
384    
385     if (pRegion->lfos[i].pan != 0) {
386     if(panLFOs.size() < panLFOs.capacity()) panLFOs.add(LFOs[LFOs.size() - 1]);
387     else std::cerr << "Maximum number of LFOs reached!" << std::endl;
388     }
389     }
390    
391 iliev 2224 suPitchLFO.suDepthCC.SetCCs(pRegion->pitchlfo_depthcc);
392    
393 iliev 2218 Units.clear();
394    
395     Units.add(&suVolEG);
396 iliev 2222 Units.add(&suFilEG);
397 iliev 2220 Units.add(&suPitchEG);
398 iliev 2221 Units.add(&suPitchLFO);
399 iliev 2224 Units.add(&suPitchLFO.suDepthCC);
400 iliev 2221 Units.add(&suAmpLFO);
401     Units.add(&suFilLFO);
402 iliev 2218
403 iliev 2219 for (int i = 0; i < EGs.size(); i++) {
404 iliev 2218 Units.add(EGs[i]);
405     }
406    
407 iliev 2219 for (int i = 0; i < LFOs.size(); i++) {
408     Units.add(LFOs[i]);
409     }
410    
411 iliev 2218 Units.add(&suEndpoint);
412    
413     SignalUnitRack::Trigger();
414     }
415    
416     EndpointSignalUnit* SfzSignalUnitRack::GetEndpointUnit() {
417     return &suEndpoint;
418     }
419    
420     void SfzSignalUnitRack::EnterFadeOutStage() {
421     suVolEG.EG.enterFadeOutStage();
422    
423     for (int i = 0; i < volEGs.size(); i++) {
424     volEGs[i]->EG.enterFadeOutStage();
425     }
426     }
427    
428     }} // namespace LinuxSampler::sfz

  ViewVC Help
Powered by ViewVC