/[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 2533 - (hide annotations) (download)
Sat Mar 8 09:04:42 2014 UTC (10 years, 1 month ago) by persson
File size: 98854 byte(s) 
* sfz parser bugfix: generation of velocity curves etc should not be
  done after each "#include", only after the main file is parsed
* sfz parser bugfix: line numbers in error messages were wrong after
  "#include"
* disabled build of LSCP shell on windows
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 persson 2091 std::set<float*> velcurves;
881 iliev 2012 for (int i = 0; i < _instrument->regions.size(); i++) {
882     ::sfz::Region* pRegion = _instrument->regions[i];
883     int low = pRegion->lokey;
884     int high = pRegion->hikey;
885 persson 2115 if (low != -1) { // lokey -1 means region doesn't play on note-on
886     // hikey -1 is the same as no limit, except that it
887     // also enables on_locc/on_hicc
888     if (high == -1) high = 127;
889     if (low < 0 || low > 127 || high < 0 || high > 127 || low > high) {
890     std::cerr << "Invalid key range: " << low << " - " << high << std::endl;
891     } else {
892     for (int j = low; j <= high; j++) _instrument->KeyBindings[j] = true;
893     }
894 iliev 2012 }
895    
896     // get keyswitches
897     low = pRegion->sw_lokey;
898 persson 2086 if (low < 0) low = 0;
899 iliev 2012 high = pRegion->sw_hikey;
900 persson 2086 if (high == -1) {
901 iliev 2012 // Key switches not defined, so nothing to do
902 persson 2086 } else if (low >= 0 && low <= 127 && high >= 0 && high <= 127 && high >= low) {
903 iliev 2012 for (int j = low; j <= high; j++) _instrument->KeySwitchBindings[j] = true;
904     } else {
905     std::cerr << "Invalid key switch range: " << low << " - " << high << std::endl;
906     }
907 persson 2082
908     // create velocity response curve
909 persson 2091
910     // don't use copy-on-write here, instead change the actual
911     // unique buffers in memory
912     float* velcurve = const_cast<float*>(&pRegion->amp_velcurve[0]);
913     if (velcurves.insert(velcurve).second) {
914     int prev = 0;
915     float prevvalue = 0;
916     for (int v = 0 ; v < 128 ; v++) {
917     if (velcurve[v] >= 0) {
918     float step = (velcurve[v] - prevvalue) / (v - prev);
919     for ( ; prev < v ; prev++) {
920     velcurve[prev] = prevvalue;
921     prevvalue += step;
922     }
923     }
924     }
925     if (prev) {
926     float step = (1 - prevvalue) / (127 - prev);
927     for ( ; prev < 128 ; prev++) {
928     velcurve[prev] = prevvalue;
929 persson 2082 prevvalue += step;
930     }
931 persson 2091 } else {
932     // default curve
933     for (int v = 0 ; v < 128 ; v++) {
934     velcurve[v] = v * v / (127.0 * 127.0);
935     }
936 persson 2082 }
937     }
938 iliev 2012 }
939 persson 2106
940     _instrument->pLookupTable = new LookupTable(_instrument);
941 persson 2115
942     // create separate lookup tables for controller triggered
943     // regions, one for each CC
944     for (int i = 0 ; i < 128 ; i++) {
945     _instrument->pLookupTableCC[i] = new LookupTable(_instrument, i);
946     }
947 iliev 2230
948 iliev 2233 for (int i = 0; i < _instrument->regions.size(); i++) {
949     Region* r = _instrument->regions[i];
950 iliev 2230
951     copyCurves(r->volume_curvecc, r->volume_oncc);
952 iliev 2233 r->volume_curvecc.clear();
953    
954 iliev 2232 copySmoothValues(r->volume_smoothcc, r->volume_oncc);
955 iliev 2233 r->volume_smoothcc.clear();
956 iliev 2230
957 iliev 2265 copyStepValues(r->volume_stepcc, r->volume_oncc);
958     r->volume_stepcc.clear();
959    
960 iliev 2264 copyCurves(r->pitch_curvecc, r->pitch_oncc);
961     r->pitch_curvecc.clear();
962    
963     copySmoothValues(r->pitch_smoothcc, r->pitch_oncc);
964     r->pitch_smoothcc.clear();
965    
966     copyStepValues(r->pitch_stepcc, r->pitch_oncc);
967     r->pitch_stepcc.clear();
968    
969 iliev 2237 copyCurves(r->pan_curvecc, r->pan_oncc);
970     r->pan_curvecc.clear();
971    
972     copySmoothValues(r->pan_smoothcc, r->pan_oncc);
973     r->pan_smoothcc.clear();
974    
975 iliev 2265 copyStepValues(r->pan_stepcc, r->pan_oncc);
976     r->pan_stepcc.clear();
977    
978 iliev 2252 copyCurves(r->cutoff_curvecc, r->cutoff_oncc);
979     r->cutoff_curvecc.clear();
980    
981     copySmoothValues(r->cutoff_smoothcc, r->cutoff_oncc);
982     r->cutoff_smoothcc.clear();
983    
984 iliev 2265 copyStepValues(r->cutoff_stepcc, r->cutoff_oncc);
985     r->cutoff_stepcc.clear();
986    
987 iliev 2252 copyCurves(r->cutoff2_curvecc, r->cutoff2_oncc);
988     r->cutoff2_curvecc.clear();
989    
990     copySmoothValues(r->cutoff2_smoothcc, r->cutoff2_oncc);
991     r->cutoff2_smoothcc.clear();
992    
993 iliev 2265 copyStepValues(r->cutoff2_stepcc, r->cutoff2_oncc);
994     r->cutoff2_stepcc.clear();
995    
996 iliev 2252 copyCurves(r->resonance_curvecc, r->resonance_oncc);
997     r->resonance_curvecc.clear();
998    
999     copySmoothValues(r->resonance_smoothcc, r->resonance_oncc);
1000     r->resonance_smoothcc.clear();
1001    
1002 iliev 2265 copyStepValues(r->resonance_stepcc, r->resonance_oncc);
1003     r->resonance_stepcc.clear();
1004    
1005 iliev 2252 copyCurves(r->resonance2_curvecc, r->resonance2_oncc);
1006     r->resonance2_curvecc.clear();
1007    
1008     copySmoothValues(r->resonance2_smoothcc, r->resonance2_oncc);
1009     r->resonance2_smoothcc.clear();
1010    
1011 iliev 2265 copyStepValues(r->resonance2_stepcc, r->resonance2_oncc);
1012     r->resonance2_stepcc.clear();
1013    
1014 iliev 2237 for (int j = 0; j < r->eg.size(); j++) {
1015     copyCurves(r->eg[j].pan_curvecc, r->eg[j].pan_oncc);
1016     r->eg[j].pan_curvecc.clear();
1017     }
1018    
1019 iliev 2233 for (int j = 0; j < r->lfos.size(); j++) {
1020 iliev 2299 r->lfos[j].copySmoothValues();
1021     r->lfos[j].copyStepValues();
1022    
1023 iliev 2233 copySmoothValues(r->lfos[j].volume_smoothcc, r->lfos[j].volume_oncc);
1024     r->lfos[j].volume_smoothcc.clear();
1025    
1026 iliev 2265 copyStepValues(r->lfos[j].volume_stepcc, r->lfos[j].volume_oncc);
1027     r->lfos[j].volume_stepcc.clear();
1028    
1029 iliev 2233 copySmoothValues(r->lfos[j].freq_smoothcc, r->lfos[j].freq_oncc);
1030     r->lfos[j].freq_smoothcc.clear();
1031    
1032 iliev 2265 copyStepValues(r->lfos[j].freq_stepcc, r->lfos[j].freq_oncc);
1033     r->lfos[j].freq_stepcc.clear();
1034    
1035 iliev 2233 copySmoothValues(r->lfos[j].pitch_smoothcc, r->lfos[j].pitch_oncc);
1036     r->lfos[j].pitch_smoothcc.clear();
1037    
1038 iliev 2265 copyStepValues(r->lfos[j].pitch_stepcc, r->lfos[j].pitch_oncc);
1039     r->lfos[j].pitch_stepcc.clear();
1040    
1041 iliev 2233 copySmoothValues(r->lfos[j].pan_smoothcc, r->lfos[j].pan_oncc);
1042     r->lfos[j].pan_smoothcc.clear();
1043    
1044 iliev 2265 copyStepValues(r->lfos[j].pan_stepcc, r->lfos[j].pan_oncc);
1045     r->lfos[j].pan_stepcc.clear();
1046    
1047 iliev 2233 copySmoothValues(r->lfos[j].cutoff_smoothcc, r->lfos[j].cutoff_oncc);
1048     r->lfos[j].cutoff_smoothcc.clear();
1049    
1050 iliev 2265 copyStepValues(r->lfos[j].cutoff_stepcc, r->lfos[j].cutoff_oncc);
1051     r->lfos[j].cutoff_stepcc.clear();
1052    
1053 iliev 2233 copySmoothValues(r->lfos[j].resonance_smoothcc, r->lfos[j].resonance_oncc);
1054     r->lfos[j].resonance_smoothcc.clear();
1055 iliev 2265
1056     copyStepValues(r->lfos[j].resonance_stepcc, r->lfos[j].resonance_oncc);
1057     r->lfos[j].resonance_stepcc.clear();
1058 iliev 2233 }
1059 iliev 2230 }
1060 iliev 2012 }
1061    
1062 persson 2533 void File::parseFile(std::string file, SampleManager* pSampleManager){
1063     enum token_type_t { HEADER, OPCODE };
1064     token_type_t token_type;
1065     std::string token_string;
1066    
1067     std::ifstream fs(file.c_str());
1068     currentDir = LinuxSampler::Path::stripLastName(file);
1069     std::string token;
1070     std::string line;
1071     currentLine = 0;
1072    
1073     while (std::getline(fs, line))
1074     {
1075     currentLine++;
1076     // COMMENT
1077     std::string::size_type slash_index = line.find("//");
1078     if (slash_index != std::string::npos)
1079     line.resize(slash_index);
1080    
1081     // #include
1082     if (line.find("#include ") == 0) {
1083     size_t fname_start = line.find("\"");
1084     if (fname_start == std::string::npos) continue;
1085    
1086     size_t fname_end = line.find("\"", fname_start + 1);
1087     if (fname_end == std::string::npos || fname_start == fname_end)
1088     continue;
1089     std::string fname = line.substr(fname_start + 1, fname_end - fname_start - 1);
1090    
1091     if (!currentDir.empty() && !LinuxSampler::Path(fname).isAbsolute())
1092     fname = currentDir + LinuxSampler::File::DirSeparator + fname;
1093    
1094     std::string cd = currentDir; // backup current dir
1095     int cl = currentLine;
1096     parseFile(fname, pSampleManager);
1097     currentDir = cd; // restore currentDir (since altered by parsefile())
1098     currentLine = cl;
1099     continue;
1100     }
1101    
1102     // DEFINITION
1103     std::stringstream linestream(line);
1104     int spaces = 0;
1105     while (linestream >> token)
1106     {
1107     linestream >> std::noskipws;
1108     if (token[0] == '<' && token[token.size()-1] == '>')
1109     {
1110     // HEAD
1111     if (!token_string.empty())
1112     {
1113     switch (token_type)
1114     {
1115     case HEADER:
1116     push_header(token_string);
1117     break;
1118     case OPCODE:
1119     push_opcode(token_string);
1120     break;
1121     }
1122     token_string.erase();
1123     }
1124     token_string.append(token);
1125     token_type = HEADER;
1126     }
1127     else if (token.find('=') != std::string::npos)
1128     {
1129     // HEAD
1130     if (!token_string.empty())
1131     {
1132     switch (token_type)
1133     {
1134     case HEADER:
1135     push_header(token_string);
1136     break;
1137     case OPCODE:
1138     push_opcode(token_string);
1139     break;
1140     }
1141     token_string.erase();
1142     }
1143     token_string.append(token);
1144     token_type = OPCODE;
1145     }
1146     else
1147     {
1148     // TAIL
1149     token_string.append(spaces, ' ');
1150     token_string.append(token);
1151     }
1152     spaces = 0;
1153     while (isspace(linestream.peek())) {
1154     linestream.ignore();
1155     spaces++;
1156     }
1157     }
1158    
1159     // EOL
1160     if (!token_string.empty())
1161     {
1162     switch (token_type)
1163     {
1164     case HEADER:
1165     push_header(token_string);
1166     break;
1167     case OPCODE:
1168     push_opcode(token_string);
1169     break;
1170     }
1171     token_string.erase();
1172     }
1173     }
1174     }
1175    
1176 iliev 2012 File::~File()
1177     {
1178     delete _current_group;
1179     delete _instrument;
1180     }
1181    
1182     Instrument*
1183     File::GetInstrument()
1184     {
1185     return _instrument;
1186     }
1187 iliev 2230
1188     void File::copyCurves(LinuxSampler::ArrayList<CC>& curves, LinuxSampler::ArrayList<CC>& dest) {
1189     for (int i = 0; i < curves.size(); i++) {
1190     for (int j = 0; j < dest.size(); j++) {
1191     if (curves[i].Controller == dest[j].Controller) {
1192     dest[j].Curve = curves[i].Curve;
1193     }
1194     }
1195     }
1196     }
1197 iliev 2232
1198     void File::copySmoothValues(LinuxSampler::ArrayList<CC>& smooths, LinuxSampler::ArrayList<CC>& dest) {
1199     for (int i = 0; i < smooths.size(); i++) {
1200     for (int j = 0; j < dest.size(); j++) {
1201     if (smooths[i].Controller == dest[j].Controller) {
1202     dest[j].Smooth = smooths[i].Smooth;
1203     }
1204     }
1205     }
1206     }
1207 iliev 2237
1208 iliev 2264 void File::copyStepValues(LinuxSampler::ArrayList<CC>& steps, LinuxSampler::ArrayList<CC>& dest) {
1209     for (int i = 0; i < steps.size(); i++) {
1210     for (int j = 0; j < dest.size(); j++) {
1211     if (steps[i].Controller == dest[j].Controller) {
1212     dest[j].Step = steps[i].Step;
1213     }
1214     }
1215     }
1216     }
1217    
1218 iliev 2237 int File::ToInt(const std::string& s) throw(LinuxSampler::Exception) {
1219     int i;
1220     std::istringstream iss(s);
1221     if(!(iss >> i)) {
1222     std::ostringstream oss;
1223     oss << "Line " << currentLine << ": Expected an integer";
1224     throw LinuxSampler::Exception(oss.str());
1225     }
1226     return i;
1227     }
1228 iliev 2012
1229 iliev 2237 float File::ToFloat(const std::string& s) throw(LinuxSampler::Exception) {
1230     float i;
1231     std::istringstream iss(s);
1232     if(!(iss >> i)) {
1233     std::ostringstream oss;
1234     oss << "Line " << currentLine << ": Expected a floating-point number";
1235     throw LinuxSampler::Exception(oss.str());
1236     }
1237     return i;
1238     }
1239    
1240 iliev 2012 void
1241     File::push_header(std::string token)
1242     {
1243     if (token == "<group>")
1244     {
1245     _current_section = GROUP;
1246     _current_group->Reset();
1247 persson 2055 pCurDef = _current_group;
1248 iliev 2012 }
1249     else if (token == "<region>")
1250     {
1251     _current_section = REGION;
1252     _current_region = _current_group->RegionFactory();
1253 persson 2055 pCurDef = _current_region;
1254 iliev 2012 _instrument->regions.push_back(_current_region);
1255 persson 2055 _current_region->SetInstrument(_instrument);
1256 iliev 2012 }
1257     else if (token == "<control>")
1258     {
1259     _current_section = CONTROL;
1260     default_path = "";
1261     octave_offset = 0;
1262     note_offset = 0;
1263     }
1264 iliev 2230 else if (token == "<curve>")
1265     {
1266     _current_section = CURVE;
1267     _instrument->curves.add(Curve());
1268     _current_curve = &_instrument->curves[_instrument->curves.size() - 1];
1269     }
1270 iliev 2012 else
1271     {
1272     _current_section = UNKNOWN;
1273     std::cerr << "The header '" << token << "' is unsupported by libsfz!" << std::endl;
1274     }
1275     }
1276    
1277     void
1278     File::push_opcode(std::string token)
1279     {
1280     if (_current_section == UNKNOWN)
1281     return;
1282    
1283     std::string::size_type delimiter_index = token.find('=');
1284     std::string key = token.substr(0, delimiter_index);
1285     std::string value = token.substr(delimiter_index + 1);
1286 iliev 2229 int x, y, z;
1287 iliev 2230
1288     if (_current_section == CURVE) {
1289     if (sscanf(key.c_str(), "v%d", &x)) {
1290     if (x < 0 || x > 127) {
1291     std::cerr << "Invalid curve index: " << x << std::endl;
1292     }
1293     _current_curve->v[x] = check(key, 0.0f, 1.0f, ToFloat(value));
1294     } else {
1295     std::cerr << "The opcode '" << key << "' in section <curve> is unsupported by libsfz!" << std::endl;
1296     }
1297    
1298     return;
1299     }
1300 iliev 2012
1301     // sample definition
1302     if ("sample" == key)
1303     {
1304     std::string path = default_path + value;
1305     #ifndef WIN32
1306 persson 2311 for (int i = 0; i < path.length(); i++) if (path[i] == '\\') path[i] = '/';
1307     bool absolute = path[0] == '/';
1308     #else
1309     bool absolute = path[0] == '/' || path[0] == '\\' ||
1310     (path.length() >= 2 && isalpha(path[0]) && path[1] == ':');
1311 iliev 2012 #endif
1312 persson 2311 if (!absolute) path = currentDir + LinuxSampler::File::DirSeparator + path;
1313 iliev 2012 if(pCurDef) pCurDef->sample = path;
1314     return;
1315     }
1316    
1317     // control header directives
1318     else if ("default_path" == key)
1319     {
1320     switch (_current_section)
1321     {
1322     case CONTROL:
1323     default_path = value;
1324     }
1325     return;
1326     }
1327     else if ("octave_offset" == key)
1328     {
1329     switch (_current_section)
1330     {
1331     case CONTROL:
1332     octave_offset = ToInt(value);
1333     }
1334     return;
1335     }
1336     else if ("note_offset" == key)
1337     {
1338     switch (_current_section)
1339     {
1340     case CONTROL:
1341     note_offset = ToInt(value);
1342     }
1343     return;
1344     }
1345    
1346     // input controls
1347     else if ("lochan" == key) pCurDef->lochan = ToInt(value);
1348     else if ("hichan" == key) pCurDef->hichan = ToInt(value);
1349 persson 2058 else if ("lokey" == key) pCurDef->lokey = parseKey(value);
1350     else if ("hikey" == key) pCurDef->hikey = parseKey(value);
1351 iliev 2012 else if ("key" == key)
1352     {
1353 persson 2058 pCurDef->lokey = pCurDef->hikey = pCurDef->pitch_keycenter = parseKey(value);
1354 iliev 2012 }
1355     else if ("lovel" == key) pCurDef->lovel = ToInt(value);
1356     else if ("hivel" == key) pCurDef->hivel = ToInt(value);
1357     else if ("lobend" == key) pCurDef->lobend = ToInt(value);
1358     else if ("hibend" == key) pCurDef->hibend = ToInt(value);
1359 persson 2106 else if ("lobpm" == key) pCurDef->lobpm = ToFloat(value);
1360     else if ("hibpm" == key) pCurDef->hibpm = ToFloat(value);
1361 iliev 2012 else if ("lochanaft" == key) pCurDef->lochanaft = ToInt(value);
1362     else if ("hichanaft" == key) pCurDef->hichanaft = ToInt(value);
1363     else if ("lopolyaft" == key) pCurDef->lopolyaft = ToInt(value);
1364     else if ("hipolyaft" == key) pCurDef->hipolyaft = ToInt(value);
1365     else if ("loprog" == key) pCurDef->loprog = ToInt(value);
1366     else if ("hiprog" == key) pCurDef->hiprog = ToInt(value);
1367     else if ("lorand" == key) pCurDef->lorand = ToFloat(value);
1368     else if ("hirand" == key) pCurDef->hirand = ToFloat(value);
1369     else if ("lotimer" == key) pCurDef->lotimer = ToFloat(value);
1370     else if ("hitimer" == key) pCurDef->hitimer = ToFloat(value);
1371     else if ("seq_length" == key) pCurDef->seq_length = ToInt(value);
1372     else if ("seq_position" == key) pCurDef->seq_position = ToInt(value);
1373 persson 2058 else if ("sw_lokey" == key) pCurDef->sw_lokey = parseKey(value);
1374     else if ("sw_hikey" == key) pCurDef->sw_hikey = parseKey(value);
1375     else if ("sw_last" == key) pCurDef->sw_last = parseKey(value);
1376     else if ("sw_down" == key) pCurDef->sw_down = parseKey(value);
1377     else if ("sw_up" == key) pCurDef->sw_up = parseKey(value);
1378     else if ("sw_previous" == key) pCurDef->sw_previous = parseKey(value);
1379 iliev 2012 else if ("sw_vel" == key)
1380     {
1381     if (value == "current") pCurDef->sw_vel = VEL_CURRENT;
1382     else if (value == "previous") pCurDef->sw_vel = VEL_PREVIOUS;
1383     }
1384     else if ("trigger" == key)
1385     {
1386     if (value == "attack") pCurDef->trigger = TRIGGER_ATTACK;
1387     else if (value == "release") pCurDef->trigger = TRIGGER_RELEASE;
1388     else if (value == "first") pCurDef->trigger = TRIGGER_FIRST;
1389     else if (value == "legato") pCurDef->trigger = TRIGGER_LEGATO;
1390     }
1391     else if ("group" == key) pCurDef->group = ToInt(value);
1392 persson 2058 else if ("off_by" == key || "offby" == key) pCurDef->off_by = ToInt(value);
1393     else if ("off_mode" == key || "offmode" == key)
1394 iliev 2012 {
1395 persson 2114 if (value == "fast") pCurDef->off_mode = OFF_FAST;
1396     else if (value == "normal") pCurDef->off_mode = OFF_NORMAL;
1397 iliev 2012 }
1398    
1399     // sample player
1400 iliev 2021 else if ("count" == key) { pCurDef->count = ToInt(value); pCurDef->loop_mode = ONE_SHOT; }
1401 iliev 2012 else if ("delay" == key) pCurDef->delay = ToFloat(value);
1402     else if ("delay_random" == key) pCurDef->delay_random = ToFloat(value);
1403     else if ("delay_beats" == key) pCurDef->delay_beats = ToInt(value);
1404     else if ("stop_beats" == key) pCurDef->stop_beats = ToInt(value);
1405     else if ("delay_samples" == key) pCurDef->delay_samples = ToInt(value);
1406     else if ("end" == key) pCurDef->end = ToInt(value);
1407     else if ("loop_crossfade" == key) pCurDef->loop_crossfade = ToFloat(value);
1408     else if ("offset_random" == key) pCurDef->offset_random = ToInt(value);
1409 persson 2058 else if ("loop_mode" == key || "loopmode" == key)
1410 iliev 2012 {
1411     if (value == "no_loop") pCurDef->loop_mode = NO_LOOP;
1412     else if (value == "one_shot") pCurDef->loop_mode = ONE_SHOT;
1413 iliev 2021 else if (value == "loop_continuous") pCurDef->loop_mode = LOOP_CONTINUOUS;
1414 iliev 2012 else if (value == "loop_sustain") pCurDef->loop_mode = LOOP_SUSTAIN;
1415     }
1416     else if ("loop_start" == key) pCurDef->loop_start = ToInt(value);
1417 iliev 2021 else if ("loopstart" == key) pCurDef->loop_start = ToInt(value); // nonstandard
1418 iliev 2012 else if ("loop_end" == key) pCurDef->loop_end = ToInt(value);
1419 iliev 2021 else if ("loopend" == key) pCurDef->loop_end = ToInt(value); // nonstandard
1420 iliev 2216 else if ("offset" == key) pCurDef->offset = ToInt(value);
1421 iliev 2012 else if ("sync_beats" == key) pCurDef->sync_beats = ToInt(value);
1422     else if ("sync_offset" == key) pCurDef->sync_offset = ToInt(value);
1423    
1424     // amplifier
1425     else if ("volume" == key) pCurDef->volume = ToFloat(value);
1426 persson 2403 else if ("amplitude" == key) pCurDef->amplitude = ToFloat(value);
1427 iliev 2012 else if ("pan" == key) pCurDef->pan = ToFloat(value);
1428     else if ("width" == key) pCurDef->width = ToFloat(value);
1429     else if ("position" == key) pCurDef->position = ToFloat(value);
1430     else if ("amp_keytrack" == key) pCurDef->amp_keytrack = ToFloat(value);
1431 persson 2058 else if ("amp_keycenter" == key) pCurDef->amp_keycenter = parseKey(value);
1432 iliev 2012 else if ("amp_veltrack" == key) pCurDef->amp_veltrack = ToFloat(value);
1433     else if ("amp_random" == key) pCurDef->amp_random = ToFloat(value);
1434 iliev 2229 else if ("rt_decay" == key || "rtdecay" == key) pCurDef->rt_decay = ToFloat(value);
1435 persson 2058 else if ("xfin_lokey" == key) pCurDef->xfin_lokey = parseKey(value);
1436     else if ("xfin_hikey" == key) pCurDef->xfin_hikey = parseKey(value);
1437     else if ("xfout_lokey" == key) pCurDef->xfout_lokey = parseKey(value);
1438     else if ("xfout_hikey" == key) pCurDef->xfout_hikey = parseKey(value);
1439 iliev 2012 else if ("xf_keycurve" == key)
1440     {
1441     if (value == "gain") pCurDef->xf_keycurve = GAIN;
1442     else if (value == "power") pCurDef->xf_keycurve = POWER;
1443     }
1444     else if ("xfin_lovel" == key) pCurDef->xfin_lovel = ToInt(value);
1445     else if ("xfin_hivel" == key) pCurDef->xfin_hivel = ToInt(value);
1446     else if ("xfout_lovel" == key) pCurDef->xfout_lovel = ToInt(value);
1447     else if ("xfout_hivel" == key) pCurDef->xfout_hivel = ToInt(value);
1448     else if ("xf_velcurve" == key)
1449     {
1450     if (value == "gain") pCurDef->xf_velcurve = GAIN;
1451     else if (value == "power") pCurDef->xf_velcurve = POWER;
1452     }
1453     else if ("xf_cccurve" == key)
1454     {
1455     if (value == "gain") pCurDef->xf_cccurve = GAIN;
1456     else if (value == "power") pCurDef->xf_cccurve = POWER;
1457     }
1458    
1459     // pitch
1460     else if ("transpose" == key) pCurDef->transpose = ToInt(value);
1461     else if ("tune" == key) pCurDef->tune = ToInt(value);
1462 persson 2058 else if ("pitch_keycenter" == key) pCurDef->pitch_keycenter = parseKey(value);
1463 iliev 2012 else if ("pitch_keytrack" == key) pCurDef->pitch_keytrack = ToInt(value);
1464     else if ("pitch_veltrack" == key) pCurDef->pitch_veltrack = ToInt(value);
1465     else if ("pitch_random" == key) pCurDef->pitch_random = ToInt(value);
1466 persson 2058 else if ("bend_up" == key || "bendup" == key) pCurDef->bend_up = ToInt(value);
1467     else if ("bend_down" == key || "benddown" == key) pCurDef->bend_down = ToInt(value);
1468 iliev 2229 else if ("bend_step" == key || "bendstep" == key) pCurDef->bend_step = ToInt(value);
1469 iliev 2012
1470     // filter
1471 persson 2086 else if ("fil_type" == key || "filtype" == key)
1472 iliev 2012 {
1473     if (value == "lpf_1p") pCurDef->fil_type = LPF_1P;
1474     else if (value == "hpf_1p") pCurDef->fil_type = HPF_1P;
1475     else if (value == "bpf_1p") pCurDef->fil_type = BPF_1P;
1476     else if (value == "brf_1p") pCurDef->fil_type = BRF_1P;
1477     else if (value == "apf_1p") pCurDef->fil_type = APF_1P;
1478     else if (value == "lpf_2p") pCurDef->fil_type = LPF_2P;
1479     else if (value == "hpf_2p") pCurDef->fil_type = HPF_2P;
1480     else if (value == "bpf_2p") pCurDef->fil_type = BPF_2P;
1481     else if (value == "brf_2p") pCurDef->fil_type = BRF_2P;
1482     else if (value == "pkf_2p") pCurDef->fil_type = PKF_2P;
1483     else if (value == "lpf_4p") pCurDef->fil_type = LPF_4P;
1484     else if (value == "hpf_4p") pCurDef->fil_type = HPF_4P;
1485     else if (value == "lpf_6p") pCurDef->fil_type = LPF_6P;
1486     else if (value == "hpf_6p") pCurDef->fil_type = HPF_6P;
1487     }
1488     else if ("fil2_type" == key)
1489     {
1490     if (value == "lpf_1p") pCurDef->fil2_type = LPF_1P;
1491     else if (value == "hpf_1p") pCurDef->fil2_type = HPF_1P;
1492     else if (value == "bpf_1p") pCurDef->fil2_type = BPF_1P;
1493     else if (value == "brf_1p") pCurDef->fil2_type = BRF_1P;
1494     else if (value == "apf_1p") pCurDef->fil2_type = APF_1P;
1495     else if (value == "lpf_2p") pCurDef->fil2_type = LPF_2P;
1496     else if (value == "hpf_2p") pCurDef->fil2_type = HPF_2P;
1497     else if (value == "bpf_2p") pCurDef->fil2_type = BPF_2P;
1498     else if (value == "brf_2p") pCurDef->fil2_type = BRF_2P;
1499     else if (value == "pkf_2p") pCurDef->fil2_type = PKF_2P;
1500     else if (value == "lpf_4p") pCurDef->fil2_type = LPF_4P;
1501     else if (value == "hpf_4p") pCurDef->fil2_type = HPF_4P;
1502     else if (value == "lpf_6p") pCurDef->fil2_type = LPF_6P;
1503     else if (value == "hpf_6p") pCurDef->fil2_type = HPF_6P;
1504     }
1505     else if ("cutoff" == key) pCurDef->cutoff = ToFloat(value);
1506     else if ("cutoff2" == key) pCurDef->cutoff2 = ToFloat(value);
1507 iliev 2252 else if ("cutoff_chanaft" == key) {
1508     pCurDef->cutoff_chanaft = check(key, -9600, 9600, ToInt(value));
1509     pCurDef->cutoff_oncc.add( CC(128, check(key, -9600, 9600, ToInt(value))) );
1510     } else if ("cutoff2_chanaft" == key) pCurDef->cutoff2_chanaft = ToInt(value);
1511 iliev 2012 else if ("cutoff_polyaft" == key) pCurDef->cutoff_polyaft = ToInt(value);
1512     else if ("cutoff2_polyaft" == key) pCurDef->cutoff2_polyaft = ToInt(value);
1513     else if ("resonance" == key) pCurDef->resonance = ToFloat(value);
1514     else if ("resonance2" == key) pCurDef->resonance2 = ToFloat(value);
1515     else if ("fil_keytrack" == key) pCurDef->fil_keytrack = ToInt(value);
1516     else if ("fil2_keytrack" == key) pCurDef->fil2_keytrack = ToInt(value);
1517 persson 2058 else if ("fil_keycenter" == key) pCurDef->fil_keycenter = parseKey(value);
1518     else if ("fil2_keycenter" == key) pCurDef->fil2_keycenter = parseKey(value);
1519 iliev 2012 else if ("fil_veltrack" == key) pCurDef->fil_veltrack = ToInt(value);
1520     else if ("fil2_veltrack" == key) pCurDef->fil2_veltrack = ToInt(value);
1521     else if ("fil_random" == key) pCurDef->fil_random = ToInt(value);
1522     else if ("fil2_random" == key) pCurDef->fil2_random = ToInt(value);
1523    
1524     // per voice equalizer
1525     else if ("eq1_freq" == key) pCurDef->eq1_freq = ToFloat(value);
1526     else if ("eq2_freq" == key) pCurDef->eq2_freq = ToFloat(value);
1527     else if ("eq3_freq" == key) pCurDef->eq3_freq = ToFloat(value);
1528     else if ("eq1_vel2freq" == key) pCurDef->eq1_vel2freq = ToFloat(value);
1529     else if ("eq2_vel2freq" == key) pCurDef->eq2_vel2freq = ToFloat(value);
1530     else if ("eq3_vel2freq" == key) pCurDef->eq3_vel2freq = ToFloat(value);
1531     else if ("eq1_bw" == key) pCurDef->eq1_bw = ToFloat(value);
1532     else if ("eq2_bw" == key) pCurDef->eq2_bw = ToFloat(value);
1533     else if ("eq3_bw" == key) pCurDef->eq3_bw = ToFloat(value);
1534     else if ("eq1_gain" == key) pCurDef->eq1_gain = ToFloat(value);
1535     else if ("eq2_gain" == key) pCurDef->eq2_gain = ToFloat(value);
1536     else if ("eq3_gain" == key) pCurDef->eq3_gain = ToFloat(value);
1537     else if ("eq1_vel2gain" == key) pCurDef->eq1_vel2gain = ToFloat(value);
1538     else if ("eq2_vel2gain" == key) pCurDef->eq2_vel2gain = ToFloat(value);
1539     else if ("eq3_vel2gain" == key) pCurDef->eq3_vel2gain = ToFloat(value);
1540    
1541 persson 2082 else if (sscanf(key.c_str(), "amp_velcurve_%d", &x)) {
1542 persson 2091 pCurDef->amp_velcurve.set(x, ToFloat(value));
1543 persson 2082 }
1544 iliev 2225
1545 persson 2055 // v2 envelope generators
1546     else if (sscanf(key.c_str(), "eg%d%n", &x, &y)) {
1547     const char* s = key.c_str() + y;
1548 iliev 2229 if (sscanf(s, "_time%d%n", &y, &z)) {
1549     const char* s2 = s + z;
1550     if (strcmp(s2, "") == 0) egnode(x, y).time = check(key, 0.0f, 100.0f, ToFloat(value));
1551     else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).time_oncc.add( CC(z, check(key, 0.0f, 100.0f, ToFloat(value))) );
1552     } else if (sscanf(s, "_level%d%n", &y, &z)) {
1553     const char* s2 = s + z;
1554     if (strcmp(s2, "") == 0) egnode(x, y).level = check(key, 0.0f, 1.0f, ToFloat(value));
1555     else if (sscanf(s2, "_oncc%d", &z)) egnode(x, y).level_oncc.add( CC(z, check(key, 0.0f, 1.0f, ToFloat(value))) );
1556     }
1557 persson 2055 else if (sscanf(s, "_shape%d", &y)) egnode(x, y).shape = ToFloat(value);
1558     else if (sscanf(s, "_curve%d", &y)) egnode(x, y).curve = ToFloat(value);
1559     else if (strcmp(s, "_sustain") == 0) eg(x).sustain = ToInt(value);
1560     else if (strcmp(s, "_loop") == 0) eg(x).loop = ToInt(value);
1561     else if (strcmp(s, "_loop_count") == 0) eg(x).loop_count = ToInt(value);
1562     else if (strcmp(s, "_amplitude") == 0) eg(x).amplitude = ToFloat(value);
1563 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))) );
1564     else if (strcmp(s, "_volume") == 0) eg(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1565     else if (sscanf(s, "_volume_oncc%d", &y)) eg(x).volume_oncc.add( CC(y, check(key, -144.0f, 6.0f, ToFloat(value))) );
1566 persson 2055 else if (strcmp(s, "_cutoff") == 0) eg(x).cutoff = ToFloat(value);
1567 iliev 2235 else if (sscanf(s, "_cutoff_oncc%d", &y)) eg(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1568     else if (strcmp(s, "_pitch") == 0) eg(x).pitch = check(key, -9600, 9600, ToInt(value));
1569     else if (sscanf(s, "_pitch_oncc%d", &y)) eg(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1570     else if (strcmp(s, "_resonance") == 0) eg(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1571     else if (sscanf(s, "_resonance_oncc%d", &y)) eg(x).resonance_oncc.add( CC(y, check(key, 0.0f, 40.0f, ToFloat(value))) );
1572 iliev 2237 else if (strcmp(s, "_pan") == 0) eg(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1573     else if (strcmp(s, "_pan_curve") == 0) eg(x).pan_curve = check(key, 0, 30000, ToInt(value));
1574     else if (sscanf(s, "_pan_oncc%d", &y)) eg(x).pan_oncc.add( CC(y, check(key, -100.0f, 100.0f, ToFloat(value))) );
1575     else if (sscanf(s, "_pan_curvecc%d", &y)) eg(x).pan_curvecc.add( CC(y, 0.0f, check(key, 0, 30000, ToInt(value))) );
1576 iliev 2299 else if (strcmp(s, "_eq1freq") == 0) eg(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1577     else if (strcmp(s, "_eq2freq") == 0) eg(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1578     else if (strcmp(s, "_eq3freq") == 0) eg(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1579     else if (strcmp(s, "_eq1bw") == 0) eg(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1580     else if (strcmp(s, "_eq2bw") == 0) eg(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1581     else if (strcmp(s, "_eq3bw") == 0) eg(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1582     else if (strcmp(s, "_eq1gain") == 0) eg(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1583     else if (strcmp(s, "_eq2gain") == 0) eg(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1584     else if (strcmp(s, "_eq3gain") == 0) eg(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1585     else if (sscanf(s, "_eq1freq_oncc%d", &y)) eg(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1586     else if (sscanf(s, "_eq2freq_oncc%d", &y)) eg(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1587     else if (sscanf(s, "_eq3freq_oncc%d", &y)) eg(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1588     else if (sscanf(s, "_eq1bw_oncc%d", &y)) eg(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1589     else if (sscanf(s, "_eq2bw_oncc%d", &y)) eg(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1590     else if (sscanf(s, "_eq3bw_oncc%d", &y)) eg(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1591     else if (sscanf(s, "_eq1gain_oncc%d", &y)) eg(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1592     else if (sscanf(s, "_eq2gain_oncc%d", &y)) eg(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1593     else if (sscanf(s, "_eq3gain_oncc%d", &y)) eg(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1594 persson 2055 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1595     }
1596    
1597     // v1 envelope generators
1598 iliev 2018 else if ("ampeg_delay" == key) pCurDef->ampeg_delay = ToFloat(value);
1599     else if ("ampeg_start" == key) pCurDef->ampeg_start = ToFloat(value);
1600     else if ("ampeg_attack" == key) pCurDef->ampeg_attack = ToFloat(value);
1601     else if ("ampeg_hold" == key) pCurDef->ampeg_hold = ToFloat(value);
1602     else if ("ampeg_decay" == key) pCurDef->ampeg_decay = ToFloat(value);
1603     else if ("ampeg_sustain" == key) pCurDef->ampeg_sustain = ToFloat(value);
1604 persson 2176 else if ("ampeg_release" == key) pCurDef->ampeg_release = ToFloat(value);
1605     else if ("ampeg_vel2delay" == key) pCurDef->ampeg_vel2delay = ToFloat(value);
1606     else if ("ampeg_vel2attack" == key) pCurDef->ampeg_vel2attack = ToFloat(value);
1607     else if ("ampeg_vel2hold" == key) pCurDef->ampeg_vel2hold = ToFloat(value);
1608     else if ("ampeg_vel2decay" == key) pCurDef->ampeg_vel2decay = ToFloat(value);
1609     else if ("ampeg_vel2sustain" == key) pCurDef->ampeg_vel2sustain = ToFloat(value);
1610     else if ("ampeg_vel2release" == key) pCurDef->ampeg_vel2release = ToFloat(value);
1611 iliev 2018 else if ("fileg_delay" == key) pCurDef->fileg_delay = ToFloat(value);
1612     else if ("fileg_start" == key) pCurDef->fileg_start = ToFloat(value);
1613     else if ("fileg_attack" == key) pCurDef->fileg_attack = ToFloat(value);
1614     else if ("fileg_hold" == key) pCurDef->fileg_hold = ToFloat(value);
1615     else if ("fileg_decay" == key) pCurDef->fileg_decay = ToFloat(value);
1616     else if ("fileg_sustain" == key) pCurDef->fileg_sustain = ToFloat(value);
1617     else if ("fileg_release" == key) pCurDef->fileg_release = ToFloat(value);
1618 iliev 2222 else if ("fileg_depth" == key) pCurDef->fileg_depth = check(key, -12000, 12000, ToInt(value));
1619     else if ("fileg_vel2delay" == key) pCurDef->fileg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1620     else if ("fileg_vel2attack" == key) pCurDef->fileg_vel2attack = ToFloat(value);
1621     else if ("fileg_vel2hold" == key) pCurDef->fileg_vel2hold = ToFloat(value);
1622     else if ("fileg_vel2decay" == key) pCurDef->fileg_vel2decay = ToFloat(value);
1623     else if ("fileg_vel2sustain" == key) pCurDef->fileg_vel2sustain = ToFloat(value);
1624     else if ("fileg_vel2release" == key) pCurDef->fileg_vel2release = ToFloat(value);
1625 iliev 2018 else if ("pitcheg_delay" == key) pCurDef->pitcheg_delay = ToFloat(value);
1626     else if ("pitcheg_start" == key) pCurDef->pitcheg_start = ToFloat(value);
1627 iliev 2220 else if ("pitcheg_attack" == key) pCurDef->pitcheg_attack = ToFloat(value);
1628     else if ("pitcheg_hold" == key) pCurDef->pitcheg_hold = ToFloat(value);
1629 iliev 2018 else if ("pitcheg_decay" == key) pCurDef->pitcheg_decay = ToFloat(value);
1630 iliev 2220 else if ("pitcheg_sustain" == key) pCurDef->pitcheg_sustain = ToFloat(value);
1631     else if ("pitcheg_release" == key) pCurDef->pitcheg_release = ToFloat(value);
1632     else if ("pitcheg_depth" == key) pCurDef->pitcheg_depth = check(key, -12000, 12000, ToInt(value));
1633     else if ("pitcheg_vel2delay" == key) pCurDef->pitcheg_vel2delay = check(key, -100.0f, 100.0f, ToFloat(value));
1634     else if ("pitcheg_vel2attack" == key) pCurDef->pitcheg_vel2attack = ToFloat(value);
1635     else if ("pitcheg_vel2hold" == key) pCurDef->pitcheg_vel2hold = ToFloat(value);
1636     else if ("pitcheg_vel2decay" == key) pCurDef->pitcheg_vel2decay = ToFloat(value);
1637     else if ("pitcheg_vel2sustain" == key) pCurDef->pitcheg_vel2sustain = ToFloat(value);
1638     else if ("pitcheg_vel2release" == key) pCurDef->pitcheg_vel2release = ToFloat(value);
1639    
1640 persson 2072
1641     // v1 LFO
1642     else if ("amplfo_delay" == key) pCurDef->amplfo_delay = ToFloat(value);
1643     else if ("amplfo_fade" == key) pCurDef->amplfo_fade = ToFloat(value);
1644     else if ("amplfo_freq" == key) pCurDef->amplfo_freq = ToFloat(value);
1645 iliev 2253 else if ("amplfo_freqchanaft" == key) pCurDef->amplfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1646 persson 2072 else if ("amplfo_depth" == key) pCurDef->amplfo_depth = ToFloat(value);
1647 iliev 2253 else if ("amplfo_depthchanaft" == key) pCurDef->amplfo_depthcc.add( CC(128, check(key, -10.0f, 10.0f, ToFloat(value))) );
1648 persson 2072 else if ("fillfo_delay" == key) pCurDef->fillfo_delay = ToFloat(value);
1649     else if ("fillfo_fade" == key) pCurDef->fillfo_fade = ToFloat(value);
1650     else if ("fillfo_freq" == key) pCurDef->fillfo_freq = ToFloat(value);
1651 iliev 2253 else if ("fillfo_freqchanaft" == key) pCurDef->fillfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1652 persson 2072 else if ("fillfo_depth" == key) pCurDef->fillfo_depth = ToFloat(value);
1653 iliev 2253 else if ("fillfo_depthchanaft" == key) pCurDef->fillfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1654 persson 2072 else if ("pitchlfo_delay" == key) pCurDef->pitchlfo_delay = ToFloat(value);
1655     else if ("pitchlfo_fade" == key) pCurDef->pitchlfo_fade = ToFloat(value);
1656     else if ("pitchlfo_freq" == key) pCurDef->pitchlfo_freq = ToFloat(value);
1657 iliev 2253 else if ("pitchlfo_freqchanaft" == key) pCurDef->pitchlfo_freqcc.add( CC(128, check(key, -200.0f, 200.0f, ToFloat(value))) );
1658 persson 2072 else if ("pitchlfo_depth" == key) pCurDef->pitchlfo_depth = ToInt(value);
1659 iliev 2253 else if ("pitchlfo_depthchanaft" == key) pCurDef->pitchlfo_depthcc.add( CC(128, check(key, -1200, 1200, ToInt(value))) );
1660 iliev 2218
1661 iliev 2253
1662 iliev 2218 // v2 LFO
1663     else if (sscanf(key.c_str(), "lfo%d%n", &x, &y)) {
1664     const char* s = key.c_str() + y;
1665     if (strcmp(s, "_freq") == 0) lfo(x).freq = check(key, 0.0f, 20.0f, ToFloat(value));
1666 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))) );
1667 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))) );
1668 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))) );
1669 iliev 2218 else if (strcmp(s, "_wave") == 0) lfo(x).wave = ToInt(value);
1670     else if (strcmp(s, "_delay") == 0) lfo(x).delay = check(key, 0.0f, 100.0f, ToFloat(value));
1671 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))) );
1672 iliev 2226 else if (strcmp(s, "_fade") == 0) lfo(x).fade = check(key, 0.0f, 100.0f, ToFloat(value));
1673     else if (sscanf(s, "_fade_oncc%d", &y)) lfo(x).fade_oncc.add( CC(y, check(key, 0.0f, 100.0f, ToFloat(value))) );
1674 iliev 2225 else if (strcmp(s, "_phase") == 0) lfo(x).phase = check(key, 0.0f, 360.0f, ToFloat(value));
1675     else if (sscanf(s, "_phase_oncc%d", &y)) lfo(x).phase_oncc.add( CC(y, check(key, 0.0f, 360.0f, ToFloat(value))) );
1676 iliev 2221 else if (strcmp(s, "_volume") == 0) lfo(x).volume = check(key, -144.0f, 6.0f, ToFloat(value));
1677 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))) );
1678     else if (sscanf(s, "_volume_smoothcc%d", &y)) lfo(x).volume_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1679 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))) );
1680 iliev 2218 else if (strcmp(s, "_pitch") == 0) lfo(x).pitch = check(key, -9600, 9600, ToInt(value));
1681 iliev 2225 else if (sscanf(s, "_pitch_oncc%d", &y)) lfo(x).pitch_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1682 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))) );
1683 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))) );
1684 iliev 2218 else if (strcmp(s, "_cutoff") == 0) lfo(x).cutoff = check(key, -9600, 9600, ToInt(value));
1685 iliev 2233 else if (sscanf(s, "_cutoff_oncc%d", &y)) lfo(x).cutoff_oncc.add( CC(y, check(key, -9600, 9600, ToInt(value))) );
1686     else if (sscanf(s, "_cutoff_smoothcc%d", &y)) lfo(x).cutoff_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1687 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))) );
1688 iliev 2218 else if (strcmp(s, "_resonance") == 0) lfo(x).resonance = check(key, 0.0f, 40.0f, ToFloat(value));
1689 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))) );
1690     else if (sscanf(s, "_resonance_smoothcc%d", &y)) lfo(x).resonance_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1691 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))) );
1692 iliev 2218 else if (strcmp(s, "_pan") == 0) lfo(x).pan = check(key, -100.0f, 100.0f, ToFloat(value));
1693 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))) );
1694     else if (sscanf(s, "_pan_smoothcc%d", &y)) lfo(x).pan_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1695 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))) );
1696 iliev 2299 else if (strcmp(s, "_eq1freq") == 0) lfo(x).eq1freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1697     else if (strcmp(s, "_eq2freq") == 0) lfo(x).eq2freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1698     else if (strcmp(s, "_eq3freq") == 0) lfo(x).eq3freq = check(key, 0.0f, 30000.0f, ToFloat(value));
1699     else if (strcmp(s, "_eq1bw") == 0) lfo(x).eq1bw = check(key, 0.001f, 4.0f, ToFloat(value));
1700     else if (strcmp(s, "_eq2bw") == 0) lfo(x).eq2bw = check(key, 0.001f, 4.0f, ToFloat(value));
1701     else if (strcmp(s, "_eq3bw") == 0) lfo(x).eq3bw = check(key, 0.001f, 4.0f, ToFloat(value));
1702     else if (strcmp(s, "_eq1gain") == 0) lfo(x).eq1gain = check(key, -96.0f, 24.0f, ToFloat(value));
1703     else if (strcmp(s, "_eq2gain") == 0) lfo(x).eq2gain = check(key, -96.0f, 24.0f, ToFloat(value));
1704     else if (strcmp(s, "_eq3gain") == 0) lfo(x).eq3gain = check(key, -96.0f, 24.0f, ToFloat(value));
1705     else if (sscanf(s, "_eq1freq_oncc%d", &y)) lfo(x).eq1freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1706     else if (sscanf(s, "_eq1freq_smoothcc%d", &y)) lfo(x).eq1freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1707     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))) );
1708     else if (sscanf(s, "_eq2freq_oncc%d", &y)) lfo(x).eq2freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1709     else if (sscanf(s, "_eq2freq_smoothcc%d", &y)) lfo(x).eq2freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1710     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))) );
1711     else if (sscanf(s, "_eq3freq_oncc%d", &y)) lfo(x).eq3freq_oncc.add( CC(y, check(key, 0.0f, 30000.0f, ToFloat(value))) );
1712     else if (sscanf(s, "_eq3freq_smoothcc%d", &y)) lfo(x).eq3freq_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1713     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))) );
1714     else if (sscanf(s, "_eq1bw_oncc%d", &y)) lfo(x).eq1bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1715     else if (sscanf(s, "_eq1bw_smoothcc%d", &y)) lfo(x).eq1bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1716     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))) );
1717     else if (sscanf(s, "_eq2bw_oncc%d", &y)) lfo(x).eq2bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1718     else if (sscanf(s, "_eq2bw_smoothcc%d", &y)) lfo(x).eq2bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1719     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))) );
1720     else if (sscanf(s, "_eq3bw_oncc%d", &y)) lfo(x).eq3bw_oncc.add( CC(y, check(key, 0.001f, 4.0f, ToFloat(value))) );
1721     else if (sscanf(s, "_eq3bw_smoothcc%d", &y)) lfo(x).eq3bw_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1722     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))) );
1723     else if (sscanf(s, "_eq1gain_oncc%d", &y)) lfo(x).eq1gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1724     else if (sscanf(s, "_eq1gain_smoothcc%d", &y)) lfo(x).eq1gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1725     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))) );
1726     else if (sscanf(s, "_eq2gain_oncc%d", &y)) lfo(x).eq2gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1727     else if (sscanf(s, "_eq2gain_smoothcc%d", &y)) lfo(x).eq2gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1728     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))) );
1729     else if (sscanf(s, "_eq3gain_oncc%d", &y)) lfo(x).eq3gain_oncc.add( CC(y, check(key, -96.0f, 24.0f, ToFloat(value))) );
1730     else if (sscanf(s, "_eq3gain_smoothcc%d", &y)) lfo(x).eq3gain_smoothcc.add( CC(y, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1731     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))) );
1732 iliev 2218 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1733     }
1734 iliev 2230
1735 iliev 2225 // CCs
1736     else if (key.find("cc") != std::string::npos)
1737     {
1738     std::string::size_type delimiter_index = key.find("cc");
1739     std::string key_cc = key.substr(0, delimiter_index);
1740 iliev 2250 if (key_cc.size() > 3 && !strcmp(key_cc.c_str() + (key_cc.size() - 3), "_on")) {
1741     key_cc = key_cc.substr(0, key_cc.size() - 3);
1742     }
1743 iliev 2225 int num_cc = ToInt(key.substr(delimiter_index + 2));
1744    
1745     // input controls
1746     if ("lo" == key_cc) pCurDef->locc.set(num_cc, ToInt(value));
1747     else if ("hi" == key_cc) pCurDef->hicc.set(num_cc, ToInt(value));
1748     else if ("start_lo" == key_cc) pCurDef->start_locc.set(num_cc, ToInt(value));
1749     else if ("start_hi" == key_cc) pCurDef->start_hicc.set(num_cc, ToInt(value));
1750     else if ("stop_lo" == key_cc) pCurDef->stop_locc.set(num_cc, ToInt(value));
1751     else if ("stop_hi" == key_cc) pCurDef->stop_hicc.set(num_cc, ToInt(value));
1752     else if ("on_lo" == key_cc) pCurDef->on_locc.set(num_cc, ToInt(value));
1753     else if ("on_hi" == key_cc) pCurDef->on_hicc.set(num_cc, ToInt(value));
1754    
1755     // sample player
1756 iliev 2250 else if ("delay" == key_cc) pCurDef->delay_oncc.set(num_cc, ToFloat(value));
1757     else if ("delay_samples" == key_cc) pCurDef->delay_samples_oncc.set(num_cc, ToInt(value));
1758     else if ("offset" == key_cc) pCurDef->offset_oncc.set(num_cc, ToInt(value));
1759 iliev 2225
1760     // amplifier
1761 iliev 2250 else if ("gain" == key_cc || "gain_" == key_cc) pCurDef->gain_oncc.set(num_cc, ToFloat(value));
1762 iliev 2225 else if ("xfin_lo" == key_cc) pCurDef->xfin_locc.set(num_cc, ToInt(value));
1763     else if ("xfin_hi" == key_cc) pCurDef->xfin_hicc.set(num_cc, ToInt(value));
1764     else if ("xfout_lo" == key_cc) pCurDef->xfout_locc.set(num_cc, ToInt(value));
1765     else if ("xfout_hi" == key_cc) pCurDef->xfout_hicc.set(num_cc, ToInt(value));
1766 iliev 2264
1767     // pitch
1768     else if ("pitch" == key_cc) pCurDef->pitch_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1769     else if ("pitch_smooth" == key_cc) pCurDef->pitch_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1770     else if ("pitch_curve" == key_cc) pCurDef->pitch_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1771     else if ("pitch_step" == key_cc) pCurDef->pitch_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0, 1200, ToInt(value))) );
1772 iliev 2225
1773     // filter
1774 iliev 2250 else if ("cutoff" == key_cc || "cutoff_" == key_cc) {
1775 iliev 2252 pCurDef->cutoff_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1776     } else if ("cutoff2" == key_cc) pCurDef->cutoff2_oncc.add( CC(num_cc, check(key, -9600, 9600, ToInt(value))) );
1777     else if ("cutoff_smooth" == key_cc) pCurDef->cutoff_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1778     else if ("cutoff2_smooth" == key_cc) pCurDef->cutoff2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1779 iliev 2265 else if ("cutoff_step" == key_cc) pCurDef->cutoff_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1780     else if ("cutoff2_step" == key_cc) pCurDef->cutoff2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, -1200, 1200, ToInt(value))) );
1781 iliev 2252 else if ("cutoff_curve" == key_cc) pCurDef->cutoff_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1782     else if ("cutoff2_curve" == key_cc) pCurDef->cutoff2_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1783     else if ("resonance" == key_cc) pCurDef->resonance_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1784     else if ("resonance2" == key_cc) pCurDef->resonance2_oncc.add( CC(num_cc, check(key, 0.0f, 40.0f, ToFloat(value))) );
1785     else if ("resonance_smooth" == key_cc) pCurDef->resonance_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1786     else if ("resonance2_smooth" == key_cc) pCurDef->resonance2_smoothcc.add( CC(num_cc, 0, -1, check(key, 0, 100000 /* max? */, ToInt(value))) );
1787 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))) );
1788     else if ("resonance2_step" == key_cc) pCurDef->resonance2_stepcc.add( CC(num_cc, 0, -1, 0, check(key, 0.0f, 40.0f, ToFloat(value))) );
1789 iliev 2252 else if ("resonance_curve" == key_cc) pCurDef->resonance_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1790     else if ("resonance2_curve" == key_cc) pCurDef->resonance2_curvecc.add( CC(num_cc, 0.0f, check(key, 0, 30000, ToInt(value))) );
1791 iliev 2225
1792     // per voice equalizer
1793 iliev 2250 else if ("eq1_freq" == key_cc) pCurDef->eq1_freq_oncc.set(num_cc, ToInt(value));
1794     else if ("eq2_freq" == key_cc) pCurDef->eq2_freq_oncc.set(num_cc, ToInt(value));
1795     else if ("eq3_freq" == key_cc) pCurDef->eq3_freq_oncc.set(num_cc, ToInt(value));
1796     else if ("eq1_bw" == key_cc) pCurDef->eq1_bw_oncc.set(num_cc, ToInt(value));
1797     else if ("eq2_bw" == key_cc) pCurDef->eq2_bw_oncc.set(num_cc, ToInt(value));
1798     else if ("eq3_bw" == key_cc) pCurDef->eq3_bw_oncc.set(num_cc, ToInt(value));
1799     else if ("eq1_gain" == key_cc) pCurDef->eq1_gain_oncc.set(num_cc, ToInt(value));
1800     else if ("eq2_gain" == key_cc) pCurDef->eq2_gain_oncc.set(num_cc, ToInt(value));
1801     else if ("eq3_gain" == key_cc) pCurDef->eq3_gain_oncc.set(num_cc, ToInt(value));
1802 iliev 2229
1803     else if ("ampeg_delay" == key_cc) pCurDef->ampeg_delaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1804     else if ("ampeg_start" == key_cc) pCurDef->ampeg_startcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1805     else if ("ampeg_attack" == key_cc) pCurDef->ampeg_attackcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1806     else if ("ampeg_hold" == key_cc) pCurDef->ampeg_holdcc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1807     else if ("ampeg_decay" == key_cc) pCurDef->ampeg_decaycc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1808     else if ("ampeg_sustain" == key_cc) pCurDef->ampeg_sustaincc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1809     else if ("ampeg_release" == key_cc) pCurDef->ampeg_releasecc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1810    
1811 iliev 2250 else if ("fileg_delay" == key_cc) pCurDef->fileg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1812     else if ("fileg_start" == key_cc) pCurDef->fileg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1813     else if ("fileg_attack" == key_cc) pCurDef->fileg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1814     else if ("fileg_hold" == key_cc) pCurDef->fileg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1815     else if ("fileg_decay" == key_cc) pCurDef->fileg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1816     else if ("fileg_sustain" == key_cc) pCurDef->fileg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1817     else if ("fileg_release" == key_cc) pCurDef->fileg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1818     else if ("fileg_depth" == key_cc) pCurDef->fileg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
1819 iliev 2249
1820 iliev 2250 else if ("pitcheg_delay" == key_cc) pCurDef->pitcheg_delay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1821     else if ("pitcheg_start" == key_cc) pCurDef->pitcheg_start_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1822     else if ("pitcheg_attack" == key_cc) pCurDef->pitcheg_attack_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1823     else if ("pitcheg_hold" == key_cc) pCurDef->pitcheg_hold_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1824     else if ("pitcheg_decay" == key_cc) pCurDef->pitcheg_decay_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1825     else if ("pitcheg_sustain" == key_cc) pCurDef->pitcheg_sustain_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1826     else if ("pitcheg_release" == key_cc) pCurDef->pitcheg_release_oncc.add( CC(num_cc, check(key, -100.0f, 100.0f, ToFloat(value))) );
1827     else if ("pitcheg_depth" == key_cc) pCurDef->pitcheg_depth_oncc.add( CC(num_cc, check(key, -12000, 12000, ToInt(value))) );
1828 iliev 2249
1829 iliev 2250 else if ("pitchlfo_delay" == key_cc) pCurDef->pitchlfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1830     else if ("pitchlfo_fade" == key_cc) pCurDef->pitchlfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1831 iliev 2253 else if ("pitchlfo_depth" == key_cc) pCurDef->pitchlfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
1832 iliev 2227 else if ("pitchlfo_freq" == key_cc) pCurDef->pitchlfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
1833 iliev 2250 else if ("fillfo_delay" == key_cc) pCurDef->fillfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1834     else if ("fillfo_fade" == key_cc) pCurDef->fillfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1835 iliev 2233 else if ("fillfo_depth" == key_cc) pCurDef->fillfo_depthcc.add( CC(num_cc, check(key, -1200, 1200, ToInt(value))) );
1836 iliev 2227 else if ("fillfo_freq" == key_cc) pCurDef->fillfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
1837 iliev 2250 else if ("amplfo_delay" == key_cc) pCurDef->amplfo_delay_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1838     else if ("amplfo_fade" == key_cc) pCurDef->amplfo_fade_oncc.add( CC(num_cc, check(key, 0.0f, 100.0f, ToFloat(value))) );
1839 iliev 2233 else if ("amplfo_depth" == key_cc) pCurDef->amplfo_depthcc.add( CC(num_cc, check(key, -10.0f, 10.0f, ToFloat(value))) );
1840 iliev 2227 else if ("amplfo_freq" == key_cc) pCurDef->amplfo_freqcc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
1841 iliev 2250 else if ("volume" == key_cc) pCurDef->volume_oncc.add( CC(num_cc, check(key, -144.0f, 100.0f, ToFloat(value))) );
1842 iliev 2230 else if ("volume_curve" == key_cc) pCurDef->volume_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1843 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))) );
1844 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))) );
1845 persson 2382 else if ("pan" == key_cc) pCurDef->pan_oncc.add( CC(num_cc, check(key, -200.0f, 200.0f, ToFloat(value))) );
1846 iliev 2237 else if ("pan_curve" == key_cc) pCurDef->pan_curvecc.add( CC(num_cc, 0, check(key, 0, 30000, ToInt(value))) );
1847     else if ("pan_smooth" == key_cc) pCurDef->pan_smoothcc.add( CC(num_cc, 0, -1, check(key, 0.0f, 100000.0f /* max? */, ToFloat(value))) );
1848 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))) );
1849 iliev 2225 else std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1850     }
1851    
1852 iliev 2018 else {
1853 iliev 2012 std::cerr << "The opcode '" << key << "' is unsupported by libsfz!" << std::endl;
1854     }
1855     }
1856    
1857 persson 2058 int File::parseKey(const std::string& s) {
1858     int i;
1859     std::istringstream iss(s);
1860     if (isdigit(iss.peek())) {
1861     iss >> i;
1862     } else {
1863     switch (tolower(iss.get())) {
1864     case 'c': i = 0; break;
1865     case 'd': i = 2; break;
1866     case 'e': i = 4; break;
1867     case 'f': i = 5; break;
1868     case 'g': i = 7; break;
1869     case 'a': i = 9; break;
1870     case 'b': i = 11; break;
1871 persson 2115 case '-': if (s == "-1") return -1;
1872 persson 2058 default:
1873     std::cerr << "Not a note: " << s << std::endl;
1874     return 0;
1875     }
1876     if (iss.peek() == '#') {
1877     i++;
1878     iss.get();
1879     } else if (tolower(iss.peek()) == 'b') {
1880     i--;
1881     iss.get();
1882     }
1883     int octave;
1884     if (!(iss >> octave)) {
1885     std::cerr << "Not a note: " << s << std::endl;
1886     return 0;
1887     }
1888     i += (octave + 1) * 12;
1889     }
1890     return i + note_offset + 12 * octave_offset;
1891     }
1892    
1893 persson 2055 EGNode::EGNode() : time(0), level(0), shape(0), curve(0) {
1894     }
1895 iliev 2229
1896     void EGNode::Copy(const EGNode& egNode) {
1897     time = egNode.time;
1898     level = egNode.level;
1899     shape = egNode.shape;
1900     curve = egNode.curve;
1901    
1902     time_oncc = egNode.time_oncc;
1903     level_oncc = egNode.level_oncc;
1904     }
1905 persson 2055
1906     EG::EG() :
1907 iliev 2237 sustain(0), loop(0), loop_count(0), amplitude(0), pan(0), pan_curve(-1),
1908 iliev 2235 cutoff(0), pitch(0), resonance(0), volume(-200) /* less than -144 dB is considered unset */
1909     { }
1910 iliev 2229
1911     void EG::Copy(const EG& eg) {
1912 iliev 2299 EqImpl::Copy(static_cast<const EqImpl>(eg));
1913    
1914 iliev 2229 sustain = eg.sustain;
1915     loop = eg.loop;
1916     loop_count = eg.loop_count;
1917     amplitude = eg.amplitude;
1918 iliev 2235 volume = eg.volume;
1919 iliev 2229 cutoff = eg.cutoff;
1920 iliev 2235 pitch = eg.pitch;
1921     resonance = eg.resonance;
1922 iliev 2237 pan = eg.pan;
1923     pan_curve = eg.pan_curve;
1924 iliev 2229 node = eg.node;
1925 iliev 2235
1926     amplitude_oncc = eg.amplitude_oncc;
1927     volume_oncc = eg.volume_oncc;
1928     cutoff_oncc = eg.cutoff_oncc;
1929     pitch_oncc = eg.pitch_oncc;
1930     resonance_oncc = eg.resonance_oncc;
1931 iliev 2237 pan_oncc = eg.pan_oncc;
1932     pan_curvecc = eg.pan_curvecc;
1933 iliev 2229 }
1934 iliev 2218
1935     LFO::LFO(): freq (-1),/* -1 is used to determine whether the LFO was initialized */
1936 iliev 2251 fade(0), phase(0), wave(0), delay(0), pitch(0), cutoff(0), resonance(0), pan(0), volume(0) {
1937 iliev 2218
1938     }
1939 iliev 2229
1940     void LFO::Copy(const LFO& lfo) {
1941 iliev 2299 EqSmoothStepImpl::Copy(static_cast<const EqSmoothStepImpl>(lfo));
1942    
1943 iliev 2229 delay = lfo.delay;
1944     freq = lfo.freq;
1945     fade = lfo.fade;
1946     phase = lfo.phase;
1947     wave = lfo.wave;
1948     volume = lfo.volume;
1949     pitch = lfo.pitch;
1950     cutoff = lfo.cutoff;
1951     resonance = lfo.resonance;
1952     pan = lfo.pan;
1953 iliev 2233
1954     delay_oncc = lfo.delay_oncc;
1955     freq_oncc = lfo.freq_oncc;
1956     freq_smoothcc = lfo.freq_smoothcc;
1957 iliev 2265 freq_stepcc = lfo.freq_stepcc;
1958 iliev 2233 fade_oncc = lfo.fade_oncc;
1959     phase_oncc = lfo.phase_oncc;
1960     pitch_oncc = lfo.pitch_oncc;
1961     pitch_smoothcc = lfo.pitch_smoothcc;
1962 iliev 2265 pitch_stepcc = lfo.pitch_stepcc;
1963 iliev 2233 volume_oncc = lfo.volume_oncc;
1964     volume_smoothcc = lfo.volume_smoothcc;
1965 iliev 2265 volume_stepcc = lfo.volume_stepcc;
1966 iliev 2233 pan_oncc = lfo.pan_oncc;
1967     pan_smoothcc = lfo.pan_smoothcc;
1968 iliev 2265 pan_stepcc = lfo.pan_stepcc;
1969 iliev 2233 cutoff_oncc = lfo.cutoff_oncc;
1970     cutoff_smoothcc = lfo.cutoff_smoothcc;
1971 iliev 2265 cutoff_stepcc = lfo.cutoff_stepcc;
1972 iliev 2233 resonance_oncc = lfo.resonance_oncc;
1973     resonance_smoothcc = lfo.resonance_smoothcc;
1974 iliev 2265 resonance_stepcc = lfo.resonance_stepcc;
1975 iliev 2229 }
1976 iliev 2299
1977     EqImpl::EqImpl() {
1978     eq1freq = eq2freq = eq3freq = 0;
1979     eq1bw = eq2bw = eq3bw = 0;
1980     eq1gain = eq2gain = eq3gain = 0;
1981     }
1982    
1983     void EqImpl::Copy(const EqImpl& eq) {
1984     eq1freq = eq.eq1freq;
1985     eq2freq = eq.eq2freq;
1986     eq3freq = eq.eq3freq;
1987     eq1bw = eq.eq1bw;
1988     eq2bw = eq.eq2bw;
1989     eq3bw = eq.eq3bw;
1990     eq1gain = eq.eq1gain;
1991     eq2gain = eq.eq2gain;
1992     eq3gain = eq.eq3gain;
1993    
1994     eq1freq_oncc = eq.eq1freq_oncc;
1995     eq2freq_oncc = eq.eq2freq_oncc;
1996     eq3freq_oncc = eq.eq3freq_oncc;
1997     eq1bw_oncc = eq.eq1bw_oncc;
1998     eq2bw_oncc = eq.eq2bw_oncc;
1999     eq3bw_oncc = eq.eq3bw_oncc;
2000     eq1gain_oncc = eq.eq1gain_oncc;
2001     eq2gain_oncc = eq.eq2gain_oncc;
2002     eq3gain_oncc = eq.eq3gain_oncc;
2003     }
2004    
2005     bool EqImpl::HasEq() {
2006     return eq1freq || eq2freq || eq3freq || eq1bw || eq2bw || eq3bw ||
2007     eq1gain || eq2gain || eq3gain || !eq1gain_oncc.empty() ||
2008     !eq2gain_oncc.empty() || !eq3gain_oncc.empty() ||
2009     !eq1freq_oncc.empty() || !eq2freq_oncc.empty() || !eq3freq_oncc.empty() ||
2010     !eq1bw_oncc.empty() || !eq2bw_oncc.empty() || !eq3bw_oncc.empty();
2011     }
2012    
2013     void EqSmoothStepImpl::Copy(const EqSmoothStepImpl& eq) {
2014     EqImpl::Copy(eq);
2015    
2016     eq1freq_smoothcc = eq.eq1freq_smoothcc;
2017     eq2freq_smoothcc = eq.eq2freq_smoothcc;
2018     eq3freq_smoothcc = eq.eq3freq_smoothcc;
2019     eq1bw_smoothcc = eq.eq1bw_smoothcc;
2020     eq2bw_smoothcc = eq.eq2bw_smoothcc;
2021     eq3bw_smoothcc = eq.eq3bw_smoothcc;
2022     eq1gain_smoothcc = eq.eq1gain_smoothcc;
2023     eq2gain_smoothcc = eq.eq2gain_smoothcc;
2024     eq3gain_smoothcc = eq.eq3gain_smoothcc;
2025    
2026     eq1freq_stepcc = eq.eq1freq_stepcc;
2027     eq2freq_stepcc = eq.eq2freq_stepcc;
2028     eq3freq_stepcc = eq.eq3freq_stepcc;
2029     eq1bw_stepcc = eq.eq1bw_stepcc;
2030     eq2bw_stepcc = eq.eq2bw_stepcc;
2031     eq3bw_stepcc = eq.eq3bw_stepcc;
2032     eq1gain_stepcc = eq.eq1gain_stepcc;
2033     eq2gain_stepcc = eq.eq2gain_stepcc;
2034     eq3gain_stepcc = eq.eq3gain_stepcc;
2035     }
2036    
2037     void EqSmoothStepImpl::copySmoothValues() {
2038     File::copySmoothValues(eq1freq_smoothcc, eq1freq_oncc);
2039     eq1freq_smoothcc.clear();
2040    
2041     File::copySmoothValues(eq2freq_smoothcc, eq2freq_oncc);
2042     eq2freq_smoothcc.clear();
2043    
2044     File::copySmoothValues(eq3freq_smoothcc, eq3freq_oncc);
2045     eq3freq_smoothcc.clear();
2046    
2047     File::copySmoothValues(eq1bw_smoothcc, eq1bw_oncc);
2048     eq1bw_smoothcc.clear();
2049    
2050     File::copySmoothValues(eq2bw_smoothcc, eq2bw_oncc);
2051     eq2bw_smoothcc.clear();
2052    
2053     File::copySmoothValues(eq3bw_smoothcc, eq3bw_oncc);
2054     eq3bw_smoothcc.clear();
2055    
2056     File::copySmoothValues(eq1gain_smoothcc, eq1gain_oncc);
2057     eq1gain_smoothcc.clear();
2058    
2059     File::copySmoothValues(eq2gain_smoothcc, eq2gain_oncc);
2060     eq2gain_smoothcc.clear();
2061    
2062     File::copySmoothValues(eq3gain_smoothcc, eq3gain_oncc);
2063     eq3gain_smoothcc.clear();
2064     }
2065    
2066     void EqSmoothStepImpl::copyStepValues() {
2067     File::copyStepValues(eq1freq_stepcc, eq1freq_oncc);
2068     eq1freq_stepcc.clear();
2069    
2070     File::copyStepValues(eq2freq_stepcc, eq2freq_oncc);
2071     eq2freq_stepcc.clear();
2072    
2073     File::copyStepValues(eq3freq_stepcc, eq3freq_oncc);
2074     eq3freq_stepcc.clear();
2075    
2076     File::copyStepValues(eq1bw_stepcc, eq1bw_oncc);
2077     eq1bw_stepcc.clear();
2078    
2079     File::copyStepValues(eq2bw_stepcc, eq2bw_oncc);
2080     eq2bw_stepcc.clear();
2081    
2082     File::copyStepValues(eq3bw_stepcc, eq3bw_oncc);
2083     eq3bw_stepcc.clear();
2084    
2085     File::copyStepValues(eq1gain_stepcc, eq1gain_oncc);
2086     eq1gain_stepcc.clear();
2087    
2088     File::copyStepValues(eq2gain_stepcc, eq2gain_oncc);
2089     eq2gain_stepcc.clear();
2090    
2091     File::copyStepValues(eq3gain_stepcc, eq3gain_oncc);
2092     eq3gain_stepcc.clear();
2093     }
2094 persson 2055
2095 iliev 2230 EG& File::eg(int x) {
2096     while (pCurDef->eg.size() <= x) {
2097     pCurDef->eg.add(EG());
2098     }
2099     return pCurDef->eg[x];
2100     }
2101    
2102     EGNode& File::egnode(int x, int y) {
2103     EG& e = eg(x);
2104     while (e.node.size() <= y) {
2105     e.node.add(EGNode());
2106     }
2107     return e.node[y];
2108     }
2109    
2110 iliev 2218 LFO& File::lfo(int x) {
2111     while (pCurDef->lfos.size() <= x) {
2112     pCurDef->lfos.add(LFO());
2113     }
2114     return pCurDef->lfos[x];
2115     }
2116    
2117 iliev 2012 } // !namespace sfz

Properties

Name Value
svn:executable *
  ViewVC Help
Powered by ViewVC