/[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 3497 - (show annotations) (download)
Sun Mar 10 13:34:33 2019 UTC (16 months ago) by schoenebeck
File size: 109269 byte(s)
* sfz opcode 'sample': Added support for built-in sample '*silence'
  (fixes bug #310, patch by Jacek Roszkowski).
* sfz opcode 'sample': Show warning message for unknown or unsupported
  built-in sample types.
* Bumped version (2.1.0.svn7).

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 && sample != "*silence") {
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] == '<') {
1220 std::string::size_type p = token.find('>', 1);
1221 if (p != std::string::npos && p < (token.size() - 1)) {
1222 linestream.seekg(p + 1 - token.size(), std::stringstream::cur);
1223 token.erase(p + 1);
1224 }
1225 }
1226 if (token[0] == '<' && token[token.size()-1] == '>')
1227 {
1228 // HEAD
1229 if (!token_string.empty())
1230 {
1231 switch (token_type)
1232 {
1233 case HEADER:
1234 push_header(token_string);
1235 break;
1236 case OPCODE:
1237 push_opcode(token_string);
1238 break;
1239 }
1240 token_string.erase();
1241 }
1242 token_string.append(token);
1243 token_type = HEADER;
1244 }
1245 else if (token.find('=') != std::string::npos)
1246 {
1247 // HEAD
1248 if (!token_string.empty())
1249 {
1250 switch (token_type)
1251 {
1252 case HEADER:
1253 push_header(token_string);
1254 break;
1255 case OPCODE:
1256 push_opcode(token_string);
1257 break;
1258 }
1259 token_string.erase();
1260 }
1261 token_string.append(token);
1262 token_type = OPCODE;
1263 }
1264 else
1265 {
1266 // TAIL
1267 token_string.append(spaces, ' ');
1268 token_string.append(token);
1269 }
1270 spaces = 0;
1271 while (isspace(linestream.peek())) {
1272 linestream.ignore();
1273 spaces++;
1274 }
1275 }
1276
1277 // EOL
1278 if (!token_string.empty())
1279 {
1280 switch (token_type)
1281 {
1282 case HEADER:
1283 push_header(token_string);
1284 break;
1285 case OPCODE:
1286 push_opcode(token_string);
1287 break;
1288 }
1289 token_string.erase();
1290 }
1291 }
1292 }
1293
1294 File::~File()
1295 {
1296 for (int i = 0; i < _current_containers.size(); i++)
1297 {
1298 delete _current_containers.top();
1299 _current_containers.pop();
1300 }
1301 delete _instrument;
1302 }
1303
1304 Instrument*
1305 File::GetInstrument()
1306 {
1307 return _instrument;
1308 }
1309
1310 void File::copyCurves(LinuxSampler::ArrayList<CC>& curves, LinuxSampler::ArrayList<CC>& dest) {
1311 for (int i = 0; i < curves.size(); i++) {
1312 for (int j = 0; j < dest.size(); j++) {
1313 if (curves[i].Controller == dest[j].Controller) {
1314 dest[j].Curve = curves[i].Curve;
1315 }
1316 }
1317 }
1318 }
1319
1320 void File::copySmoothValues(LinuxSampler::ArrayList<CC>& smooths, LinuxSampler::ArrayList<CC>& dest) {
1321 for (int i = 0; i < smooths.size(); i++) {
1322 for (int j = 0; j < dest.size(); j++) {
1323 if (smooths[i].Controller == dest[j].Controller) {
1324 dest[j].Smooth = smooths[i].Smooth;
1325 }
1326 }
1327 }
1328 }
1329
1330 void File::copyStepValues(LinuxSampler::ArrayList<CC>& steps, LinuxSampler::ArrayList<CC>& dest) {
1331 for (int i = 0; i < steps.size(); i++) {
1332 for (int j = 0; j < dest.size(); j++) {
1333 if (steps[i].Controller == dest[j].Controller) {
1334 dest[j].Step = steps[i].Step;
1335 }
1336 }
1337 }
1338 }
1339
1340 int File::ToInt(const std::string& s) throw(LinuxSampler::Exception) {
1341 int i;
1342 std::istringstream iss(s);
1343 if(!(iss >> i)) {
1344 std::ostringstream oss;
1345 oss << "Line " << currentLine << ": Expected an integer";
1346 throw LinuxSampler::Exception(oss.str());
1347 }
1348 return i;
1349 }
1350
1351 float File::ToFloat(const std::string& s) throw(LinuxSampler::Exception) {
1352 float i;
1353 std::istringstream iss(s);
1354 if(!(iss >> i)) {
1355 std::ostringstream oss;
1356 oss << "Line " << currentLine << ": Expected a floating-point number";
1357 throw LinuxSampler::Exception(oss.str());
1358 }
1359 return i;
1360 }
1361
1362 void
1363 File::push_header(std::string token)
1364 {
1365 if (token == "<global>" ||
1366 token == "<master>" ||
1367 token == "<group>")
1368 {
1369 ContainerDefinition::section_type level = ContainerDefinition::GLOBAL; // initialized only to avoid an irrelevant compiler warning
1370
1371 if (token == "<global>")
1372 {
1373 _current_section = GLOBAL;
1374 level = ContainerDefinition::GLOBAL;
1375 }
1376 else if (token == "<master>")
1377 {
1378 _current_section = MASTER;
1379 level = ContainerDefinition::MASTER;
1380 }
1381 else if (token == "<group>")
1382 {
1383 _current_section = GROUP;
1384 level = ContainerDefinition::GROUP;
1385 }
1386
1387 ContainerDefinition* newContainer = new ContainerDefinition(level);
1388
1389 while (_current_containers.size() > 0 && _current_containers.top()->level <= level)
1390 {
1391 delete _current_containers.top();
1392 _current_containers.pop();
1393 }
1394
1395 //If the new header is a <global>, there won't be anything left in _current_containers
1396 //to copy from.
1397 if (_current_containers.size() > 0)
1398 {
1399 _current_containers.top()->CopyValuesToDefinition(newContainer);
1400 }
1401 _current_containers.push(newContainer);
1402 pCurDef = newContainer;
1403 }
1404 else if (token == "<region>")
1405 {
1406 _current_section = REGION;
1407 _current_region = new Region();
1408 _current_region->id = id++;
1409 _current_containers.top()->CopyValuesToDefinition(_current_region);
1410 pCurDef = _current_region;
1411 _instrument->regions.push_back(_current_region);
1412 _current_region->SetInstrument(_instrument);
1413 }
1414 else if (token == "<control>")
1415 {
1416 _current_section = CONTROL;
1417 default_path = "";
1418 octave_offset = 0;
1419 note_offset = 0;
1420 }
1421 else if (token == "<curve>")
1422 {
1423 _current_section = CURVE;
1424 _instrument->curves.add(Curve());
1425 _current_curve = &_instrument->curves[_instrument->curves.size() - 1];
1426 }
1427 else
1428 {
1429 _current_section = UNKNOWN;
1430 std::cerr << "The header '" << token << "' is unsupported by libsfz!" << std::endl;
1431 }
1432 }
1433
1434 void
1435 File::push_opcode(std::string token)
1436 {
1437 if (_current_section == UNKNOWN)
1438 return;
1439
1440 std::string::size_type delimiter_index = token.find('=');
1441 std::string key = token.substr(0, delimiter_index);
1442 std::string value = token.substr(delimiter_index + 1);
1443 int x, y, z;
1444
1445 // Apply macros
1446 size_t macro_start = 0;
1447 size_t macro_end = 0;
1448 std::string macro_value;
1449 while ((macro_start = value.find("$", macro_start + macro_value.size())) != std::string::npos)
1450 {
1451 macro_end = value.find_first_not_of(MACRO_NAME_CHARS, macro_start + 1);
1452 size_t macro_len = macro_end - macro_start;
1453 std::string macro_name = value.substr(macro_start, macro_len);
1454 if (_defined_macros.count(macro_name) != 0)
1455 {
1456 macro_value = _defined_macros[macro_name];
1457 value.replace(macro_start, macro_len, macro_value);
1458 }
1459 else
1460 {
1461 std::cerr << "Macro '" << macro_name << "' referenced on line ";
1462 std::cerr << currentLine << " is undefined." << std::endl;
1463 return;
1464 }
1465 }
1466
1467 if (_current_section == CURVE) {
1468 if (sscanf(key.c_str(), "v%d", &x)) {
1469 if (x < 0 || x > 127) {
1470 std::cerr << "Invalid curve index: " << x << std::endl;
1471 }
1472 _current_curve->v[x] = check(key, 0.0f, 1.0f, ToFloat(value));
1473 } else {
1474 std::cerr << "The opcode '" << key << "' in section <curve> is unsupported by libsfz!" << std::endl;
1475 }
1476
1477 return;
1478 }
1479
1480 // sample definition
1481 if ("sample" == key)
1482 {
1483 // handle built-in sample types ...
1484 if (value == "*silence") {
1485 pCurDef->sample = value;
1486 return;
1487 } else if (value.length() >= 1 && value[0] == '*') {
1488 std::cerr << "Unknown or unsupported built-in sample type '" << value << "'!" << std::endl;
1489 return;
1490 }
1491
1492 // handle external samples ...
1493 std::string path = default_path + value;
1494 #ifndef WIN32
1495 for (int i = 0; i < path.length(); i++) if (path[i] == '\\') path[i] = '/';
1496 bool absolute = path[0] == '/';
1497 #else
1498 bool absolute = path[0] == '/' || path[0] == '\\' ||
1499 (path.length() >= 2 && isalpha(path[0]) && path[1] == ':');
1500 #endif
1501 if (!absolute) path = currentDir + LinuxSampler::File::DirSeparator + path;
1502 if(pCurDef) pCurDef->sample = path;
1503 return;
1504 }
1505
1506 // control header directives
1507 else if ("default_path" == key)
1508 {
1509 switch (_current_section)
1510 {
1511 case CONTROL:
1512 default_path = value;
1513 break;
1514 default:
1515 ; // noop
1516 }
1517 return;
1518 }
1519 else if ("octave_offset" == key)
1520 {
1521 switch (_current_section)
1522 {
1523 case CONTROL:
1524 octave_offset = ToInt(value);
1525 break;
1526 default:
1527 ; // noop
1528 }
1529 return;
1530 }
1531 else if ("note_offset" == key)
1532 {
1533 switch (_current_section)
1534 {
1535 case CONTROL:
1536 note_offset = ToInt(value);
1537 break;
1538 default:
1539 ; // noop
1540 }
1541 return;
1542 }
1543
1544 // input controls
1545 else if ("lochan" == key) pCurDef->lochan = ToInt(value);
1546 else if ("hichan" == key) pCurDef->hichan = ToInt(value);
1547 else if ("lokey" == key) pCurDef->lokey = parseKey(value);
1548 else if ("hikey" == key) pCurDef->hikey = parseKey(value);
1549 else if ("key" == key)
1550 {
1551 pCurDef->lokey = pCurDef->hikey = pCurDef->pitch_keycenter = parseKey(value);
1552 }
1553 else if ("lovel" == key) pCurDef->lovel = ToInt(value);
1554 else if ("hivel" == key) pCurDef->hivel = ToInt(value);
1555 else if ("lobend" == key) pCurDef->lobend = ToInt(value);
1556 else if ("hibend" == key) pCurDef->hibend = ToInt(value);
1557 else if ("lobpm" == key) pCurDef->lobpm = ToFloat(value);
1558 else if ("hibpm" == key) pCurDef->hibpm = ToFloat(value);
1559 else if ("lochanaft" == key) pCurDef->lochanaft = ToInt(value);
1560 else if ("hichanaft" == key) pCurDef->hichanaft = ToInt(value);
1561 else if ("lopolyaft" == key) pCurDef->lopolyaft = ToInt(value);
1562 else if ("hipolyaft" == key) pCurDef->hipolyaft = ToInt(value);
1563 else if ("loprog" == key) pCurDef->loprog = ToInt(value);
1564 else if ("hiprog" == key) pCurDef->hiprog = ToInt(value);
1565 else if ("lorand" == key) pCurDef->lorand = ToFloat(value);
1566 else if ("hirand" == key) pCurDef->hirand = ToFloat(value);
1567 else if ("lotimer" == key) pCurDef->lotimer = ToFloat(value);
1568 else if ("hitimer" == key) pCurDef->hitimer = ToFloat(value);
1569 else if ("seq_length" == key) pCurDef->seq_length = ToInt(value);
1570 else if ("seq_position" == key) pCurDef->seq_position = ToInt(value);
1571 else if ("sw_lokey" == key) pCurDef->sw_lokey = parseKey(value);
1572 else if ("sw_hikey" == key) pCurDef->sw_hikey = parseKey(value);
1573 else if ("sw_last" == key) pCurDef->sw_last = parseKey(value);
1574 else if ("sw_down" == key) pCurDef->sw_down = parseKey(value);
1575 else if ("sw_up" == key) pCurDef->sw_up = parseKey(value);
1576 else if ("sw_previous" == key) pCurDef->sw_previous = parseKey(value);
1577 else if ("sw_vel" == key)
1578 {
1579 if (value == "current") pCurDef->sw_vel = VEL_CURRENT;
1580 else if (value == "previous") pCurDef->sw_vel = VEL_PREVIOUS;
1581 }
1582 else if ("trigger" == key)
1583 {
1584 if (value == "attack") pCurDef->trigger = TRIGGER_ATTACK;
1585 else if (value == "release") pCurDef->trigger = TRIGGER_RELEASE;
1586 else if (value == "first") pCurDef->trigger = TRIGGER_FIRST;
1587 else if (value == "legato") pCurDef->trigger = TRIGGER_LEGATO;
1588 }
1589 else if ("group" == key) pCurDef->group = ToInt(value);
1590 else if ("off_by" == key || "offby" == key) pCurDef->off_by = ToInt(value);
1591 else if ("off_mode" == key || "offmode" == key)
1592 {
1593 if (value == "fast") pCurDef->off_mode = OFF_FAST;
1594 else if (value == "normal") pCurDef->off_mode = OFF_NORMAL;
1595 }
1596
1597 // sample player
1598 else if ("count" == key) { pCurDef->count = ToInt(value); pCurDef->loop_mode = ONE_SHOT; }
1599 else if ("delay" == key) pCurDef->delay = ToFloat(value);
1600 else if ("delay_random" == key) pCurDef->delay_random = ToFloat(value);
1601 else if ("delay_beats" == key) pCurDef->delay_beats = ToInt(value);
1602 else if ("stop_beats" == key) pCurDef->stop_beats = ToInt(value);
1603 else if ("delay_samples" == key) pCurDef->delay_samples = ToInt(value);
1604 else if ("end" == key) pCurDef->end = ToInt(value);
1605 else if ("loop_crossfade" == key) pCurDef->loop_crossfade = ToFloat(value);
1606 else if ("offset_random" == key) pCurDef->offset_random = ToInt(value);
1607 else if ("loop_mode" == key || "loopmode" == key)
1608 {
1609 if (value == "no_loop") pCurDef->loop_mode = NO_LOOP;
1610 else if (value == "one_shot") pCurDef->loop_mode = ONE_SHOT;
1611 else if (value == "loop_continuous") pCurDef->loop_mode = LOOP_CONTINUOUS;
1612 else if (value == "loop_sustain") pCurDef->loop_mode = LOOP_SUSTAIN;
1613 }
1614 else if ("loop_start" == key) pCurDef->loop_start = ToInt(value);
1615 else if ("loopstart" == key) pCurDef->loop_start = ToInt(value); // nonstandard
1616 else if ("loop_end" == key) pCurDef->loop_end = ToInt(value);
1617 else if ("loopend" == key) pCurDef->loop_end = ToInt(value); // nonstandard
1618 else if ("offset" == key) pCurDef->offset = ToInt(value);
1619 else if ("sync_beats" == key) pCurDef->sync_beats = ToInt(value);
1620 else if ("sync_offset" == key) pCurDef->sync_offset = ToInt(value);
1621
1622 // amplifier
1623 else if ("volume" == key) pCurDef->volume = ToFloat(value);
1624 else if ("amplitude" == key) pCurDef->amplitude = ToFloat(value);
1625 else if ("pan" == key) pCurDef->pan = ToFloat(value);
1626 else if ("width" == key) pCurDef->width = ToFloat(value);
1627 else if ("position" == key) pCurDef->position = ToFloat(value);
1628 else if ("amp_keytrack" == key) pCurDef->amp_keytrack = ToFloat(value);
1629 else if ("amp_keycenter" == key) pCurDef->amp_keycenter = parseKey(value);
1630 else if ("amp_veltrack" == key) pCurDef->amp_veltrack = ToFloat(value);
1631 else if ("amp_random" == key) pCurDef->amp_random = ToFloat(value);
1632 else if ("rt_decay" == key || "rtdecay" == key) pCurDef->rt_decay = ToFloat(value);
1633 else if ("xfin_lokey" == key) pCurDef->xfin_lokey = parseKey(value);
1634 else if ("xfin_hikey" == key) pCurDef->xfin_hikey = parseKey(value);
1635 else if ("xfout_lokey" == key) pCurDef->xfout_lokey = parseKey(value);
1636 else if ("xfout_hikey" == key) pCurDef->xfout_hikey = parseKey(value);
1637 else if ("xf_keycurve" == key)
1638 {
1639 if (value == "gain") pCurDef->xf_keycurve = GAIN;
1640 else if (value == "power") pCurDef->xf_keycurve = POWER;
1641 }
1642 else if ("xfin_lovel" == key) pCurDef->xfin_lovel = ToInt(value);
1643 else if ("xfin_hivel" == key) pCurDef->xfin_hivel = ToInt(value);
1644 else if ("xfout_lovel" == key) pCurDef->xfout_lovel = ToInt(value);
1645 else if ("xfout_hivel" == key) pCurDef->xfout_hivel = ToInt(value);
1646 else if ("xf_velcurve" == key)
1647 {
1648 if (value == "gain") pCurDef->xf_velcurve = GAIN;
1649 else if (value == "power") pCurDef->xf_velcurve = POWER;
1650 }
1651 else if ("xf_cccurve" == key)
1652 {
1653 if (value == "gain") pCurDef->xf_cccurve = GAIN;
1654 else if (value == "power") pCurDef->xf_cccurve = POWER;
1655 }
1656
1657 // pitch
1658 else if ("transpose" == key) pCurDef->transpose = ToInt(value);
1659 else if ("tune" == key) pCurDef->tune = ToInt(value);
1660 else if ("pitch_keycenter" == key) pCurDef->pitch_keycenter = parseKey(value);
1661 else if ("pitch_keytrack" == key) pCurDef->pitch_keytrack = ToInt(value);
1662 else if ("pitch_veltrack" == key) pCurDef->pitch_veltrack = ToInt(value);
1663 else if ("pitch_random" == key) pCurDef->pitch_random = ToInt(value);
1664 else if ("bend_up" == key || "bendup" == key) pCurDef->bend_up = ToInt(value);
1665 else if ("bend_down" == key || "benddown" == key) pCurDef->bend_down = ToInt(value);
1666 else if ("bend_step" == key || "bendstep" == key) pCurDef->bend_step = ToInt(value);
1667
1668 // filter
1669 else if ("fil_type" == key || "filtype" == key)
1670 {
1671 if (value == "lpf_1p") pCurDef->fil_type = LPF_1P;
1672 else if (value == "hpf_1p") pCurDef->fil_type = HPF_1P;
1673 else if (value == "bpf_1p") pCurDef->fil_type = BPF_1P;
1674 else if (value == "brf_1p") pCurDef->fil_type = BRF_1P;
1675 else if (value == "apf_1p") pCurDef->fil_type = APF_1P;
1676 else if (value == "lpf_2p") pCurDef->fil_type = LPF_2P;
1677 else if (value == "hpf_2p") pCurDef->fil_type = HPF_2P;
1678 else if (value == "bpf_2p") pCurDef->fil_type = BPF_2P;
1679 else if (value == "brf_2p") pCurDef->fil_type = BRF_2P;
1680 else if (value == "pkf_2p") pCurDef->fil_type = PKF_2P;
1681 else if (value == "lpf_4p") pCurDef->fil_type = LPF_4P;
1682 else if (value == "hpf_4p") pCurDef->fil_type = HPF_4P;
1683 else if (value == "lpf_6p") pCurDef->fil_type = LPF_6P;
1684 else if (value == "hpf_6p") pCurDef->fil_type = HPF_6P;
1685 }
1686 else if ("fil2_type" == key)
1687 {
1688 if (value == "lpf_1p") pCurDef->fil2_type = LPF_1P;
1689 else if (value == "hpf_1p") pCurDef->fil2_type = HPF_1P;
1690 else if (value == "bpf_1p") pCurDef->fil2_type = BPF_1P;
1691 else if (value == "brf_1p") pCurDef->fil2_type = BRF_1P;
1692 else if (value == "apf_1p") pCurDef->fil2_type = APF_1P;
1693 else if (value == "lpf_2p") pCurDef->fil2_type = LPF_2P;
1694 else if (value == "hpf_2p") pCurDef->fil2_type = HPF_2P;
1695 else if (value == "bpf_2p") pCurDef->fil2_type = BPF_2P;
1696 else if (value == "brf_2p") pCurDef->fil2_type = BRF_2P;
1697 else if (value == "pkf_2p") pCurDef->fil2_type = PKF_2P;
1698 else if (value == "lpf_4p") pCurDef->fil2_type = LPF_4P;
1699 else if (value == "hpf_4p") pCurDef->fil2_type = HPF_4P;
1700 else if (value == "lpf_6p") pCurDef->fil2_type = LPF_6P;
1701 else if (value == "hpf_6p") pCurDef->fil2_type = HPF_6P;
1702 }
1703 else if ("cutoff" == key) pCurDef->cutoff = ToFloat(value);
1704 else if ("cutoff2" == key) pCurDef->cutoff2 = ToFloat(value);
1705 else if ("cutoff_chanaft" == key) {
1706 pCurDef->cutoff_chanaft = check(key, -9600, 9600, ToInt(value));
1707 pCurDef->cutoff_oncc.add( CC(128, check(key, -9600, 9600, ToInt(value))) );
1708 } else if ("cutoff2_chanaft" == key) pCurDef->cutoff2_chanaft = ToInt(value);
1709 else if ("cutoff_polyaft" == key) pCurDef->cutoff_polyaft = ToInt(value);
1710 else if ("cutoff2_polyaft" == key) pCurDef->cutoff2_polyaft = ToInt(value);
1711 else if ("resonance" == key) pCurDef->resonance = ToFloat(value);
1712 else if ("resonance2" == key) pCurDef->resonance2 = ToFloat(value);
1713 else if ("fil_keytrack" == key) pCurDef->fil_keytrack = ToInt(value);
1714 else if ("fil2_keytrack" == key) pCurDef->fil2_keytrack = ToInt(value);
1715 else if ("fil_keycenter" == key) pCurDef->fil_keycenter = parseKey(value);
1716 else if ("fil2_keycenter" == key) pCurDef->fil2_keycenter = parseKey(value);
1717 else if ("fil_veltrack" == key) pCurDef->fil_veltrack = ToInt(value);
1718 else if ("fil2_veltrack" == key) pCurDef->fil2_veltrack = ToInt(value);
1719 else if ("fil_random" == key) pCurDef->fil_random = ToInt(value);
1720 else if ("fil2_random" == key) pCurDef->fil2_random = ToInt(value);
1721
1722 // per voice equalizer
1723 else if ("eq1_freq" == key) pCurDef->eq1_freq = ToFloat(value);
1724 else if ("eq2_freq" == key) pCurDef->eq2_freq = ToFloat(value);
1725 else if ("eq3_freq" == key) pCurDef->eq3_freq = ToFloat(value);
1726 else if ("eq1_vel2freq" == key) pCurDef->eq1_vel2freq = ToFloat(value);
1727 else if ("eq2_vel2freq" == key) pCurDef->eq2_vel2freq = ToFloat(value);
1728 else if ("eq3_vel2freq" == key) pCurDef->eq3_vel2freq = ToFloat(value);
1729 else if ("eq1_bw" == key) pCurDef->eq1_bw = ToFloat(value);
1730 else if ("eq2_bw" == key) pCurDef->eq2_bw = ToFloat(value);
1731 else if ("eq3_bw" == key) pCurDef->eq3_bw = ToFloat(value);
1732 else if ("eq1_gain" == key) pCurDef->eq1_gain = ToFloat(value);
1733 else if ("eq2_gain" == key) pCurDef->eq2_gain = ToFloat(value);
1734 else if ("eq3_gain" == key) pCurDef->eq3_gain = ToFloat(value);
1735 else if ("eq1_vel2gain" == key) pCurDef->eq1_vel2gain = ToFloat(value);
1736 else if ("eq2_vel2gain" == key) pCurDef->eq2_vel2gain = ToFloat(value);
1737 else if ("eq3_vel2gain" == key) pCurDef->eq3_vel2gain = ToFloat(value);
1738
1739 else if (sscanf(key.c_str(), "amp_velcurve_%d", &x)) {
1740 pCurDef->amp_velcurve.set(x, ToFloat(value));
1741 }
1742
1743 // v2 envelope generators
1744 else if (sscanf(key.c_str(), "eg%d%n", &x, &y)) {
1745 const char* s = key.c_str() + y;
1746 if (sscanf(s, "_time%d%n", &y, &z)) {
1747 const char* s2 = s + z;
1748 if (strcmp(s2, "") == 0) egnode(x, y).time = check(key, 0.0f, 100.0f, ToFloat(value));
1749 else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).time_oncc.add( CC(z, check(key, 0.0f, 100.0f, ToFloat(value))) );
1750 } else if (sscanf(s, "_level%d%n", &y, &z)) {
1751 const char* s2 = s + z;
1752 if (strcmp(s2, "") == 0) egnode(x, y).level = check(key, 0.0f, 1.0f, ToFloat(value));
1753 else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).level_oncc.add( CC(z, check(key, 0.0f, 1.0f, ToFloat(value))) );
1754 }
1755 else if (sscanf(s, "_shape%d", &y)) egnode(x, y).shape = ToFloat(value);
1756 else if (sscanf(s, "_curve%d", &y)) egnode(x, y).curve = ToFloat(value);
1757 else if (strcmp(s, "_sustain") == 0) eg(x).sustain = ToInt(value);
1758 else if (strcmp(s, "_loop") == 0) eg(x).loop = ToInt(value);
1759 else if (strcmp(s, "_loop_count") == 0) eg(x).loop_count = ToInt(value);
1760 else if (strcmp(s, "_amplitude") == 0) eg(x).amplitude = ToFloat(value);
1761 else if (sscanf(s, "_amplitude_oncc%d", &y)) eg(x).amplitude_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1762 else if (strcmp(s, "_volume") == 0) eg(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1763 else if (sscanf(s, "_volume_oncc%d", &y)) eg(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1764 else if (strcmp(s, "_cutoff") == 0) eg(x).cutoff = ToFloat(value);
1765 else if (sscanf(s, "_cutoff_oncc%d", &y)) eg(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1766 else if (strcmp(s, "_pitch") == 0) eg(x).pitch = check(key, -9600, 9600, ToInt(value));
1767 else if (sscanf(s, "_pitch_oncc%d", &y)) eg(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1768 else if (strcmp(s, "_resonance") == 0) eg(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1769 else if (sscanf(s, "_resonance_oncc%d", &y)) eg(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1770 else if (strcmp(s, "_pan") == 0) eg(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1771 else if (strcmp(s, "_pan_curve") == 0) eg(x).pan_curve = check(key, 0, 30000, ToInt(value));
1772 else if (sscanf(s, "_pan_oncc%d", &y)) eg(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1773 else if (sscanf(s, "_pan_curvecc%d", &y)) eg(x).pan_curvecc.add( CC(y, 0.0f, check(key, 0, 30000, ToInt(value))) );
1774 else if (strcmp(s, "_eq1freq") == 0) eg(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1775 else if (strcmp(s, "_eq2freq") == 0) eg(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1776 else if (strcmp(s, "_eq3freq") == 0) eg(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1777 else if (strcmp(s, "_eq1bw") == 0) eg(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1778 else if (strcmp(s, "_eq2bw") == 0) eg(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1779 else if (strcmp(s, "_eq3bw") == 0) eg(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1780 else if (strcmp(s, "_eq1gain") == 0) eg(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1781 else if (strcmp(s, "_eq2gain") == 0) eg(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1782 else if (strcmp(s, "_eq3gain") == 0) eg(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1783 else if (sscanf(s, "_eq1freq_oncc%d", &y)) eg(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1784 else if (sscanf(s, "_eq2freq_oncc%d", &y)) eg(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1785 else if (sscanf(s, "_eq3freq_oncc%d", &y)) eg(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1786 else if (sscanf(s, "_eq1bw_oncc%d", &y)) eg(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1787 else if (sscanf(s, "_eq2bw_oncc%d", &y)) eg(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1788 else if (sscanf(s, "_eq3bw_oncc%d", &y)) eg(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1789 else if (sscanf(s, "_eq1gain_oncc%d", &y)) eg(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1790 else if (sscanf(s, "_eq2gain_oncc%d", &y)) eg(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1791 else if (sscanf(s, "_eq3gain_oncc%d", &y)) eg(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1792 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1793 }
1794
1795 // v1 envelope generators
1796 else if ("ampeg_delay" == key) pCurDef->ampeg_delay = ToFloat(value);
1797 else if ("ampeg_start" == key) pCurDef->ampeg_start = ToFloat(value);
1798 else if ("ampeg_attack" == key) pCurDef->ampeg_attack = ToFloat(value);
1799 else if ("ampeg_hold" == key) pCurDef->ampeg_hold = ToFloat(value);
1800 else if ("ampeg_decay" == key) pCurDef->ampeg_decay = ToFloat(value);
1801 else if ("ampeg_sustain" == key) pCurDef->ampeg_sustain = ToFloat(value);
1802 else if ("ampeg_release" == key) pCurDef->ampeg_release = ToFloat(value);
1803 else if ("ampeg_vel2delay" == key) pCurDef->ampeg_vel2delay = ToFloat(value);
1804 else if ("ampeg_vel2attack" == key) pCurDef->ampeg_vel2attack = ToFloat(value);
1805 else if ("ampeg_vel2hold" == key) pCurDef->ampeg_vel2hold = ToFloat(value);
1806 else if ("ampeg_vel2decay" == key) pCurDef->ampeg_vel2decay = ToFloat(value);
1807 else if ("ampeg_vel2sustain" == key) pCurDef->ampeg_vel2sustain = ToFloat(value);
1808 else if ("ampeg_vel2release" == key) pCurDef->ampeg_vel2release = ToFloat(value);
1809 else if ("fileg_delay" == key) pCurDef->fileg_delay = ToFloat(value);
1810 else if ("fileg_start" == key) pCurDef->fileg_start = ToFloat(value);
1811 else if ("fileg_attack" == key) pCurDef->fileg_attack = ToFloat(value);
1812 else if ("fileg_hold" == key) pCurDef->fileg_hold = ToFloat(value);
1813 else if ("fileg_decay" == key) pCurDef->fileg_decay = ToFloat(value);
1814 else if ("fileg_sustain" == key) pCurDef->fileg_sustain = ToFloat(value);
1815 else if ("fileg_release" == key) pCurDef->fileg_release = ToFloat(value);
1816 else if ("fileg_depth" == key) pCurDef->fileg_depth = check(key, -12000, 12000, ToInt(value));
1817 else if ("fileg_vel2delay" == key) pCurDef->fileg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1818 else if ("fileg_vel2attack" == key) pCurDef->fileg_vel2attack = ToFloat(value);
1819 else if ("fileg_vel2hold" == key) pCurDef->fileg_vel2hold = ToFloat(value);
1820 else if ("fileg_vel2decay" == key) pCurDef->fileg_vel2decay = ToFloat(value);
1821 else if ("fileg_vel2sustain" == key) pCurDef->fileg_vel2sustain = ToFloat(value);
1822 else if ("fileg_vel2release" == key) pCurDef->fileg_vel2release = ToFloat(value);
1823 else if ("pitcheg_delay" == key) pCurDef->pitcheg_delay = ToFloat(value);
1824 else if ("pitcheg_start" == key) pCurDef->pitcheg_start = ToFloat(value);
1825 else if ("pitcheg_attack" == key) pCurDef->pitcheg_attack = ToFloat(value);
1826 else if ("pitcheg_hold" == key) pCurDef->pitcheg_hold = ToFloat(value);
1827 else if ("pitcheg_decay" == key) pCurDef->pitcheg_decay = ToFloat(value);
1828 else if ("pitcheg_sustain" == key) pCurDef->pitcheg_sustain = ToFloat(value);
1829 else if ("pitcheg_release" == key) pCurDef->pitcheg_release = ToFloat(value);
1830 else if ("pitcheg_depth" == key) pCurDef->pitcheg_depth = check(key, -12000, 12000, ToInt(value));
1831 else if ("pitcheg_vel2delay" == key) pCurDef->pitcheg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1832 else if ("pitcheg_vel2attack" == key) pCurDef->pitcheg_vel2attack = ToFloat(value);
1833 else if ("pitcheg_vel2hold" == key) pCurDef->pitcheg_vel2hold = ToFloat(value);
1834 else if ("pitcheg_vel2decay" == key) pCurDef->pitcheg_vel2decay = ToFloat(value);
1835 else if ("pitcheg_vel2sustain" == key) pCurDef->pitcheg_vel2sustain = ToFloat(value);
1836 else if ("pitcheg_vel2release" == key) pCurDef->pitcheg_vel2release = ToFloat(value);
1837
1838
1839 // v1 LFO
1840 else if ("amplfo_delay" == key) pCurDef->amplfo_delay = ToFloat(value);
1841 else if ("amplfo_fade" == key) pCurDef->amplfo_fade = ToFloat(value);
1842 else if ("amplfo_freq" == key) pCurDef->amplfo_freq = ToFloat(value);
1843 else if ("amplfo_freqchanaft" == key) pCurDef->amplfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1844 else if ("amplfo_depth" == key) pCurDef->amplfo_depth = ToFloat(value);
1845 else if ("amplfo_depthchanaft" == key) pCurDef->amplfo_depthcc.add( CC(128, check(key, -10.0f, 10.0f, ToFloat(value))) );
1846 else if ("fillfo_delay" == key) pCurDef->fillfo_delay = ToFloat(value);
1847 else if ("fillfo_fade" == key) pCurDef->fillfo_fade = ToFloat(value);
1848 else if ("fillfo_freq" == key) pCurDef->fillfo_freq = ToFloat(value);
1849 else if ("fillfo_freqchanaft" == key) pCurDef->fillfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1850 else if ("fillfo_depth" == key) pCurDef->fillfo_depth = ToFloat(value);
1851 else if ("fillfo_depthchanaft" == key) pCurDef->fillfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1852 else if ("pitchlfo_delay" == key) pCurDef->pitchlfo_delay = ToFloat(value);
1853 else if ("pitchlfo_fade" == key) pCurDef->pitchlfo_fade = ToFloat(value);
1854 else if ("pitchlfo_freq" == key) pCurDef->pitchlfo_freq = ToFloat(value);
1855 else if ("pitchlfo_freqchanaft" == key) pCurDef->pitchlfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1856 else if ("pitchlfo_depth" == key) pCurDef->pitchlfo_depth = ToInt(value);
1857 else if ("pitchlfo_depthchanaft" == key) pCurDef->pitchlfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1858
1859
1860 // v2 LFO
1861 else if (sscanf(key.c_str(), "lfo%d%n", &x, &y)) {
1862 const char* s = key.c_str() + y;
1863 if (strcmp(s, "_freq") == 0) lfo(x).freq = check(key, 0.0f, 20.0f, ToFloat(value));
1864 else if (sscanf(s, "_freq_oncc%d", &y)) lfo(x).freq_oncc.add( CC(y, check(key, 0.0f, 20.0f, ToFloat(value))) );
1865 else if (sscanf(s, "_freq_smoothcc%d", &y)) lfo(x).freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1866 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))) );
1867 else if (strcmp(s, "_wave") == 0) lfo(x).wave = ToInt(value);
1868 else if (strcmp(s, "_delay") == 0) lfo(x).delay = check(key, 0.0f, 100.0f, ToFloat(value));
1869 else if (sscanf(s, "_delay_oncc%d", &y)) lfo(x).delay_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1870 else if (strcmp(s, "_fade") == 0) lfo(x).fade = check(key, 0.0f, 100.0f, ToFloat(value));
1871 else if (sscanf(s, "_fade_oncc%d", &y)) lfo(x).fade_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1872 else if (strcmp(s, "_phase") == 0) lfo(x).phase = check(key, 0.0f, 360.0f, ToFloat(value));
1873 else if (sscanf(s, "_phase_oncc%d", &y)) lfo(x).phase_oncc.add( CC(y, check(key, 0.0f, 360.0f, ToFloat(value))) );
1874 else if (strcmp(s, "_volume") == 0) lfo(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1875 else if (sscanf(s, "_volume_oncc%d", &y)) lfo(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1876 else if (sscanf(s, "_volume_smoothcc%d", &y)) lfo(x).volume_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1877 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))) );
1878 else if (strcmp(s, "_pitch") == 0) lfo(x).pitch = check(key, -9600, 9600, ToInt(value));
1879 else if (sscanf(s, "_pitch_oncc%d", &y)) lfo(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1880 else if (sscanf(s, "_pitch_smoothcc%d", &y)) lfo(x).pitch_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1881 else if (sscanf(s, "_pitch_stepcc%d", &y)) lfo(x).pitch_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1882 else if (strcmp(s, "_cutoff") == 0) lfo(x).cutoff = check(key, -9600, 9600, ToInt(value));
1883 else if (sscanf(s, "_cutoff_oncc%d", &y)) lfo(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1884 else if (sscanf(s, "_cutoff_smoothcc%d", &y)) lfo(x).cutoff_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1885 else if (sscanf(s, "_cutoff_stepcc%d", &y)) lfo(x).cutoff_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1886 else if (strcmp(s, "_resonance") == 0) lfo(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1887 else if (sscanf(s, "_resonance_oncc%d", &y)) lfo(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1888 else if (sscanf(s, "_resonance_smoothcc%d", &y)) lfo(x).resonance_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1889 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))) );
1890 else if (strcmp(s, "_pan") == 0) lfo(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1891 else if (sscanf(s, "_pan_oncc%d", &y)) lfo(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1892 else if (sscanf(s, "_pan_smoothcc%d", &y)) lfo(x).pan_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1893 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))) );
1894 else if (strcmp(s, "_eq1freq") == 0) lfo(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1895 else if (strcmp(s, "_eq2freq") == 0) lfo(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1896 else if (strcmp(s, "_eq3freq") == 0) lfo(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1897 else if (strcmp(s, "_eq1bw") == 0) lfo(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1898 else if (strcmp(s, "_eq2bw") == 0) lfo(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1899 else if (strcmp(s, "_eq3bw") == 0) lfo(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1900 else if (strcmp(s, "_eq1gain") == 0) lfo(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1901 else if (strcmp(s, "_eq2gain") == 0) lfo(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1902 else if (strcmp(s, "_eq3gain") == 0) lfo(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1903 else if (sscanf(s, "_eq1freq_oncc%d", &y)) lfo(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1904 else if (sscanf(s, "_eq1freq_smoothcc%d", &y)) lfo(x).eq1freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1905 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))) );
1906 else if (sscanf(s, "_eq2freq_oncc%d", &y)) lfo(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1907 else if (sscanf(s, "_eq2freq_smoothcc%d", &y)) lfo(x).eq2freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1908 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))) );
1909 else if (sscanf(s, "_eq3freq_oncc%d", &y)) lfo(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1910 else if (sscanf(s, "_eq3freq_smoothcc%d", &y)) lfo(x).eq3freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1911 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))) );
1912 else if (sscanf(s, "_eq1bw_oncc%d", &y)) lfo(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1913 else if (sscanf(s, "_eq1bw_smoothcc%d", &y)) lfo(x).eq1bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1914 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))) );
1915 else if (sscanf(s, "_eq2bw_oncc%d", &y)) lfo(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1916 else if (sscanf(s, "_eq2bw_smoothcc%d", &y)) lfo(x).eq2bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1917 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))) );
1918 else if (sscanf(s, "_eq3bw_oncc%d", &y)) lfo(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1919 else if (sscanf(s, "_eq3bw_smoothcc%d", &y)) lfo(x).eq3bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1920 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))) );
1921 else if (sscanf(s, "_eq1gain_oncc%d", &y)) lfo(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1922 else if (sscanf(s, "_eq1gain_smoothcc%d", &y)) lfo(x).eq1gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1923 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))) );
1924 else if (sscanf(s, "_eq2gain_oncc%d", &y)) lfo(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1925 else if (sscanf(s, "_eq2gain_smoothcc%d", &y)) lfo(x).eq2gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1926 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))) );
1927 else if (sscanf(s, "_eq3gain_oncc%d", &y)) lfo(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1928 else if (sscanf(s, "_eq3gain_smoothcc%d", &y)) lfo(x).eq3gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1929 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))) );
1930 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1931 }
1932
1933 // CCs
1934 else if (key.find("cc") != std::string::npos)
1935 {
1936 std::string::size_type delimiter_index = key.find("cc");
1937 std::string key_cc = key.substr(0, delimiter_index);
1938 if (key_cc.size() > 3 && !strcmp(key_cc.c_str() + (key_cc.size() - 3), "_on")) {
1939 key_cc = key_cc.substr(0, key_cc.size() - 3);
1940 }
1941
1942 // Apply macros
1943 std::string num_cc_str = key.substr(delimiter_index + 2);
1944
1945 if (num_cc_str[0] == '$')
1946 {
1947 if (_defined_macros.count(num_cc_str) == 0)
1948 {
1949 std::cerr << "Macro '" << value << "' referenced on line ";
1950 std::cerr << currentLine << " is undefined." << std::endl;
1951 return;
1952 }
1953
1954 num_cc_str = _defined_macros[num_cc_str];
1955 }
1956
1957 int num_cc = ToInt(num_cc_str);
1958 if (num_cc < 0 || num_cc > 127) {
1959 std::cerr << "sfz: WARNING: CC " << num_cc << " of opcode '" << key;
1960 std::cerr << "' is an invalid MIDI controller number." << std::endl;
1961 }
1962
1963 // input controls
1964 if ("lo" == key_cc) pCurDef->locc.set(num_cc, ToInt(value));
1965 else if ("hi" == key_cc) pCurDef->hicc.set(num_cc, ToInt(value));
1966 else if ("start_lo" == key_cc) pCurDef->start_locc.set(num_cc, ToInt(value));
1967 else if ("start_hi" == key_cc) pCurDef->start_hicc.set(num_cc, ToInt(value));
1968 else if ("stop_lo" == key_cc) pCurDef->stop_locc.set(num_cc, ToInt(value));
1969 else if ("stop_hi" == key_cc) pCurDef->stop_hicc.set(num_cc, ToInt(value));
1970 else if ("on_lo" == key_cc) pCurDef->on_locc.set(num_cc, ToInt(value));
1971 else if ("on_hi" == key_cc) pCurDef->on_hicc.set(num_cc, ToInt(value));
1972
1973 // sample player
1974 else if ("delay" == key_cc) pCurDef->delay_oncc.set(num_cc, ToFloat(value));
1975 else if ("delay_samples" == key_cc) pCurDef->delay_samples_oncc.set(num_cc, ToInt(value));
1976 else if ("offset" == key_cc) pCurDef->offset_oncc.set(num_cc, ToInt(value));
1977
1978 // amplifier
1979 else if ("gain" == key_cc || "gain_" == key_cc) pCurDef->gain_oncc.set(num_cc, ToFloat(value));
1980 else if ("xfin_lo" == key_cc) pCurDef->xfin_locc.set(num_cc, ToInt(value));
1981 else if ("xfin_hi" == key_cc) pCurDef->xfin_hicc.set(num_cc, ToInt(value));
1982 else if ("xfout_lo" == key_cc) pCurDef->xfout_locc.set(num_cc, ToInt(value));
1983 else if ("xfout_hi" == key_cc) pCurDef->xfout_hicc.set(num_cc, ToInt(value));
1984
1985 // pitch
1986 else if ("pitch" == key_cc) pCurDef->pitch_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1987 else if ("pitch_smooth" == key_cc) pCurDef->pitch_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1988 else if ("pitch_curve" == key_cc) pCurDef->pitch_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1989 else if ("pitch_step" == key_cc) pCurDef->pitch_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0, 1200, ToInt(value))) );
1990
1991 // filter
1992 else if ("cutoff" == key_cc || "cutoff_" == key_cc) {
1993 pCurDef->cutoff_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1994 } else if ("cutoff2" == key_cc) pCurDef->cutoff2_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1995 else if ("cutoff_smooth" == key_cc) pCurDef->cutoff_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1996 else if ("cutoff2_smooth" == key_cc) pCurDef->cutoff2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1997 else if ("cutoff_step" == key_cc) pCurDef->cutoff_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1998 else if ("cutoff2_step" == key_cc) pCurDef->cutoff2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1999 else if ("cutoff_curve" == key_cc) pCurDef->cutoff_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2000 else if ("cutoff2_curve" == key_cc) pCurDef->cutoff2_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2001 else if ("resonance" == key_cc) pCurDef->resonance_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
2002 else if ("resonance2" == key_cc) pCurDef->resonance2_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
2003 else if ("resonance_smooth" == key_cc) pCurDef->resonance_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
2004 else if ("resonance2_smooth" == key_cc) pCurDef->resonance2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
2005 else if ("resonance_step" == key_cc) pCurDef->resonance_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
2006 else if ("resonance2_step" == key_cc) pCurDef->resonance2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
2007 else if ("resonance_curve" == key_cc) pCurDef->resonance_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
2008 else if ("resonance2_curve" == key_cc) pCurDef->resonance2_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
2009
2010 // per voice equalizer
2011 else if ("eq1_freq" == key_cc) pCurDef->eq1_freq_oncc.set(num_cc, ToInt(value));
2012 else if ("eq2_freq" == key_cc) pCurDef->eq2_freq_oncc.set(num_cc, ToInt(value));
2013 else if ("eq3_freq" == key_cc) pCurDef->eq3_freq_oncc.set(num_cc, ToInt(value));
2014 else if ("eq1_bw" == key_cc) pCurDef->eq1_bw_oncc.set(num_cc, ToInt(value));
2015 else if ("eq2_bw" == key_cc) pCurDef->eq2_bw_oncc.set(num_cc, ToInt(value));
2016 else if ("eq3_bw" == key_cc) pCurDef->eq3_bw_oncc.set(num_cc, ToInt(value));
2017 else if ("eq1_gain" == key_cc) pCurDef->eq1_gain_oncc.set(num_cc, ToInt(value));
2018 else if ("eq2_gain" == key_cc) pCurDef->eq2_gain_oncc.set(num_cc, ToInt(value));
2019 else if ("eq3_gain" == key_cc) pCurDef->eq3_gain_oncc.set(num_cc, ToInt(value));
2020
2021 else if ("ampeg_delay" == key_cc) pCurDef->ampeg_delaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2022 else if ("ampeg_start" == key_cc) pCurDef->ampeg_startcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2023 else if ("ampeg_attack" == key_cc) pCurDef->ampeg_attackcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2024 else if ("ampeg_hold" == key_cc) pCurDef->ampeg_holdcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2025 else if ("ampeg_decay" == key_cc) pCurDef->ampeg_decaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2026 else if ("ampeg_sustain" == key_cc) pCurDef->ampeg_sustaincc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2027 else if ("ampeg_release" == key_cc) pCurDef->ampeg_releasecc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2028
2029 else if ("fileg_delay" == key_cc) pCurDef->fileg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2030 else if ("fileg_start" == key_cc) pCurDef->fileg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2031 else if ("fileg_attack" == key_cc) pCurDef->fileg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2032 else if ("fileg_hold" == key_cc) pCurDef->fileg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2033 else if ("fileg_decay" == key_cc) pCurDef->fileg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2034 else if ("fileg_sustain" == key_cc) pCurDef->fileg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2035 else if ("fileg_release" == key_cc) pCurDef->fileg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2036 else if ("fileg_depth" == key_cc) pCurDef->fileg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2037
2038 else if ("pitcheg_delay" == key_cc) pCurDef->pitcheg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2039 else if ("pitcheg_start" == key_cc) pCurDef->pitcheg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2040 else if ("pitcheg_attack" == key_cc) pCurDef->pitcheg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2041 else if ("pitcheg_hold" == key_cc) pCurDef->pitcheg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2042 else if ("pitcheg_decay" == key_cc) pCurDef->pitcheg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2043 else if ("pitcheg_sustain" == key_cc) pCurDef->pitcheg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2044 else if ("pitcheg_release" == key_cc) pCurDef->pitcheg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2045 else if ("pitcheg_depth" == key_cc) pCurDef->pitcheg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2046
2047 else if ("pitchlfo_delay" == key_cc) pCurDef->pitchlfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2048 else if ("pitchlfo_fade" == key_cc) pCurDef->pitchlfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2049 else if ("pitchlfo_depth" == key_cc) pCurDef->pitchlfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2050 else if ("pitchlfo_freq" == key_cc) pCurDef->pitchlfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2051 else if ("fillfo_delay" == key_cc) pCurDef->fillfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2052 else if ("fillfo_fade" == key_cc) pCurDef->fillfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2053 else if ("fillfo_depth" == key_cc) pCurDef->fillfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2054 else if ("fillfo_freq" == key_cc) pCurDef->fillfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2055 else if ("amplfo_delay" == key_cc) pCurDef->amplfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2056 else if ("amplfo_fade" == key_cc) pCurDef->amplfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2057 else if ("amplfo_depth" == key_cc) pCurDef->amplfo_depthcc.add( CC(num_cc, check(key, -10.0f, 10.0f, ToFloat(value))) );
2058 else if ("amplfo_freq" == key_cc) pCurDef->amplfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2059 else if ("volume" == key_cc) pCurDef->volume_oncc.add( CC(num_cc, check(key, -144.0f, 100.0f, ToFloat(value))) );
2060 else if ("volume_curve" == key_cc) pCurDef->volume_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2061 else if ("volume_smooth" == key_cc) pCurDef->volume_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2062 else if ("volume_step" == key_cc) pCurDef->volume_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -20.0f, 20.0f, ToFloat(value))) );
2063 else if ("pan" == key_cc) pCurDef->pan_oncc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2064 else if ("pan_curve" == key_cc) pCurDef->pan_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2065 else if ("pan_smooth" == key_cc) pCurDef->pan_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2066 else if ("pan_step" == key_cc) pCurDef->pan_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -100.0f, 100.0f, ToFloat(value))) );
2067 else if ("set_" == key_cc) _instrument->initialCCValues[num_cc] = (num_cc < 128) ? check(key, 0, 127, ToInt(value)) : ToInt(value);
2068 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2069 }
2070
2071 else {
2072 std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2073 }
2074 }
2075
2076 int File::parseKey(const std::string& s) {
2077 int i;
2078 std::istringstream iss(s);
2079 if (isdigit(iss.peek())) {
2080 iss >> i;
2081 } else {
2082 switch (tolower(iss.get())) {
2083 case 'c': i = 0; break;
2084 case 'd': i = 2; break;
2085 case 'e': i = 4; break;
2086 case 'f': i = 5; break;
2087 case 'g': i = 7; break;
2088 case 'a': i = 9; break;
2089 case 'b': i = 11; break;
2090 case '-': if (s == "-1") return -1;
2091 default:
2092 std::cerr << "Not a note: " << s << std::endl;
2093 return 0;
2094 }
2095 if (iss.peek() == '#') {
2096 i++;
2097 iss.get();
2098 } else if (tolower(iss.peek()) == 'b') {
2099 i--;
2100 iss.get();
2101 }
2102 int octave;
2103 if (!(iss >> octave)) {
2104 std::cerr << "Not a note: " << s << std::endl;
2105 return 0;
2106 }
2107 i += (octave + 1) * 12;
2108 }
2109 return i + note_offset + 12 * octave_offset;
2110 }
2111
2112 EGNode::EGNode() : time(0), level(0), shape(0), curve(0) {
2113 }
2114
2115 void EGNode::Copy(const EGNode& egNode) {
2116 time = egNode.time;
2117 level = egNode.level;
2118 shape = egNode.shape;
2119 curve = egNode.curve;
2120
2121 time_oncc = egNode.time_oncc;
2122 level_oncc = egNode.level_oncc;
2123 }
2124
2125 EG::EG() :
2126 sustain(0), loop(0), loop_count(0), amplitude(0), volume(-200), /* less than -144 dB is considered unset */
2127 cutoff(0), pitch(0), resonance(0), pan(0), pan_curve(-1)
2128 { }
2129
2130 void EG::Copy(const EG& eg) {
2131 EqImpl::Copy(static_cast<const EqImpl>(eg));
2132
2133 sustain = eg.sustain;
2134 loop = eg.loop;
2135 loop_count = eg.loop_count;
2136 amplitude = eg.amplitude;
2137 volume = eg.volume;
2138 cutoff = eg.cutoff;
2139 pitch = eg.pitch;
2140 resonance = eg.resonance;
2141 pan = eg.pan;
2142 pan_curve = eg.pan_curve;
2143 node = eg.node;
2144
2145 amplitude_oncc = eg.amplitude_oncc;
2146 volume_oncc = eg.volume_oncc;
2147 cutoff_oncc = eg.cutoff_oncc;
2148 pitch_oncc = eg.pitch_oncc;
2149 resonance_oncc = eg.resonance_oncc;
2150 pan_oncc = eg.pan_oncc;
2151 pan_curvecc = eg.pan_curvecc;
2152 }
2153
2154 LFO::LFO():
2155 delay(0),
2156 freq(-1), /* -1 is used to determine whether the LFO was initialized */
2157 fade(0), phase(0), wave(0), volume(0), pitch(0), cutoff(0), resonance(0), pan(0)
2158 {
2159 }
2160
2161 void LFO::Copy(const LFO& lfo) {
2162 EqSmoothStepImpl::Copy(static_cast<const EqSmoothStepImpl>(lfo));
2163
2164 delay = lfo.delay;
2165 freq = lfo.freq;
2166 fade = lfo.fade;
2167 phase = lfo.phase;
2168 wave = lfo.wave;
2169 volume = lfo.volume;
2170 pitch = lfo.pitch;
2171 cutoff = lfo.cutoff;
2172 resonance = lfo.resonance;
2173 pan = lfo.pan;
2174
2175 delay_oncc = lfo.delay_oncc;
2176 freq_oncc = lfo.freq_oncc;
2177 freq_smoothcc = lfo.freq_smoothcc;
2178 freq_stepcc = lfo.freq_stepcc;
2179 fade_oncc = lfo.fade_oncc;
2180 phase_oncc = lfo.phase_oncc;
2181 pitch_oncc = lfo.pitch_oncc;
2182 pitch_smoothcc = lfo.pitch_smoothcc;
2183 pitch_stepcc = lfo.pitch_stepcc;
2184 volume_oncc = lfo.volume_oncc;
2185 volume_smoothcc = lfo.volume_smoothcc;
2186 volume_stepcc = lfo.volume_stepcc;
2187 pan_oncc = lfo.pan_oncc;
2188 pan_smoothcc = lfo.pan_smoothcc;
2189 pan_stepcc = lfo.pan_stepcc;
2190 cutoff_oncc = lfo.cutoff_oncc;
2191 cutoff_smoothcc = lfo.cutoff_smoothcc;
2192 cutoff_stepcc = lfo.cutoff_stepcc;
2193 resonance_oncc = lfo.resonance_oncc;
2194 resonance_smoothcc = lfo.resonance_smoothcc;
2195 resonance_stepcc = lfo.resonance_stepcc;
2196 }
2197
2198 EqImpl::EqImpl() {
2199 eq1freq = eq2freq = eq3freq = 0;
2200 eq1bw = eq2bw = eq3bw = 0;
2201 eq1gain = eq2gain = eq3gain = 0;
2202 }
2203
2204 void EqImpl::Copy(const EqImpl& eq) {
2205 eq1freq = eq.eq1freq;
2206 eq2freq = eq.eq2freq;
2207 eq3freq = eq.eq3freq;
2208 eq1bw = eq.eq1bw;
2209 eq2bw = eq.eq2bw;
2210 eq3bw = eq.eq3bw;
2211 eq1gain = eq.eq1gain;
2212 eq2gain = eq.eq2gain;
2213 eq3gain = eq.eq3gain;
2214
2215 eq1freq_oncc = eq.eq1freq_oncc;
2216 eq2freq_oncc = eq.eq2freq_oncc;
2217 eq3freq_oncc = eq.eq3freq_oncc;
2218 eq1bw_oncc = eq.eq1bw_oncc;
2219 eq2bw_oncc = eq.eq2bw_oncc;
2220 eq3bw_oncc = eq.eq3bw_oncc;
2221 eq1gain_oncc = eq.eq1gain_oncc;
2222 eq2gain_oncc = eq.eq2gain_oncc;
2223 eq3gain_oncc = eq.eq3gain_oncc;
2224 }
2225
2226 bool EqImpl::HasEq() {
2227 return eq1freq || eq2freq || eq3freq || eq1bw || eq2bw || eq3bw ||
2228 eq1gain || eq2gain || eq3gain || !eq1gain_oncc.empty() ||
2229 !eq2gain_oncc.empty() || !eq3gain_oncc.empty() ||
2230 !eq1freq_oncc.empty() || !eq2freq_oncc.empty() || !eq3freq_oncc.empty() ||
2231 !eq1bw_oncc.empty() || !eq2bw_oncc.empty() || !eq3bw_oncc.empty();
2232 }
2233
2234 void EqSmoothStepImpl::Copy(const EqSmoothStepImpl& eq) {
2235 EqImpl::Copy(eq);