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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2235 - (show annotations) (download)
Wed Aug 10 19:40:39 2011 UTC (12 years, 8 months ago) by iliev
File size: 28657 byte(s) 
* sfz engine: implemented opcodes egN_amplitude_onccX,
  egN_volume, egN_volume_onccX, egN_cutoff, egN_cutoff_onccX,
  egN_pitch, egN_pitch_onccX, egN_resonance, egN_resonance_onccX
1 /***************************************************************************
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 #include <SF.h>
26
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 float SfzSignalUnit::GetInfluence(ArrayList< ::sfz::CC>& cc) {
38 float f = 0;
39 for (int i = 0; i < cc.size(); i++) {
40 int val = pVoice->GetControllerValue(cc[i].Controller);
41 f += (val / 127.0f) * cc[i].Influence;
42 }
43 return f;
44 }
45
46
47 EGv2Unit::EGv2Unit(SfzSignalUnitRack* rack)
48 : EGUnit< ::LinuxSampler::sfz::EG>(rack),
49 suAmpOnCC(rack), suVolOnCC(rack), suPitchOnCC(rack), suCutoffOnCC(rack), suResOnCC(rack)
50 { }
51
52 void EGv2Unit::Trigger() {
53 egInfo = *pEGInfo;
54 for (int i = 0; i < egInfo.node.size(); i++) {
55 float f = GetInfluence(egInfo.node[i].level_oncc);
56 egInfo.node[i].level = std::min(egInfo.node[i].level + f, 1.0f);
57
58 f = GetInfluence(egInfo.node[i].time_oncc);
59 egInfo.node[i].time = std::min(egInfo.node[i].time + f, 100.0f);
60 }
61 EG.trigger(egInfo, GetSampleRate(), pVoice->MIDIVelocity);
62 }
63
64
65 void PitchEGUnit::Trigger() {
66 ::sfz::Region* const pRegion = pVoice->pRegion;
67 depth = pRegion->pitcheg_depth;
68
69 // the length of the decay and release curves are dependent on the velocity
70 const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
71
72 // set the delay trigger
73 uiDelayTrigger = (pRegion->pitcheg_delay + pRegion->pitcheg_vel2delay * velrelease) * GetSampleRate();
74
75 EG.trigger(uint(pRegion->pitcheg_start * 10),
76 std::max(0.0, pRegion->pitcheg_attack + pRegion->pitcheg_vel2attack * velrelease),
77 std::max(0.0, pRegion->pitcheg_hold + pRegion->pitcheg_vel2hold * velrelease),
78 std::max(0.0, pRegion->pitcheg_decay + pRegion->pitcheg_vel2decay * velrelease),
79 uint(std::min(std::max(0.0, 10 * (pRegion->pitcheg_sustain + pRegion->pitcheg_vel2sustain * velrelease)), 1000.0)),
80 std::max(0.0, pRegion->pitcheg_release + pRegion->pitcheg_vel2release * velrelease),
81 GetSampleRate());
82 }
83
84
85 void FilEGUnit::Trigger() {
86 ::sfz::Region* const pRegion = pVoice->pRegion;
87 depth = pRegion->fileg_depth;
88
89 // the length of the decay and release curves are dependent on the velocity
90 const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
91
92 // set the delay trigger
93 uiDelayTrigger = (pRegion->fileg_delay + pRegion->fileg_vel2delay * velrelease) * GetSampleRate();
94
95 EG.trigger(uint(pRegion->fileg_start * 10),
96 std::max(0.0, pRegion->fileg_attack + pRegion->fileg_vel2attack * velrelease),
97 std::max(0.0, pRegion->fileg_hold + pRegion->fileg_vel2hold * velrelease),
98 std::max(0.0, pRegion->fileg_decay + pRegion->fileg_vel2decay * velrelease),
99 uint(std::min(std::max(0.0, 10 * (pRegion->fileg_sustain + pRegion->fileg_vel2sustain * velrelease)), 1000.0)),
100 std::max(0.0, pRegion->fileg_release + pRegion->fileg_vel2release * velrelease),
101 GetSampleRate());
102 }
103
104
105 void AmpEGUnit::Trigger() {
106 ::sfz::Region* const pRegion = pVoice->pRegion;
107
108 // the length of the decay and release curves are dependent on the velocity
109 const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
110
111 // set the delay trigger
112 float delay = pRegion->ampeg_delay + pRegion->ampeg_vel2delay * velrelease;
113 delay += GetInfluence(pRegion->ampeg_delaycc);
114 uiDelayTrigger = std::max(0.0f, delay) * GetSampleRate();
115
116 float start = (pRegion->ampeg_start + GetInfluence(pRegion->ampeg_startcc)) * 10;
117
118 float attack = pRegion->ampeg_attack + pRegion->ampeg_vel2attack * velrelease;
119 attack = std::max(0.0f, attack + GetInfluence(pRegion->ampeg_attackcc));
120
121 float hold = pRegion->ampeg_hold + pRegion->ampeg_vel2hold * velrelease;
122 hold = std::max(0.0f, hold + GetInfluence(pRegion->ampeg_holdcc));
123
124 float decay = pRegion->ampeg_decay + pRegion->ampeg_vel2decay * velrelease;
125 decay = std::max(0.0f, decay + GetInfluence(pRegion->ampeg_decaycc));
126
127 float sustain = pRegion->ampeg_sustain + pRegion->ampeg_vel2sustain * velrelease;
128 sustain = 10 * (sustain + GetInfluence(pRegion->ampeg_sustaincc));
129
130 float release = pRegion->ampeg_release + pRegion->ampeg_vel2release * velrelease;
131 release = std::max(0.0f, release + GetInfluence(pRegion->ampeg_releasecc));
132
133 EG.trigger (
134 uint(std::min(std::max(0.0f, start), 1000.0f)), attack, hold, decay,
135 uint(std::min(std::max(0.0f, sustain), 1000.0f)), release, GetSampleRate()
136 );
137 }
138
139
140 LFOUnit::LFOUnit(SfzSignalUnitRack* rack)
141 : SfzSignalUnit(rack), pLfoInfo(NULL), pLFO(NULL),
142 suFadeEG(rack), suFreqOnCC(rack, this), suDepthOnCC(rack)
143 { }
144
145 LFOUnit::LFOUnit(const LFOUnit& Unit)
146 : SfzSignalUnit(Unit), suFadeEG(static_cast<SfzSignalUnitRack*>(Unit.pRack)),
147 suFreqOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack), this),
148 suDepthOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack))
149 {
150 Copy(Unit);
151 }
152
153 void LFOUnit::Increment() {
154 if (DelayStage()) return;
155
156 SignalUnit::Increment();
157
158 Level = pLFO->Render();
159 if (suFadeEG.Active()) Level *= suFadeEG.GetLevel();
160 }
161
162 void LFOUnit::Trigger() {
163 //reset
164 Level = 0;
165
166 // set the delay trigger
167 uiDelayTrigger = (pLfoInfo->delay + GetInfluence(pLfoInfo->delay_oncc)) * GetSampleRate();
168 if(pLfoInfo->fade != 0 || !pLfoInfo->fade_oncc.empty()) {
169 float f = pLfoInfo->fade;
170 f += GetInfluence(pLfoInfo->fade_oncc);
171
172 if (f != 0) {
173 suFadeEG.uiDelayTrigger = pLfoInfo->delay * GetSampleRate();
174 suFadeEG.EG.trigger(0, f, 0, 0, 1000, 0, GetSampleRate());
175 }
176 }
177 }
178
179 void LFOUnit::ValueChanged(CCSignalUnit* pUnit) {
180 pLFO->SetFrequency(std::max(0.0f, suFreqOnCC.GetLevel() + pLfoInfo->freq), GetSampleRate());
181 }
182
183
184 void LFOv1Unit::Trigger() {
185 LFOUnit::Trigger();
186
187 lfo.trigger (
188 pLfoInfo->freq + suFreqOnCC.GetLevel(),
189 start_level_mid,
190 1, 0, false, GetSampleRate()
191 );
192 lfo.update(0);
193 }
194
195
196 LFOv2Unit::LFOv2Unit(SfzSignalUnitRack* rack)
197 : LFOUnit(rack), lfos(8), lfo0(1200.0f), lfo1(1200.0f), lfo2(1200.0f),
198 lfo3(1200.0f), lfo4(1200.0f), lfo5(1200.0f), lfo6(1200.0f), lfo7(1200.0f),
199 suVolOnCC(rack), suPitchOnCC(rack), suPanOnCC(rack), suCutoffOnCC(rack), suResOnCC(rack)
200 {
201 lfos.add(&lfo0);
202 lfos.add(&lfo1);
203 lfos.add(&lfo2);
204 lfos.add(&lfo3);
205 lfos.add(&lfo4);
206 lfos.add(&lfo5);
207 lfos.add(&lfo6);
208 lfos.add(&lfo7);
209 }
210
211 void LFOv2Unit::Trigger() {
212 LFOUnit::Trigger();
213
214 if (pLfoInfo->wave < 0 || pLfoInfo->wave >= lfos.size()) pLFO = &lfo0;
215 else pLFO = lfos[pLfoInfo->wave];
216
217 pLFO->Trigger (
218 pLfoInfo->freq + suFreqOnCC.GetLevel(),
219 start_level_mid,
220 1, 0, false, GetSampleRate()
221 );
222 pLFO->Update(0);
223
224 float phase = pLfoInfo->phase + GetInfluence(pLfoInfo->phase_oncc);
225 if (phase != 0) pLFO->SetPhase(phase);
226 }
227
228 void AmpLFOUnit::Trigger() {
229 ::sfz::Region* const pRegion = pVoice->pRegion;
230 pLfoInfo->delay = pRegion->amplfo_delay;
231 pLfoInfo->freq = pRegion->amplfo_freq;
232 pLfoInfo->fade = pRegion->amplfo_fade;
233 pLfoInfo->volume = pRegion->amplfo_depth;
234
235 LFOv1Unit::Trigger();
236 }
237
238 void PitchLFOUnit::Trigger() {
239 ::sfz::Region* const pRegion = pVoice->pRegion;
240 pLfoInfo->delay = pRegion->pitchlfo_delay;
241 pLfoInfo->freq = pRegion->pitchlfo_freq;
242 pLfoInfo->fade = pRegion->pitchlfo_fade;
243 pLfoInfo->pitch = pRegion->pitchlfo_depth;
244
245 LFOv1Unit::Trigger();
246 }
247
248 void FilLFOUnit::Trigger() {
249 ::sfz::Region* const pRegion = pVoice->pRegion;
250 pLfoInfo->delay = pRegion->fillfo_delay;
251 pLfoInfo->freq = pRegion->fillfo_freq;
252 pLfoInfo->fade = pRegion->fillfo_fade;
253 pLfoInfo->cutoff = pRegion->fillfo_depth;
254
255 LFOv1Unit::Trigger();
256 }
257
258 CCUnit::CCUnit(SfzSignalUnitRack* rack, Listener* l): CCSignalUnit(rack, l) {
259 pVoice = NULL;
260 }
261
262 void CCUnit::Trigger() {
263 for (int i = 0; i < Ctrls.size(); i++) {
264 Ctrls[i].Value = pVoice->GetControllerValue(Ctrls[i].Controller);
265 if (Ctrls[i].pSmoother != NULL) Ctrls[i].pSmoother->setValue(Ctrls[i].Value);
266 }
267 CCSignalUnit::Trigger();
268 }
269
270 void CCUnit::SetCCs(::sfz::Array<int>& cc) {
271 RemoveAllCCs();
272 for (int i = 0; i < 128; i++) {
273 if (cc[i] != 0) AddCC(i, cc[i]);
274 }
275 }
276
277 void CCUnit::SetCCs(ArrayList< ::sfz::CC>& cc) {
278 RemoveAllCCs();
279 for (int i = 0; i < cc.size(); i++) {
280 if (cc[i].Influence != 0) {
281 short int curve = cc[i].Curve;
282 if (curve >= GetCurveCount()) curve = -1;
283 AddSmoothCC(cc[i].Controller, cc[i].Influence, curve, cc[i].Smooth);
284 }
285 }
286 }
287
288 void CCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
289 AddCC(Controller, Influence, Curve);
290 }
291
292 int CCUnit::GetCurveCount() {
293 return pVoice->pRegion->GetInstrument()->curves.size();
294 }
295
296 ::sfz::Curve* CCUnit::GetCurve(int idx) {
297 return &pVoice->pRegion->GetInstrument()->curves[idx];
298 }
299
300 double CCUnit::GetSampleRate() {
301 return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
302 }
303
304 void SmoothCCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
305 if (Smooth > 0) {
306 Smoothers[Controller].trigger(Smooth / 1000.0f, GetSampleRate());
307 AddCC(Controller, Influence, Curve, &Smoothers[Controller]);
308 } else {
309 AddCC(Controller, Influence, Curve);
310 }
311 }
312
313
314 EndpointUnit::EndpointUnit(SfzSignalUnitRack* rack): EndpointSignalUnit(rack) {
315
316 }
317
318 SfzSignalUnitRack* const EndpointUnit::GetRack() {
319 return static_cast<SfzSignalUnitRack* const>(pRack);
320 }
321
322 void EndpointUnit::Trigger() {
323
324 }
325
326 bool EndpointUnit::Active() {
327 if (GetRack()->suVolEG.Active()) return true;
328
329 bool b = false;
330 for (int i = 0; i < GetRack()->volEGs.size(); i++) {
331 if (GetRack()->volEGs[i]->Active()) { b = true; break; }
332 }
333
334 return b;
335 }
336
337 float EndpointUnit::GetVolume() {
338 float vol = GetRack()->suVolEG.Active() ? GetRack()->suVolEG.GetLevel() : 0;
339
340 for (int i = 0; i < GetRack()->volEGs.size(); i++) {
341 EGv2Unit* eg = GetRack()->volEGs[i];
342 if (!eg->Active()) continue;
343
344 float dB = eg->suVolOnCC.Active() ? eg->suVolOnCC.GetLevel() : -200;
345 if (dB < -144) dB = eg->pEGInfo->volume;
346 else if (eg->pEGInfo->volume >= -144) dB += eg->pEGInfo->volume;
347
348 float amp = eg->suAmpOnCC.Active() ? eg->suAmpOnCC.GetLevel() : 0;
349 amp = (amp + eg->pEGInfo->amplitude) / 100.0f;
350
351 if (dB >= -144) {
352 if (amp == 0 && eg->suAmpOnCC.GetCCCount() == 0) amp = 1.0f;
353 amp *= ::sf2::ToRatio(dB * 10.0);
354 }
355
356 vol += amp * eg->GetLevel();
357 }
358
359 AmpLFOUnit* u = &(GetRack()->suAmpLFO);
360 CCSignalUnit* u2 = &(GetRack()->suAmpLFO.suDepthOnCC);
361 float f = u2->Active() ? u2->GetLevel() : 0;
362 vol *= u->Active() ? ::sf2::ToRatio((u->GetLevel() * (u->pLfoInfo->volume + f) * 10.0)) : 1;
363
364 vol *= ::sf2::ToRatio(GetRack()->suVolOnCC.GetLevel() * 10.0);
365
366 for (int i = 0; i < GetRack()->volLFOs.size(); i++) {
367 LFOv2Unit* lfo = GetRack()->volLFOs[i];
368 if (!lfo->Active()) continue;
369
370 float f = lfo->suVolOnCC.Active() ? lfo->suVolOnCC.GetLevel() : 0;
371 vol *= ::sf2::ToRatio(lfo->GetLevel() * (lfo->pLfoInfo->volume + f) * 10.0);
372 }
373
374 return vol;
375 }
376
377 float EndpointUnit::GetFilterCutoff() {
378 float val;
379
380 FilLFOUnit* u = &(GetRack()->suFilLFO);
381 CCSignalUnit* u1 = &(GetRack()->suFilLFO.suDepthOnCC);
382 float f = u1->Active() ? u1->GetLevel() : 0;
383 val = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * (u->pLfoInfo->cutoff + f)) : 1;
384
385 FilEGUnit* u2 = &(GetRack()->suFilEG);
386 val *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * u2->depth) : 1;
387
388 for (int i = 0; i < GetRack()->filEGs.size(); i++) {
389 EGv2Unit* eg = GetRack()->filEGs[i];
390 if (!eg->Active()) continue;
391
392 float f = eg->suCutoffOnCC.Active() ? eg->suCutoffOnCC.GetLevel() : 0;
393 f = eg->GetLevel() * (eg->pEGInfo->cutoff + f);
394 val *= RTMath::CentsToFreqRatioUnlimited(f);
395 }
396
397 for (int i = 0; i < GetRack()->filLFOs.size(); i++) {
398 LFOv2Unit* lfo = GetRack()->filLFOs[i];
399 if (!lfo->Active()) continue;
400
401 float f = lfo->suCutoffOnCC.Active() ? lfo->suCutoffOnCC.GetLevel() : 0;
402 f = lfo->GetLevel() * (lfo->pLfoInfo->cutoff + f);
403 val *= RTMath::CentsToFreqRatioUnlimited(f);
404 }
405
406 return val;
407 }
408
409 float EndpointUnit::CalculateFilterCutoff(float cutoff) {
410 cutoff *= GetFilterCutoff();
411 float maxCutoff = 0.49 * pVoice->GetSampleRate();
412 return cutoff > maxCutoff ? maxCutoff : cutoff;
413 }
414
415 float EndpointUnit::GetPitch() {
416 double p;
417 EGv1Unit* u = &(GetRack()->suPitchEG);
418 p = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->depth) : 1;
419
420 for (int i = 0; i < GetRack()->pitchEGs.size(); i++) {
421 EGv2Unit* eg = GetRack()->pitchEGs[i];
422 if (!eg->Active()) continue;
423
424 float f = eg->suPitchOnCC.Active() ? eg->suPitchOnCC.GetLevel() : 0;
425 p *= RTMath::CentsToFreqRatioUnlimited(eg->GetLevel() * (eg->pEGInfo->pitch + f));
426 }
427
428 PitchLFOUnit* u2 = &(GetRack()->suPitchLFO);
429 CCSignalUnit* u3 = &(GetRack()->suPitchLFO.suDepthOnCC);
430 float f = u3->Active() ? u3->GetLevel() : 0;
431 p *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * (u2->pLfoInfo->pitch + f)) : 1;
432
433 for (int i = 0; i < GetRack()->pitchLFOs.size(); i++) {
434 LFOv2Unit* lfo = GetRack()->pitchLFOs[i];
435 if (!lfo->Active()) continue;
436
437 float f = lfo->suPitchOnCC.Active() ? lfo->suPitchOnCC.GetLevel() : 0;
438 p *= RTMath::CentsToFreqRatioUnlimited(lfo->GetLevel() * (lfo->pLfoInfo->pitch + f));
439 }
440
441 return p;
442 }
443
444 float EndpointUnit::GetResonance() {
445 float val = 0;
446
447 for (int i = 0; i < GetRack()->resEGs.size(); i++) {
448 EGv2Unit* eg = GetRack()->resEGs[i];
449 if (!eg->Active()) continue;
450
451 float f = eg->suResOnCC.Active() ? eg->suResOnCC.GetLevel() : 0;
452 val += eg->GetLevel() * (eg->pEGInfo->resonance + f);
453 }
454
455 for (int i = 0; i < GetRack()->resLFOs.size(); i++) {
456 LFOv2Unit* lfo = GetRack()->resLFOs[i];
457 if (!lfo->Active()) continue;
458
459 float f = lfo->suResOnCC.Active() ? lfo->suResOnCC.GetLevel() : 0;
460 val += lfo->GetLevel() * (lfo->pLfoInfo->resonance + f);
461 }
462
463 return val;
464 }
465
466 float EndpointUnit::GetPan() {
467 float pan = 0;
468
469 for (int i = 0; i < GetRack()->panLFOs.size(); i++) {
470 LFOv2Unit* lfo = GetRack()->panLFOs[i];
471 if (!lfo->Active()) continue;
472
473 float f = lfo->suPanOnCC.Active() ? lfo->suPanOnCC.GetLevel() : 0;
474 pan += lfo->GetLevel() * (lfo->pLfoInfo->pan + f);
475 }
476
477 if(pan < -100) return -100;
478 if(pan > 100) return 100;
479
480 return pan;
481 }
482
483
484 SfzSignalUnitRack::SfzSignalUnitRack(Voice* voice)
485 : SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this), suFilEG(this), suPitchEG(this),
486 EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount), filEGs(maxEgCount), resEGs(maxEgCount), suVolOnCC(this),
487 suAmpLFO(this), suPitchLFO(this), suFilLFO(this),
488 LFOs(maxLfoCount), volLFOs(maxLfoCount), pitchLFOs(maxLfoCount),
489 filLFOs(maxLfoCount), resLFOs(maxLfoCount), panLFOs(maxLfoCount)
490 {
491 suEndpoint.pVoice = suVolEG.pVoice = suFilEG.pVoice = suPitchEG.pVoice = voice;
492 suAmpLFO.pVoice = suPitchLFO.pVoice = suFilLFO.pVoice = suVolOnCC.pVoice = voice;
493 suPitchLFO.suDepthOnCC.pVoice = suPitchLFO.suFadeEG.pVoice = suPitchLFO.suFreqOnCC.pVoice = voice;
494 suFilLFO.suFadeEG.pVoice = suFilLFO.suDepthOnCC.pVoice = suFilLFO.suFreqOnCC.pVoice = voice;
495 suAmpLFO.suFadeEG.pVoice = suAmpLFO.suDepthOnCC.pVoice = suAmpLFO.suFreqOnCC.pVoice = voice;
496
497 for (int i = 0; i < EGs.capacity(); i++) {
498 EGs[i] = new EGv2Unit(this);
499 EGs[i]->pVoice = voice;
500 EGs[i]->suAmpOnCC.pVoice = voice;
501 EGs[i]->suVolOnCC.pVoice = voice;
502 EGs[i]->suPitchOnCC.pVoice = voice;
503 EGs[i]->suCutoffOnCC.pVoice = voice;
504 EGs[i]->suResOnCC.pVoice = voice;
505 }
506
507 for (int i = 0; i < LFOs.capacity(); i++) {
508 LFOs[i] = new LFOv2Unit(this);
509 LFOs[i]->pVoice = voice;
510 LFOs[i]->suFadeEG.pVoice = voice;
511 LFOs[i]->suVolOnCC.pVoice = voice;
512 LFOs[i]->suPitchOnCC.pVoice = voice;
513 LFOs[i]->suFreqOnCC.pVoice = voice;
514 LFOs[i]->suPanOnCC.pVoice = voice;
515 LFOs[i]->suCutoffOnCC.pVoice = voice;
516 LFOs[i]->suResOnCC.pVoice = voice;
517 }
518 }
519
520 SfzSignalUnitRack::~SfzSignalUnitRack() {
521 for (int i = 0; i < EGs.capacity(); i++) {
522 delete EGs[i]; EGs[i] = NULL;
523 }
524
525 for (int i = 0; i < LFOs.capacity(); i++) {
526 delete LFOs[i]; LFOs[i] = NULL;
527 }
528 }
529
530 void SfzSignalUnitRack::Trigger() {
531 EGs.clear();
532 volEGs.clear();
533 pitchEGs.clear();
534 filEGs.clear();
535 resEGs.clear();
536
537 LFOs.clear();
538 volLFOs.clear();
539 pitchLFOs.clear();
540 filLFOs.clear();
541 resLFOs.clear();
542 panLFOs.clear();
543
544 ::sfz::Region* const pRegion = pVoice->pRegion;
545
546 suVolOnCC.SetCCs(pRegion->volume_oncc);
547
548 for (int i = 0; i < pRegion->eg.size(); i++) {
549 if (pRegion->eg[i].node.size() == 0) continue;
550
551 if(EGs.size() < EGs.capacity()) {
552 EGv2Unit eg(this);
553 eg.pEGInfo = &(pRegion->eg[i]);
554 EGs.increment()->Copy(eg);
555 EGs[EGs.size() - 1]->suAmpOnCC.SetCCs(pRegion->eg[i].amplitude_oncc);
556 EGs[EGs.size() - 1]->suVolOnCC.SetCCs(pRegion->eg[i].volume_oncc);
557 EGs[EGs.size() - 1]->suPitchOnCC.SetCCs(pRegion->eg[i].pitch_oncc);
558 EGs[EGs.size() - 1]->suCutoffOnCC.SetCCs(pRegion->eg[i].cutoff_oncc);
559 EGs[EGs.size() - 1]->suResOnCC.SetCCs(pRegion->eg[i].resonance_oncc);
560 } else { std::cerr << "Maximum number of EGs reached!" << std::endl; break; }
561
562 if ( pRegion->eg[i].amplitude > 0 || !pRegion->eg[i].amplitude_oncc.empty() ||
563 pRegion->eg[i].volume > -145 || !pRegion->eg[i].volume_oncc.empty()
564 ) {
565 if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
566 else std::cerr << "Maximum number of EGs reached!" << std::endl;
567 }
568
569 if (pRegion->eg[i].cutoff != 0 || !pRegion->eg[i].cutoff_oncc.empty()) {
570 if(filEGs.size() < filEGs.capacity()) filEGs.add(EGs[EGs.size() - 1]);
571 else std::cerr << "Maximum number of EGs reached!" << std::endl;
572 }
573
574 if (pRegion->eg[i].resonance != 0 || !pRegion->eg[i].resonance_oncc.empty()) {
575 if(resEGs.size() < resEGs.capacity()) resEGs.add(EGs[EGs.size() - 1]);
576 else std::cerr << "Maximum number of EGs reached!" << std::endl;
577 }
578
579 if (pRegion->eg[i].pitch != 0 || !pRegion->eg[i].pitch_oncc.empty()) {
580 if(pitchEGs.size() < pitchEGs.capacity()) pitchEGs.add(EGs[EGs.size() - 1]);
581 else std::cerr << "Maximum number of EGs reached!" << std::endl;
582 }
583 }
584
585 if (pRegion->ampeg_sustain == -1) {
586 if (volEGs.size() > 0) pRegion->ampeg_sustain = 0;
587 else pRegion->ampeg_sustain = 100;
588 }
589
590 // LFO
591 for (int i = 0; i < pRegion->lfos.size(); i++) {
592 if (pRegion->lfos[i].freq == -1) continue; // Not initialized
593
594 if(LFOs.size() < LFOs.capacity()) {
595 LFOv2Unit lfo(this);
596 lfo.pLfoInfo = &(pRegion->lfos[i]);
597 LFOs.increment()->Copy(lfo);
598 LFOs[LFOs.size() - 1]->suVolOnCC.SetCCs(pRegion->lfos[i].volume_oncc);
599 LFOs[LFOs.size() - 1]->suPitchOnCC.SetCCs(pRegion->lfos[i].pitch_oncc);
600 LFOs[LFOs.size() - 1]->suFreqOnCC.SetCCs(pRegion->lfos[i].freq_oncc);
601 LFOs[LFOs.size() - 1]->suPanOnCC.SetCCs(pRegion->lfos[i].pan_oncc);
602 LFOs[LFOs.size() - 1]->suCutoffOnCC.SetCCs(pRegion->lfos[i].cutoff_oncc);
603 LFOs[LFOs.size() - 1]->suResOnCC.SetCCs(pRegion->lfos[i].resonance_oncc);
604 } else { std::cerr << "Maximum number of LFOs reached!" << std::endl; break; }
605
606 if (pRegion->lfos[i].volume != 0 || !pRegion->lfos[i].volume_oncc.empty()) {
607 if(volLFOs.size() < volLFOs.capacity()) volLFOs.add(LFOs[LFOs.size() - 1]);
608 else std::cerr << "Maximum number of LFOs reached!" << std::endl;
609 }
610
611 if (pRegion->lfos[i].pitch != 0 || !pRegion->lfos[i].pitch_oncc.empty()) {
612 if(pitchLFOs.size() < pitchLFOs.capacity()) pitchLFOs.add(LFOs[LFOs.size() - 1]);
613 else std::cerr << "Maximum number of LFOs reached!" << std::endl;
614 }
615
616 if (pRegion->lfos[i].cutoff != 0 || !pRegion->lfos[i].cutoff_oncc.empty()) {
617 if(filLFOs.size() < filLFOs.capacity()) filLFOs.add(LFOs[LFOs.size() - 1]);
618 else std::cerr << "Maximum number of LFOs reached!" << std::endl;
619 }
620
621 if (pRegion->lfos[i].resonance != 0 || !pRegion->lfos[i].resonance_oncc.empty()) {
622 if(resLFOs.size() < resLFOs.capacity()) resLFOs.add(LFOs[LFOs.size() - 1]);
623 else std::cerr << "Maximum number of LFOs reached!" << std::endl;
624 }
625
626 if (pRegion->lfos[i].pan != 0 || !pRegion->lfos[i].pan_oncc.empty()) {
627 if(panLFOs.size() < panLFOs.capacity()) panLFOs.add(LFOs[LFOs.size() - 1]);
628 else std::cerr << "Maximum number of LFOs reached!" << std::endl;
629 }
630 }
631
632 suPitchLFO.suDepthOnCC.SetCCs(pRegion->pitchlfo_depthcc);
633 suPitchLFO.suFreqOnCC.SetCCs(pRegion->pitchlfo_freqcc);
634
635 suFilLFO.suDepthOnCC.SetCCs(pRegion->fillfo_depthcc);
636 suFilLFO.suFreqOnCC.SetCCs(pRegion->fillfo_freqcc);
637
638 suAmpLFO.suDepthOnCC.SetCCs(pRegion->amplfo_depthcc);
639 suAmpLFO.suFreqOnCC.SetCCs(pRegion->amplfo_freqcc);
640
641 Units.clear();
642
643 Units.add(&suVolOnCC);
644
645 Units.add(&suVolEG);
646 Units.add(&suFilEG);
647 Units.add(&suPitchEG);
648
649 Units.add(&suPitchLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
650 Units.add(&suPitchLFO);
651 Units.add(&suPitchLFO.suDepthOnCC);
652 Units.add(&suPitchLFO.suFadeEG);
653
654 Units.add(&suAmpLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
655 Units.add(&suAmpLFO.suDepthOnCC);
656 Units.add(&suAmpLFO);
657 Units.add(&suAmpLFO.suFadeEG);
658
659 Units.add(&suFilLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
660 Units.add(&suFilLFO.suDepthOnCC);
661 Units.add(&suFilLFO);
662 Units.add(&suFilLFO.suFadeEG);
663
664 for (int i = 0; i < EGs.size(); i++) {
665 Units.add(EGs[i]);
666 Units.add(&(EGs[i]->suAmpOnCC));
667 Units.add(&(EGs[i]->suVolOnCC));
668 Units.add(&(EGs[i]->suPitchOnCC));
669 Units.add(&(EGs[i]->suCutoffOnCC));
670 Units.add(&(EGs[i]->suResOnCC));
671 }
672
673 for (int i = 0; i < LFOs.size(); i++) {
674 Units.add(&(LFOs[i]->suFreqOnCC)); // Don't change order! (should be triggered before the LFO)
675 Units.add(LFOs[i]);
676 Units.add(&(LFOs[i]->suFadeEG));
677 Units.add(&(LFOs[i]->suVolOnCC));
678 Units.add(&(LFOs[i]->suPitchOnCC));
679 Units.add(&(LFOs[i]->suPanOnCC));
680 Units.add(&(LFOs[i]->suCutoffOnCC));
681 Units.add(&(LFOs[i]->suResOnCC));
682 }
683
684 Units.add(&suEndpoint);
685
686 SignalUnitRack::Trigger();
687 }
688
689 EndpointSignalUnit* SfzSignalUnitRack::GetEndpointUnit() {
690 return &suEndpoint;
691 }
692
693 void SfzSignalUnitRack::EnterFadeOutStage() {
694 suVolEG.EG.enterFadeOutStage();
695
696 for (int i = 0; i < volEGs.size(); i++) {
697 volEGs[i]->EG.enterFadeOutStage();
698 }
699 }
700
701 }} // namespace LinuxSampler::sfz
  ViewVC Help
Powered by ViewVC