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

Properties

Name Value
svn:executable *
  ViewVC Help
Powered by ViewVC