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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3082 - (hide annotations) (download)
Mon Jan 9 18:39:35 2017 UTC (7 years, 3 months ago) by schoenebeck
File size: 108095 byte(s) 
* Added support for sfz extension opcode 'script' which may be used to
  load real-time instrument script file (NKSP script language).
* Removed code duplication in SFZ file loading code.
* Bumped version (2.0.0.svn37).
1 iliev 2012 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 persson 2055 * Copyright (C) 2008 Anders Dahnielson <anders@dahnielson.com> *
6 persson 2856 * Copyright (C) 2009 - 2016 Anders Dahnielson and Grigor Iliev *
7 iliev 2012 * *
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 persson 2058 #include <cctype>
29 persson 2055 #include <cstdio>
30     #include <cstring>
31 iliev 2012
32     #include "../../common/File.h"
33     #include "../../common/Path.h"
34 persson 2106 #include "LookupTable.h"
35 schoenebeck 3082 #include "../../common/global_private.h"
36 iliev 2012
37     namespace sfz
38     {
39 iliev 2218 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 iliev 2012
54 iliev 2234 Sample* SampleManager::FindSample(std::string samplePath, uint offset, int end) {
55 iliev 2021 std::map<Sample*, std::set<Region*> >::iterator it = sampleMap.begin();
56 iliev 2012 for (; it != sampleMap.end(); it++) {
57 iliev 2216 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 iliev 2234 if (it->first->Offset == offset && it->first->End == end) return it->first;
63 iliev 2216 }
64 iliev 2012 }
65    
66     return NULL;
67     }
68    
69     /////////////////////////////////////////////////////////////
70 schoenebeck 3082 // class Script
71 iliev 2012
72 schoenebeck 3082 Script::Script(LinuxSampler::Path path) : m_path(path) {
73     }
74 iliev 2012
75 schoenebeck 3082 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 iliev 2012 /////////////////////////////////////////////////////////////
103     // class Articulation
104    
105     Articulation::Articulation()
106     {
107     }
108    
109     Articulation::~Articulation()
110     {
111     }
112    
113     /////////////////////////////////////////////////////////////
114     // class Definition
115    
116 persson 2091 Definition::Definition()
117 iliev 2012 {
118     }
119    
120     Definition::~Definition()
121     {
122     }
123    
124     /////////////////////////////////////////////////////////////
125     // class Region
126    
127     Region::Region()
128     {
129     pSample = NULL;
130 persson 2072 seq_counter = 1;
131 iliev 2012 }
132    
133     Region::~Region()
134     {
135     DestroySampleIfNotUsed();
136     }
137    
138 iliev 2021 Sample* Region::GetSample(bool create)
139 iliev 2012 {
140 persson 2317 if (pSample == NULL && create) {
141 iliev 2234 uint i = offset ? *offset : 0;
142 persson 2317 Sample* sf = GetInstrument()->GetSampleManager()->FindSample(sample, i, end);
143 iliev 2012 if (sf != NULL) pSample = sf; // Reuse already created sample
144 persson 2317 else pSample = new Sample(sample, false, i, end);
145 iliev 2012 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 persson 2101 bool Region::OnKey(const Query& q) {
161 persson 2106 // 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 persson 2101 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 iliev 2012
171 persson 2086 ( sw_last == -1 ||
172 persson 2101 ((sw_last >= sw_lokey && sw_last <= sw_hikey) ? (q.last_sw_key == sw_last) : false) ) &&
173 iliev 2012
174 persson 2086 ( sw_down == -1 ||
175 persson 2101 ((sw_down >= sw_lokey && (sw_hikey == -1 || sw_down <= sw_hikey)) ? (q.sw[sw_down]) : false) ) &&
176 iliev 2012
177 persson 2086 ( sw_up == -1 ||
178 persson 2101 ((sw_up >= sw_lokey && (sw_hikey == -1 || sw_up <= sw_hikey)) ? (!q.sw[sw_up]) : true) ) &&
179 iliev 2012
180 persson 2101 ((trigger & q.trig) != 0)
181 iliev 2012 );
182    
183     if (!is_triggered)
184     return false;
185    
186 persson 2072 // 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 iliev 2012 }
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 iliev 2021 bool Region::HasLoop() {
201 persson 2317 bool b = loop_mode == LOOP_UNSET ? pSample->GetLoops() :
202     (loop_mode == LOOP_CONTINUOUS || loop_mode == LOOP_SUSTAIN);
203     return b && GetLoopEnd() > GetLoopStart();
204 iliev 2021 }
205    
206     uint Region::GetLoopStart() {
207 persson 2167 return (!loop_start) ? pSample->GetLoopStart() : *loop_start;
208 iliev 2021 }
209    
210     uint Region::GetLoopEnd() {
211 persson 2167 return (!loop_end) ? pSample->GetLoopEnd() : *loop_end;
212 iliev 2021 }
213    
214     uint Region::GetLoopCount() {
215     return (!count) ? 0 : *count;
216     }
217    
218 iliev 2012 /////////////////////////////////////////////////////////////
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 persson 2106 pLookupTable = 0;
226 iliev 2230
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 iliev 2012 }
234    
235     Instrument::~Instrument()
236     {
237 persson 2106 for (int i = 0; i < regions.size(); i++) {
238     delete regions[i];
239 iliev 2012 }
240 persson 2106 delete pLookupTable;
241 persson 2115 for (int i = 0 ; i < 128 ; i++) {
242     delete pLookupTableCC[i];
243     }
244 iliev 2012 }
245    
246 persson 2106 void Query::search(const Instrument* pInstrument) {
247     pRegionList = &pInstrument->pLookupTable->query(*this);
248     regionIndex = 0;
249 persson 2101 }
250    
251 persson 2115 void Query::search(const Instrument* pInstrument, int triggercc) {
252     pRegionList = &pInstrument->pLookupTableCC[triggercc]->query(*this);
253     regionIndex = 0;
254     }
255    
256 persson 2101 Region* Query::next() {
257 persson 2106 for ( ; regionIndex < pRegionList->size() ; regionIndex++) {
258     if ((*pRegionList)[regionIndex]->OnKey(*this)) {
259     return (*pRegionList)[regionIndex++];
260     }
261 iliev 2012 }
262 persson 2101 return 0;
263 iliev 2012 }
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 persson 2856 // class ContainerDefinition
289 iliev 2012
290 persson 2856 ContainerDefinition::ContainerDefinition(section_type type)
291 iliev 2012 {
292     Reset();
293 persson 2856 level = type;
294 iliev 2012 }
295    
296 persson 2856 ContainerDefinition::~ContainerDefinition()
297 iliev 2012 {
298     }
299    
300     void
301 persson 2856 ContainerDefinition::Reset()
302 iliev 2012 {
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 iliev 2027 group = 0;
333 persson 2114 off_by = 0;
334 iliev 2012 off_mode = OFF_FAST;
335    
336     // sample player
337 schoenebeck 3082 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 persson 2317 end = 0;
344 schoenebeck 3082 loop_crossfade = optional<float>::nothing;
345     offset = optional<uint>::nothing;
346     offset_random = optional<int>::nothing;
347 persson 2167 loop_mode = LOOP_UNSET;
348 schoenebeck 3082 loop_start = optional<int>::nothing;
349     loop_end = optional<int>::nothing;
350     sync_beats = optional<int>::nothing;
351     sync_offset = optional<int>::nothing;
352 iliev 2012
353     // amplifier
354     volume = 0;
355 iliev 2231 volume_oncc.clear();
356     volume_curvecc.clear();
357 iliev 2232 volume_smoothcc.clear();
358 iliev 2265 volume_stepcc.clear();
359 persson 2403 amplitude = 100;
360 iliev 2012 pan = 0;
361 iliev 2237 pan_oncc.clear();
362     pan_curvecc.clear();
363     pan_smoothcc.clear();
364 iliev 2265 pan_stepcc.clear();
365 iliev 2012 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 iliev 2264
391     pitch_oncc.clear();
392     pitch_smoothcc.clear();
393     pitch_curvecc.clear();
394     pitch_stepcc.clear();
395 iliev 2012
396     // filter
397     fil_type = LPF_2P;
398 schoenebeck 3082 cutoff = optional<float>::nothing;
399 iliev 2012 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 schoenebeck 3082 cutoff2 = optional<float>::nothing;
409 iliev 2012 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 iliev 2252
417     cutoff_oncc.clear();
418     cutoff_smoothcc.clear();
419     cutoff_curvecc.clear();
420 iliev 2265 cutoff_stepcc.clear();
421 iliev 2252 cutoff2_oncc.clear();
422     cutoff2_smoothcc.clear();
423     cutoff2_curvecc.clear();
424 iliev 2265 cutoff2_stepcc.clear();
425 iliev 2252
426     resonance_oncc.clear();
427     resonance_smoothcc.clear();
428     resonance_curvecc.clear();
429 iliev 2265 resonance_stepcc.clear();
430 iliev 2252 resonance2_oncc.clear();
431     resonance2_smoothcc.clear();
432     resonance2_curvecc.clear();
433 iliev 2265 resonance2_stepcc.clear();
434 iliev 2012
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 persson 2091 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 iliev 2012
465     // sample player
466 persson 2091 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 iliev 2012
470     // amplifier
471 persson 2091 amp_velcurve.set(i, -1);
472     gain_oncc.set(i, 0);
473     xfin_locc.set(i, 0);
474     xfin_hicc.set(i, 0);
475 iliev 2236 xfout_locc.set(i, 0);
476     xfout_hicc.set(i, 0);
477 iliev 2012
478     // per voice equalizer
479 persson 2091 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 iliev 2012 }
489 iliev 2018
490 persson 2055 eg.clear();
491 iliev 2231 lfos.clear();
492 persson 2055
493 iliev 2018 // deprecated
494     ampeg_delay = 0;
495     ampeg_start = 0; //in percentage
496     ampeg_attack = 0;
497     ampeg_hold = 0;
498     ampeg_decay = 0;
499 iliev 2218 ampeg_sustain = -1; // in percentage
500 iliev 2018 ampeg_release = 0;
501    
502 persson 2176 ampeg_vel2delay = 0;
503     ampeg_vel2attack = 0;
504     ampeg_vel2hold = 0;
505     ampeg_vel2decay = 0;
506     ampeg_vel2sustain = 0;
507     ampeg_vel2release = 0;
508 iliev 2231
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 persson 2176
517 iliev 2018 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 iliev 2222 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 iliev 2249
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 iliev 2222
542 iliev 2018 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 iliev 2220 pitcheg_depth = 0;
550 persson 2072
551 iliev 2220 pitcheg_vel2delay = 0;
552     pitcheg_vel2attack = 0;
553     pitcheg_vel2hold = 0;
554     pitcheg_vel2decay = 0;
555     pitcheg_vel2sustain = 0;
556     pitcheg_vel2release = 0;
557 iliev 2249
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 iliev 2220
567 persson 2072 amplfo_delay = 0;
568     amplfo_fade = 0;
569 iliev 2229 amplfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
570 persson 2072 amplfo_depth = 0;
571 iliev 2248 amplfo_delay_oncc.clear();
572     amplfo_fade_oncc.clear();
573 iliev 2233 amplfo_depthcc.clear();
574 iliev 2231 amplfo_freqcc.clear();
575 persson 2072
576     fillfo_delay = 0;
577     fillfo_fade = 0;
578 iliev 2229 fillfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
579 persson 2072 fillfo_depth = 0;
580 iliev 2248 fillfo_delay_oncc.clear();
581     fillfo_fade_oncc.clear();
582 iliev 2233 fillfo_depthcc.clear();
583 iliev 2231 fillfo_freqcc.clear();
584 persson 2072
585     pitchlfo_delay = 0;
586     pitchlfo_fade = 0;
587 iliev 2229 pitchlfo_freq = -1; /* -1 is used to determine whether the LFO was initialized */
588 persson 2072 pitchlfo_depth = 0;
589 iliev 2248 pitchlfo_delay_oncc.clear();
590     pitchlfo_fade_oncc.clear();
591 iliev 2253 pitchlfo_depthcc.clear();
592 iliev 2231 pitchlfo_freqcc.clear();
593 iliev 2012 }
594    
595 persson 2856 void ContainerDefinition::CopyValuesToDefinition(Definition* definition)
596 iliev 2012 {
597 persson 2856 // This is where the current settings are copied to the new definition.
598 iliev 2012
599     // sample definition
600 persson 2856 definition->sample = sample;
601 iliev 2012
602     // input control
603 persson 2856 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 iliev 2012
645     // sample player
646 persson 2856 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 iliev 2012
665     // amplifier
666 persson 2856 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 iliev 2012
702     // pitch
703 persson 2856 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 iliev 2264
713 persson 2856 definition->pitch_oncc = pitch_oncc;
714     definition->pitch_smoothcc = pitch_smoothcc;
715     definition->pitch_curvecc = pitch_curvecc;
716     definition->pitch_stepcc = pitch_stepcc;
717 iliev 2012
718     // filter
719 persson 2856 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 iliev 2012
737 persson 2856 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 iliev 2012
755     // per voice equalizer
756 persson 2856 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 iliev 2012
781 persson 2055 // envelope generator
782 persson 2856 definition->eg = eg;
783 persson 2055
784 iliev 2018 // deprecated
785 persson 2856 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 iliev 2018
793 persson 2856 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 iliev 2229
800 persson 2856 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 persson 2176
808 persson 2856 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 iliev 2018
817 persson 2856 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 iliev 2249
824 persson 2856 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 iliev 2222
833 persson 2856 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 iliev 2018
842 persson 2856 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 iliev 2249
849 persson 2856 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 iliev 2220
858 persson 2856 definition->amplfo_delay = amplfo_delay;
859     definition->amplfo_fade = amplfo_fade;
860     definition->amplfo_freq = amplfo_freq;
861     definition->amplfo_depth = amplfo_depth;
862 iliev 2227
863 persson 2856 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 persson 2072
868 persson 2856 definition->fillfo_delay = fillfo_delay;
869     definition->fillfo_fade = fillfo_fade;
870     definition->fillfo_freq = fillfo_freq;
871     definition->fillfo_depth = fillfo_depth;
872 iliev 2227
873 persson 2856 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 persson 2072
878 persson 2856 definition->pitchlfo_delay = pitchlfo_delay;
879     definition->pitchlfo_fade = pitchlfo_fade;
880     definition->pitchlfo_freq = pitchlfo_freq;
881     definition->pitchlfo_depth = pitchlfo_depth;
882 iliev 2224
883 persson 2856 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 iliev 2229
888 persson 2856 definition->eg = eg;
889     definition->lfos = lfos;
890 iliev 2012 }
891    
892     /////////////////////////////////////////////////////////////
893     // class File
894    
895 persson 2856 const std::string File::MACRO_NAME_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
896     const std::string File::MACRO_VALUE_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_. /\\";
897    
898 iliev 2012 File::File(std::string file, SampleManager* pSampleManager) :
899 persson 2856 _current_section(GLOBAL),
900 schoenebeck 3034 id(0),
901 iliev 2012 default_path(""),
902     octave_offset(0),
903 schoenebeck 3034 note_offset(0)
904 iliev 2012 {
905     _instrument = new Instrument(LinuxSampler::Path::getBaseName(file), pSampleManager);
906 persson 2856 ContainerDefinition* defaultGlobalContainer = new ContainerDefinition(ContainerDefinition::GLOBAL);
907     _current_containers.push(defaultGlobalContainer);
908     pCurDef = defaultGlobalContainer;
909 schoenebeck 2529
910     parseFile(file,pSampleManager);
911    
912 persson 2091 std::set<float*> velcurves;
913 iliev 2012 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 persson 2115 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 iliev 2012 }
927    
928     // get keyswitches
929     low = pRegion->sw_lokey;
930 persson 2086 if (low < 0) low = 0;
931 iliev 2012 high = pRegion->sw_hikey;
932 persson 2086 if (high == -1) {
933 iliev 2012 // Key switches not defined, so nothing to do
934 persson 2086 } else if (low >= 0 && low <= 127 && high >= 0 && high <= 127 && high >= low) {
935 iliev 2012 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 persson 2082
940     // create velocity response curve
941 persson 2091
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 persson 2082 prevvalue += step;
962     }
963 persson 2091 } else {
964     // default curve
965     for (int v = 0 ; v < 128 ; v++) {
966     velcurve[v] = v * v / (127.0 * 127.0);
967     }
968 persson 2082 }
969     }
970 iliev 2012 }
971 persson 2106
972     _instrument->pLookupTable = new LookupTable(_instrument);
973 persson 2115
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 iliev 2230
980 iliev 2233 for (int i = 0; i < _instrument->regions.size(); i++) {
981     Region* r = _instrument->regions[i];
982 iliev 2230
983     copyCurves(r->volume_curvecc, r->volume_oncc);
984 iliev 2233 r->volume_curvecc.clear();
985    
986 iliev 2232 copySmoothValues(r->volume_smoothcc, r->volume_oncc);
987 iliev 2233 r->volume_smoothcc.clear();
988 iliev 2230
989 iliev 2265 copyStepValues(r->volume_stepcc, r->volume_oncc);
990     r->volume_stepcc.clear();
991    
992 iliev 2264 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 iliev 2237 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 iliev 2265 copyStepValues(r->pan_stepcc, r->pan_oncc);
1008     r->pan_stepcc.clear();
1009    
1010 iliev 2252 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 iliev 2265 copyStepValues(r->cutoff_stepcc, r->cutoff_oncc);
1017     r->cutoff_stepcc.clear();
1018    
1019 iliev 2252 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 iliev 2265 copyStepValues(r->cutoff2_stepcc, r->cutoff2_oncc);
1026     r->cutoff2_stepcc.clear();
1027    
1028 iliev 2252 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 iliev 2265 copyStepValues(r->resonance_stepcc, r->resonance_oncc);
1035     r->resonance_stepcc.clear();
1036    
1037 iliev 2252 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 iliev 2265 copyStepValues(r->resonance2_stepcc, r->resonance2_oncc);
1044     r->resonance2_stepcc.clear();
1045    
1046 iliev 2237 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 iliev 2233 for (int j = 0; j < r->lfos.size(); j++) {
1052 iliev 2299 r->lfos[j].copySmoothValues();
1053     r->lfos[j].copyStepValues();
1054    
1055 iliev 2233 copySmoothValues(r->lfos[j].volume_smoothcc, r->lfos[j].volume_oncc);
1056     r->lfos[j].volume_smoothcc.clear();
1057    
1058 iliev 2265 copyStepValues(r->lfos[j].volume_stepcc, r->lfos[j].volume_oncc);
1059     r->lfos[j].volume_stepcc.clear();
1060    
1061 iliev 2233 copySmoothValues(r->lfos[j].freq_smoothcc, r->lfos[j].freq_oncc);
1062     r->lfos[j].freq_smoothcc.clear();
1063    
1064 iliev 2265 copyStepValues(r->lfos[j].freq_stepcc, r->lfos[j].freq_oncc);
1065     r->lfos[j].freq_stepcc.clear();
1066    
1067 iliev 2233 copySmoothValues(r->lfos[j].pitch_smoothcc, r->lfos[j].pitch_oncc);
1068     r->lfos[j].pitch_smoothcc.clear();
1069    
1070 iliev 2265 copyStepValues(r->lfos[j].pitch_stepcc, r->lfos[j].pitch_oncc);
1071     r->lfos[j].pitch_stepcc.clear();
1072    
1073 iliev 2233 copySmoothValues(r->lfos[j].pan_smoothcc, r->lfos[j].pan_oncc);
1074     r->lfos[j].pan_smoothcc.clear();
1075    
1076 iliev 2265 copyStepValues(r->lfos[j].pan_stepcc, r->lfos[j].pan_oncc);
1077     r->lfos[j].pan_stepcc.clear();
1078    
1079 iliev 2233 copySmoothValues(r->lfos[j].cutoff_smoothcc, r->lfos[j].cutoff_oncc);
1080     r->lfos[j].cutoff_smoothcc.clear();
1081    
1082 iliev 2265 copyStepValues(r->lfos[j].cutoff_stepcc, r->lfos[j].cutoff_oncc);
1083     r->lfos[j].cutoff_stepcc.clear();
1084    
1085 iliev 2233 copySmoothValues(r->lfos[j].resonance_smoothcc, r->lfos[j].resonance_oncc);
1086     r->lfos[j].resonance_smoothcc.clear();
1087 iliev 2265
1088     copyStepValues(r->lfos[j].resonance_stepcc, r->lfos[j].resonance_oncc);
1089     r->lfos[j].resonance_stepcc.clear();
1090 iliev 2233 }
1091 iliev 2230 }
1092 iliev 2012 }
1093    
1094 persson 2533 void File::parseFile(std::string file, SampleManager* pSampleManager){
1095     enum token_type_t { HEADER, OPCODE };
1096 schoenebeck 3054 token_type_t token_type = (token_type_t) -1;
1097 persson 2533 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 persson 2856 // #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 schoenebeck 3082 // 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 persson 2533
1211     // DEFINITION
1212     std::stringstream linestream(line);
1213     int spaces = 0;
1214     while (linestream >> token)
1215     {
1216     linestream >> std::noskipws;
1217     if (token[0] == '<' && token[token.size()-1] == '>')
1218     {
1219     // HEAD
1220     if (!token_string.empty())
1221     {
1222     switch (token_type)
1223     {
1224     case HEADER:
1225     push_header(token_string);
1226     break;
1227     case OPCODE:
1228     push_opcode(token_string);
1229     break;
1230     }
1231     token_string.erase();
1232     }
1233     token_string.append(token);
1234     token_type = HEADER;
1235     }
1236     else if (token.find('=') != std::string::npos)
1237     {
1238     // HEAD
1239     if (!token_string.empty())
1240     {
1241     switch (token_type)
1242     {
1243     case HEADER:
1244     push_header(token_string);
1245     break;
1246     case OPCODE:
1247     push_opcode(token_string);
1248     break;
1249     }
1250     token_string.erase();
1251     }
1252     token_string.append(token);
1253     token_type = OPCODE;
1254     }
1255     else
1256     {
1257     // TAIL
1258     token_string.append(spaces, ' ');
1259     token_string.append(token);
1260     }
1261     spaces = 0;
1262     while (isspace(linestream.peek())) {
1263     linestream.ignore();
1264     spaces++;
1265     }
1266     }
1267    
1268     // EOL
1269     if (!token_string.empty())
1270     {
1271     switch (token_type)
1272     {
1273     case HEADER:
1274     push_header(token_string);
1275     break;
1276     case OPCODE:
1277     push_opcode(token_string);
1278     break;
1279     }
1280     token_string.erase();
1281     }
1282     }
1283     }
1284    
1285 iliev 2012 File::~File()
1286     {
1287 persson 2856 for (int i = 0; i < _current_containers.size(); i++)
1288     {
1289     delete _current_containers.top();
1290     _current_containers.pop();
1291     }
1292 iliev 2012 delete _instrument;
1293     }
1294    
1295     Instrument*
1296     File::GetInstrument()
1297     {
1298     return _instrument;
1299     }
1300 iliev 2230
1301     void File::copyCurves(LinuxSampler::ArrayList<CC>& curves, LinuxSampler::ArrayList<CC>& dest) {
1302     for (int i = 0; i < curves.size(); i++) {
1303     for (int j = 0; j < dest.size(); j++) {
1304     if (curves[i].Controller == dest[j].Controller) {
1305     dest[j].Curve = curves[i].Curve;
1306     }
1307     }
1308     }
1309     }
1310 iliev 2232
1311     void File::copySmoothValues(LinuxSampler::ArrayList<CC>& smooths, LinuxSampler::ArrayList<CC>& dest) {
1312     for (int i = 0; i < smooths.size(); i++) {
1313     for (int j = 0; j < dest.size(); j++) {
1314     if (smooths[i].Controller == dest[j].Controller) {
1315     dest[j].Smooth = smooths[i].Smooth;
1316     }
1317     }
1318     }
1319     }
1320 iliev 2237
1321 iliev 2264 void File::copyStepValues(LinuxSampler::ArrayList<CC>& steps, LinuxSampler::ArrayList<CC>& dest) {
1322     for (int i = 0; i < steps.size(); i++) {
1323     for (int j = 0; j < dest.size(); j++) {
1324     if (steps[i].Controller == dest[j].Controller) {
1325     dest[j].Step = steps[i].Step;
1326     }
1327     }
1328     }
1329     }
1330    
1331 iliev 2237 int File::ToInt(const std::string& s) throw(LinuxSampler::Exception) {
1332     int i;
1333     std::istringstream iss(s);
1334     if(!(iss >> i)) {
1335     std::ostringstream oss;
1336     oss << "Line " << currentLine << ": Expected an integer";
1337     throw LinuxSampler::Exception(oss.str());
1338     }
1339     return i;
1340     }
1341 iliev 2012
1342 iliev 2237 float File::ToFloat(const std::string& s) throw(LinuxSampler::Exception) {
1343     float i;
1344     std::istringstream iss(s);
1345     if(!(iss >> i)) {
1346     std::ostringstream oss;
1347     oss << "Line " << currentLine << ": Expected a floating-point number";
1348     throw LinuxSampler::Exception(oss.str());
1349     }
1350     return i;
1351     }
1352    
1353 iliev 2012 void
1354     File::push_header(std::string token)
1355     {
1356 persson 2856 if (token == "<global>" ||
1357     token == "<master>" ||
1358     token == "<group>")
1359 iliev 2012 {
1360 schoenebeck 3034 ContainerDefinition::section_type level = ContainerDefinition::GLOBAL; // initialized only to avoid an irrelevant compiler warning
1361    
1362 persson 2856 if (token == "<global>")
1363     {
1364     _current_section = GLOBAL;
1365     level = ContainerDefinition::GLOBAL;
1366     }
1367     else if (token == "<master>")
1368     {
1369     _current_section = MASTER;
1370     level = ContainerDefinition::MASTER;
1371     }
1372     else if (token == "<group>")
1373     {
1374     _current_section = GROUP;
1375     level = ContainerDefinition::GROUP;
1376     }
1377 schoenebeck 3034
1378 persson 2856 ContainerDefinition* newContainer = new ContainerDefinition(level);
1379    
1380     while (_current_containers.size() > 0 && _current_containers.top()->level <= level)
1381     {
1382     delete _current_containers.top();
1383     _current_containers.pop();
1384     }
1385    
1386     //If the new header is a <global>, there won't be anything left in _current_containers
1387     //to copy from.
1388     if (_current_containers.size() > 0)
1389     {
1390     _current_containers.top()->CopyValuesToDefinition(newContainer);
1391     }
1392     _current_containers.push(newContainer);
1393     pCurDef = newContainer;
1394 iliev 2012 }
1395     else if (token == "<region>")
1396     {
1397     _current_section = REGION;
1398 persson 2856 _current_region = new Region();
1399     _current_region->id = id++;
1400     _current_containers.top()->CopyValuesToDefinition(_current_region);
1401 persson 2055 pCurDef = _current_region;
1402 iliev 2012 _instrument->regions.push_back(_current_region);
1403 persson 2055 _current_region->SetInstrument(_instrument);
1404 iliev 2012 }
1405     else if (token == "<control>")
1406     {
1407     _current_section = CONTROL;
1408     default_path = "";
1409     octave_offset = 0;
1410     note_offset = 0;
1411     }
1412 iliev 2230 else if (token == "<curve>")
1413     {
1414     _current_section = CURVE;
1415     _instrument->curves.add(Curve());
1416     _current_curve = &_instrument->curves[_instrument->curves.size() - 1];
1417     }
1418 iliev 2012 else
1419     {
1420     _current_section = UNKNOWN;
1421     std::cerr << "The header '" << token << "' is unsupported by libsfz!" << std::endl;
1422     }
1423     }
1424    
1425     void
1426     File::push_opcode(std::string token)
1427     {
1428     if (_current_section == UNKNOWN)
1429     return;
1430    
1431     std::string::size_type delimiter_index = token.find('=');
1432     std::string key = token.substr(0, delimiter_index);
1433     std::string value = token.substr(delimiter_index + 1);
1434 iliev 2229 int x, y, z;
1435 iliev 2230
1436 persson 2856 // Apply macros
1437     size_t macro_start = 0;
1438     size_t macro_end = 0;
1439     std::string macro_value;
1440     while ((macro_start = value.find("$", macro_start + macro_value.size())) != std::string::npos)
1441     {
1442     macro_end = value.find_first_not_of(MACRO_NAME_CHARS, macro_start + 1);
1443     size_t macro_len = macro_end - macro_start;
1444     std::string macro_name = value.substr(macro_start, macro_len);
1445     if (_defined_macros.count(macro_name) != 0)
1446     {
1447     macro_value = _defined_macros[macro_name];
1448     value.replace(macro_start, macro_len, macro_value);
1449     }
1450     else
1451     {
1452     std::cerr << "Macro '" << macro_name << "' referenced on line ";
1453     std::cerr << currentLine << " is undefined." << std::endl;
1454     return;
1455     }
1456     }
1457    
1458 iliev 2230 if (_current_section == CURVE) {
1459     if (sscanf(key.c_str(), "v%d", &x)) {
1460     if (x < 0 || x > 127) {
1461     std::cerr << "Invalid curve index: " << x << std::endl;
1462     }
1463     _current_curve->v[x] = check(key, 0.0f, 1.0f, ToFloat(value));
1464     } else {
1465     std::cerr << "The opcode '" << key << "' in section <curve> is unsupported by libsfz!" << std::endl;
1466     }
1467    
1468     return;
1469     }
1470 iliev 2012
1471     // sample definition
1472     if ("sample" == key)
1473     {
1474     std::string path = default_path + value;
1475     #ifndef WIN32
1476 persson 2311 for (int i = 0; i < path.length(); i++) if (path[i] == '\\') path[i] = '/';
1477     bool absolute = path[0] == '/';
1478     #else
1479     bool absolute = path[0] == '/' || path[0] == '\\' ||
1480     (path.length() >= 2 && isalpha(path[0]) && path[1] == ':');
1481 iliev 2012 #endif
1482 persson 2311 if (!absolute) path = currentDir + LinuxSampler::File::DirSeparator + path;
1483 iliev 2012 if(pCurDef) pCurDef->sample = path;
1484     return;
1485     }
1486    
1487     // control header directives
1488     else if ("default_path" == key)
1489     {
1490     switch (_current_section)
1491     {
1492     case CONTROL:
1493     default_path = value;
1494 schoenebeck 3054 break;
1495     default:
1496     ; // noop
1497 iliev 2012 }
1498     return;
1499     }
1500     else if ("octave_offset" == key)
1501     {
1502     switch (_current_section)
1503     {
1504     case CONTROL:
1505     octave_offset = ToInt(value);
1506 schoenebeck 3054 break;
1507     default:
1508     ; // noop
1509 iliev 2012 }
1510     return;
1511     }
1512     else if ("note_offset" == key)
1513     {
1514     switch (_current_section)
1515     {
1516     case CONTROL:
1517     note_offset = ToInt(value);
1518 schoenebeck 3054 break;
1519     default:
1520     ; // noop
1521 iliev 2012 }
1522     return;
1523     }
1524    
1525     // input controls
1526     else if ("lochan" == key) pCurDef->lochan = ToInt(value);
1527     else if ("hichan" == key) pCurDef->hichan = ToInt(value);
1528 persson 2058 else if ("lokey" == key) pCurDef->lokey = parseKey(value);
1529     else if ("hikey" == key) pCurDef->hikey = parseKey(value);
1530 iliev 2012 else if ("key" == key)
1531     {
1532 persson 2058 pCurDef->lokey = pCurDef->hikey = pCurDef->pitch_keycenter = parseKey(value);
1533 iliev 2012 }
1534     else if ("lovel" == key) pCurDef->lovel = ToInt(value);
1535     else if ("hivel" == key) pCurDef->hivel = ToInt(value);
1536     else if ("lobend" == key) pCurDef->lobend = ToInt(value);
1537     else if ("hibend" == key) pCurDef->hibend = ToInt(value);
1538 persson 2106 else if ("lobpm" == key) pCurDef->lobpm = ToFloat(value);
1539     else if ("hibpm" == key) pCurDef->hibpm = ToFloat(value);
1540 iliev 2012 else if ("lochanaft" == key) pCurDef->lochanaft = ToInt(value);
1541     else if ("hichanaft" == key) pCurDef->hichanaft = ToInt(value);
1542     else if ("lopolyaft" == key) pCurDef->lopolyaft = ToInt(value);
1543     else if ("hipolyaft" == key) pCurDef->hipolyaft = ToInt(value);
1544     else if ("loprog" == key) pCurDef->loprog = ToInt(value);
1545     else if ("hiprog" == key) pCurDef->hiprog = ToInt(value);
1546     else if ("lorand" == key) pCurDef->lorand = ToFloat(value);
1547     else if ("hirand" == key) pCurDef->hirand = ToFloat(value);
1548     else if ("lotimer" == key) pCurDef->lotimer = ToFloat(value);
1549     else if ("hitimer" == key) pCurDef->hitimer = ToFloat(value);
1550     else if ("seq_length" == key) pCurDef->seq_length = ToInt(value);
1551     else if ("seq_position" == key) pCurDef->seq_position = ToInt(value);
1552 persson 2058 else if ("sw_lokey" == key) pCurDef->sw_lokey = parseKey(value);
1553     else if ("sw_hikey" == key) pCurDef->sw_hikey = parseKey(value);
1554     else if ("sw_last" == key) pCurDef->sw_last = parseKey(value);
1555     else if ("sw_down" == key) pCurDef->sw_down = parseKey(value);
1556     else if ("sw_up" == key) pCurDef->sw_up = parseKey(value);
1557     else if ("sw_previous" == key) pCurDef->sw_previous = parseKey(value);
1558 iliev 2012 else if ("sw_vel" == key)
1559     {
1560     if (value == "current") pCurDef->sw_vel = VEL_CURRENT;
1561     else if (value == "previous") pCurDef->sw_vel = VEL_PREVIOUS;
1562     }
1563     else if ("trigger" == key)
1564     {
1565     if (value == "attack") pCurDef->trigger = TRIGGER_ATTACK;
1566     else if (value == "release") pCurDef->trigger = TRIGGER_RELEASE;
1567     else if (value == "first") pCurDef->trigger = TRIGGER_FIRST;
1568     else if (value == "legato") pCurDef->trigger = TRIGGER_LEGATO;
1569     }
1570     else if ("group" == key) pCurDef->group = ToInt(value);
1571 persson 2058 else if ("off_by" == key || "offby" == key) pCurDef->off_by = ToInt(value);
1572     else if ("off_mode" == key || "offmode" == key)
1573 iliev 2012 {
1574 persson 2114 if (value == "fast") pCurDef->off_mode = OFF_FAST;
1575     else if (value == "normal") pCurDef->off_mode = OFF_NORMAL;
1576 iliev 2012 }
1577    
1578     // sample player
1579 iliev 2021 else if ("count" == key) { pCurDef->count = ToInt(value); pCurDef->loop_mode = ONE_SHOT; }
1580 iliev 2012 else if ("delay" == key) pCurDef->delay = ToFloat(value);
1581     else if ("delay_random" == key) pCurDef->delay_random = ToFloat(value);
1582     else if ("delay_beats" == key) pCurDef->delay_beats = ToInt(value);
1583     else if ("stop_beats" == key) pCurDef->stop_beats = ToInt(value);
1584     else if ("delay_samples" == key) pCurDef->delay_samples = ToInt(value);
1585     else if ("end" == key) pCurDef->end = ToInt(value);
1586     else if ("loop_crossfade" == key) pCurDef->loop_crossfade = ToFloat(value);
1587     else if ("offset_random" == key) pCurDef->offset_random = ToInt(value);
1588 persson 2058 else if ("loop_mode" == key || "loopmode" == key)
1589 iliev 2012 {
1590     if (value == "no_loop") pCurDef->loop_mode = NO_LOOP;
1591     else if (value == "one_shot") pCurDef->loop_mode = ONE_SHOT;
1592 iliev 2021 else if (value == "loop_continuous") pCurDef->loop_mode = LOOP_CONTINUOUS;
1593 iliev 2012 else if (value == "loop_sustain") pCurDef->loop_mode = LOOP_SUSTAIN;
1594     }
1595     else if ("loop_start" == key) pCurDef->loop_start = ToInt(value);
1596 iliev 2021 else if ("loopstart" == key) pCurDef->loop_start = ToInt(value); // nonstandard
1597 iliev 2012 else if ("loop_end" == key) pCurDef->loop_end = ToInt(value);
1598 iliev 2021 else if ("loopend" == key) pCurDef->loop_end = ToInt(value); // nonstandard
1599 iliev 2216 else if ("offset" == key) pCurDef->offset = ToInt(value);
1600 iliev 2012 else if ("sync_beats" == key) pCurDef->sync_beats = ToInt(value);
1601     else if ("sync_offset" == key) pCurDef->sync_offset = ToInt(value);
1602    
1603     // amplifier
1604     else if ("volume" == key) pCurDef->volume = ToFloat(value);
1605 persson 2403 else if ("amplitude" == key) pCurDef->amplitude = ToFloat(value);
1606 iliev 2012 else if ("pan" == key) pCurDef->pan = ToFloat(value);
1607     else if ("width" == key) pCurDef->width = ToFloat(value);
1608     else if ("position" == key) pCurDef->position = ToFloat(value);
1609     else if ("amp_keytrack" == key) pCurDef->amp_keytrack = ToFloat(value);
1610 persson 2058 else if ("amp_keycenter" == key) pCurDef->amp_keycenter = parseKey(value);
1611 iliev 2012 else if ("amp_veltrack" == key) pCurDef->amp_veltrack = ToFloat(value);
1612     else if ("amp_random" == key) pCurDef->amp_random = ToFloat(value);
1613 iliev 2229 else if ("rt_decay" == key || "rtdecay" == key) pCurDef->rt_decay = ToFloat(value);
1614 persson 2058 else if ("xfin_lokey" == key) pCurDef->xfin_lokey = parseKey(value);
1615     else if ("xfin_hikey" == key) pCurDef->xfin_hikey = parseKey(value);
1616     else if ("xfout_lokey" == key) pCurDef->xfout_lokey = parseKey(value);
1617     else if ("xfout_hikey" == key) pCurDef->xfout_hikey = parseKey(value);
1618 iliev 2012 else if ("xf_keycurve" == key)
1619     {
1620     if (value == "gain") pCurDef->xf_keycurve = GAIN;
1621     else if (value == "power") pCurDef->xf_keycurve = POWER;
1622     }
1623     else if ("xfin_lovel" == key) pCurDef->xfin_lovel = ToInt(value);
1624     else if ("xfin_hivel" == key) pCurDef->xfin_hivel = ToInt(value);
1625     else if ("xfout_lovel" == key) pCurDef->xfout_lovel = ToInt(value);
1626     else if ("xfout_hivel" == key) pCurDef->xfout_hivel = ToInt(value);
1627     else if ("xf_velcurve" == key)
1628     {
1629     if (value == "gain") pCurDef->xf_velcurve = GAIN;
1630     else if (value == "power") pCurDef->xf_velcurve = POWER;
1631     }
1632     else if ("xf_cccurve" == key)
1633     {
1634     if (value == "gain") pCurDef->xf_cccurve = GAIN;
1635     else if (value == "power") pCurDef->xf_cccurve = POWER;
1636     }
1637    
1638     // pitch
1639     else if ("transpose" == key) pCurDef->transpose = ToInt(value);
1640     else if ("tune" == key) pCurDef->tune = ToInt(value);
1641 persson 2058 else if ("pitch_keycenter" == key) pCurDef->pitch_keycenter = parseKey(value);
1642 iliev 2012 else if ("pitch_keytrack" == key) pCurDef->pitch_keytrack = ToInt(value);
1643     else if ("pitch_veltrack" == key) pCurDef->pitch_veltrack = ToInt(value);
1644     else if ("pitch_random" == key) pCurDef->pitch_random = ToInt(value);
1645 persson 2058 else if ("bend_up" == key || "bendup" == key) pCurDef->bend_up = ToInt(value);
1646     else if ("bend_down" == key || "benddown" == key) pCurDef->bend_down = ToInt(value);
1647 iliev 2229 else if ("bend_step" == key || "bendstep" == key) pCurDef->bend_step = ToInt(value);
1648 iliev 2012
1649     // filter
1650 persson 2086 else if ("fil_type" == key || "filtype" == key)
1651 iliev 2012 {
1652     if (value == "lpf_1p") pCurDef->fil_type = LPF_1P;
1653     else if (value == "hpf_1p") pCurDef->fil_type = HPF_1P;
1654     else if (value == "bpf_1p") pCurDef->fil_type = BPF_1P;
1655     else if (value == "brf_1p") pCurDef->fil_type = BRF_1P;
1656     else if (value == "apf_1p") pCurDef->fil_type = APF_1P;
1657     else if (value == "lpf_2p") pCurDef->fil_type = LPF_2P;
1658     else if (value == "hpf_2p") pCurDef->fil_type = HPF_2P;
1659     else if (value == "bpf_2p") pCurDef->fil_type = BPF_2P;
1660     else if (value == "brf_2p") pCurDef->fil_type = BRF_2P;
1661     else if (value == "pkf_2p") pCurDef->fil_type = PKF_2P;
1662     else if (value == "lpf_4p") pCurDef->fil_type = LPF_4P;
1663     else if (value == "hpf_4p") pCurDef->fil_type = HPF_4P;
1664     else if (value == "lpf_6p") pCurDef->fil_type = LPF_6P;
1665     else if (value == "hpf_6p") pCurDef->fil_type = HPF_6P;
1666     }
1667     else if ("fil2_type" == key)
1668     {
1669     if (value == "lpf_1p") pCurDef->fil2_type = LPF_1P;
1670     else if (value == "hpf_1p") pCurDef->fil2_type = HPF_1P;
1671     else if (value == "bpf_1p") pCurDef->fil2_type = BPF_1P;
1672     else if (value == "brf_1p") pCurDef->fil2_type = BRF_1P;
1673     else if (value == "apf_1p") pCurDef->fil2_type = APF_1P;
1674     else if (value == "lpf_2p") pCurDef->fil2_type = LPF_2P;
1675     else if (value == "hpf_2p") pCurDef->fil2_type = HPF_2P;
1676     else if (value == "bpf_2p") pCurDef->fil2_type = BPF_2P;
1677     else if (value == "brf_2p") pCurDef->fil2_type = BRF_2P;
1678     else if (value == "pkf_2p") pCurDef->fil2_type = PKF_2P;
1679     else if (value == "lpf_4p") pCurDef->fil2_type = LPF_4P;
1680     else if (value == "hpf_4p") pCurDef->fil2_type = HPF_4P;
1681     else if (value == "lpf_6p") pCurDef->fil2_type = LPF_6P;
1682     else if (value == "hpf_6p") pCurDef->fil2_type = HPF_6P;
1683     }
1684     else if ("cutoff" == key) pCurDef->cutoff = ToFloat(value);
1685     else if ("cutoff2" == key) pCurDef->cutoff2 = ToFloat(value);
1686 iliev 2252 else if ("cutoff_chanaft" == key) {
1687     pCurDef->cutoff_chanaft = check(key, -9600, 9600, ToInt(value));
1688     pCurDef->cutoff_oncc.add( CC(128, check(key, -9600, 9600, ToInt(value))) );
1689     } else if ("cutoff2_chanaft" == key) pCurDef->cutoff2_chanaft = ToInt(value);
1690 iliev 2012 else if ("cutoff_polyaft" == key) pCurDef->cutoff_polyaft = ToInt(value);
1691     else if ("cutoff2_polyaft" == key) pCurDef->cutoff2_polyaft = ToInt(value);
1692     else if ("resonance" == key) pCurDef->resonance = ToFloat(value);
1693     else if ("resonance2" == key) pCurDef->resonance2 = ToFloat(value);
1694     else if ("fil_keytrack" == key) pCurDef->fil_keytrack = ToInt(value);
1695     else if ("fil2_keytrack" == key) pCurDef->fil2_keytrack = ToInt(value);
1696 persson 2058 else if ("fil_keycenter" == key) pCurDef->fil_keycenter = parseKey(value);
1697     else if ("fil2_keycenter" == key) pCurDef->fil2_keycenter = parseKey(value);
1698 iliev 2012 else if ("fil_veltrack" == key) pCurDef->fil_veltrack = ToInt(value);
1699     else if ("fil2_veltrack" == key) pCurDef->fil2_veltrack = ToInt(value);
1700     else if ("fil_random" == key) pCurDef->fil_random = ToInt(value);
1701     else if ("fil2_random" == key) pCurDef->fil2_random = ToInt(value);
1702    
1703     // per voice equalizer
1704     else if ("eq1_freq" == key) pCurDef->eq1_freq = ToFloat(value);
1705     else if ("eq2_freq" == key) pCurDef->eq2_freq = ToFloat(value);
1706     else if ("eq3_freq" == key) pCurDef->eq3_freq = ToFloat(value);
1707     else if ("eq1_vel2freq" == key) pCurDef->eq1_vel2freq = ToFloat(value);
1708     else if ("eq2_vel2freq" == key) pCurDef->eq2_vel2freq = ToFloat(value);
1709     else if ("eq3_vel2freq" == key) pCurDef->eq3_vel2freq = ToFloat(value);
1710     else if ("eq1_bw" == key) pCurDef->eq1_bw = ToFloat(value);
1711     else if ("eq2_bw" == key) pCurDef->eq2_bw = ToFloat(value);
1712     else if ("eq3_bw" == key) pCurDef->eq3_bw = ToFloat(value);
1713     else if ("eq1_gain" == key) pCurDef->eq1_gain = ToFloat(value);
1714     else if ("eq2_gain" == key) pCurDef->eq2_gain = ToFloat(value);
1715     else if ("eq3_gain" == key) pCurDef->eq3_gain = ToFloat(value);
1716     else if ("eq1_vel2gain" == key) pCurDef->eq1_vel2gain = ToFloat(value);
1717     else if ("eq2_vel2gain" == key) pCurDef->eq2_vel2gain = ToFloat(value);
1718     else if ("eq3_vel2gain" == key) pCurDef->eq3_vel2gain = ToFloat(value);
1719    
1720 persson 2082 else if (sscanf(key.c_str(), "amp_velcurve_%d", &x)) {
1721 persson 2091 pCurDef->amp_velcurve.set(x, ToFloat(value));
1722 persson 2082 }
1723 iliev 2225
1724 persson 2055 // v2 envelope generators
1725     else if (sscanf(key.c_str(), "eg%d%n", &x, &y)) {
1726     const char* s = key.c_str() + y;
1727 iliev 2229 if (sscanf(s, "_time%d%n", &y, &z)) {
1728     const char* s2 = s + z;
1729     if (strcmp(s2, "") == 0) egnode(x, y).time = check(key, 0.0f, 100.0f, ToFloat(value));
1730     else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).time_oncc.add( CC(z, check(key, 0.0f, 100.0f, ToFloat(value))) );
1731     } else if (sscanf(s, "_level%d%n", &y, &z)) {
1732     const char* s2 = s + z;
1733     if (strcmp(s2, "") == 0) egnode(x, y).level = check(key, 0.0f, 1.0f, ToFloat(value));
1734     else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).level_oncc.add( CC(z, check(key, 0.0f, 1.0f, ToFloat(value))) );
1735     }
1736 persson 2055 else if (sscanf(s, "_shape%d", &y)) egnode(x, y).shape = ToFloat(value);
1737     else if (sscanf(s, "_curve%d", &y)) egnode(x, y).curve = ToFloat(value);
1738     else if (strcmp(s, "_sustain") == 0) eg(x).sustain = ToInt(value);
1739     else if (strcmp(s, "_loop") == 0) eg(x).loop = ToInt(value);
1740     else if (strcmp(s, "_loop_count") == 0) eg(x).loop_count = ToInt(value);
1741     else if (strcmp(s, "_amplitude") == 0) eg(x).amplitude = ToFloat(value);
1742 iliev 2235 else if (sscanf(s, "_amplitude_oncc%d", &y)) eg(x).amplitude_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1743     else if (strcmp(s, "_volume") == 0) eg(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1744     else if (sscanf(s, "_volume_oncc%d", &y)) eg(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1745 persson 2055 else if (strcmp(s, "_cutoff") == 0) eg(x).cutoff = ToFloat(value);
1746 iliev 2235 else if (sscanf(s, "_cutoff_oncc%d", &y)) eg(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1747     else if (strcmp(s, "_pitch") == 0) eg(x).pitch = check(key, -9600, 9600, ToInt(value));
1748     else if (sscanf(s, "_pitch_oncc%d", &y)) eg(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1749     else if (strcmp(s, "_resonance") == 0) eg(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1750     else if (sscanf(s, "_resonance_oncc%d", &y)) eg(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1751 iliev 2237 else if (strcmp(s, "_pan") == 0) eg(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1752     else if (strcmp(s, "_pan_curve") == 0) eg(x).pan_curve = check(key, 0, 30000, ToInt(value));
1753     else if (sscanf(s, "_pan_oncc%d", &y)) eg(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1754     else if (sscanf(s, "_pan_curvecc%d", &y)) eg(x).pan_curvecc.add( CC(y, 0.0f, check(key, 0, 30000, ToInt(value))) );
1755 iliev 2299 else if (strcmp(s, "_eq1freq") == 0) eg(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1756     else if (strcmp(s, "_eq2freq") == 0) eg(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1757     else if (strcmp(s, "_eq3freq") == 0) eg(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1758     else if (strcmp(s, "_eq1bw") == 0) eg(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1759     else if (strcmp(s, "_eq2bw") == 0) eg(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1760     else if (strcmp(s, "_eq3bw") == 0) eg(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1761     else if (strcmp(s, "_eq1gain") == 0) eg(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1762     else if (strcmp(s, "_eq2gain") == 0) eg(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1763     else if (strcmp(s, "_eq3gain") == 0) eg(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1764     else if (sscanf(s, "_eq1freq_oncc%d", &y)) eg(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1765     else if (sscanf(s, "_eq2freq_oncc%d", &y)) eg(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1766     else if (sscanf(s, "_eq3freq_oncc%d", &y)) eg(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1767     else if (sscanf(s, "_eq1bw_oncc%d", &y)) eg(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1768     else if (sscanf(s, "_eq2bw_oncc%d", &y)) eg(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1769     else if (sscanf(s, "_eq3bw_oncc%d", &y)) eg(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1770     else if (sscanf(s, "_eq1gain_oncc%d", &y)) eg(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1771     else if (sscanf(s, "_eq2gain_oncc%d", &y)) eg(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1772     else if (sscanf(s, "_eq3gain_oncc%d", &y)) eg(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1773 persson 2055 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1774     }
1775    
1776     // v1 envelope generators
1777 iliev 2018 else if ("ampeg_delay" == key) pCurDef->ampeg_delay = ToFloat(value);
1778     else if ("ampeg_start" == key) pCurDef->ampeg_start = ToFloat(value);
1779     else if ("ampeg_attack" == key) pCurDef->ampeg_attack = ToFloat(value);
1780     else if ("ampeg_hold" == key) pCurDef->ampeg_hold = ToFloat(value);
1781     else if ("ampeg_decay" == key) pCurDef->ampeg_decay = ToFloat(value);
1782     else if ("ampeg_sustain" == key) pCurDef->ampeg_sustain = ToFloat(value);
1783 persson 2176 else if ("ampeg_release" == key) pCurDef->ampeg_release = ToFloat(value);
1784     else if ("ampeg_vel2delay" == key) pCurDef->ampeg_vel2delay = ToFloat(value);
1785     else if ("ampeg_vel2attack" == key) pCurDef->ampeg_vel2attack = ToFloat(value);
1786     else if ("ampeg_vel2hold" == key) pCurDef->ampeg_vel2hold = ToFloat(value);
1787     else if ("ampeg_vel2decay" == key) pCurDef->ampeg_vel2decay = ToFloat(value);
1788     else if ("ampeg_vel2sustain" == key) pCurDef->ampeg_vel2sustain = ToFloat(value);
1789     else if ("ampeg_vel2release" == key) pCurDef->ampeg_vel2release = ToFloat(value);
1790 iliev 2018 else if ("fileg_delay" == key) pCurDef->fileg_delay = ToFloat(value);
1791     else if ("fileg_start" == key) pCurDef->fileg_start = ToFloat(value);
1792     else if ("fileg_attack" == key) pCurDef->fileg_attack = ToFloat(value);
1793     else if ("fileg_hold" == key) pCurDef->fileg_hold = ToFloat(value);
1794     else if ("fileg_decay" == key) pCurDef->fileg_decay = ToFloat(value);
1795     else if ("fileg_sustain" == key) pCurDef->fileg_sustain = ToFloat(value);
1796     else if ("fileg_release" == key) pCurDef->fileg_release = ToFloat(value);
1797 iliev 2222 else if ("fileg_depth" == key) pCurDef->fileg_depth = check(key, -12000, 12000, ToInt(value));
1798     else if ("fileg_vel2delay" == key) pCurDef->fileg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1799     else if ("fileg_vel2attack" == key) pCurDef->fileg_vel2attack = ToFloat(value);
1800     else if ("fileg_vel2hold" == key) pCurDef->fileg_vel2hold = ToFloat(value);
1801     else if ("fileg_vel2decay" == key) pCurDef->fileg_vel2decay = ToFloat(value);
1802     else if ("fileg_vel2sustain" == key) pCurDef->fileg_vel2sustain = ToFloat(value);
1803     else if ("fileg_vel2release" == key) pCurDef->fileg_vel2release = ToFloat(value);
1804 iliev 2018 else if ("pitcheg_delay" == key) pCurDef->pitcheg_delay = ToFloat(value);
1805     else if ("pitcheg_start" == key) pCurDef->pitcheg_start = ToFloat(value);
1806 iliev 2220 else if ("pitcheg_attack" == key) pCurDef->pitcheg_attack = ToFloat(value);
1807     else if ("pitcheg_hold" == key) pCurDef->pitcheg_hold = ToFloat(value);
1808 iliev 2018 else if ("pitcheg_decay" == key) pCurDef->pitcheg_decay = ToFloat(value);
1809 iliev 2220 else if ("pitcheg_sustain" == key) pCurDef->pitcheg_sustain = ToFloat(value);
1810     else if ("pitcheg_release" == key) pCurDef->pitcheg_release = ToFloat(value);
1811     else if ("pitcheg_depth" == key) pCurDef->pitcheg_depth = check(key, -12000, 12000, ToInt(value));
1812     else if ("pitcheg_vel2delay" == key) pCurDef->pitcheg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1813     else if ("pitcheg_vel2attack" == key) pCurDef->pitcheg_vel2attack = ToFloat(value);
1814     else if ("pitcheg_vel2hold" == key) pCurDef->pitcheg_vel2hold = ToFloat(value);
1815     else if ("pitcheg_vel2decay" == key) pCurDef->pitcheg_vel2decay = ToFloat(value);
1816     else if ("pitcheg_vel2sustain" == key) pCurDef->pitcheg_vel2sustain = ToFloat(value);
1817     else if ("pitcheg_vel2release" == key) pCurDef->pitcheg_vel2release = ToFloat(value);
1818    
1819 persson 2072
1820     // v1 LFO
1821     else if ("amplfo_delay" == key) pCurDef->amplfo_delay = ToFloat(value);
1822     else if ("amplfo_fade" == key) pCurDef->amplfo_fade = ToFloat(value);
1823     else if ("amplfo_freq" == key) pCurDef->amplfo_freq = ToFloat(value);
1824 iliev 2253 else if ("amplfo_freqchanaft" == key) pCurDef->amplfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1825 persson 2072 else if ("amplfo_depth" == key) pCurDef->amplfo_depth = ToFloat(value);
1826 iliev 2253 else if ("amplfo_depthchanaft" == key) pCurDef->amplfo_depthcc.add( CC(128, check(key, -10.0f, 10.0f, ToFloat(value))) );
1827 persson 2072 else if ("fillfo_delay" == key) pCurDef->fillfo_delay = ToFloat(value);
1828     else if ("fillfo_fade" == key) pCurDef->fillfo_fade = ToFloat(value);
1829     else if ("fillfo_freq" == key) pCurDef->fillfo_freq = ToFloat(value);
1830 iliev 2253 else if ("fillfo_freqchanaft" == key) pCurDef->fillfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1831 persson 2072 else if ("fillfo_depth" == key) pCurDef->fillfo_depth = ToFloat(value);
1832 iliev 2253 else if ("fillfo_depthchanaft" == key) pCurDef->fillfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1833 persson 2072 else if ("pitchlfo_delay" == key) pCurDef->pitchlfo_delay = ToFloat(value);
1834     else if ("pitchlfo_fade" == key) pCurDef->pitchlfo_fade = ToFloat(value);
1835     else if ("pitchlfo_freq" == key) pCurDef->pitchlfo_freq = ToFloat(value);
1836 iliev 2253 else if ("pitchlfo_freqchanaft" == key) pCurDef->pitchlfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1837 persson 2072 else if ("pitchlfo_depth" == key) pCurDef->pitchlfo_depth = ToInt(value);
1838 iliev 2253 else if ("pitchlfo_depthchanaft" == key) pCurDef->pitchlfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1839 iliev 2218
1840 iliev 2253
1841 iliev 2218 // v2 LFO
1842     else if (sscanf(key.c_str(), "lfo%d%n", &x, &y)) {
1843     const char* s = key.c_str() + y;
1844     if (strcmp(s, "_freq") == 0) lfo(x).freq = check(key, 0.0f, 20.0f, ToFloat(value));
1845 iliev 2227 else if (sscanf(s, "_freq_oncc%d", &y)) lfo(x).freq_oncc.add( CC(y, check(key, 0.0f, 20.0f, ToFloat(value))) );
1846 iliev 2233 else if (sscanf(s, "_freq_smoothcc%d", &y)) lfo(x).freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1847 iliev 2265 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))) );
1848 iliev 2218 else if (strcmp(s, "_wave") == 0) lfo(x).wave = ToInt(value);
1849     else if (strcmp(s, "_delay") == 0) lfo(x).delay = check(key, 0.0f, 100.0f, ToFloat(value));
1850 iliev 2233 else if (sscanf(s, "_delay_oncc%d", &y)) lfo(x).delay_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1851 iliev 2226 else if (strcmp(s, "_fade") == 0) lfo(x).fade = check(key, 0.0f, 100.0f, ToFloat(value));
1852     else if (sscanf(s, "_fade_oncc%d", &y)) lfo(x).fade_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1853 iliev 2225 else if (strcmp(s, "_phase") == 0) lfo(x).phase = check(key, 0.0f, 360.0f, ToFloat(value));
1854     else if (sscanf(s, "_phase_oncc%d", &y)) lfo(x).phase_oncc.add( CC(y, check(key, 0.0f, 360.0f, ToFloat(value))) );
1855 iliev 2221 else if (strcmp(s, "_volume") == 0) lfo(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1856 iliev 2233 else if (sscanf(s, "_volume_oncc%d", &y)) lfo(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1857     else if (sscanf(s, "_volume_smoothcc%d", &y)) lfo(x).volume_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1858 iliev 2265 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))) );
1859 iliev 2218 else if (strcmp(s, "_pitch") == 0) lfo(x).pitch = check(key, -9600, 9600, ToInt(value));
1860 iliev 2225 else if (sscanf(s, "_pitch_oncc%d", &y)) lfo(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1861 iliev 2233 else if (sscanf(s, "_pitch_smoothcc%d", &y)) lfo(x).pitch_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1862 iliev 2265 else if (sscanf(s, "_pitch_stepcc%d", &y)) lfo(x).pitch_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1863 iliev 2218 else if (strcmp(s, "_cutoff") == 0) lfo(x).cutoff = check(key, -9600, 9600, ToInt(value));
1864 iliev 2233 else if (sscanf(s, "_cutoff_oncc%d", &y)) lfo(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1865     else if (sscanf(s, "_cutoff_smoothcc%d", &y)) lfo(x).cutoff_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1866 iliev 2265 else if (sscanf(s, "_cutoff_stepcc%d", &y)) lfo(x).cutoff_stepcc.add( CC(y, 0, -1, 0, check(key, -9600, 9600, ToInt(value))) );
1867 iliev 2218 else if (strcmp(s, "_resonance") == 0) lfo(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1868 iliev 2233 else if (sscanf(s, "_resonance_oncc%d", &y)) lfo(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1869     else if (sscanf(s, "_resonance_smoothcc%d", &y)) lfo(x).resonance_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1870 iliev 2265 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))) );
1871 iliev 2218 else if (strcmp(s, "_pan") == 0) lfo(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1872 iliev 2233 else if (sscanf(s, "_pan_oncc%d", &y)) lfo(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1873     else if (sscanf(s, "_pan_smoothcc%d", &y)) lfo(x).pan_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1874 iliev 2265 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))) );
1875 iliev 2299 else if (strcmp(s, "_eq1freq") == 0) lfo(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1876     else if (strcmp(s, "_eq2freq") == 0) lfo(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1877     else if (strcmp(s, "_eq3freq") == 0) lfo(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1878     else if (strcmp(s, "_eq1bw") == 0) lfo(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1879     else if (strcmp(s, "_eq2bw") == 0) lfo(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1880     else if (strcmp(s, "_eq3bw") == 0) lfo(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1881     else if (strcmp(s, "_eq1gain") == 0) lfo(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1882     else if (strcmp(s, "_eq2gain") == 0) lfo(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1883     else if (strcmp(s, "_eq3gain") == 0) lfo(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1884     else if (sscanf(s, "_eq1freq_oncc%d", &y)) lfo(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1885     else if (sscanf(s, "_eq1freq_smoothcc%d", &y)) lfo(x).eq1freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1886     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))) );
1887     else if (sscanf(s, "_eq2freq_oncc%d", &y)) lfo(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1888     else if (sscanf(s, "_eq2freq_smoothcc%d", &y)) lfo(x).eq2freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1889     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))) );
1890     else if (sscanf(s, "_eq3freq_oncc%d", &y)) lfo(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1891     else if (sscanf(s, "_eq3freq_smoothcc%d", &y)) lfo(x).eq3freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1892     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))) );
1893     else if (sscanf(s, "_eq1bw_oncc%d", &y)) lfo(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1894     else if (sscanf(s, "_eq1bw_smoothcc%d", &y)) lfo(x).eq1bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1895     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))) );
1896     else if (sscanf(s, "_eq2bw_oncc%d", &y)) lfo(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1897     else if (sscanf(s, "_eq2bw_smoothcc%d", &y)) lfo(x).eq2bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1898     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))) );
1899     else if (sscanf(s, "_eq3bw_oncc%d", &y)) lfo(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1900     else if (sscanf(s, "_eq3bw_smoothcc%d", &y)) lfo(x).eq3bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1901     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))) );
1902     else if (sscanf(s, "_eq1gain_oncc%d", &y)) lfo(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1903     else if (sscanf(s, "_eq1gain_smoothcc%d", &y)) lfo(x).eq1gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1904     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))) );
1905     else if (sscanf(s, "_eq2gain_oncc%d", &y)) lfo(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1906     else if (sscanf(s, "_eq2gain_smoothcc%d", &y)) lfo(x).eq2gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1907     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))) );
1908     else if (sscanf(s, "_eq3gain_oncc%d", &y)) lfo(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1909     else if (sscanf(s, "_eq3gain_smoothcc%d", &y)) lfo(x).eq3gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1910     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))) );
1911 iliev 2218 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1912     }
1913 iliev 2230
1914 iliev 2225 // CCs
1915     else if (key.find("cc") != std::string::npos)
1916     {
1917     std::string::size_type delimiter_index = key.find("cc");
1918     std::string key_cc = key.substr(0, delimiter_index);
1919 iliev 2250 if (key_cc.size() > 3 && !strcmp(key_cc.c_str() + (key_cc.size() - 3), "_on")) {
1920     key_cc = key_cc.substr(0, key_cc.size() - 3);
1921     }
1922 persson 2856
1923     // Apply macros
1924     std::string num_cc_str = key.substr(delimiter_index + 2);
1925    
1926     if (num_cc_str[0] == '$')
1927     {
1928     if (_defined_macros.count(num_cc_str) == 0)
1929     {
1930     std::cerr << "Macro '" << value << "' referenced on line ";
1931     std::cerr << currentLine << " is undefined." << std::endl;
1932     return;
1933     }
1934    
1935     num_cc_str = _defined_macros[num_cc_str];
1936     }
1937    
1938     int num_cc = ToInt(num_cc_str);
1939 iliev 2225
1940     // input controls
1941     if ("lo" == key_cc) pCurDef->locc.set(num_cc, ToInt(value));
1942     else if ("hi" == key_cc) pCurDef->hicc.set(num_cc, ToInt(value));
1943     else if ("start_lo" == key_cc) pCurDef->start_locc.set(num_cc, ToInt(value));
1944     else if ("start_hi" == key_cc) pCurDef->start_hicc.set(num_cc, ToInt(value));
1945     else if ("stop_lo" == key_cc) pCurDef->stop_locc.set(num_cc, ToInt(value));
1946     else if ("stop_hi" == key_cc) pCurDef->stop_hicc.set(num_cc, ToInt(value));
1947     else if ("on_lo" == key_cc) pCurDef->on_locc.set(num_cc, ToInt(value));
1948     else if ("on_hi" == key_cc) pCurDef->on_hicc.set(num_cc, ToInt(value));
1949    
1950     // sample player
1951 iliev 2250 else if ("delay" == key_cc) pCurDef->delay_oncc.set(num_cc, ToFloat(value));
1952     else if ("delay_samples" == key_cc) pCurDef->delay_samples_oncc.set(num_cc, ToInt(value));
1953     else if ("offset" == key_cc) pCurDef->offset_oncc.set(num_cc, ToInt(value));
1954 iliev 2225
1955     // amplifier
1956 iliev 2250 else if ("gain" == key_cc || "gain_" == key_cc) pCurDef->gain_oncc.set(num_cc, ToFloat(value));
1957 iliev 2225 else if ("xfin_lo" == key_cc) pCurDef->xfin_locc.set(num_cc, ToInt(value));
1958     else if ("xfin_hi" == key_cc) pCurDef->xfin_hicc.set(num_cc, ToInt(value));
1959     else if ("xfout_lo" == key_cc) pCurDef->xfout_locc.set(num_cc, ToInt(value));
1960     else if ("xfout_hi" == key_cc) pCurDef->xfout_hicc.set(num_cc, ToInt(value));
1961 iliev 2264
1962     // pitch
1963     else if ("pitch" == key_cc) pCurDef->pitch_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1964     else if ("pitch_smooth" == key_cc) pCurDef->pitch_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1965     else if ("pitch_curve" == key_cc) pCurDef->pitch_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1966     else if ("pitch_step" == key_cc) pCurDef->pitch_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0, 1200, ToInt(value))) );
1967 iliev 2225
1968     // filter
1969 iliev 2250 else if ("cutoff" == key_cc || "cutoff_" == key_cc) {
1970 iliev 2252 pCurDef->cutoff_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1971     } else if ("cutoff2" == key_cc) pCurDef->cutoff2_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1972     else if ("cutoff_smooth" == key_cc) pCurDef->cutoff_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1973     else if ("cutoff2_smooth" == key_cc) pCurDef->cutoff2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1974 iliev 2265 else if ("cutoff_step" == key_cc) pCurDef->cutoff_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1975     else if ("cutoff2_step" == key_cc) pCurDef->cutoff2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1976 iliev 2252 else if ("cutoff_curve" == key_cc) pCurDef->cutoff_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1977     else if ("cutoff2_curve" == key_cc) pCurDef->cutoff2_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1978     else if ("resonance" == key_cc) pCurDef->resonance_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1979     else if ("resonance2" == key_cc) pCurDef->resonance2_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1980     else if ("resonance_smooth" == key_cc) pCurDef->resonance_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1981     else if ("resonance2_smooth" == key_cc) pCurDef->resonance2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1982 iliev 2265 else if ("resonance_step" == key_cc) pCurDef->resonance_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1983     else if ("resonance2_step" == key_cc) pCurDef->resonance2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1984 iliev 2252 else if ("resonance_curve" == key_cc) pCurDef->resonance_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1985     else if ("resonance2_curve" == key_cc) pCurDef->resonance2_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1986 iliev 2225
1987     // per voice equalizer
1988 iliev 2250 else if ("eq1_freq" == key_cc) pCurDef->eq1_freq_oncc.set(num_cc, ToInt(value));
1989     else if ("eq2_freq" == key_cc) pCurDef->eq2_freq_oncc.set(num_cc, ToInt(value));
1990     else if ("eq3_freq" == key_cc) pCurDef->eq3_freq_oncc.set(num_cc, ToInt(value));
1991     else if ("eq1_bw" == key_cc) pCurDef->eq1_bw_oncc.set(num_cc, ToInt(value));
1992     else if ("eq2_bw" == key_cc) pCurDef->eq2_bw_oncc.set(num_cc, ToInt(value));
1993     else if ("eq3_bw" == key_cc) pCurDef->eq3_bw_oncc.set(num_cc, ToInt(value));
1994     else if ("eq1_gain" == key_cc) pCurDef->eq1_gain_oncc.set(num_cc, ToInt(value));
1995     else if ("eq2_gain" == key_cc) pCurDef->eq2_gain_oncc.set(num_cc, ToInt(value));
1996     else if ("eq3_gain" == key_cc) pCurDef->eq3_gain_oncc.set(num_cc, ToInt(value));
1997 iliev 2229
1998     else if ("ampeg_delay" == key_cc) pCurDef->ampeg_delaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1999     else if ("ampeg_start" == key_cc) pCurDef->ampeg_startcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2000     else if ("ampeg_attack" == key_cc) pCurDef->ampeg_attackcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2001     else if ("ampeg_hold" == key_cc) pCurDef->ampeg_holdcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2002     else if ("ampeg_decay" == key_cc) pCurDef->ampeg_decaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2003     else if ("ampeg_sustain" == key_cc) pCurDef->ampeg_sustaincc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2004     else if ("ampeg_release" == key_cc) pCurDef->ampeg_releasecc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2005    
2006 iliev 2250 else if ("fileg_delay" == key_cc) pCurDef->fileg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2007     else if ("fileg_start" == key_cc) pCurDef->fileg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2008     else if ("fileg_attack" == key_cc) pCurDef->fileg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2009     else if ("fileg_hold" == key_cc) pCurDef->fileg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2010     else if ("fileg_decay" == key_cc) pCurDef->fileg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2011     else if ("fileg_sustain" == key_cc) pCurDef->fileg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2012     else if ("fileg_release" == key_cc) pCurDef->fileg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2013     else if ("fileg_depth" == key_cc) pCurDef->fileg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2014 iliev 2249
2015 iliev 2250 else if ("pitcheg_delay" == key_cc) pCurDef->pitcheg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2016     else if ("pitcheg_start" == key_cc) pCurDef->pitcheg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2017     else if ("pitcheg_attack" == key_cc) pCurDef->pitcheg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2018     else if ("pitcheg_hold" == key_cc) pCurDef->pitcheg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2019     else if ("pitcheg_decay" == key_cc) pCurDef->pitcheg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2020     else if ("pitcheg_sustain" == key_cc) pCurDef->pitcheg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2021     else if ("pitcheg_release" == key_cc) pCurDef->pitcheg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
2022     else if ("pitcheg_depth" == key_cc) pCurDef->pitcheg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
2023 iliev 2249
2024 iliev 2250 else if ("pitchlfo_delay" == key_cc) pCurDef->pitchlfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2025     else if ("pitchlfo_fade" == key_cc) pCurDef->pitchlfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2026 iliev 2253 else if ("pitchlfo_depth" == key_cc) pCurDef->pitchlfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2027 iliev 2227 else if ("pitchlfo_freq" == key_cc) pCurDef->pitchlfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2028 iliev 2250 else if ("fillfo_delay" == key_cc) pCurDef->fillfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2029     else if ("fillfo_fade" == key_cc) pCurDef->fillfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2030 iliev 2233 else if ("fillfo_depth" == key_cc) pCurDef->fillfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
2031 iliev 2227 else if ("fillfo_freq" == key_cc) pCurDef->fillfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2032 iliev 2250 else if ("amplfo_delay" == key_cc) pCurDef->amplfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2033     else if ("amplfo_fade" == key_cc) pCurDef->amplfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
2034 iliev 2233 else if ("amplfo_depth" == key_cc) pCurDef->amplfo_depthcc.add( CC(num_cc, check(key, -10.0f, 10.0f, ToFloat(value))) );
2035 iliev 2227 else if ("amplfo_freq" == key_cc) pCurDef->amplfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2036 iliev 2250 else if ("volume" == key_cc) pCurDef->volume_oncc.add( CC(num_cc, check(key, -144.0f, 100.0f, ToFloat(value))) );
2037 iliev 2230 else if ("volume_curve" == key_cc) pCurDef->volume_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2038 iliev 2232 else if ("volume_smooth" == key_cc) pCurDef->volume_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2039 iliev 2265 else if ("volume_step" == key_cc) pCurDef->volume_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -20.0f, 20.0f, ToFloat(value))) );
2040 persson 2382 else if ("pan" == key_cc) pCurDef->pan_oncc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
2041 iliev 2237 else if ("pan_curve" == key_cc) pCurDef->pan_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
2042     else if ("pan_smooth" == key_cc) pCurDef->pan_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
2043 iliev 2265 else if ("pan_step" == key_cc) pCurDef->pan_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -100.0f, 100.0f, ToFloat(value))) );
2044 iliev 2225 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2045     }
2046    
2047 iliev 2018 else {
2048 iliev 2012 std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
2049     }
2050     }
2051    
2052 persson 2058 int File::parseKey(const std::string& s) {
2053     int i;
2054     std::istringstream iss(s);
2055     if (isdigit(iss.peek())) {
2056     iss >> i;
2057     } else {
2058     switch (tolower(iss.get())) {
2059     case 'c': i = 0; break;
2060     case 'd': i = 2; break;
2061     case 'e': i = 4; break;
2062     case 'f': i = 5; break;
2063     case 'g': i = 7; break;
2064     case 'a': i = 9; break;
2065     case 'b': i = 11; break;
2066 persson 2115 case '-': if (s == "-1") return -1;
2067 persson 2058 default:
2068     std::cerr << "Not a note: " << s << std::endl;
2069     return 0;
2070     }
2071     if (iss.peek() == '#') {
2072     i++;
2073     iss.get();
2074     } else if (tolower(iss.peek()) == 'b') {
2075     i--;
2076     iss.get();
2077     }
2078     int octave;
2079     if (!(iss >> octave)) {
2080     std::cerr << "Not a note: " << s << std::endl;
2081     return 0;
2082     }
2083     i += (octave + 1) * 12;
2084     }
2085     return i + note_offset + 12 * octave_offset;
2086     }
2087    
2088 persson 2055 EGNode::EGNode() : time(0), level(0), shape(0), curve(0) {
2089     }
2090 iliev 2229
2091     void EGNode::Copy(const EGNode& egNode) {
2092     time = egNode.time;
2093     level = egNode.level;
2094     shape = egNode.shape;
2095     curve = egNode.curve;
2096    
2097     time_oncc = egNode.time_oncc;
2098     level_oncc = egNode.level_oncc;
2099     }
2100 persson 2055
2101     EG::EG() :
2102 schoenebeck 3034 sustain(0), loop(0), loop_count(0), amplitude(0), volume(-200), /* less than -144 dB is considered unset */
2103     cutoff(0), pitch(0), resonance(0), pan(0), pan_curve(-1)
2104 iliev 2235 { }
2105 iliev 2229
2106     void EG::Copy(const EG& eg) {
2107 iliev 2299 EqImpl::Copy(static_cast<const EqImpl>(eg));
2108    
2109 iliev 2229 sustain = eg.sustain;
2110     loop = eg.loop;
2111     loop_count = eg.loop_count;
2112     amplitude = eg.amplitude;
2113 iliev 2235 volume = eg.volume;
2114 iliev 2229 cutoff = eg.cutoff;
2115 iliev 2235 pitch = eg.pitch;
2116     resonance = eg.resonance;
2117 iliev 2237 pan = eg.pan;
2118     pan_curve = eg.pan_curve;
2119 iliev 2229 node = eg.node;
2120 iliev 2235
2121     amplitude_oncc = eg.amplitude_oncc;
2122     volume_oncc = eg.volume_oncc;
2123     cutoff_oncc = eg.cutoff_oncc;
2124     pitch_oncc = eg.pitch_oncc;
2125     resonance_oncc = eg.resonance_oncc;
2126 iliev 2237 pan_oncc = eg.pan_oncc;
2127     pan_curvecc = eg.pan_curvecc;
2128 iliev 2229 }
2129 iliev 2218
2130 schoenebeck 3034 LFO::LFO():
2131     delay(0),
2132     freq(-1), /* -1 is used to determine whether the LFO was initialized */
2133     fade(0), phase(0), wave(0), volume(0), pitch(0), cutoff(0), resonance(0), pan(0)
2134     {
2135 iliev 2218 }
2136 schoenebeck 3034
2137 iliev 2229 void LFO::Copy(const LFO& lfo) {
2138 iliev 2299 EqSmoothStepImpl::Copy(static_cast<const EqSmoothStepImpl>(lfo));
2139    
2140 iliev 2229 delay = lfo.delay;
2141     freq = lfo.freq;
2142     fade = lfo.fade;
2143     phase = lfo.phase;
2144     wave = lfo.wave;
2145     volume = lfo.volume;
2146     pitch = lfo.pitch;
2147     cutoff = lfo.cutoff;
2148     resonance = lfo.resonance;
2149     pan = lfo.pan;
2150 iliev 2233
2151     delay_oncc = lfo.delay_oncc;
2152     freq_oncc = lfo.freq_oncc;
2153     freq_smoothcc = lfo.freq_smoothcc;
2154 iliev 2265 freq_stepcc = lfo.freq_stepcc;
2155 iliev 2233 fade_oncc = lfo.fade_oncc;
2156     phase_oncc = lfo.phase_oncc;
2157     pitch_oncc = lfo.pitch_oncc;
2158     pitch_smoothcc = lfo.pitch_smoothcc;
2159 iliev 2265 pitch_stepcc = lfo.pitch_stepcc;
2160 iliev 2233 volume_oncc = lfo.volume_oncc;
2161     volume_smoothcc = lfo.volume_smoothcc;
2162 iliev 2265 volume_stepcc = lfo.volume_stepcc;
2163 iliev 2233 pan_oncc = lfo.pan_oncc;
2164     pan_smoothcc = lfo.pan_smoothcc;
2165 iliev 2265 pan_stepcc = lfo.pan_stepcc;
2166 iliev 2233 cutoff_oncc = lfo.cutoff_oncc;
2167     cutoff_smoothcc = lfo.cutoff_smoothcc;
2168 iliev 2265 cutoff_stepcc = lfo.cutoff_stepcc;
2169 iliev 2233 resonance_oncc = lfo.resonance_oncc;
2170     resonance_smoothcc = lfo.resonance_smoothcc;
2171 iliev 2265 resonance_stepcc = lfo.resonance_stepcc;
2172 iliev 2229 }
2173 iliev 2299
2174     EqImpl::EqImpl() {
2175     eq1freq = eq2freq = eq3freq = 0;
2176     eq1bw = eq2bw = eq3bw = 0;
2177     eq1gain = eq2gain = eq3gain = 0;
2178     }
2179    
2180     void EqImpl::Copy(const EqImpl& eq) {
2181     eq1freq = eq.eq1freq;
2182     eq2freq = eq.eq2freq;
2183     eq3freq = eq.eq3freq;
2184     eq1bw = eq.eq1bw;
2185     eq2bw = eq.eq2bw;
2186     eq3bw = eq.eq3bw;
2187     eq1gain = eq.eq1gain;
2188     eq2gain = eq.eq2gain;
2189     eq3gain = eq.eq3gain;
2190    
2191     eq1freq_oncc = eq.eq1freq_oncc;
2192     eq2freq_oncc = eq.eq2freq_oncc;
2193     eq3freq_oncc = eq.eq3freq_oncc;
2194     eq1bw_oncc = eq.eq1bw_oncc;
2195     eq2bw_oncc = eq.eq2bw_oncc;
2196     eq3bw_oncc = eq.eq3bw_oncc;
2197     eq1gain_oncc = eq.eq1gain_oncc;
2198     eq2gain_oncc = eq.eq2gain_oncc;
2199     eq3gain_oncc = eq.eq3gain_oncc;
2200     }
2201    
2202     bool EqImpl::HasEq() {
2203     return eq1freq || eq2freq || eq3freq || eq1bw || eq2bw || eq3bw ||
2204     eq1gain || eq2gain || eq3gain || !eq1gain_oncc.empty() ||
2205     !eq2gain_oncc.empty() || !eq3gain_oncc.empty() ||
2206     !eq1freq_oncc.empty() || !eq2freq_oncc.empty() || !eq3freq_oncc.empty() ||
2207     !eq1bw_oncc.empty() || !eq2bw_oncc.empty() || !eq3bw_oncc.empty();
2208     }
2209    
2210     void EqSmoothStepImpl::Copy(const EqSmoothStepImpl& eq) {
2211     EqImpl::Copy(eq);
2212    
2213     eq1freq_smoothcc = eq.eq1freq_smoothcc;
2214     eq2freq_smoothcc = eq.eq2freq_smoothcc;
2215     eq3freq_smoothcc = eq.eq3freq_smoothcc;
2216     eq1bw_smoothcc = eq.eq1bw_smoothcc;
2217     eq2bw_smoothcc = eq.eq2bw_smoothcc;
2218     eq3bw_smoothcc = eq.eq3bw_smoothcc;
2219     eq1gain_smoothcc = eq.eq1gain_smoothcc;
2220     eq2gain_smoothcc = eq.eq2gain_smoothcc;
2221     eq3gain_smoothcc = eq.eq3gain_smoothcc;
2222    
2223     eq1freq_stepcc = eq.eq1freq_stepcc;
2224     eq2freq_stepcc = eq.eq2freq_stepcc;
2225     eq3freq_stepcc = eq.eq3freq_stepcc;
2226     eq1bw_stepcc = eq.eq1bw_stepcc;
2227     eq2bw_stepcc = eq.eq2bw_stepcc;
2228     eq3bw_stepcc = eq.eq3bw_stepcc;
2229     eq1gain_stepcc = eq.eq1gain_stepcc;
2230     eq2gain_stepcc = eq.eq2gain_stepcc;
2231     eq3gain_stepcc = eq.eq3gain_stepcc;
2232     }
2233    
2234     void EqSmoothStepImpl::copySmoothValues() {
2235     File::copySmoothValues(eq1freq_smoothcc, eq1freq_oncc);
2236     eq1freq_smoothcc.clear();
2237    
2238     File::copySmoothValues(eq2freq_smoothcc, eq2freq_oncc);
2239     eq2freq_smoothcc.clear();
2240    
2241     File::copySmoothValues(eq3freq_smoothcc, eq3freq_oncc);
2242     eq3freq_smoothcc.clear();
2243    
2244     File::copySmoothValues(eq1bw_smoothcc, eq1bw_oncc);
2245     eq1bw_smoothcc.clear();
2246    
2247     File::copySmoothValues(eq2bw_smoothcc, eq2bw_oncc);
2248     eq2bw_smoothcc.clear();
2249    
2250     File::copySmoothValues(eq3bw_smoothcc, eq3bw_oncc);
2251     eq3bw_smoothcc.clear();
2252    
2253     File::copySmoothValues(eq1gain_smoothcc, eq1gain_oncc);
2254     eq1gain_smoothcc.clear();
2255    
2256     File::copySmoothValues(eq2gain_smoothcc, eq2gain_oncc);
2257     eq2gain_smoothcc.clear();
2258    
2259     File::copySmoothValues(eq3gain_smoothcc, eq3gain_oncc);
2260     eq3gain_smoothcc.clear();
2261     }
2262    
2263     void EqSmoothStepImpl::copyStepValues() {
2264     File::copyStepValues(eq1freq_stepcc, eq1freq_oncc);
2265     eq1freq_stepcc.clear();
2266    
2267     File::copyStepValues(eq2freq_stepcc, eq2freq_oncc);
2268     eq2freq_stepcc.clear();
2269    
2270     File::copyStepValues(eq3freq_stepcc, eq3freq_oncc);
2271     eq3freq_stepcc.clear();
2272    
2273     File::copyStepValues(eq1bw_stepcc, eq1bw_oncc);
2274     eq1bw_stepcc.clear();
2275    
2276     File::copyStepValues(eq2bw_stepcc, eq2bw_oncc);
2277     eq2bw_stepcc.clear();
2278    
2279     File::copyStepValues(eq3bw_stepcc, eq3bw_oncc);
2280     eq3bw_stepcc.clear();
2281    
2282     File::copyStepValues(eq1gain_stepcc, eq1gain_oncc);
2283     eq1gain_stepcc.clear();
2284    
2285     File::copyStepValues(eq2gain_stepcc, eq2gain_oncc);
2286     eq2gain_stepcc.clear();
2287    
2288     File::copyStepValues(eq3gain_stepcc, eq3gain_oncc);
2289     eq3gain_stepcc.clear();
2290     }
2291 persson 2055
2292 iliev 2230 EG& File::eg(int x) {
2293     while (pCurDef->eg.size() <= x) {
2294     pCurDef->eg.add(EG());
2295     }
2296     return pCurDef->eg[x];
2297     }
2298    
2299     EGNode& File::egnode(int x, int y) {
2300     EG& e = eg(x);
2301     while (e.node.size() <= y) {
2302     e.node.add(EGNode());
2303     }
2304     return e.node[y];
2305     }
2306    
2307 iliev 2218 LFO& File::lfo(int x) {
2308     while (pCurDef->lfos.size() <= x) {
2309     pCurDef->lfos.add(LFO());
2310     }
2311     return pCurDef->lfos[x];
2312     }
2313    
2314 iliev 2012 } // !namespace sfz

Properties

Name Value
svn:executable *
  ViewVC Help
Powered by ViewVC