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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3095 - (show annotations) (download)
Wed Jan 18 14:52:31 2017 UTC (7 years, 2 months ago) by schoenebeck
File size: 108484 byte(s)
* SFZ engine: Implemented opcode set_ccN
  (initial patch by Giovanni Senatore).
* SFZ engine: print a warning if a CC related
  opcode uses an invalid MIDI controller number.
* Bumped version (2.0.0.svn41).

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2008 Anders Dahnielson <anders@dahnielson.com> *
6 * Copyright (C) 2009 - 2016 Anders Dahnielson and Grigor Iliev *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #include "sfz.h"
25
26 #include <iostream>
27 #include <sstream>
28 #include <cctype>
29 #include <cstdio>
30 #include <cstring>
31
32 #include "../../common/File.h"
33 #include "../../common/Path.h"
34 #include "LookupTable.h"
35 #include "../../common/global_private.h"
36
37 namespace sfz
38 {
39 template <typename T> T check(std::string name, T min, T max, T val) {
40 if (val < min) {
41 std::cerr << "sfz: The value of opcode '" << name;
42 std::cerr << "' is below the minimum allowed value (min=" << min << "): " << val << std::endl;
43 val = min;
44 }
45 if (val > max) {
46 std::cerr << "sfz: The value of opcode '" << name;
47 std::cerr << "' is above the maximum allowed value (max=" << max << "): " << val << std::endl;
48 val = max;
49 }
50
51 return val;
52 }
53
54 Sample* SampleManager::FindSample(std::string samplePath, uint offset, int end) {
55 std::map<Sample*, std::set<Region*> >::iterator it = sampleMap.begin();
56 for (; it != sampleMap.end(); it++) {
57 if (it->first->GetFile() == samplePath) {
58 /* Because the start of the sample is cached in RAM we treat
59 * same sample with different offset as different samples
60 * // TODO: Ignore offset when the whole sample is cached in RAM?
61 */
62 if (it->first->Offset == offset && it->first->End == end) return it->first;
63 }
64 }
65
66 return NULL;
67 }
68
69 /////////////////////////////////////////////////////////////
70 // class Script
71
72 Script::Script(LinuxSampler::Path path) : m_path(path) {
73 }
74
75 Script::Script(String path) : m_path(LinuxSampler::Path::fromUnknownFS(path)) {
76 }
77
78 Script::~Script() {
79 }
80
81 String Script::Name() const {
82 return m_path.getName();
83 }
84
85 Script::Language_t Script::Language() {
86 return LANGUAGE_NKSP;
87 }
88
89 String Script::GetSourceCode() {
90 std::ifstream f(m_path.toNativeFSPath().c_str());
91 std::string s;
92 // reserve required space on string object
93 f.seekg(0, std::ios::end);
94 s.reserve(f.tellg());
95 f.seekg(0, std::ios::beg);
96 // read entire content from file and assign it to string object
97 s.assign((std::istreambuf_iterator<char>(f)),
98 std::istreambuf_iterator<char>());
99 return s;
100 }
101
102 /////////////////////////////////////////////////////////////
103 // class Articulation
104
105 Articulation::Articulation()
106 {
107 }
108
109 Articulation::~Articulation()
110 {
111 }
112
113 /////////////////////////////////////////////////////////////
114 // class Definition
115
116 Definition::Definition()
117 {
118 }
119
120 Definition::~Definition()
121 {
122 }
123
124 /////////////////////////////////////////////////////////////
125 // class Region
126
127 Region::Region()
128 {
129 pSample = NULL;
130 seq_counter = 1;
131 }
132
133 Region::~Region()
134 {
135 DestroySampleIfNotUsed();
136 }
137
138 Sample* Region::GetSample(bool create)
139 {
140 if (pSample == NULL && create) {
141 uint i = offset ? *offset : 0;
142 Sample* sf = GetInstrument()->GetSampleManager()->FindSample(sample, i, end);
143 if (sf != NULL) pSample = sf; // Reuse already created sample
144 else pSample = new Sample(sample, false, i, end);
145 GetInstrument()->GetSampleManager()->AddSampleConsumer(pSample, this);
146 }
147 return pSample;
148 }
149
150 void Region::DestroySampleIfNotUsed() {
151 if (pSample == NULL) return;
152 GetInstrument()->GetSampleManager()->RemoveSampleConsumer(pSample, this);
153 if (!GetInstrument()->GetSampleManager()->HasSampleConsumers(pSample)) {
154 GetInstrument()->GetSampleManager()->RemoveSample(pSample);
155 delete pSample;
156 pSample = NULL;
157 }
158 }
159
160 bool Region::OnKey(const Query& q) {
161 // As the region comes from a LookupTable search on the query,
162 // the following parameters are not checked here: chan, key,
163 // vel, chanaft, polyaft, prog, sw_previous, cc. They are all
164 // handled by the lookup table.
165 bool is_triggered(
166 q.bend >= lobend && q.bend <= hibend &&
167 q.bpm >= lobpm && q.bpm < hibpm &&
168 q.rand >= lorand && q.rand < hirand &&
169 q.timer >= lotimer && q.timer <= hitimer &&
170
171 ( sw_last == -1 ||
172 ((sw_last >= sw_lokey && sw_last <= sw_hikey) ? (q.last_sw_key == sw_last) : false) ) &&
173
174 ( sw_down == -1 ||
175 ((sw_down >= sw_lokey && (sw_hikey == -1 || sw_down <= sw_hikey)) ? (q.sw[sw_down]) : false) ) &&
176
177 ( sw_up == -1 ||
178 ((sw_up >= sw_lokey && (sw_hikey == -1 || sw_up <= sw_hikey)) ? (!q.sw[sw_up]) : true) ) &&
179
180 ((trigger & q.trig) != 0)
181 );
182
183 if (!is_triggered)
184 return false;
185
186 // seq_position has to be checked last, so we know that we
187 // increment the right counter
188 is_triggered = (seq_counter == seq_position);
189 seq_counter = (seq_counter % seq_length) + 1;
190
191 return is_triggered;
192 }
193
194 Articulation*
195 Region::GetArticulation(int bend, uint8_t bpm, uint8_t chanaft, uint8_t polyaft, uint8_t* cc)
196 {
197 return new Articulation(); //todo: implement GetArticulation()
198 }
199
200 bool Region::HasLoop() {
201 bool b = loop_mode == LOOP_UNSET ? pSample->GetLoops() :
202 (loop_mode == LOOP_CONTINUOUS || loop_mode == LOOP_SUSTAIN);
203 return b && GetLoopEnd() > GetLoopStart();
204 }
205
206 uint Region::GetLoopStart() {
207 return (!loop_start) ? pSample->GetLoopStart() : *loop_start;
208 }
209
210 uint Region::GetLoopEnd() {
211 return (!loop_end) ? pSample->GetLoopEnd() : *loop_end;
212 }
213
214 uint Region::GetLoopCount() {
215 return (!count) ? 0 : *count;
216 }
217
218 /////////////////////////////////////////////////////////////
219 // class Instrument
220
221 Instrument::Instrument(std::string name, SampleManager* pSampleManager) : KeyBindings(128, false), KeySwitchBindings(128, false)
222 {
223 this->name = name;
224 this->pSampleManager = pSampleManager ? pSampleManager : this;
225 pLookupTable = 0;
226
227 // The first 6 curves are defined internally (actually 7 with the one at index 0)
228 Curve c;
229 for (int i = 0; i < 128; i++) c.v[i] = i / 127.0f;
230 curves.add(c); curves.add(c); curves.add(c); curves.add(c);
231 curves.add(c); curves.add(c); curves.add(c);
232 ///////
233 }
234
235 Instrument::~Instrument()
236 {
237 for (int i = 0; i < regions.size(); i++) {
238 delete regions[i];
239 }
240 delete pLookupTable;
241 for (int i = 0 ; i < 128 ; i++) {
242 delete pLookupTableCC[i];
243 }
244 }
245
246 void Query::search(const Instrument* pInstrument) {
247 pRegionList = &pInstrument->pLookupTable->query(*this);
248 regionIndex = 0;
249 }
250
251 void Query::search(const Instrument* pInstrument, int triggercc) {
252 pRegionList = &pInstrument->pLookupTableCC[triggercc]->query(*this);
253 regionIndex = 0;
254 }
255
256 Region* Query::next() {
257 for ( ; regionIndex < pRegionList->size() ; regionIndex++) {
258 if ((*pRegionList)[regionIndex]->OnKey(*this)) {
259 return (*pRegionList)[regionIndex++];
260 }
261 }
262 return 0;
263 }
264
265 bool Instrument::DestroyRegion(Region* pRegion) {
266 for (std::vector<Region*>::iterator it = regions.begin(); it != regions.end(); it++) {
267 if(*it == pRegion) {
268 regions.erase(it);
269 delete pRegion;
270 return true;
271 }
272 }
273
274 return false;
275 }
276
277 bool Instrument::HasKeyBinding(uint8_t key) {
278 if (key > 127) return false;
279 return KeyBindings[key];
280 }
281
282 bool Instrument::HasKeySwitchBinding(uint8_t key) {
283 if (key > 127) return false;
284 return KeySwitchBindings[key];
285 }
286
287 /////////////////////////////////////////////////////////////
288 // class ContainerDefinition
289
290 ContainerDefinition::ContainerDefinition(section_type type)
291 {
292 Reset();
293 level = type;
294 }
295
296 ContainerDefinition::~ContainerDefinition()
297 {
298 }
299
300 void
301 ContainerDefinition::Reset()
302 {
303 // This is where all the default values are set.
304
305 // sample definition default
306 sample = "";
307
308 // input control
309 lochan = 1; hichan = 16;
310 lokey = 0; hikey = 127;
311 lovel = 0; hivel = 127;
312 lobend = -8192; hibend = 8192;
313 lobpm = 0; hibpm = 500;
314 lochanaft = 0; hichanaft = 127;
315 lopolyaft = 0; hipolyaft = 127;
316 loprog = 0; hiprog = 127;
317 lorand = 0.0; hirand = 1.0;
318 lotimer = 0.0; hitimer = 0.0;
319
320 seq_length = 1;
321 seq_position = 1;
322
323 sw_lokey = -1; sw_hikey = -1;
324 sw_last = -1;
325 sw_down = -1;
326 sw_up = -1;
327 sw_previous = -1;
328 sw_vel = VEL_CURRENT;
329
330 trigger = TRIGGER_ATTACK;
331
332 group = 0;
333 off_by = 0;
334 off_mode = OFF_FAST;
335
336 // sample player
337 count = optional<int>::nothing;
338 delay = optional<float>::nothing;
339 delay_random = optional<float>::nothing;
340 delay_beats = optional<int>::nothing;
341 stop_beats = optional<int>::nothing;
342 delay_samples = optional<int>::nothing;
343 end = 0;
344 loop_crossfade = optional<float>::nothing;
345 offset = optional<uint>::nothing;
346 offset_random = optional<int>::nothing;
347 loop_mode = LOOP_UNSET;
348 loop_start = optional<int>::nothing;
349 loop_end = optional<int>::nothing;
350 sync_beats = optional<int>::nothing;
351 sync_offset = optional<int>::nothing;
352
353 // amplifier
354 volume = 0;
355 volume_oncc.clear();
356 volume_curvecc.clear();
357 volume_smoothcc.clear();
358 volume_stepcc.clear();
359 amplitude = 100;
360 pan = 0;
361 pan_oncc.clear();
362 pan_curvecc.clear();
363 pan_smoothcc.clear();
364 pan_stepcc.clear();
365 width = 100;
366 position = 0;
367 amp_keytrack = 0;
368 amp_keycenter = 60;
369 amp_veltrack = 100;
370 amp_random = 0;
371 rt_decay = 0;
372 xfin_lokey = 0; xfin_hikey = 0;
373 xfout_lokey = 127; xfout_hikey = 127;
374 xf_keycurve = POWER;
375 xfin_lovel = 0; xfin_hivel = 0;
376 xfout_lovel = 127; xfout_hivel = 127;
377 xf_velcurve = POWER;
378 xf_cccurve = POWER;
379
380 // pitch
381 transpose = 0;
382 tune = 0;
383 pitch_keycenter = 60;
384 pitch_keytrack = 100;
385 pitch_veltrack = 0;
386 pitch_random = 0;
387 bend_up = 200;
388 bend_down = -200;
389 bend_step = 1;
390
391 pitch_oncc.clear();
392 pitch_smoothcc.clear();
393 pitch_curvecc.clear();
394 pitch_stepcc.clear();
395
396 // filter
397 fil_type = LPF_2P;
398 cutoff = optional<float>::nothing;
399 cutoff_chanaft = 0;
400 cutoff_polyaft = 0;
401 resonance = 0;
402 fil_keytrack = 0;
403 fil_keycenter = 60;
404 fil_veltrack = 0;
405 fil_random = 0;
406
407 fil2_type = LPF_2P;
408 cutoff2 = optional<float>::nothing;
409 cutoff2_chanaft = 0;
410 cutoff2_polyaft = 0;
411 resonance2 = 0;
412 fil2_keytrack = 0;
413 fil2_keycenter = 60;
414 fil2_veltrack = 0;
415 fil2_random = 0;
416
417 cutoff_oncc.clear();
418 cutoff_smoothcc.clear();
419 cutoff_curvecc.clear();
420 cutoff_stepcc.clear();
421 cutoff2_oncc.clear();
422 cutoff2_smoothcc.clear();
423 cutoff2_curvecc.clear();
424 cutoff2_stepcc.clear();
425
426 resonance_oncc.clear();
427 resonance_smoothcc.clear();
428 resonance_curvecc.clear();
429 resonance_stepcc.clear();
430 resonance2_oncc.clear();
431 resonance2_smoothcc.clear();
432 resonance2_curvecc.clear();
433 resonance2_stepcc.clear();
434
435 // per voice equalizer
436 eq1_freq = 50;
437 eq2_freq = 500;
438 eq3_freq = 5000;
439 eq1_vel2freq = 0;
440 eq2_vel2freq = 0;
441 eq3_vel2freq = 0;
442 eq1_bw = 1;
443 eq2_bw = 1;
444 eq3_bw = 1;
445 eq1_gain = 0;
446 eq2_gain = 0;
447 eq3_gain = 0;
448 eq1_vel2gain = 0;
449 eq2_vel2gain = 0;
450 eq3_vel2gain = 0;
451
452 // CCs
453 for (int i = 0; i < 128; ++i)
454 {
455 // input control
456 locc.set(i, 0);
457 hicc.set(i, 127);
458 start_locc.set(i, -1);
459 start_hicc.set(i, -1);
460 stop_locc.set(i, -1);
461 stop_hicc.set(i, -1);
462 on_locc.set(i, -1);
463 on_hicc.set(i, -1);
464
465 // sample player
466 delay_oncc.set(i, optional<float>::nothing);
467 delay_samples_oncc.set(i, optional<int>::nothing);
468 offset_oncc.set(i, optional<int>::nothing);
469
470 // amplifier
471 amp_velcurve.set(i, -1);
472 gain_oncc.set(i, 0);
473 xfin_locc.set(i, 0);
474 xfin_hicc.set(i, 0);
475 xfout_locc.set(i, 0);
476 xfout_hicc.set(i, 0);
477
478 // per voice equalizer
479 eq1_freq_oncc.set(i, 0);
480 eq2_freq_oncc.set(i, 0);
481 eq3_freq_oncc.set(i, 0);
482 eq1_bw_oncc.set(i, 0);
483 eq2_bw_oncc.set(i, 0);
484 eq3_bw_oncc.set(i, 0);
485 eq1_gain_oncc.set(i, 0);
486 eq2_gain_oncc.set(i, 0);
487 eq3_gain_oncc.set(i, 0);
488 }
489
490 eg.clear();
491 lfos.clear();
492
493 // deprecated
494 ampeg_delay = 0;
495 ampeg_start = 0; //in percentage
496 ampeg_attack = 0;
497 ampeg_hold = 0;
498 ampeg_decay = 0;
499 ampeg_sustain = -1; // in percentage
500 ampeg_release = 0;
501
502 ampeg_vel2delay = 0;
503 ampeg_vel2attack = 0;
504 ampeg_vel2hold = 0;
505 ampeg_vel2decay = 0;
506 ampeg_vel2sustain = 0;
507 ampeg_vel2release = 0;
508
509 ampeg_delaycc.clear();
510 ampeg_startcc.clear();
511 ampeg_attackcc.clear();
512 ampeg_holdcc.clear();
513 ampeg_decaycc.clear();
514 ampeg_sustaincc.clear();
515 ampeg_releasecc.clear();
516
517 fileg_delay = 0;
518 fileg_start = 0; //in percentage
519 fileg_attack = 0;
520 fileg_hold = 0;
521 fileg_decay = 0;
522 fileg_sustain = 100; // in percentage
523 fileg_release = 0;
524
525 fileg_vel2delay = 0;
526 fileg_vel2attack = 0;
527 fileg_vel2hold = 0;
528 fileg_vel2decay = 0;
529 fileg_vel2sustain = 0;
530 fileg_vel2release = 0;
531 fileg_depth = 0;
532
533 fileg_delay_oncc.clear();
534 fileg_start_oncc.clear();
535 fileg_attack_oncc.clear();
536 fileg_hold_oncc.clear();
537 fileg_decay_oncc.clear();
538 fileg_sustain_oncc.clear();
539 fileg_release_oncc.clear();
540 fileg_depth_oncc.clear();
541
542 pitcheg_delay = 0;
543 pitcheg_start = 0; //in percentage
544 pitcheg_attack = 0;
545 pitcheg_hold = 0;
546 pitcheg_decay = 0;
547 pitcheg_sustain = 100; // in percentage
548 pitcheg_release = 0;
549 pitcheg_depth = 0;
550
551 pitcheg_vel2delay = 0;
552 pitcheg_vel2attack = 0;
553 pitcheg_vel2hold = 0;
554 pitcheg_vel2decay = 0;
555 pitcheg_vel2sustain = 0;
556 pitcheg_vel2release = 0;
557
558 pitcheg_delay_oncc.clear();
559 pitcheg_start_oncc.clear();
560 pitcheg_attack_oncc.clear();
561 pitcheg_hold_oncc.clear();
562 pitcheg_decay_oncc.clear();
563 pitcheg_sustain_oncc.clear();
564 pitcheg_release_oncc.clear();
565 pitcheg_depth_oncc.clear();
566
567 amplfo_delay = 0;
568 amplfo_fade = 0;
569 amplfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
570 amplfo_depth = 0;
571 amplfo_delay_oncc.clear();
572 amplfo_fade_oncc.clear();
573 amplfo_depthcc.clear();
574 amplfo_freqcc.clear();
575
576 fillfo_delay = 0;
577 fillfo_fade = 0;
578 fillfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
579 fillfo_depth = 0;
580 fillfo_delay_oncc.clear();
581 fillfo_fade_oncc.clear();
582 fillfo_depthcc.clear();
583 fillfo_freqcc.clear();
584
585 pitchlfo_delay = 0;
586 pitchlfo_fade = 0;
587 pitchlfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
588 pitchlfo_depth = 0;
589 pitchlfo_delay_oncc.clear();
590 pitchlfo_fade_oncc.clear();
591 pitchlfo_depthcc.clear();
592 pitchlfo_freqcc.clear();
593 }
594
595 void ContainerDefinition::CopyValuesToDefinition(Definition* definition)
596 {
597 // This is where the current settings are copied to the new definition.
598
599 // sample definition
600 definition->sample = sample;
601
602 // input control
603 definition->lochan = lochan;
604 definition->hichan = hichan;
605 definition->lokey = lokey;
606 definition->hikey = hikey;
607 definition->lovel = lovel;
608 definition->hivel = hivel;
609 definition->locc = locc;
610 definition->hicc = hicc;
611 definition->lobend = lobend;
612 definition->hibend = hibend;
613 definition->lobpm = lobpm;
614 definition->hibpm = hibpm;
615 definition->lochanaft = lochanaft;
616 definition->hichanaft = hichanaft;
617 definition->lopolyaft = lopolyaft;
618 definition->hipolyaft = hipolyaft;
619 definition->loprog = loprog;
620 definition->hiprog = hiprog;
621 definition->lorand = lorand;
622 definition->hirand = hirand;
623 definition->lotimer = lotimer;
624 definition->hitimer = hitimer;
625 definition->seq_length = seq_length;
626 definition->seq_position = seq_position;
627 definition->start_locc = start_locc;
628 definition->start_hicc = start_hicc;
629 definition->stop_locc = stop_locc;
630 definition->stop_hicc = stop_hicc;
631 definition->sw_lokey = sw_lokey;
632 definition->sw_hikey = sw_hikey;
633 definition->sw_last = sw_last;
634 definition->sw_down = sw_down;
635 definition->sw_up = sw_up;
636 definition->sw_previous = sw_previous;
637 definition->sw_vel = sw_vel;
638 definition->trigger = trigger;
639 definition->group = group;
640 definition->off_by = off_by;
641 definition->off_mode = off_mode;
642 definition->on_locc = on_locc;
643 definition->on_hicc = on_hicc;
644
645 // sample player
646 definition->count = count;
647 definition->delay = delay;
648 definition->delay_random = delay_random;
649 definition->delay_oncc = delay_oncc;
650 definition->delay_beats = delay_beats;
651 definition->stop_beats = stop_beats;
652 definition->delay_samples = delay_samples;
653 definition->delay_samples_oncc = delay_samples_oncc;
654 definition->end = end;
655 definition->loop_crossfade = loop_crossfade;
656 definition->offset = offset;
657 definition->offset_random = offset_random;
658 definition->offset_oncc = offset_oncc;
659 definition->loop_mode = loop_mode;
660 definition->loop_start = loop_start;
661 definition->loop_end = loop_end;
662 definition->sync_beats = sync_beats;
663 definition->sync_offset = sync_offset;
664
665 // amplifier
666 definition->volume = volume;
667 definition->volume_oncc = volume_oncc;
668 definition->volume_curvecc = volume_curvecc;
669 definition->volume_smoothcc = volume_smoothcc;
670 definition->volume_stepcc = volume_stepcc;
671 definition->amplitude = amplitude;
672 definition->pan = pan;
673 definition->pan_oncc = pan_oncc;
674 definition->pan_curvecc = pan_curvecc;
675 definition->pan_smoothcc = pan_smoothcc;
676 definition->pan_stepcc = pan_stepcc;
677 definition->width = width;
678 definition->position = position;
679 definition->amp_keytrack = amp_keytrack;
680 definition->amp_keycenter = amp_keycenter;
681 definition->amp_veltrack = amp_veltrack;
682 definition->amp_velcurve = amp_velcurve;
683 definition->amp_random = amp_random;
684 definition->rt_decay = rt_decay;
685 definition->gain_oncc = gain_oncc;
686 definition->xfin_lokey = xfin_lokey;
687 definition->xfin_hikey = xfin_hikey;
688 definition->xfout_lokey = xfout_lokey;
689 definition->xfout_hikey = xfout_hikey;
690 definition->xf_keycurve = xf_keycurve;
691 definition->xfin_lovel = xfin_lovel;
692 definition->xfin_hivel = xfin_lovel;
693 definition->xfout_lovel = xfout_lovel;
694 definition->xfout_hivel = xfout_hivel;
695 definition->xf_velcurve = xf_velcurve;
696 definition->xfin_locc = xfin_locc;
697 definition->xfin_hicc = xfin_hicc;
698 definition->xfout_locc = xfout_locc;
699 definition->xfout_hicc = xfout_hicc;
700 definition->xf_cccurve = xf_cccurve;
701
702 // pitch
703 definition->transpose = transpose;
704 definition->tune = tune;
705 definition->pitch_keycenter = pitch_keycenter;
706 definition->pitch_keytrack = pitch_keytrack;
707 definition->pitch_veltrack = pitch_veltrack;
708 definition->pitch_random = pitch_random;
709 definition->bend_up = bend_up;
710 definition->bend_down = bend_down;
711 definition->bend_step = bend_step;
712
713 definition->pitch_oncc = pitch_oncc;
714 definition->pitch_smoothcc = pitch_smoothcc;
715 definition->pitch_curvecc = pitch_curvecc;
716 definition->pitch_stepcc = pitch_stepcc;
717
718 // filter
719 definition->fil_type = fil_type;
720 definition->cutoff = cutoff;
721 definition->cutoff_oncc = cutoff_oncc;
722 definition->cutoff_smoothcc = cutoff_smoothcc;
723 definition->cutoff_stepcc = cutoff_stepcc;
724 definition->cutoff_curvecc = cutoff_curvecc;
725 definition->cutoff_chanaft = cutoff_chanaft;
726 definition->cutoff_polyaft = cutoff_polyaft;
727 definition->resonance = resonance;
728 definition->resonance_oncc = resonance_oncc;
729 definition->resonance_smoothcc = resonance_smoothcc;
730 definition->resonance_stepcc = resonance_stepcc;
731 definition->resonance_curvecc = resonance_curvecc;
732 definition->fil_keytrack = fil_keytrack;
733 definition->fil_keycenter = fil_keycenter;
734 definition->fil_veltrack = fil_veltrack;
735 definition->fil_random = fil_random;
736
737 definition->fil2_type = fil2_type;
738 definition->cutoff2 = cutoff2;
739 definition->cutoff2_oncc = cutoff2_oncc;
740 definition->cutoff2_smoothcc = cutoff2_smoothcc;
741 definition->cutoff2_stepcc = cutoff2_stepcc;
742 definition->cutoff2_curvecc = cutoff2_curvecc;
743 definition->cutoff2_chanaft = cutoff2_chanaft;
744 definition->cutoff2_polyaft = cutoff2_polyaft;
745 definition->resonance2 = resonance2;
746 definition->resonance2_oncc = resonance2_oncc;
747 definition->resonance2_smoothcc = resonance2_smoothcc;
748 definition->resonance2_stepcc = resonance2_stepcc;
749 definition->resonance2_curvecc = resonance2_curvecc;
750 definition->fil2_keytrack = fil2_keytrack;
751 definition->fil2_keycenter = fil2_keycenter;
752 definition->fil2_veltrack = fil2_veltrack;
753 definition->fil2_random = fil2_random;
754
755 // per voice equalizer
756 definition->eq1_freq = eq1_freq;
757 definition->eq2_freq = eq2_freq;
758 definition->eq3_freq = eq3_freq;
759 definition->eq1_freq_oncc = eq1_freq_oncc;
760 definition->eq2_freq_oncc = eq2_freq_oncc;
761 definition->eq3_freq_oncc = eq3_freq_oncc;
762 definition->eq1_vel2freq = eq1_vel2freq;
763 definition->eq2_vel2freq = eq2_vel2freq;
764 definition->eq3_vel2freq = eq3_vel2freq;
765 definition->eq1_bw = eq1_bw;
766 definition->eq2_bw = eq2_bw;
767 definition->eq3_bw = eq3_bw;
768 definition->eq1_bw_oncc = eq1_bw_oncc;
769 definition->eq2_bw_oncc = eq2_bw_oncc;
770 definition->eq3_bw_oncc = eq3_bw_oncc;
771 definition->eq1_gain = eq1_gain;
772 definition->eq2_gain = eq2_gain;
773 definition->eq3_gain = eq3_gain;
774 definition->eq1_gain_oncc = eq1_gain_oncc;
775 definition->eq2_gain_oncc = eq2_gain_oncc;
776 definition->eq3_gain_oncc = eq3_gain_oncc;
777 definition->eq1_vel2gain = eq1_vel2gain;
778 definition->eq2_vel2gain = eq2_vel2gain;
779 definition->eq3_vel2gain = eq3_vel2gain;
780
781 // envelope generator
782 definition->eg = eg;
783
784 // deprecated
785 definition->ampeg_delay = ampeg_delay;
786 definition->ampeg_start = ampeg_start;
787 definition->ampeg_attack = ampeg_attack;
788 definition->ampeg_hold = ampeg_hold;
789 definition->ampeg_decay = ampeg_decay;
790 definition->ampeg_sustain = ampeg_sustain;
791 definition->ampeg_release = ampeg_release;
792
793 definition->ampeg_vel2delay = ampeg_vel2delay;
794 definition->ampeg_vel2attack = ampeg_vel2attack;
795 definition->ampeg_vel2hold = ampeg_vel2hold;
796 definition->ampeg_vel2decay = ampeg_vel2decay;
797 definition->ampeg_vel2sustain = ampeg_vel2sustain;
798 definition->ampeg_vel2release = ampeg_vel2release;
799
800 definition->ampeg_delaycc = ampeg_delaycc;
801 definition->ampeg_startcc = ampeg_startcc;
802 definition->ampeg_attackcc = ampeg_attackcc;
803 definition->ampeg_holdcc = ampeg_holdcc;
804 definition->ampeg_decaycc = ampeg_decaycc;
805 definition->ampeg_sustaincc = ampeg_sustaincc;
806 definition->ampeg_releasecc = ampeg_releasecc;
807
808 definition->fileg_delay = fileg_delay;
809 definition->fileg_start = fileg_start;
810 definition->fileg_attack = fileg_attack;
811 definition->fileg_hold = fileg_hold;
812 definition->fileg_decay = fileg_decay;
813 definition->fileg_sustain = fileg_sustain;
814 definition->fileg_release = fileg_release;
815 definition->fileg_depth = fileg_depth;
816
817 definition->fileg_vel2delay = fileg_vel2delay;
818 definition->fileg_vel2attack = fileg_vel2attack;
819 definition->fileg_vel2hold = fileg_vel2hold;
820 definition->fileg_vel2decay = fileg_vel2decay;
821 definition->fileg_vel2sustain = fileg_vel2sustain;
822 definition->fileg_vel2release = fileg_vel2release;
823
824 definition->fileg_delay_oncc = fileg_delay_oncc;
825 definition->fileg_start_oncc = fileg_start_oncc;
826 definition->fileg_attack_oncc = fileg_attack_oncc;
827 definition->fileg_hold_oncc = fileg_hold_oncc;
828 definition->fileg_decay_oncc = fileg_decay_oncc;
829 definition->fileg_sustain_oncc = fileg_sustain_oncc;
830 definition->fileg_release_oncc = fileg_release_oncc;
831 definition->fileg_depth_oncc = fileg_depth_oncc;
832
833 definition->pitcheg_delay = pitcheg_delay;
834 definition->pitcheg_start = pitcheg_start;
835 definition->pitcheg_attack = pitcheg_attack;
836 definition->pitcheg_hold = pitcheg_hold;
837 definition->pitcheg_decay = pitcheg_decay;
838 definition->pitcheg_sustain = pitcheg_sustain;
839 definition->pitcheg_release = pitcheg_release;
840 definition->pitcheg_depth = pitcheg_depth;
841
842 definition->pitcheg_vel2delay = pitcheg_vel2delay;
843 definition->pitcheg_vel2attack = pitcheg_vel2attack;
844 definition->pitcheg_vel2hold = pitcheg_vel2hold;
845 definition->pitcheg_vel2decay = pitcheg_vel2decay;
846 definition->pitcheg_vel2sustain = pitcheg_vel2sustain;
847 definition->pitcheg_vel2release = pitcheg_vel2release;
848
849 definition->pitcheg_delay_oncc = pitcheg_delay_oncc;
850 definition->pitcheg_start_oncc = pitcheg_start_oncc;
851 definition->pitcheg_attack_oncc = pitcheg_attack_oncc;
852 definition->pitcheg_hold_oncc = pitcheg_hold_oncc;
853 definition->pitcheg_decay_oncc = pitcheg_decay_oncc;
854 definition->pitcheg_sustain_oncc = pitcheg_sustain_oncc;
855 definition->pitcheg_release_oncc = pitcheg_release_oncc;
856 definition->pitcheg_depth_oncc = pitcheg_depth_oncc;
857
858 definition->amplfo_delay = amplfo_delay;
859 definition->amplfo_fade = amplfo_fade;
860 definition->amplfo_freq = amplfo_freq;
861 definition->amplfo_depth = amplfo_depth;
862
863 definition->amplfo_delay_oncc = amplfo_delay_oncc;
864 definition->amplfo_fade_oncc = amplfo_fade_oncc;
865 definition->amplfo_depthcc = amplfo_depthcc;
866 definition->amplfo_freqcc = amplfo_freqcc;
867
868 definition->fillfo_delay = fillfo_delay;
869 definition->fillfo_fade = fillfo_fade;
870 definition->fillfo_freq = fillfo_freq;
871 definition->fillfo_depth = fillfo_depth;
872
873 definition->fillfo_delay_oncc = fillfo_delay_oncc;
874 definition->fillfo_fade_oncc = fillfo_fade_oncc;
875 definition->fillfo_depthcc = fillfo_depthcc;
876 definition->fillfo_freqcc = fillfo_freqcc;
877
878 definition->pitchlfo_delay = pitchlfo_delay;
879 definition->pitchlfo_fade = pitchlfo_fade;
880 definition->pitchlfo_freq = pitchlfo_freq;
881 definition->pitchlfo_depth = pitchlfo_depth;
882
883 definition->pitchlfo_delay_oncc = pitchlfo_delay_oncc;
884 definition->pitchlfo_fade_oncc = pitchlfo_fade_oncc;
885 definition->pitchlfo_depthcc = pitchlfo_depthcc;
886 definition->pitchlfo_freqcc = pitchlfo_freqcc;
887
888 definition->eg = eg;
889 definition->lfos = lfos;
890 }
891
892 /////////////////////////////////////////////////////////////
893 // class File
894
895 const std::string File::MACRO_NAME_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
896 const std::string File::MACRO_VALUE_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_. /\\";
897
898 File::File(std::string file, SampleManager* pSampleManager) :
899 _current_section(GLOBAL),
900 id(0),
901 default_path(""),
902 octave_offset(0),
903 note_offset(0)
904 {
905 _instrument = new Instrument(LinuxSampler::Path::getBaseName(file), pSampleManager);
906 ContainerDefinition* defaultGlobalContainer = new ContainerDefinition(ContainerDefinition::GLOBAL);
907 _current_containers.push(defaultGlobalContainer);
908 pCurDef = defaultGlobalContainer;
909
910 parseFile(file,pSampleManager);
911
912 std::set<float*> velcurves;
913 for (int i = 0; i < _instrument->regions.size(); i++) {
914 ::sfz::Region* pRegion = _instrument->regions[i];
915 int low = pRegion->lokey;
916 int high = pRegion->hikey;
917 if (low != -1) { // lokey -1 means region doesn't play on note-on
918 // hikey -1 is the same as no limit, except that it
919 // also enables on_locc/on_hicc
920 if (high == -1) high = 127;
921 if (low < 0 || low > 127 || high < 0 || high > 127 || low > high) {
922 std::cerr << "Invalid key range: " << low << " - " << high << std::endl;
923 } else {
924 for (int j = low; j <= high; j++) _instrument->KeyBindings[j] = true;
925 }
926 }
927
928 // get keyswitches
929 low = pRegion->sw_lokey;
930 if (low < 0) low = 0;
931 high = pRegion->sw_hikey;
932 if (high == -1) {
933 // Key switches not defined, so nothing to do
934 } else if (low >= 0 && low <= 127 && high >= 0 && high <= 127 && high >= low) {
935 for (int j = low; j <= high; j++) _instrument->KeySwitchBindings[j] = true;
936 } else {
937 std::cerr << "Invalid key switch range: " << low << " - " << high << std::endl;
938 }
939
940 // create velocity response curve
941
942 // don't use copy-on-write here, instead change the actual
943 // unique buffers in memory
944 float* velcurve = const_cast<float*>(&pRegion->amp_velcurve[0]);
945 if (velcurves.insert(velcurve).second) {
946 int prev = 0;
947 float prevvalue = 0;
948 for (int v = 0 ; v < 128 ; v++) {
949 if (velcurve[v] >= 0) {
950 float step = (velcurve[v] - prevvalue) / (v - prev);
951 for ( ; prev < v ; prev++) {
952 velcurve[prev] = prevvalue;
953 prevvalue += step;
954 }
955 }
956 }
957 if (prev) {
958 float step = (1 - prevvalue) / (127 - prev);
959 for ( ; prev < 128 ; prev++) {
960 velcurve[prev] = prevvalue;
961 prevvalue += step;
962 }
963 } else {
964 // default curve
965 for (int v = 0 ; v < 128 ; v++) {
966 velcurve[v] = v * v / (127.0 * 127.0);
967 }
968 }
969 }
970 }
971
972 _instrument->pLookupTable = new LookupTable(_instrument);
973
974 // create separate lookup tables for controller triggered
975 // regions, one for each CC
976 for (int i = 0 ; i < 128 ; i++) {
977 _instrument->pLookupTableCC[i] = new LookupTable(_instrument, i);
978 }
979
980 for (int i = 0; i < _instrument->regions.size(); i++) {
981 Region* r = _instrument->regions[i];
982
983 copyCurves(r->volume_curvecc, r->volume_oncc);
984 r->volume_curvecc.clear();
985
986 copySmoothValues(r->volume_smoothcc, r->volume_oncc);
987 r->volume_smoothcc.clear();
988
989 copyStepValues(r->volume_stepcc, r->volume_oncc);
990 r->volume_stepcc.clear();
991
992 copyCurves(r->pitch_curvecc, r->pitch_oncc);
993 r->pitch_curvecc.clear();
994
995 copySmoothValues(r->pitch_smoothcc, r->pitch_oncc);
996 r->pitch_smoothcc.clear();
997
998 copyStepValues(r->pitch_stepcc, r->pitch_oncc);
999 r->pitch_stepcc.clear();
1000
1001 copyCurves(r->pan_curvecc, r->pan_oncc);
1002 r->pan_curvecc.clear();
1003
1004 copySmoothValues(r->pan_smoothcc, r->pan_oncc);
1005 r->pan_smoothcc.clear();
1006
1007 copyStepValues(r->pan_stepcc, r->pan_oncc);
1008 r->pan_stepcc.clear();
1009
1010 copyCurves(r->cutoff_curvecc, r->cutoff_oncc);
1011 r->cutoff_curvecc.clear();
1012
1013 copySmoothValues(r->cutoff_smoothcc, r->cutoff_oncc);
1014 r->cutoff_smoothcc.clear();
1015
1016 copyStepValues(r->cutoff_stepcc, r->cutoff_oncc);
1017 r->cutoff_stepcc.clear();
1018
1019 copyCurves(r->cutoff2_curvecc, r->cutoff2_oncc);
1020 r->cutoff2_curvecc.clear();
1021
1022 copySmoothValues(r->cutoff2_smoothcc, r->cutoff2_oncc);
1023 r->cutoff2_smoothcc.clear();
1024
1025 copyStepValues(r->cutoff2_stepcc, r->cutoff2_oncc);
1026 r->cutoff2_stepcc.clear();
1027
1028 copyCurves(r->resonance_curvecc, r->resonance_oncc);
1029 r->resonance_curvecc.clear();
1030
1031 copySmoothValues(r->resonance_smoothcc, r->resonance_oncc);
1032 r->resonance_smoothcc.clear();
1033
1034 copyStepValues(r->resonance_stepcc, r->resonance_oncc);
1035 r->resonance_stepcc.clear();
1036
1037 copyCurves(r->resonance2_curvecc, r->resonance2_oncc);
1038 r->resonance2_curvecc.clear();
1039
1040 copySmoothValues(r->resonance2_smoothcc, r->resonance2_oncc);
1041 r->resonance2_smoothcc.clear();
1042
1043 copyStepValues(r->resonance2_stepcc, r->resonance2_oncc);
1044 r->resonance2_stepcc.clear();
1045
1046 for (int j = 0; j < r->eg.size(); j++) {
1047 copyCurves(r->eg[j].pan_curvecc, r->eg[j].pan_oncc);
1048 r->eg[j].pan_curvecc.clear();
1049 }
1050
1051 for (int j = 0; j < r->lfos.size(); j++) {
1052 r->lfos[j].copySmoothValues();
1053 r->lfos[j].copyStepValues();
1054
1055 copySmoothValues(r->lfos[j].volume_smoothcc, r->lfos[j].volume_oncc);
1056 r->lfos[j].volume_smoothcc.clear();
1057
1058 copyStepValues(r->lfos[j].volume_stepcc, r->lfos[j].volume_oncc);
1059 r->lfos[j].volume_stepcc.clear();
1060
1061 copySmoothValues(r->lfos[j].freq_smoothcc, r->lfos[j].freq_oncc);
1062 r->lfos[j].freq_smoothcc.clear();
1063
1064 copyStepValues(r->lfos[j].freq_stepcc, r->lfos[j].freq_oncc);
1065 r->lfos[j].freq_stepcc.clear();
1066
1067 copySmoothValues(r->lfos[j].pitch_smoothcc, r->lfos[j].pitch_oncc);
1068 r->lfos[j].pitch_smoothcc.clear();
1069
1070 copyStepValues(r->lfos[j].pitch_stepcc, r->lfos[j].pitch_oncc);
1071 r->lfos[j].pitch_stepcc.clear();
1072
1073 copySmoothValues(r->lfos[j].pan_smoothcc, r->lfos[j].pan_oncc);
1074 r->lfos[j].pan_smoothcc.clear();
1075
1076 copyStepValues(r->lfos[j].pan_stepcc, r->lfos[j].pan_oncc);
1077 r->lfos[j].pan_stepcc.clear();
1078
1079 copySmoothValues(r->lfos[j].cutoff_smoothcc, r->lfos[j].cutoff_oncc);
1080 r->lfos[j].cutoff_smoothcc.clear();
1081
1082 copyStepValues(r->lfos[j].cutoff_stepcc, r->lfos[j].cutoff_oncc);
1083 r->lfos[j].cutoff_stepcc.clear();
1084
1085 copySmoothValues(r->lfos[j].resonance_smoothcc, r->lfos[j].resonance_oncc);
1086 r->lfos[j].resonance_smoothcc.clear();
1087
1088 copyStepValues(r->lfos[j].resonance_stepcc, r->lfos[j].resonance_oncc);
1089 r->lfos[j].resonance_stepcc.clear();
1090 }
1091 }
1092 }
1093
1094 void File::parseFile(std::string file, SampleManager* pSampleManager){
1095 enum token_type_t { HEADER, OPCODE };
1096 token_type_t token_type = (token_type_t) -1;
1097 std::string token_string;
1098
1099 std::ifstream fs(file.c_str());
1100 currentDir = LinuxSampler::Path::stripLastName(file);
1101 std::string token;
1102 std::string line;
1103 currentLine = 0;
1104
1105 while (std::getline(fs, line))
1106 {
1107 currentLine++;
1108 // COMMENT
1109 std::string::size_type slash_index = line.find("//");
1110 if (slash_index != std::string::npos)
1111 line.resize(slash_index);
1112
1113 // #include
1114 if (line.find("#include ") == 0) {
1115 size_t fname_start = line.find("\"");
1116 if (fname_start == std::string::npos) continue;
1117
1118 size_t fname_end = line.find("\"", fname_start + 1);
1119 if (fname_end == std::string::npos || fname_start == fname_end)
1120 continue;
1121 std::string fname = line.substr(fname_start + 1, fname_end - fname_start - 1);
1122
1123 if (!currentDir.empty() && !LinuxSampler::Path(fname).isAbsolute())
1124 fname = currentDir + LinuxSampler::File::DirSeparator + fname;
1125
1126 std::string cd = currentDir; // backup current dir
1127 int cl = currentLine;
1128 parseFile(fname, pSampleManager);
1129 currentDir = cd; // restore currentDir (since altered by parsefile())
1130 currentLine = cl;
1131 continue;
1132 }
1133 // #define
1134 else if (line.find("#define") == 0)
1135 {
1136
1137 size_t varname_start = line.find_first_not_of("\t ", std::strlen("#define"));
1138 size_t varname_end = line.find_first_of("\t ", varname_start + 1);
1139 size_t value_start = line.find_first_not_of("\t ", varname_end + 1);
1140
1141 std::string varname = line.substr(varname_start, varname_end - varname_start);
1142 std::string value = line.substr(value_start, std::string::npos);
1143
1144 if (varname.size() == 0 || value.size() == 0)
1145 {
1146 std::cerr << "sfz error: Malformed #define statement on line " << currentLine << std::endl;
1147 continue;
1148 }
1149
1150 // Deal with DOS EOLs
1151 if (value[value.size() - 1] == '\r')
1152 {
1153 value.erase(value.size() - 1);
1154 }
1155
1156 // Check varname
1157 if (varname[0] != '$')
1158 {
1159 std::cerr << "sfz error: Macro name '" << varname;
1160 std::cerr << "' doesn't start with '$'." << std::endl;
1161 continue;
1162 }
1163 // Invalid chars
1164 if (varname.find_first_not_of(MACRO_NAME_CHARS, 1) != std::string::npos)
1165 {
1166 std::cerr << "sfz error: Macro name '" << varname;
1167 std::cerr << "' contains invalid characters." << std::endl;
1168 }
1169
1170 // Check value
1171 // Match alphanumeric, underscore, and decimal point.
1172 if (value.find_first_not_of(MACRO_VALUE_CHARS) != std::string::npos)
1173 {
1174 std::cerr << "sfz error: Macro value '" << value;
1175 std::cerr << "' contains invalid characters." << std::endl;
1176 continue;
1177 }
1178
1179 _defined_macros[varname] = value;
1180
1181 continue;
1182 }
1183 // script=path/to/scriptfile
1184 else if (line.find("script") == 0) {
1185 size_t eq = line.find_first_of("=");
1186 if (eq == std::string::npos) {
1187 std::cerr << "sfz error: opcode 'script' misses '=' character\n";
1188 continue;
1189 }
1190 std::string value = trim( line.substr(eq+1, std::string::npos) );
1191 if (value.empty()) {
1192 std::cerr << "sfz error: empty path assigned to opcode 'script'\n";
1193 continue;
1194 }
1195 LinuxSampler::Path path = LinuxSampler::Path::fromUnknownFS(value);
1196 if (!currentDir.empty() && !path.isAbsolute())
1197 path = LinuxSampler::Path::fromUnknownFS(currentDir) + path;
1198 LinuxSampler::File file(path);
1199 if (!file.Exist()) {
1200 std::cerr << "sfz error: script file '" << value << "' does not exist\n";
1201 continue;
1202 }
1203 if (!file.IsFile()) {
1204 std::cerr << "sfz error: script '" << value << "' is not a file\n";
1205 continue;
1206 }
1207 Script script(path);
1208 _instrument->scripts.push_back(script);
1209
1210 continue;
1211 }
1212
1213 // DEFINITION
1214 std::stringstream linestream(line);
1215 int spaces = 0;
1216 while (linestream >> token)
1217 {
1218 linestream >> std::noskipws;
1219 if (token[0] == '<' && token[token.size()-1] == '>')
1220 {
1221 // HEAD
1222 if (!token_string.empty())
1223 {
1224 switch (token_type)
1225 {
1226 case HEADER:
1227 push_header(token_string);
1228 break;
1229 case OPCODE:
1230 push_opcode(token_string);
1231 break;
1232 }
1233 token_string.erase();
1234 }
1235 token_string.append(token);
1236 token_type = HEADER;
1237 }
1238 else if (token.find('=') != std::string::npos)
1239 {
1240 // HEAD
1241 if (!token_string.empty())
1242 {
1243 switch (token_type)
1244 {
1245 case HEADER:
1246 push_header(token_string);
1247 break;
1248 case OPCODE:
1249 push_opcode(token_string);
1250 break;
1251 }
1252 token_string.erase();
1253 }
1254 token_string.append(token);
1255 token_type = OPCODE;
1256 }
1257 else
1258 {
1259 // TAIL
1260 token_string.append(spaces, ' ');
1261 token_string.append(token);
1262 }
1263 spaces = 0;
1264 while (isspace(linestream.peek())) {
1265 linestream.ignore();
1266 spaces++;
1267 }
1268 }
1269
1270 // EOL
1271 if (!token_string.empty())
1272 {
1273 switch (token_type)
1274 {
1275 case HEADER:
1276 push_header(token_string);
1277 break;
1278 case OPCODE:
1279 push_opcode(token_string);
1280 break;
1281 }
1282 token_string.erase();
1283 }
1284 }
1285 }
1286
1287 File::~File()
1288 {
1289 for (int i = 0; i < _current_containers.size(); i++)
1290 {
1291 delete _current_containers.top();
1292 _current_containers.pop();
1293 }
1294 delete _instrument;
1295 }
1296
1297 Instrument*
1298 File::GetInstrument()
1299 {
1300 return _instrument;
1301 }
1302
1303 void File::copyCurves(LinuxSampler::ArrayList<CC>& curves, LinuxSampler::ArrayList<CC>& dest) {
1304 for (int i = 0; i < curves.size(); i++) {
1305 for (int j = 0; j < dest.size(); j++) {
1306 if (curves[i].Controller == dest[j].Controller) {
1307 dest[j].Curve = curves[i].Curve;
1308 }
1309 }
1310 }
1311 }
1312
1313 void File::copySmoothValues(LinuxSampler::ArrayList<CC>& smooths, LinuxSampler::ArrayList<CC>& dest) {
1314 for (int i = 0; i < smooths.size(); i++) {
1315 for (int j = 0; j < dest.size(); j++) {
1316 if (smooths[i].Controller == dest[j].Controller) {
1317 dest[j].Smooth = smooths[i].Smooth;
1318 }
1319 }
1320 }
1321 }
1322
1323 void File::copyStepValues(LinuxSampler::ArrayList<CC>& steps, LinuxSampler::ArrayList<CC>& dest) {
1324 for (int i = 0; i < steps.size(); i++) {
1325 for (int j = 0; j < dest.size(); j++) {
1326 if (steps[i].Controller == dest[j].Controller) {
1327 dest[j].Step = steps[i].Step;
1328 }
1329 }
1330 }
1331 }
1332
1333 int File::ToInt(const std::string& s) throw(LinuxSampler::Exception) {
1334 int i;
1335 std::istringstream iss(s);
1336 if(!(iss >> i)) {
1337 std::ostringstream oss;
1338 oss << "Line " << currentLine << ": Expected an integer";
1339 throw LinuxSampler::Exception(oss.str());
1340 }
1341 return i;
1342 }
1343
1344 float File::ToFloat(const std::string& s) throw(LinuxSampler::Exception) {
1345 float i;
1346 std::istringstream iss(s);
1347 if(!(iss >> i)) {
1348 std::ostringstream oss;
1349 oss << "Line " << currentLine << ": Expected a floating-point number";
1350 throw LinuxSampler::Exception(oss.str());
1351 }
1352 return i;
1353 }
1354
1355 void
1356 File::push_header(std::string token)
1357 {
1358 if (token == "<global>" ||
1359 token == "<master>" ||
1360 token == "<group>")
1361 {
1362 ContainerDefinition::section_type level = ContainerDefinition::GLOBAL; // initialized only to avoid an irrelevant compiler warning
1363
1364 if (token == "<global>")
1365 {
1366 _current_section = GLOBAL;
1367 level = ContainerDefinition::GLOBAL;
1368 }
1369 else if (token == "<master>")
1370 {
1371 _current_section = MASTER;
1372 level = ContainerDefinition::MASTER;
1373 }
1374 else if (token == "<group>")
1375 {
1376 _current_section = GROUP;
1377 level = ContainerDefinition::GROUP;
1378 }
1379
1380 ContainerDefinition* newContainer = new ContainerDefinition(level);
1381
1382 while (_current_containers.size() > 0 && _current_containers.top()->level <= level)
1383 {
1384 delete _current_containers.top();
1385 _current_containers.pop();
1386 }
1387
1388 //If the new header is a <global>, there won't be anything left in _current_containers
1389 //to copy from.
1390 if (_current_containers.size() > 0)
1391 {
1392 _current_containers.top()->CopyValuesToDefinition(newContainer);
1393 }
1394 _current_containers.push(newContainer);
1395 pCurDef = newContainer;
1396 }
1397 else if (token == "<region>")
1398 {
1399 _current_section = REGION;
1400 _current_region = new Region();
1401 _current_region->id = id++;
1402 _current_containers.top()->CopyValuesToDefinition(_current_region);
1403 pCurDef = _current_region;
1404 _instrument->regions.push_back(_current_region);
1405 _current_region->SetInstrument(_instrument);
1406 }
1407 else if (token == "<control>")
1408 {
1409 _current_section = CONTROL;
1410 default_path = "";
1411 octave_offset = 0;
1412 note_offset = 0;
1413 }
1414 else if (token == "<curve>")
1415 {
1416 _current_section = CURVE;
1417 _instrument->curves.add(Curve());
1418 _current_curve = &_instrument->curves[_instrument->curves.size() - 1];
1419 }
1420 else
1421 {
1422 _current_section = UNKNOWN;
1423 std::cerr << "The header '" << token << "' is unsupported by libsfz!" << std::endl;
1424 }
1425 }
1426
1427 void
1428 File::push_opcode(std::string token)
1429 {
1430 if (_current_section == UNKNOWN)
1431 return;
1432
1433 std::string::size_type delimiter_index = token.find('=');
1434 std::string key = token.substr(0, delimiter_index);
1435 std::string value = token.substr(delimiter_index + 1);
1436 int x, y, z;
1437
1438 // Apply macros
1439 size_t macro_start = 0;
1440 size_t macro_end = 0;
1441 std::string macro_value;
1442 while ((macro_start = value.find("$", macro_start + macro_value.size())) != std::string::npos)
1443 {
1444 macro_end = value.find_first_not_of(MACRO_NAME_CHARS, macro_start + 1);
1445 size_t macro_len = macro_end - macro_start;
1446 std::string macro_name = value.substr(macro_start, macro_len);
1447 if (_defined_macros.count(macro_name) != 0)
1448 {
1449 macro_value = _defined_macros[macro_name];
1450 value.replace(macro_start, macro_len, macro_value);
1451 }
1452 else
1453 {
1454 std::cerr << "Macro '" << macro_name << "' referenced on line ";
1455 std::cerr << currentLine << " is undefined." << std::endl;
1456 return;
1457 }
1458 }
1459
1460 if (_current_section == CURVE) {
1461 if (sscanf(key.c_str(), "v%d", &x)) {
1462 if (x < 0 || x > 127) {
1463 std::cerr << "Invalid curve index: " << x << std::endl;
1464 }
1465 _current_curve->v[x] = check(key, 0.0f, 1.0f, ToFloat(value));
1466 } else {
1467 std::cerr << "The opcode '" << key << "' in section <curve> is unsupported by libsfz!" << std::endl;
1468 }
1469
1470 return;
1471 }
1472
1473 // sample definition
1474 if ("sample" == key)
1475 {
1476 std::string path = default_path + value;
1477 #ifndef WIN32
1478 for (int i = 0; i < path.length(); i++) if (path[i] == '\\') path[i] = '/';
1479 bool absolute = path[0] == '/';
1480 #else
1481 bool absolute = path[0] == '/' || path[0] == '\\' ||
1482 (path.length() >= 2 && isalpha(path[0]) && path[1] == ':');
1483 #endif
1484 if (!absolute) path = currentDir + LinuxSampler::File::DirSeparator + path;
1485 if(pCurDef) pCurDef->sample = path;
1486 return;
1487 }
1488
1489 // control header directives
1490 else if ("default_path" == key)
1491 {
1492 switch (_current_section)
1493 {
1494 case CONTROL:
1495 default_path = value;
1496 break;
1497 default:
1498 ; // noop
1499 }
1500 return;
1501 }
1502 else if ("octave_offset" == key)
1503 {
1504 switch (_current_section)
1505 {
1506 case CONTROL:
1507 octave_offset = ToInt(value);
1508 break;
1509 default:
1510 ; // noop
1511 }
1512 return;
1513 }
1514 else if ("note_offset" == key)
1515 {
1516 switch (_current_section)
1517 {
1518 case CONTROL:
1519 note_offset = ToInt(value);
1520 break;
1521 default:
1522 ; // noop
1523 }
1524 return;
1525 }
1526
1527 // input controls
1528 else if ("lochan" == key) pCurDef->lochan = ToInt(value);
1529 else if ("hichan" == key) pCurDef->hichan = ToInt(value);
1530 else if ("lokey" == key) pCurDef->lokey = parseKey(value);
1531 else if ("hikey" == key) pCurDef->hikey = parseKey(value);
1532 else if ("key" == key)
1533 {
1534 pCurDef->lokey = pCurDef->hikey = pCurDef->pitch_keycenter = parseKey(value);
1535 }
1536 else if ("lovel" == key) pCurDef->lovel = ToInt(value);
1537 else if ("hivel" == key) pCurDef->hivel = ToInt(value);
1538 else if ("lobend" == key) pCurDef->lobend = ToInt(value);
1539 else if ("hibend" == key) pCurDef->hibend = ToInt(value);
1540 else if ("lobpm" == key) pCurDef->lobpm = ToFloat(value);
1541 else if ("hibpm" == key) pCurDef->hibpm = ToFloat(value);
1542 else if ("lochanaft" == key) pCurDef->lochanaft = ToInt(value);
1543 else if ("hichanaft" == key) pCurDef->hichanaft = ToInt(value);
1544 else if ("lopolyaft" == key) pCurDef->lopolyaft = ToInt(value);
1545 else if ("hipolyaft" == key) pCurDef->hipolyaft = ToInt(value);
1546 else if ("loprog" == key) pCurDef->loprog = ToInt(value);
1547 else if ("hiprog" == key) pCurDef->hiprog = ToInt(value);
1548 else if ("lorand" == key) pCurDef->lorand = ToFloat(value);
1549 else if ("hirand" == key) pCurDef->hirand = ToFloat(value);
1550 else if ("lotimer" == key) pCurDef->lotimer = ToFloat(value);
1551 else if ("hitimer" == key) pCurDef->hitimer = ToFloat(value);
1552 else if ("seq_length" == key) pCurDef->seq_length = ToInt(value);
1553 else if ("seq_position" == key) pCurDef->seq_position = ToInt(value);
1554 else if ("sw_lokey" == key) pCurDef->sw_lokey = parseKey(value);
1555 else if ("sw_hikey" == key) pCurDef->sw_hikey = parseKey(value);
1556 else if ("sw_last" == key) pCurDef->sw_last = parseKey(value);
1557 else if ("sw_down" == key) pCurDef->sw_down = parseKey(value);
1558 else if ("sw_up" == key) pCurDef->sw_up = parseKey(value);
1559 else if ("sw_previous" == key) pCurDef->sw_previous = parseKey(value);
1560 else if ("sw_vel" == key)
1561 {
1562 if (value == "current") pCurDef->sw_vel = VEL_CURRENT;
1563 else if (value == "previous") pCurDef->sw_vel = VEL_PREVIOUS;
1564 }
1565 else if ("trigger" == key)
1566 {
1567 if (value == "attack") pCurDef->trigger = TRIGGER_ATTACK;
1568 else if (value == "release") pCurDef->trigger = TRIGGER_RELEASE;
1569 else if (value == "first") pCurDef->trigger = TRIGGER_FIRST;
1570 else if (value == "legato") pCurDef->trigger = TRIGGER_LEGATO;
1571 }
1572 else if ("group" == key) pCurDef->group = ToInt(value);
1573 else if ("off_by" == key || "offby" == key) pCurDef->off_by = ToInt(value);
1574 else if ("off_mode" == key || "offmode" == key)
1575 {
1576 if (value == "fast") pCurDef->off_mode = OFF_FAST;
1577 else if (value == "normal") pCurDef->off_mode = OFF_NORMAL;
1578 }
1579
1580 // sample player
1581 else if ("count" == key) { pCurDef->count = ToInt(value); pCurDef->loop_mode = ONE_SHOT; }
1582 else if ("delay" == key) pCurDef->delay = ToFloat(value);
1583 else if ("delay_random" == key) pCurDef->delay_random = ToFloat(value);
1584 else if ("delay_beats" == key) pCurDef->delay_beats = ToInt(value);
1585 else if ("stop_beats" == key) pCurDef->stop_beats = ToInt(value);
1586 else if ("delay_samples" == key) pCurDef->delay_samples = ToInt(value);
1587 else if ("end" == key) pCurDef->end = ToInt(value);
1588 else if ("loop_crossfade" == key) pCurDef->loop_crossfade = ToFloat(value);
1589 else if ("offset_random" == key) pCurDef->offset_random = ToInt(value);
1590 else if ("loop_mode" == key || "loopmode" == key)
1591 {
1592 if (value == "no_loop") pCurDef->loop_mode = NO_LOOP;
1593 else if (value == "one_shot") pCurDef->loop_mode = ONE_SHOT;
1594 else if (value == "loop_continuous") pCurDef->loop_mode = LOOP_CONTINUOUS;
1595 else if (value == "loop_sustain") pCurDef->loop_mode = LOOP_SUSTAIN;
1596 }
1597 else if ("loop_start" == key) pCurDef->loop_start = ToInt(value);
1598 else if ("loopstart" == key) pCurDef->loop_start = ToInt(value); // nonstandard
1599 else if ("loop_end" == key) pCurDef->loop_end = ToInt(value);
1600 else if ("loopend" == key) pCurDef->loop_end = ToInt(value); // nonstandard
1601 else if ("offset" == key) pCurDef->offset = ToInt(value);
1602 else if ("sync_beats" == key) pCurDef->sync_beats = ToInt(value);
1603 else if ("sync_offset" == key) pCurDef->sync_offset = ToInt(value);
1604
1605 // amplifier
1606 else if ("volume" == key) pCurDef->volume = ToFloat(value);
1607 else if ("amplitude" == key) pCurDef->amplitude = ToFloat(value);
1608 else if ("pan" == key) pCurDef->pan = ToFloat(value);
1609 else if ("width" == key) pCurDef->width = ToFloat(value);
1610 else if ("position" == key) pCurDef->position = ToFloat(value);
1611 else if ("amp_keytrack" == key) pCurDef->amp_keytrack = ToFloat(value);
1612 else if ("amp_keycenter" == key) pCurDef->amp_keycenter = parseKey(value);
1613 else if ("amp_veltrack" == key) pCurDef->amp_veltrack = ToFloat(value);
1614 else if ("amp_random" == key) pCurDef->amp_random = ToFloat(value);
1615 else if ("rt_decay" == key || "rtdecay" == key) pCurDef->rt_decay = ToFloat(value);
1616 else if ("xfin_lokey" == key) pCurDef->xfin_lokey = parseKey(value);
1617 else if ("xfin_hikey" == key) pCurDef->xfin_hikey = parseKey(value);
1618 else if ("xfout_lokey" == key) pCurDef->xfout_lokey = parseKey(value);
1619 else if ("xfout_hikey" == key) pCurDef->xfout_hikey = parseKey(value);
1620 else if ("xf_keycurve" == key)
1621 {
1622 if (value == "gain") pCurDef->xf_keycurve = GAIN;
1623 else if (value == "power") pCurDef->xf_keycurve = POWER;
1624 }
1625 else if ("xfin_lovel" == key) pCurDef->xfin_lovel = ToInt(value);
1626 else if ("xfin_hivel" == key) pCurDef->xfin_hivel = ToInt(value);
1627 else if ("xfout_lovel" == key) pCurDef->xfout_lovel = ToInt(value);
1628 else if ("xfout_hivel" == key) pCurDef->xfout_hivel = ToInt(value);
1629 else if ("xf_velcurve" == key)
1630 {
1631 if (value == "gain") pCurDef->xf_velcurve = GAIN;
1632 else if (value == "power") pCurDef->xf_velcurve = POWER;
1633 }
1634 else if ("xf_cccurve" == key)
1635 {
1636 if (value == "gain") pCurDef->xf_cccurve = GAIN;
1637 else if (value == "power") pCurDef->xf_cccurve = POWER;
1638 }
1639
1640 // pitch
1641 else if ("transpose" == key) pCurDef->transpose = ToInt(value);
1642 else if ("tune" == key) pCurDef->tune = ToInt(value);
1643 else if ("pitch_keycenter" == key) pCurDef->pitch_keycenter = parseKey(value);
1644 else if ("pitch_keytrack" == key) pCurDef->pitch_keytrack = ToInt(value);
1645 else if ("pitch_veltrack" == key) pCurDef->pitch_veltrack = ToInt(value);
1646 else if ("pitch_random" == key) pCurDef->pitch_random = ToInt(value);
1647 else if ("bend_up" == key || "bendup" == key) pCurDef->bend_up = ToInt(value);
1648 else if ("bend_down" == key || "benddown" == key) pCurDef->bend_down = ToInt(value);
1649 else if ("bend_step" == key || "bendstep" == key) pCurDef->bend_step = ToInt(value);
1650
1651 // filter
1652 else if ("fil_type" == key || "filtype" == key)
1653 {
1654 if (value == "lpf_1p") pCurDef->fil_type = LPF_1P;
1655 else if (value == "hpf_1p") pCurDef->fil_type = HPF_1P;
1656 else if (value == "bpf_1p") pCurDef->fil_type = BPF_1P;
1657 else if (value == "brf_1p") pCurDef->fil_type = BRF_1P;
1658 else if (value == "apf_1p") pCurDef->fil_type = APF_1P;
1659 else if (value == "lpf_2p") pCurDef->fil_type = LPF_2P;
1660 else if (value == "hpf_2p") pCurDef->fil_type = HPF_2P;
1661 else if (value == "bpf_2p") pCurDef->fil_type = BPF_2P;
1662 else if (value == "brf_2p") pCurDef->fil_type = BRF_2P;
1663 else if (value == "pkf_2p") pCurDef->fil_type = PKF_2P;
1664 else if (value == "lpf_4p") pCurDef->fil_type = LPF_4P;
1665 else if (value == "hpf_4p") pCurDef->fil_type = HPF_4P;
1666 else if (value == "lpf_6p") pCurDef->fil_type = LPF_6P;
1667 else if (value == "hpf_6p") pCurDef->fil_type = HPF_6P;
1668 }
1669 else if ("fil2_type" == key)
1670 {
1671 if (value == "lpf_1p") pCurDef->fil2_type = LPF_1P;
1672 else if (value == "hpf_1p") pCurDef->fil2_type = HPF_1P;
1673 else if (value == "bpf_1p") pCurDef->fil2_type = BPF_1P;
1674 else if (value == "brf_1p") pCurDef->fil2_type = BRF_1P;
1675 else if (value == "apf_1p") pCurDef->fil2_type = APF_1P;
1676 else if (value == "lpf_2p") pCurDef->fil2_type = LPF_2P;
1677 else if (value == "hpf_2p") pCurDef->fil2_type = HPF_2P;
1678 else if (value == "bpf_2p") pCurDef->fil2_type = BPF_2P;
1679 else if (value == "brf_2p") pCurDef->fil2_type = BRF_2P;
1680 else if (value == "pkf_2p") pCurDef->fil2_type = PKF_2P;
1681 else if (value == "lpf_4p") pCurDef->fil2_type = LPF_4P;
1682 else if (value == "hpf_4p") pCurDef->fil2_type = HPF_4P;
1683 else if (value == "lpf_6p") pCurDef->fil2_type = LPF_6P;
1684 else if (value == "hpf_6p") pCurDef->fil2_type = HPF_6P;
1685 }
1686 else if ("cutoff" == key) pCurDef->cutoff = ToFloat(value);
1687 else if ("cutoff2" == key) pCurDef->cutoff2 = ToFloat(value);
1688 else if ("cutoff_chanaft" == key) {
1689 pCurDef->cutoff_chanaft = check(key, -9600, 9600, ToInt(value));
1690 pCurDef->cutoff_oncc.add( CC(128, check(key, -9600, 9600, ToInt(value))) );
1691 } else if ("cutoff2_chanaft" == key) pCurDef->cutoff2_chanaft = ToInt(value);
1692 else if ("cutoff_polyaft" == key) pCurDef->cutoff_polyaft = ToInt(value);
1693 else if ("cutoff2_polyaft" == key) pCurDef->cutoff2_polyaft = ToInt(value);
1694 else if ("resonance" == key) pCurDef->resonance = ToFloat(value);
1695 else if ("resonance2" == key) pCurDef->resonance2 = ToFloat(value);
1696 else if ("fil_keytrack" == key) pCurDef->fil_keytrack = ToInt(value);
1697 else if ("fil2_keytrack" == key) pCurDef->fil2_keytrack = ToInt(value);
1698 else if ("fil_keycenter" == key) pCurDef->fil_keycenter = parseKey(value);
1699 else if ("fil2_keycenter" == key) pCurDef->fil2_keycenter = parseKey(value);
1700 else if ("fil_veltrack" == key) pCurDef->fil_veltrack = ToInt(value);
1701 else if ("fil2_veltrack" == key) pCurDef->fil2_veltrack = ToInt(value);
1702 else if ("fil_random" == key) pCurDef->fil_random = ToInt(value);
1703 else if ("fil2_random" == key) pCurDef->fil2_random = ToInt(value);
1704
1705 // per voice equalizer
1706 else if ("eq1_freq" == key) pCurDef->eq1_freq = ToFloat(value);
1707 else if ("eq2_freq" == key) pCurDef->eq2_freq = ToFloat(value);
1708 else if ("eq3_freq" == key) pCurDef->eq3_freq = ToFloat(value);
1709 else if ("eq1_vel2freq" == key) pCurDef->eq1_vel2freq = ToFloat(value);
1710 else if ("eq2_vel2freq" == key) pCurDef->eq2_vel2freq = ToFloat(value);
1711 else if ("eq3_vel2freq" == key) pCurDef->eq3_vel2freq = ToFloat(value);
1712 else if ("eq1_bw" == key) pCurDef->eq1_bw = ToFloat(value);
1713 else if ("eq2_bw" == key) pCurDef->eq2_bw = ToFloat(value);
1714 else if ("eq3_bw" == key) pCurDef->eq3_bw = ToFloat(value);
1715 else if ("eq1_gain" == key) pCurDef->eq1_gain = ToFloat(value);
1716 else if ("eq2_gain" == key) pCurDef->eq2_gain = ToFloat(value);
1717 else if ("eq3_gain" == key) pCurDef->eq3_gain = ToFloat(value);
1718 else if ("eq1_vel2gain" == key) pCurDef->eq1_vel2gain = ToFloat(value);
1719 else if ("eq2_vel2gain" == key) pCurDef->eq2_vel2gain = ToFloat(value);
1720 else if ("eq3_vel2gain" == key) pCurDef->eq3_vel2gain = ToFloat(value);
1721
1722 else if (sscanf(key.c_str(), "amp_velcurve_%d", &x)) {
1723 pCurDef->amp_velcurve.set(x, ToFloat(value));
1724 }
1725
1726 // v2 envelope generators
1727 else if (sscanf(key.c_str(), "eg%d%n", &x, &y)) {
1728 const char* s = key.c_str() + y;
1729 if (sscanf(s, "_time%d%n", &y, &z)) {
1730 const char* s2 = s + z;
1731 if (strcmp(s2, "") == 0) egnode(x, y).time = check(key, 0.0f, 100.0f, ToFloat(value));
1732 else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).time_oncc.add( CC(z, check(key, 0.0f, 100.0f, ToFloat(value))) );
1733 } else if (sscanf(s, "_level%d%n", &y, &z)) {
1734 const char* s2 = s + z;
1735 if (strcmp(s2, "") == 0) egnode(x, y).level = check(key, 0.0f, 1.0f, ToFloat(value));
1736 else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).level_oncc.add( CC(z, check(key, 0.0f, 1.0f, ToFloat(value))) );
1737 }
1738 else if (sscanf(s, "_shape%d", &y)) egnode(x, y).shape = ToFloat(value);
1739 else if (sscanf(s, "_curve%d", &y)) egnode(x, y).curve = ToFloat(value);
1740 else if (strcmp(s, "_sustain") == 0) eg(x).sustain = ToInt(value);
1741 else if (strcmp(s, "_loop") == 0) eg(x).loop = ToInt(value);
1742 else if (strcmp(s, "_loop_count") == 0) eg(x).loop_count = ToInt(value);
1743 else if (strcmp(s, "_amplitude") == 0) eg(x).amplitude = ToFloat(value);
1744 else if (sscanf(s, "_amplitude_oncc%d", &y)) eg(x).amplitude_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1745 else if (strcmp(s, "_volume") == 0) eg(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1746 else if (sscanf(s, "_volume_oncc%d", &y)) eg(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1747 else if (strcmp(s, "_cutoff") == 0) eg(x).cutoff = ToFloat(value);
1748 else if (sscanf(s, "_cutoff_oncc%d", &y)) eg(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1749 else if (strcmp(s, "_pitch") == 0) eg(x).pitch = check(key, -9600, 9600, ToInt(value));
1750 else if (sscanf(s, "_pitch_oncc%d", &y)) eg(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1751 else if (strcmp(s, "_resonance") == 0) eg(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1752 else if (sscanf(s, "_resonance_oncc%d", &y)) eg(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1753 else if (strcmp(s, "_pan") == 0) eg(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1754 else if (strcmp(s, "_pan_curve") == 0) eg(x).pan_curve = check(key, 0, 30000, ToInt(value));
1755 else if (sscanf(s, "_pan_oncc%d", &y)) eg(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1756 else if (sscanf(s, "_pan_curvecc%d", &y)) eg(x).pan_curvecc.add( CC(y, 0.0f, check(key, 0, 30000, ToInt(value))) );
1757 else if (strcmp(s, "_eq1freq") == 0) eg(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1758 else if (strcmp(s, "_eq2freq") == 0) eg(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1759 else if (strcmp(s, "_eq3freq") == 0) eg(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1760 else if (strcmp(s, "_eq1bw") == 0) eg(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1761 else if (strcmp(s, "_eq2bw") == 0) eg(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1762 else if (strcmp(s, "_eq3bw") == 0) eg(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1763 else if (strcmp(s, "_eq1gain") == 0) eg(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1764 else if (strcmp(s, "_eq2gain") == 0) eg(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1765 else if (strcmp(s, "_eq3gain") == 0) eg(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1766 else if (sscanf(s, "_eq1freq_oncc%d", &y)) eg(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1767 else if (sscanf(s, "_eq2freq_oncc%d", &y)) eg(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1768 else if (sscanf(s, "_eq3freq_oncc%d", &y)) eg(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1769 else if (sscanf(s, "_eq1bw_oncc%d", &y)) eg(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1770 else if (sscanf(s, "_eq2bw_oncc%d", &y)) eg(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1771 else if (sscanf(s, "_eq3bw_oncc%d", &y)) eg(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1772 else if (sscanf(s, "_eq1gain_oncc%d", &y)) eg(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1773 else if (sscanf(s, "_eq2gain_oncc%d", &y)) eg(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1774 else if (sscanf(s, "_eq3gain_oncc%d", &y)) eg(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1775 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1776 }
1777
1778 // v1 envelope generators
1779 else if ("ampeg_delay" == key) pCurDef->ampeg_delay = ToFloat(value);
1780 else if ("ampeg_start" == key) pCurDef->ampeg_start = ToFloat(value);
1781 else if ("ampeg_attack" == key) pCurDef->ampeg_attack = ToFloat(value);
1782 else if ("ampeg_hold" == key) pCurDef->ampeg_hold = ToFloat(value);
1783 else if ("ampeg_decay" == key) pCurDef->ampeg_decay = ToFloat(value);
1784 else if ("ampeg_sustain" == key) pCurDef->ampeg_sustain = ToFloat(value);
1785 else if ("ampeg_release" == key) pCurDef->ampeg_release = ToFloat(value);
1786 else if ("ampeg_vel2delay" == key) pCurDef->ampeg_vel2delay = ToFloat(value);
1787 else if ("ampeg_vel2attack" == key) pCurDef->ampeg_vel2attack = ToFloat(value);
1788 else if ("ampeg_vel2hold" == key) pCurDef->ampeg_vel2hold = ToFloat(value);
1789 else if ("ampeg_vel2decay" == key) pCurDef->ampeg_vel2decay = ToFloat(value);
1790 else if ("ampeg_vel2sustain" == key) pCurDef->ampeg_vel2sustain = ToFloat(value);
1791 else if ("ampeg_vel2release" == key) pCurDef->ampeg_vel2release = ToFloat(value);
1792 else if ("fileg_delay" == key) pCurDef->fileg_delay = ToFloat(value);
1793 else if ("fileg_start" == key) pCurDef->fileg_start = ToFloat(value);
1794 else if ("fileg_attack" == key) pCurDef->fileg_attack = ToFloat(value);
1795 else if ("fileg_hold" == key) pCurDef->fileg_hold = ToFloat(value);
1796 else if ("fileg_decay" == key) pCurDef->fileg_decay = ToFloat(value);
1797 else if ("fileg_sustain" == key) pCurDef->fileg_sustain = ToFloat(value);
1798 else if ("fileg_release" == key) pCurDef->fileg_release = ToFloat(value);
1799 else if ("fileg_depth" == key) pCurDef->fileg_depth = check(key, -12000, 12000, ToInt(value));
1800 else if ("fileg_vel2delay" == key) pCurDef->fileg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1801 else if ("fileg_vel2attack" == key) pCurDef->fileg_vel2attack = ToFloat(value);
1802 else if ("fileg_vel2hold" == key) pCurDef->fileg_vel2hold = ToFloat(value);
1803 else if ("fileg_vel2decay" == key) pCurDef->fileg_vel2decay = ToFloat(value);
1804 else if ("fileg_vel2sustain" == key) pCurDef->fileg_vel2sustain = ToFloat(value);
1805 else if ("fileg_vel2release" == key) pCurDef->fileg_vel2release = ToFloat(value);
1806 else if ("pitcheg_delay" == key) pCurDef->pitcheg_delay = ToFloat(value);
1807 else if ("pitcheg_start" == key) pCurDef->pitcheg_start = ToFloat(value);
1808 else if ("pitcheg_attack" == key) pCurDef->pitcheg_attack = ToFloat(value);
1809 else if ("pitcheg_hold" == key) pCurDef->pitcheg_hold = ToFloat(value);
1810 else if ("pitcheg_decay" == key) pCurDef->pitcheg_decay = ToFloat(value);
1811 else if ("pitcheg_sustain" == key) pCurDef->pitcheg_sustain = ToFloat(value);
1812 else if ("pitcheg_release" == key) pCurDef->pitcheg_release = ToFloat(value);
1813 else if ("pitcheg_depth" == key) pCurDef->pitcheg_depth = check(key, -12000, 12000, ToInt(value));
1814 else if ("pitcheg_vel2delay" == key) pCurDef->pitcheg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1815 else if ("pitcheg_vel2attack" == key) pCurDef->pitcheg_vel2attack = ToFloat(value);
1816 else if ("pitcheg_vel2hold" == key) pCurDef->pitcheg_vel2hold = ToFloat(value);
1817 else if ("pitcheg_vel2decay" == key) pCurDef->pitcheg_vel2decay = ToFloat(value);
1818 else if ("pitcheg_vel2sustain" == key) pCurDef->pitcheg_vel2sustain = ToFloat(value);
1819 else if ("pitcheg_vel2release" == key) pCurDef->pitcheg_vel2release = ToFloat(value);
1820
1821
1822 // v1 LFO
1823 else if ("amplfo_delay" == key) pCurDef->amplfo_delay = ToFloat(value);
1824 else if ("amplfo_fade" == key) pCurDef->amplfo_fade = ToFloat(value);
1825 else if ("amplfo_freq" == key) pCurDef->amplfo_freq = ToFloat(value);
1826 else if ("amplfo_freqchanaft" == key) pCurDef->amplfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1827 else if ("amplfo_depth" == key) pCurDef->amplfo_depth = ToFloat(value);
1828 else if ("amplfo_depthchanaft" == key) pCurDef->amplfo_depthcc.add( CC(128, check(key, -10.0f, 10.0f, ToFloat(value))) );
1829 else if ("fillfo_delay" == key) pCurDef->fillfo_delay = ToFloat(value);
1830 else if ("fillfo_fade" == key) pCurDef->fillfo_fade = ToFloat(value);
1831 else if ("fillfo_freq" == key) pCurDef->fillfo_freq = ToFloat(value);
1832 else if ("fillfo_freqchanaft" == key) pCurDef->fillfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1833 else if ("fillfo_depth" == key) pCurDef->fillfo_depth = ToFloat(value);
1834 else if ("fillfo_depthchanaft" == key) pCurDef->fillfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1835 else if ("pitchlfo_delay" == key) pCurDef->pitchlfo_delay = ToFloat(value);
1836 else if ("pitchlfo_fade" == key) pCurDef->pitchlfo_fade = ToFloat(value);
1837 else if ("pitchlfo_freq" == key) pCurDef->pitchlfo_freq = ToFloat(value);
1838 else if ("pitchlfo_freqchanaft" == key) pCurDef->pitchlfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1839 else if ("pitchlfo_depth" == key) pCurDef->pitchlfo_depth = ToInt(value);
1840 else if ("pitchlfo_depthchanaft" == key) pCurDef->pitchlfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1841
1842
1843 // v2 LFO
1844 else if (sscanf(key.c_str(), "lfo%d%n", &x, &y)) {
1845 const char* s = key.c_str() + y;
1846 if (strcmp(s, "_freq") == 0) lfo(x).freq = check(key, 0.0f, 20.0f, ToFloat(value));
1847 else if (sscanf(s, "_freq_oncc%d", &y)) lfo(x).freq_oncc.add( CC(y, check(key, 0.0f, 20.0f, ToFloat(value))) );
1848 else if (sscanf(s, "_freq_smoothcc%d", &y)) lfo(x).freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1849 else if (sscanf(s, "_freq_stepcc%d", &y)) lfo(x).freq_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 20.0f, ToFloat(value))) );
1850 else if (strcmp(s, "_wave") == 0) lfo(x).wave = ToInt(value);
1851 else if (strcmp(s, "_delay") == 0) lfo(x).delay = check(key, 0.0f, 100.0f, ToFloat(value));
1852 else if (sscanf(s, "_delay_oncc%d", &y)) lfo(x).delay_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1853 else if (strcmp(s, "_fade") == 0) lfo(x).fade = check(key, 0.0f, 100.0f, ToFloat(value));
1854 else if (sscanf(s, "_fade_oncc%d", &y)) lfo(x).fade_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1855 else if (strcmp(s, "_phase") == 0) lfo(x).phase = check(key, 0.0f, 360.0f, ToFloat(value));
1856 else if (sscanf(s, "_phase_oncc%d", &y)) lfo(x).phase_oncc.add( CC(y, check(key, 0.0f, 360.0f, ToFloat(value))) );
1857 else if (strcmp(s, "_volume") == 0) lfo(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1858 else if (sscanf(s, "_volume_oncc%d", &y)) lfo(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1859 else if (sscanf(s, "_volume_smoothcc%d", &y)) lfo(x).volume_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1860 else if (sscanf(s, "_volume_stepcc%d", &y)) lfo(x).volume_stepcc.add( CC(y, 0, -1, 0, check(key, -20.0f, 20.0f, ToFloat(value))) );
1861 else if (strcmp(s, "_pitch") == 0) lfo(x).pitch = check(key, -9600, 9600, ToInt(value));
1862 else if (sscanf(s, "_pitch_oncc%d", &y)) lfo(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1863 else if (sscanf(s, "_pitch_smoothcc%d", &y)) lfo(x).pitch_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1864 else if (sscanf(s, "_pitch_stepcc%d", &y)) lfo(x).pitch_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1865 else if (strcmp(s, "_cutoff") == 0) lfo(x).cutoff = check(key, -9600, 9600, ToInt(value));
1866 else if (sscanf(s, "_cutoff_oncc%d", &y)) lfo(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1867 else if (sscanf(s, "_cutoff_smoothcc%d", &y)) lfo(x).cutoff_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1868 else if (sscanf(s, "_cutoff_stepcc%d", &y)) lfo(x).cutoff_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1869 else if (strcmp(s, "_resonance") == 0) lfo(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1870 else if (sscanf(s, "_resonance_oncc%d", &y)) lfo(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1871 else if (sscanf(s, "_resonance_smoothcc%d", &y)) lfo(x).resonance_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1872 else if (sscanf(s, "_resonance_stepcc%d", &y)) lfo(x).resonance_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1873 else if (strcmp(s, "_pan") == 0) lfo(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1874 else if (sscanf(s, "_pan_oncc%d", &y)) lfo(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1875 else if (sscanf(s, "_pan_smoothcc%d", &y)) lfo(x).pan_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1876 else if (sscanf(s, "_pan_stepcc%d", &y)) lfo(x).pan_stepcc.add( CC(y, 0, -1, 0, check(key, -100.0f, 100.0f, ToFloat(value))) );
1877 else if (strcmp(s, "_eq1freq") == 0) lfo(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1878 else if (strcmp(s, "_eq2freq") == 0) lfo(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1879 else if (strcmp(s, "_eq3freq") == 0) lfo(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1880 else if (strcmp(s, "_eq1bw") == 0) lfo(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1881 else if (strcmp(s, "_eq2bw") == 0) lfo(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1882 else if (strcmp(s, "_eq3bw") == 0) lfo(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1883 else if (strcmp(s, "_eq1gain") == 0) lfo(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1884 else if (strcmp(s, "_eq2gain") == 0) lfo(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1885 else if (strcmp(s, "_eq3gain") == 0) lfo(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1886 else if (sscanf(s, "_eq1freq_oncc%d", &y)) lfo(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1887 else if (sscanf(s, "_eq1freq_smoothcc%d", &y)) lfo(x).eq1freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1888 else if (sscanf(s, "_eq1freq_stepcc%d", &y)) lfo(x).eq1freq_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1889 else if (sscanf(s, "_eq2freq_oncc%d", &y)) lfo(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1890 else if (sscanf(s, "_eq2freq_smoothcc%d", &y)) lfo(x).eq2freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1891 else if (sscanf(s, "_eq2freq_stepcc%d", &y)) lfo(x).eq2freq_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1892 else if (sscanf(s, "_eq3freq_oncc%d", &y)) lfo(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1893 else if (sscanf(s, "_eq3freq_smoothcc%d", &y)) lfo(x).eq3freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1894 else if (sscanf(s, "_eq3freq_stepcc%d", &y)) lfo(x).eq3freq_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1895 else if (sscanf(s, "_eq1bw_oncc%d", &y)) lfo(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1896 else if (sscanf(s, "_eq1bw_smoothcc%d", &y)) lfo(x).eq1bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1897 else if (sscanf(s, "_eq1bw_stepcc%d", &y)) lfo(x).eq1bw_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1898 else if (sscanf(s, "_eq2bw_oncc%d", &y)) lfo(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1899 else if (sscanf(s, "_eq2bw_smoothcc%d", &y)) lfo(x).eq2bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1900 else if (sscanf(s, "_eq2bw_stepcc%d", &y)) lfo(x).eq2bw_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1901 else if (sscanf(s, "_eq3bw_oncc%d", &y)) lfo(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1902 else if (sscanf(s, "_eq3bw_smoothcc%d", &y)) lfo(x).eq3bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1903 else if (sscanf(s, "_eq3bw_stepcc%d", &y)) lfo(x).eq3bw_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1904 else if (sscanf(s, "_eq1gain_oncc%d", &y)) lfo(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1905 else if (sscanf(s, "_eq1gain_smoothcc%d", &y)) lfo(x).eq1gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1906 else if (sscanf(s, "_eq1gain_stepcc%d", &y)) lfo(x).eq1gain_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1907 else if (sscanf(s, "_eq2gain_oncc%d", &y)) lfo(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1908 else if (sscanf(s, "_eq2gain_smoothcc%d", &y)) lfo(x).eq2gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1909 else if (sscanf(s, "_eq2gain_stepcc%d", &y)) lfo(x).eq2gain_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1910 else if (sscanf(s, "_eq3gain_oncc%d", &y)) lfo(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1911 else if (sscanf(s, "_eq3gain_smoothcc%d", &y)) lfo(x).eq3gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1912 else if (sscanf(s, "_eq3gain_stepcc%d", &y)) lfo(x).eq3gain_stepcc.add( CC(y, 0, -1, 0, check(key, 0.0f, 4294967296.0f, ToFloat(value))) );
1913 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1914 }
1915
1916 // CCs
1917 else if (key.find("cc") != std::string::npos)
1918 {
1919 std::string::size_type delimiter_index = key.find("cc");
1920 std::string key_cc = key.substr(0, delimiter_index);
1921 if (key_cc.size() > 3 && !strcmp(key_cc.c_str() + (key_cc.size() - 3), "_on")) {
1922 key_cc = key_cc.substr(0, key_cc.size() - 3);
1923 }
1924
1925 // Apply macros
1926 std::string num_cc_str = key.substr(delimiter_index + 2);
1927
1928 if (num_cc_str[0] == '$')
1929 {
1930 if (_defined_macros.count(num_cc_str) == 0)
1931 {
1932 std::cerr << "Macro '" << value << "' referenced on line ";
1933 std::cerr << currentLine << " is undefined." << std::endl;
1934 return;
1935 }
1936
1937 num_cc_str = _defined_macros[num_cc_str];
1938 }
1939
1940 int num_cc = ToInt(num_cc_str);
1941 if (num_cc < 0 || num_cc > 127) {
1942 std::cerr << "sfz: WARNING: CC " << num_cc << " of opcode '" << key;
1943 std::cerr << "' is an invalid MIDI controller number." << std::endl;
1944 }
1945
1946 // input controls
1947 if ("lo" == key_cc) pCurDef->locc.set(num_cc, ToInt(value));
1948 else if ("hi" == key_cc) pCurDef->hicc.set(num_cc, ToInt(value));
1949 else if ("start_lo" == key_cc) pCurDef->start_locc.set(num_cc, ToInt(value));
1950 else if ("start_hi" == key_cc) pCurDef->start_hicc.set(num_cc, ToInt(value));
1951 else if ("stop_lo" == key_cc) pCurDef->stop_locc.set(num_cc, ToInt(value));
1952 else if ("stop_hi" == key_cc) pCurDef->stop_hicc.set(num_cc, ToInt(value));
1953 else if ("on_lo" == key_cc) pCurDef->on_locc.set(num_cc, ToInt(value));
1954 else if ("on_hi" == key_cc) pCurDef->on_hicc.set(num_cc, ToInt(value));
1955
1956 // sample player
1957 else if ("delay" == key_cc) pCurDef->delay_oncc.set(num_cc, ToFloat(value));
1958 else if ("delay_samples" == key_cc) pCurDef->delay_samples_oncc.set(num_cc, ToInt(value));
1959 else if ("offset" == key_cc) pCurDef->offset_oncc.set(num_cc, ToInt(value));
1960
1961 // amplifier
1962 else if ("gain" == key_cc || "gain_" == key_cc) pCurDef->gain_oncc.set(num_cc, ToFloat(value));
1963 else if ("xfin_lo" == key_cc) pCurDef->xfin_locc.set(num_cc, ToInt(value));
1964 else if ("xfin_hi" == key_cc) pCurDef->xfin_hicc.set(num_cc, ToInt(value));
1965 else if ("xfout_lo" == key_cc) pCurDef->xfout_locc.set(num_cc, ToInt(value));
1966 else if ("xfout_hi" == key_cc) pCurDef->xfout_hicc.set(num_cc, ToInt(value));
1967
1968 // pitch
1969 else if ("pitch" == key_cc) pCurDef->pitch_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1970 else if ("pitch_smooth" == key_cc) pCurDef->pitch_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1971 else if ("pitch_curve" == key_cc) pCurDef->pitch_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1972 else if ("pitch_step" == key_cc) pCurDef->pitch_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0, 1200, ToInt(value))) );
1973
1974 // filter
1975 else if ("cutoff" == key_cc || "cutoff_" == key_cc) {
1976 pCurDef->cutoff_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1977 } else if ("cutoff2" == key_cc) pCurDef->cutoff2_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1978 else if ("cutoff_smooth" == key_cc) pCurDef->cutoff_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1979 else if ("cutoff2_smooth" == key_cc) pCurDef->cutoff2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1980 else if ("cutoff_step" == key_cc) pCurDef->cutoff_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1981 else if ("cutoff2_step" == key_cc) pCurDef->cutoff2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1982 else if ("cutoff_curve" == key_cc) pCurDef->cutoff_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1983 else if ("cutoff2_curve" == key_cc) pCurDef->cutoff2_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1984 else if ("resonance" == key_cc) pCurDef->resonance_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1985 else if ("resonance2" == key_cc) pCurDef->resonance2_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1986 else if ("resonance_smooth" == key_cc) pCurDef->resonance_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1987 else if ("resonance2_smooth" == key_cc) pCurDef->resonance2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1988 else if ("resonance_step" == key_cc) pCurDef->resonance_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1989 else if ("resonance2_step" == key_cc) pCurDef->resonance2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1990 else if ("resonance_curve" == key_cc) pCurDef->resonance_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1991 else if ("resonance2_curve" == key_cc) pCurDef->resonance2_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1992
1993 // per voice equalizer
1994 else if ("eq1_freq" == key_cc) pCurDef->eq1_freq_oncc.set(num_cc, ToInt(value));
1995 else if ("eq2_freq" == key_cc) pCurDef->eq2_freq_oncc.set(num_cc, ToInt(value));
1996 else if ("eq3_freq" == key_cc) pCurDef->eq3_freq_oncc.set(num_cc, ToInt(value));
1997 else if ("eq1_bw" == key_cc) pCurDef->eq1_bw_oncc.set(num_cc, ToInt(value));
1998 else if ("eq2_bw" == key_cc) pCurDef->eq2_bw_oncc.set(num_cc, ToInt(value));
1999 else if ("eq3_bw" == key_cc) pCurDef->eq3_bw_oncc.set(num_cc, ToInt(value));
2000 else if ("eq1_gain" == key_cc) pCurDef->eq1_gain_oncc.set(num_cc, ToInt(value));
2001 else if ("eq2_gain" == key_cc) pCurDef->eq2_gain_oncc.set(num_cc, ToInt(value));
2002 else if ("eq3_gain" == key_cc) pCurDef->eq3_gain_oncc.set(num_cc, ToInt(value));
2003
2004 else if ("ampeg_delay" == key_cc) pCurDef->ampeg_delaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2005 else if ("ampeg_start" == key_cc) pCurDef->ampeg_startcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2006 else if ("ampeg_attack" == key_cc) pCurDef->ampeg_attackcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2007 else if ("ampeg_hold" == key_cc) pCurDef->ampeg_holdcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2008 else if ("ampeg_decay" == key_cc) pCurDef->ampeg_decaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2009 else if ("ampeg_sustain" == key_cc) pCurDef->ampeg_sustaincc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2010 else if ("ampeg_release" == key_cc) pCurDef->ampeg_releasecc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2011
2012 else if ("fileg_delay" == key_cc) pCurDef->fileg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2013 else if ("fileg_start" == key_cc) pCurDef->fileg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2014 else if ("fileg_attack" == key_cc) pCurDef->fileg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2015 else if ("fileg_hold" == key_cc) pCurDef->fileg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2016 else if ("fileg_decay" == key_cc) pCurDef->fileg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2017 else if ("fileg_sustain" == key_cc) pCurDef->fileg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2018 else if ("fileg_release" == key_cc) pCurDef->fileg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2019 else if ("fileg_depth" == key_cc) pCurDef->fileg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2020
2021 else if ("pitcheg_delay" == key_cc) pCurDef->pitcheg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2022 else if ("pitcheg_start" == key_cc) pCurDef->pitcheg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2023 else if ("pitcheg_attack" == key_cc) pCurDef->pitcheg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2024 else if ("pitcheg_hold" == key_cc) pCurDef->pitcheg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2025 else if ("pitcheg_decay" == key_cc) pCurDef->pitcheg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2026 else if ("pitcheg_sustain" == key_cc) pCurDef->pitcheg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2027 else if ("pitcheg_release" == key_cc) pCurDef->pitcheg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2028 else if ("pitcheg_depth" == key_cc) pCurDef->pitcheg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2029
2030 else if ("pitchlfo_delay" == key_cc) pCurDef->pitchlfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2031 else if ("pitchlfo_fade" == key_cc) pCurDef->pitchlfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2032 else if ("pitchlfo_depth" == key_cc) pCurDef->pitchlfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2033 else if ("pitchlfo_freq" == key_cc) pCurDef->pitchlfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2034 else if ("fillfo_delay" == key_cc) pCurDef->fillfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2035 else if ("fillfo_fade" == key_cc) pCurDef->fillfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2036 else if ("fillfo_depth" == key_cc) pCurDef->fillfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2037 else if ("fillfo_freq" == key_cc) pCurDef->fillfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2038 else if ("amplfo_delay" == key_cc) pCurDef->amplfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2039 else if ("amplfo_fade" == key_cc) pCurDef->amplfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2040 else if ("amplfo_depth" == key_cc) pCurDef->amplfo_depthcc.add( CC(num_cc, check(key, -10.0f, 10.0f, ToFloat(value))) );
2041 else if ("amplfo_freq" == key_cc) pCurDef->amplfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2042 else if ("volume" == key_cc) pCurDef->volume_oncc.add( CC(num_cc, check(key, -144.0f, 100.0f, ToFloat(value))) );
2043 else if ("volume_curve" == key_cc) pCurDef->volume_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2044 else if ("volume_smooth" == key_cc) pCurDef->volume_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2045 else if ("volume_step" == key_cc) pCurDef->volume_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -20.0f, 20.0f, ToFloat(value))) );
2046 else if ("pan" == key_cc) pCurDef->pan_oncc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2047 else if ("pan_curve" == key_cc) pCurDef->pan_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2048 else if ("pan_smooth" == key_cc) pCurDef->pan_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2049 else if ("pan_step" == key_cc) pCurDef->pan_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -100.0f, 100.0f, ToFloat(value))) );
2050 else if ("set_" == key_cc) _instrument->initialCCValues[num_cc] = (num_cc < 128) ? check(key, 0, 127, ToInt(value)) : ToInt(value);
2051 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2052 }
2053
2054 else {
2055 std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2056 }
2057 }
2058
2059 int File::parseKey(const std::string& s) {
2060 int i;
2061 std::istringstream iss(s);
2062 if (isdigit(iss.peek())) {
2063 iss >> i;
2064 } else {
2065 switch (tolower(iss.get())) {
2066 case 'c': i = 0; break;
2067 case 'd': i = 2; break;
2068 case 'e': i = 4; break;
2069 case 'f': i = 5; break;
2070 case 'g': i = 7; break;
2071 case 'a': i = 9; break;
2072 case 'b': i = 11; break;
2073 case '-': if (s == "-1") return -1;
2074 default:
2075 std::cerr << "Not a note: " << s << std::endl;
2076 return 0;
2077 }
2078 if (iss.peek() == '#') {
2079 i++;
2080 iss.get();
2081 } else if (tolower(iss.peek()) == 'b') {
2082 i--;
2083 iss.get();
2084 }
2085 int octave;
2086 if (!(iss >> octave)) {
2087 std::cerr << "Not a note: " << s << std::endl;
2088 return 0;
2089 }
2090 i += (octave + 1) * 12;
2091 }
2092 return i + note_offset + 12 * octave_offset;
2093 }
2094
2095 EGNode::EGNode() : time(0), level(0), shape(0), curve(0) {
2096 }
2097
2098 void EGNode::Copy(const EGNode& egNode) {
2099 time = egNode.time;
2100 level = egNode.level;
2101 shape = egNode.shape;
2102 curve = egNode.curve;
2103
2104 time_oncc = egNode.time_oncc;
2105 level_oncc = egNode.level_oncc;
2106 }
2107
2108 EG::EG() :
2109 sustain(0), loop(0), loop_count(0), amplitude(0), volume(-200), /* less than -144 dB is considered unset */
2110 cutoff(0), pitch(0), resonance(0), pan(0), pan_curve(-1)
2111 { }
2112
2113 void EG::Copy(const EG& eg) {
2114 EqImpl::Copy(static_cast<const EqImpl>(eg));
2115
2116 sustain = eg.sustain;
2117 loop = eg.loop;
2118 loop_count = eg.loop_count;
2119 amplitude = eg.amplitude;
2120 volume = eg.volume;
2121 cutoff = eg.cutoff;
2122 pitch = eg.pitch;
2123 resonance = eg.resonance;
2124 pan = eg.pan;
2125 pan_curve = eg.pan_curve;
2126 node = eg.node;
2127
2128 amplitude_oncc = eg.amplitude_oncc;
2129 volume_oncc = eg.volume_oncc;
2130 cutoff_oncc = eg.cutoff_oncc;
2131 pitch_oncc = eg.pitch_oncc;
2132 resonance_oncc = eg.resonance_oncc;
2133 pan_oncc = eg.pan_oncc;
2134 pan_curvecc = eg.pan_curvecc;
2135 }
2136
2137 LFO::LFO():
2138 delay(0),
2139 freq(-1), /* -1 is used to determine whether the LFO was initialized */
2140 fade(0), phase(0), wave(0), volume(0), pitch(0), cutoff(0), resonance(0), pan(0)
2141 {
2142 }
2143
2144 void LFO::Copy(const LFO& lfo) {
2145 EqSmoothStepImpl::Copy(static_cast<const EqSmoothStepImpl>(lfo));
2146
2147 delay = lfo.delay;
2148 freq = lfo.freq;
2149 fade = lfo.fade;
2150 phase = lfo.phase;
2151 wave = lfo.wave;
2152 volume = lfo.volume;
2153 pitch = lfo.pitch;
2154 cutoff = lfo.cutoff;
2155 resonance = lfo.resonance;
2156 pan = lfo.pan;
2157
2158 delay_oncc = lfo.delay_oncc;
2159 freq_oncc = lfo.freq_oncc;
2160 freq_smoothcc = lfo.freq_smoothcc;
2161 freq_stepcc = lfo.freq_stepcc;
2162 fade_oncc = lfo.fade_oncc;
2163 phase_oncc = lfo.phase_oncc;
2164 pitch_oncc = lfo.pitch_oncc;
2165 pitch_smoothcc = lfo.pitch_smoothcc;
2166 pitch_stepcc = lfo.pitch_stepcc;
2167 volume_oncc = lfo.volume_oncc;
2168 volume_smoothcc = lfo.volume_smoothcc;
2169 volume_stepcc = lfo.volume_stepcc;
2170 pan_oncc = lfo.pan_oncc;
2171 pan_smoothcc = lfo.pan_smoothcc;
2172 pan_stepcc = lfo.pan_stepcc;
2173 cutoff_oncc = lfo.cutoff_oncc;
2174 cutoff_smoothcc = lfo.cutoff_smoothcc;
2175 cutoff_stepcc = lfo.cutoff_stepcc;
2176 resonance_oncc = lfo.resonance_oncc;
2177 resonance_smoothcc = lfo.resonance_smoothcc;
2178 resonance_stepcc = lfo.resonance_stepcc;
2179 }
2180
2181 EqImpl::EqImpl() {
2182 eq1freq = eq2freq = eq3freq = 0;
2183 eq1bw = eq2bw = eq3bw = 0;
2184 eq1gain = eq2gain = eq3gain = 0;
2185 }
2186
2187 void EqImpl::Copy(const EqImpl& eq) {
2188 eq1freq = eq.eq1freq;
2189 eq2freq = eq.eq2freq;
2190 eq3freq = eq.eq3freq;
2191 eq1bw = eq.eq1bw;
2192 eq2bw = eq.eq2bw;
2193 eq3bw = eq.eq3bw;
2194 eq1gain = eq.eq1gain;
2195 eq2gain = eq.eq2gain;
2196 eq3gain = eq.eq3gain;
2197
2198 eq1freq_oncc = eq.eq1freq_oncc;
2199 eq2freq_oncc = eq.eq2freq_oncc;
2200 eq3freq_oncc = eq.eq3freq_oncc;
2201 eq1bw_oncc = eq.eq1bw_oncc;
2202 eq2bw_oncc = eq.eq2bw_oncc;
2203 eq3bw_oncc = eq.eq3bw_oncc;
2204 eq1gain_oncc = eq.eq1gain_oncc;
2205 eq2gain_oncc = eq.eq2gain_oncc;
2206 eq3gain_oncc = eq.eq3gain_oncc;
2207 }
2208
2209 bool EqImpl::HasEq() {
2210 return eq1freq || eq2freq || eq3freq || eq1bw || eq2bw || eq3bw ||
2211 eq1gain || eq2gain || eq3gain || !eq1gain_oncc.empty() ||
2212 !eq2gain_oncc.empty() || !eq3gain_oncc.empty() ||
2213 !eq1freq_oncc.empty() || !eq2freq_oncc.empty() || !eq3freq_oncc.empty() ||
2214 !eq1bw_oncc.empty() || !eq2bw_oncc.empty() || !eq3bw_oncc.empty();
2215 }
2216
2217 void EqSmoothStepImpl::Copy(const EqSmoothStepImpl& eq) {
2218 EqImpl::Copy(eq);
2219
2220 eq1freq_smoothcc = eq.eq1freq_smoothcc;
2221 eq2freq_smoothcc = eq.eq2freq_smoothcc;
2222 eq3freq_smoothcc = eq.eq3freq_smoothcc;
2223 eq1bw_smoothcc = eq.eq1bw_smoothcc;
2224 eq2bw_smoothcc = eq.eq2bw_smoothcc;
2225 eq3bw_smoothcc = eq.eq3bw_smoothcc;
2226 eq1gain_smoothcc = eq.eq1gain_smoothcc;
2227 eq2gain_smoothcc = eq.eq2gain_smoothcc;
2228 eq3gain_smoothcc = eq.eq3gain_smoothcc;
2229
2230 eq1freq_stepcc = eq.eq1freq_stepcc;
2231 eq2freq_stepcc = eq.eq2freq_stepcc;
2232 eq3freq_stepcc = eq.eq3freq_stepcc;
2233 eq1bw_stepcc = eq.eq1bw_stepcc;
2234 eq2bw_stepcc = eq.eq2bw_stepcc;
2235 eq3bw_stepcc = eq.eq3bw_stepcc;
2236 eq1gain_stepcc = eq.eq1gain_stepcc;
2237 eq2gain_stepcc = eq.eq2gain_stepcc;
2238 eq3gain_stepcc = eq.eq3gain_stepcc;
2239 }
2240
2241 void EqSmoothStepImpl::copySmoothValues() {
2242 File::copySmoothValues(eq1freq_smoothcc, eq1freq_oncc);
2243 eq1freq_smoothcc.clear();
2244
2245 File::copySmoothValues(eq2freq_smoothcc, eq2freq_oncc);
2246 eq2freq_smoothcc.clear();
2247
2248 File::copySmoothValues(eq3freq_smoothcc, eq3freq_oncc);
2249 eq3freq_smoothcc.clear();
2250
2251 File::copySmoothValues(eq1bw_smoothcc, eq1bw_oncc);
2252 eq1bw_smoothcc.clear();
2253
2254 File::copySmoothValues(eq2bw_smoothcc, eq2bw_oncc);
2255 eq2bw_smoothcc.clear();
2256
2257 File::copySmoothValues(eq3bw_smoothcc, eq3bw_oncc);
2258 eq3bw_smoothcc.clear();
2259
2260 File::copySmoothValues(eq1gain_smoothcc, eq1gain_oncc);
2261 eq1gain_smoothcc.clear();
2262
2263 File::copySmoothValues(eq2gain_smoothcc, eq2gain_oncc);
2264 eq2gain_smoothcc.clear();
2265
2266 File::copySmoothValues(eq3gain_smoothcc, eq3gain_oncc);
2267 eq3gain_smoothcc.clear();
2268 }
2269
2270 void EqSmoothStepImpl::copyStepValues() {
2271 File::copyStepValues(eq1freq_stepcc, eq1freq_oncc);
2272 eq1freq_stepcc.clear();
2273
2274 File::copyStepValues(eq2freq_stepcc, eq2freq_oncc);
2275 eq2freq_stepcc.clear();
2276
2277 File::copyStepValues(eq3freq_stepcc, eq3freq_oncc);
2278 eq3freq_stepcc.clear();
2279
2280 File::copyStepValues(eq1bw_stepcc, eq1bw_oncc);
2281 eq1bw_stepcc.clear();
2282
2283 File::copyStepValues(eq2bw_stepcc, eq2bw_oncc);
2284 eq2bw_stepcc.clear();
2285
2286 File::copyStepValues(eq3bw_stepcc, eq3bw_oncc);
2287 eq3bw_stepcc.clear();
2288
2289 File::copyStepValues(eq1gain_stepcc, eq1gain_oncc);
2290 eq1gain_stepcc.clear();
2291
2292 File::copyStepValues(eq2gain_stepcc, eq2gain_oncc);
2293 eq2gain_stepcc.clear();
2294
2295 File::copyStepValues(eq3gain_stepcc, eq3gain_oncc);
2296 eq3gain_stepcc.clear();
2297 }
2298
2299 EG& File::eg(int x) {
2300 while (pCurDef->eg.size() <= x) {
2301 pCurDef->eg.add(EG());
2302 }
2303 return pCurDef->eg[x];
2304 }
2305
2306 EGNode& File::egnode(int x, int y) {
2307 EG& e = eg(x);
2308 while (e.node.size() <= y) {
2309 e.node.add(EGNode());
2310 }
2311 return e.node[y];
2312 }
2313
2314 LFO& File::lfo(int x) {
2315 while (pCurDef->lfos.size() <= x) {
2316 pCurDef->lfos.add(LFO());
2317 }
2318 return pCurDef->lfos[x];
2319 }
2320
2321 } // !namespace sfz

Properties

Name Value
svn:executable *

  ViewVC Help
Powered by ViewVC