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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2235 - (hide annotations) (download) (as text)
Wed Aug 10 19:40:39 2011 UTC (12 years, 7 months ago) by iliev
File MIME type: text/x-c++hdr
File size: 24421 byte(s)
* sfz engine: implemented opcodes egN_amplitude_onccX,
  egN_volume, egN_volume_onccX, egN_cutoff, egN_cutoff_onccX,
  egN_pitch, egN_pitch_onccX, egN_resonance, egN_resonance_onccX

1 iliev 2012 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 persson 2055 * Copyright (C) 2008 Anders Dahnielson <anders@dahnielson.com> *
6 persson 2167 * Copyright (C) 2009 - 2011 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     #ifndef LIBSFZ_SFZ_H
25     #define LIBSFZ_SFZ_H
26    
27     #include <fstream>
28     #include <iostream>
29     #include <vector>
30     #include <string>
31     #include <stdexcept>
32    
33     #include "../common/SampleFile.h"
34     #include "../common/SampleManager.h"
35 persson 2055 #include "../../common/ArrayList.h"
36 iliev 2012
37     #define TRIGGER_ATTACK ((unsigned char) (1 << 0)) // 0x01
38     #define TRIGGER_RELEASE ((unsigned char) (1 << 1)) // 0x02
39     #define TRIGGER_FIRST ((unsigned char) (1 << 2)) // 0x04
40     #define TRIGGER_LEGATO ((unsigned char) (1 << 3)) // 0x08
41    
42 persson 2055 namespace sfz
43 iliev 2012 {
44     // Forward declarations
45     class Articulation;
46     class Region;
47     class Group;
48     class Instrument;
49     class File;
50 persson 2106 class LookupTable;
51 iliev 2234 class SampleManager;
52 persson 2055
53 iliev 2021 class Sample : public LinuxSampler::SampleFileBase<Region> {
54 iliev 2234 private:
55     int End;
56     long TotalFrames;
57    
58 iliev 2021 public:
59 iliev 2234 Sample(String File, bool DontClose = false, uint offset = 0, int end = -2 /* -2 means unspecified */)
60     : LinuxSampler::SampleFileBase<Region>(File, DontClose)
61     {
62 iliev 2216 Offset = offset;
63 iliev 2234 End = end;
64    
65     long tfc = LinuxSampler::SampleFileBase<Region>::GetTotalFrameCount();
66     if (Offset >= tfc) {
67     std::cerr << "Offset for file '" << this->GetFile() << "' too long (" << Offset << ")" << std::endl;
68     Offset = 0;
69     }
70    
71     if (End == -2 || End > tfc) TotalFrames = tfc;
72     else if (End == -1 || End < Offset) TotalFrames = 0;
73     else TotalFrames = End;
74 iliev 2216 }
75 iliev 2021 virtual ~Sample() { }
76 iliev 2234
77     virtual long GetTotalFrameCount() { return TotalFrames; }
78    
79     friend class SampleManager;
80 iliev 2021 };
81 iliev 2012
82     // Enumerations
83     enum sw_vel_t { VEL_CURRENT, VEL_PREVIOUS };
84     enum off_mode_t { OFF_FAST, OFF_NORMAL };
85 persson 2167 enum loop_mode_t { NO_LOOP, ONE_SHOT, LOOP_CONTINUOUS, LOOP_SUSTAIN, LOOP_UNSET };
86 iliev 2012 enum curve_t { GAIN, POWER };
87     enum filter_t { LPF_1P, HPF_1P, BPF_1P, BRF_1P, APF_1P,
88     LPF_2P, HPF_2P, BPF_2P, BRF_2P, PKF_2P,
89     LPF_4P, HPF_4P,
90     LPF_6P, HPF_6P };
91    
92     typedef unsigned char trigger_t;
93     typedef unsigned char uint8_t;
94    
95 iliev 2021 class SampleManager : public LinuxSampler::SampleManager<Sample, Region> {
96 iliev 2012 public:
97 iliev 2234 Sample* FindSample(std::string samplePath, uint offset, int end);
98 iliev 2012
99     protected:
100 iliev 2021 virtual void OnSampleInUse(Sample* pSample) {
101 iliev 2012 pSample->Open();
102     }
103    
104 iliev 2021 virtual void OnSampleInNotUse(Sample* pSample) {
105 iliev 2012 pSample->Close();
106     }
107     };
108 iliev 2225
109     class CC {
110     public:
111 iliev 2230 uint8_t Controller; ///< MIDI controller number.
112     short int Curve;
113     float Influence; ///< Controller Value.
114 iliev 2232 float Smooth; ///< The speed of parameter change in milliseconds
115 iliev 2225
116 iliev 2232 CC(uint8_t Controller = 0, float Influence = 0.0f, short int Curve = -1, float Smooth = 0) {
117 iliev 2225 this->Controller = Controller;
118 iliev 2230 this->Influence = Influence;
119     this->Curve = Curve;
120 iliev 2232 this->Smooth = Smooth;
121 iliev 2225 }
122    
123     CC(const CC& cc) { Copy(cc); }
124     void operator=(const CC& cc) { Copy(cc); }
125    
126     void Copy(const CC& cc) {
127     Controller = cc.Controller;
128 iliev 2230 Influence = cc.Influence;
129     Curve = cc.Curve;
130 iliev 2232 Smooth = cc.Smooth;
131 iliev 2225 }
132     };
133 iliev 2012
134     /////////////////////////////////////////////////////////////
135     // class Exception
136    
137     class Exception :
138     public std::runtime_error
139     {
140     public:
141     Exception(const std::string& msg) :
142     runtime_error(msg)
143     {
144     }
145    
146     std::string Message()
147     {
148     return what();
149     }
150    
151     void PrintMessage()
152     {
153     std::cerr << what() << std::endl << std::flush;
154     }
155     };
156    
157     /////////////////////////////////////////////////////////////
158     // class optional
159    
160     // Handy class nicked from LinuxSampler...
161     // Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck
162     // Copyright (C) 2005, 2006 Christian Schoenebeck
163    
164     class optional_base
165     {
166     public:
167     class nothing_t { public: nothing_t() {} };
168     static const nothing_t nothing;
169     };
170    
171     template<class T>
172     class optional :
173     public optional_base
174     {
175     public:
176     optional()
177     {
178     initialized = false;
179     }
180    
181     optional(T data)
182     {
183     this->data = data;
184     initialized = true;
185     }
186    
187     optional(nothing_t)
188     {
189     initialized = false;
190     }
191    
192     template <class T_inner>
193     optional(T_inner data)
194     {
195     this->data = T(data);
196     initialized = true;
197     }
198    
199     const T& get() const throw (Exception)
200     {
201     if (!initialized) throw Exception("optional variable not initialized");
202     return data;
203     }
204    
205     T& get() throw (Exception)
206     {
207     if (!initialized) throw Exception("optional variable not initialized");
208     return data;
209     }
210    
211     void unset()
212     {
213     initialized = false;
214     }
215    
216     optional& operator =(const optional& arg) throw (Exception)
217     {
218     if (!arg.initialized) {
219     initialized = false;
220     } else {
221     this->data = arg.data;
222     initialized = true;
223     }
224     return *this;
225     }
226    
227     optional& operator =(const T& arg)
228     {
229     this->data = arg;
230     initialized = true;
231     return *this;
232     }
233    
234     const T& operator *() const throw (Exception) { return get(); }
235     T& operator *() throw (Exception) { return get(); }
236    
237     const T* operator ->() const throw (Exception)
238     {
239     if (!initialized) throw Exception("optional variable not initialized");
240     return &data;
241     }
242    
243     T* operator ->() throw (Exception)
244     {
245     if (!initialized) throw Exception("optional variable not initialized");
246     return &data;
247     }
248    
249     operator bool() const { return initialized; }
250     bool operator !() const { return !initialized; }
251    
252     protected:
253     T data;
254     bool initialized;
255     };
256    
257     /////////////////////////////////////////////////////////////
258     // class Articulation
259    
260     // Articulation containing all performance parameters for synthesis
261     class Articulation
262     {
263     public:
264     Articulation();
265     virtual ~Articulation();
266     };
267    
268 persson 2055 class EGNode
269     {
270     public:
271     float time;
272     float level;
273     float shape;
274     float curve;
275 iliev 2229 LinuxSampler::ArrayList<CC> time_oncc;
276     LinuxSampler::ArrayList<CC> level_oncc;
277    
278 persson 2055 EGNode();
279 iliev 2229 EGNode(const EGNode& egNode) { Copy(egNode); }
280     void operator=(const EGNode& egNode) { Copy(egNode); }
281     void Copy(const EGNode& egNode);
282 persson 2055 };
283    
284     class EG
285     {
286     public:
287     LinuxSampler::ArrayList<EGNode> node;
288     int sustain;
289     int loop;
290     int loop_count;
291     float amplitude;
292 iliev 2235 float volume;
293 persson 2055 float cutoff;
294 iliev 2235 int pitch; // -9600 to 9600 cents
295     float resonance; // 0 to 40 dB
296    
297     LinuxSampler::ArrayList<CC> amplitude_oncc;
298     LinuxSampler::ArrayList<CC> volume_oncc;
299     LinuxSampler::ArrayList<CC> cutoff_oncc; // -9600 to 9600 cents
300     LinuxSampler::ArrayList<CC> pitch_oncc;
301     LinuxSampler::ArrayList<CC> resonance_oncc; // 0 to 40 dB
302    
303 persson 2055 EG();
304 iliev 2229 EG(const EG& eg) { Copy(eg); }
305     void operator=(const EG& eg) { Copy(eg); }
306     void Copy(const EG& eg);
307 persson 2055 };
308    
309 iliev 2218 class LFO
310     {
311     public:
312 iliev 2225 float delay; // 0 to 100 seconds
313 iliev 2218 float freq; // 0 to 20 Hz
314 iliev 2226 float fade; // 0 to 100 seconds
315 iliev 2225 float phase; // 0 to 360 degrees
316 iliev 2218 uint wave; // 0 to 4294967296
317 iliev 2221 float volume; // -144 to 6 dB
318 iliev 2218 int pitch; // -9600 to 9600 cents
319     int cutoff; // -9600 to 9600 cents
320     float resonance; // 0 to 40 dB
321     float pan; // -100 to 100 %
322 iliev 2225
323 iliev 2233 LinuxSampler::ArrayList<CC> delay_oncc; // 0 to 100 seconds
324 iliev 2227 LinuxSampler::ArrayList<CC> freq_oncc; // 0 to 20 Hz
325 iliev 2233 LinuxSampler::ArrayList<CC> freq_smoothcc; // 0 to ? milliseconds
326 iliev 2226 LinuxSampler::ArrayList<CC> fade_oncc; // 0 to 100 seconds
327 iliev 2225 LinuxSampler::ArrayList<CC> phase_oncc; // 0 to 360 degrees
328 iliev 2233 LinuxSampler::ArrayList<CC> volume_oncc; // -144 to 6 dB
329     LinuxSampler::ArrayList<CC> volume_smoothcc; // 0 to ? milliseconds
330 iliev 2225 LinuxSampler::ArrayList<CC> pitch_oncc;
331 iliev 2233 LinuxSampler::ArrayList<CC> pitch_smoothcc; // 0 to ? milliseconds
332     LinuxSampler::ArrayList<CC> pan_oncc; // -100 to 100 %
333     LinuxSampler::ArrayList<CC> pan_smoothcc; // 0 to ? milliseconds
334     LinuxSampler::ArrayList<CC> cutoff_oncc; // -9600 to 9600 cents
335     LinuxSampler::ArrayList<CC> cutoff_smoothcc; // 0 to ? milliseconds
336     LinuxSampler::ArrayList<CC> resonance_oncc; // 0 to 40 dB
337     LinuxSampler::ArrayList<CC> resonance_smoothcc; // 0 to ? milliseconds
338 iliev 2225
339 iliev 2218 LFO();
340 iliev 2229 LFO(const LFO& lfo) { Copy(lfo); }
341     void operator=(const LFO& lfo) { Copy(lfo); }
342     void Copy(const LFO& lfo);
343 iliev 2218 };
344    
345 persson 2091 // Fixed size array with copy-on-write semantics
346     template<class T>
347     class Array
348     {
349     private:
350     struct Rep {
351     int refcount;
352     T a[128];
353    
354     Rep() : refcount(1) { }
355     static void release(Rep* rep) {
356     if (!--rep->refcount) delete rep;
357     }
358     } *ptr;
359     public:
360     Array() : ptr(0) { }
361     ~Array() { Rep::release(ptr); }
362    
363     Array& operator=(const Array& array) {
364     if (this != &array) {
365     ptr = array.ptr;
366     if (ptr) ptr->refcount++;
367     }
368     return *this;
369     }
370    
371     const T& operator[](int i) const { return ptr->a[i]; }
372    
373     void set(int i, const T& v) {
374     if (!ptr) {
375     ptr = new Rep;
376     } else if (ptr->refcount > 1 && ptr->a[i] != v) {
377     Rep* newptr = new Rep(*ptr);
378     newptr->refcount = 1;
379     Rep::release(ptr);
380     ptr = newptr;
381     }
382     ptr->a[i] = v;
383     }
384     };
385    
386 iliev 2012 /////////////////////////////////////////////////////////////
387     // class Definition
388    
389     // Base definition used by groups and regions
390     class Definition
391     {
392     public:
393     Definition();
394     virtual ~Definition();
395    
396     // sample definition
397     std::string sample;
398    
399     // input controls
400     int lochan; int hichan;
401     int lokey; int hikey;
402     int lovel; int hivel;
403 persson 2091 Array<int> locc; Array<int> hicc;
404 iliev 2012 int lobend; int hibend;
405 persson 2106 float lobpm; float hibpm;
406 iliev 2012 int lochanaft; int hichanaft;
407     int lopolyaft; int hipolyaft;
408     int loprog; int hiprog;
409     float lorand; float hirand;
410     float lotimer; float hitimer;
411    
412     int seq_length;
413     int seq_position;
414    
415 persson 2091 Array<int> start_locc; Array<int> start_hicc;
416     Array<int> stop_locc; Array<int> stop_hicc;
417 iliev 2012
418     int sw_lokey; int sw_hikey;
419     int sw_last;
420     int sw_down;
421     int sw_up;
422     int sw_previous;
423     sw_vel_t sw_vel;
424    
425     trigger_t trigger;
426    
427 iliev 2027 uint group;
428 persson 2114 uint off_by;
429 iliev 2012 off_mode_t off_mode;
430    
431 persson 2091 Array<int> on_locc; Array<int> on_hicc;
432 iliev 2012
433     // sample player
434     optional<int> count;
435 persson 2091 optional<float> delay; optional<float> delay_random; Array<optional<float> > delay_oncc;
436 iliev 2012 optional<int> delay_beats; optional<int> stop_beats;
437 persson 2091 optional<int> delay_samples; Array<optional<int> > delay_samples_oncc;
438 iliev 2012 optional<int> end;
439     optional<float> loop_crossfade;
440 iliev 2234 optional<uint> offset; optional<int> offset_random; Array<optional<int> > offset_oncc;
441 iliev 2012 loop_mode_t loop_mode;
442     optional<int> loop_start; optional<int> loop_end;
443     optional<int> sync_beats;
444     optional<int> sync_offset;
445    
446     // amplifier
447     float volume;
448     float pan;
449     float width;
450     float position;
451 persson 2091 float amp_keytrack; int amp_keycenter; float amp_veltrack; Array<float> amp_velcurve; float amp_random;
452 iliev 2012 float rt_decay;
453 persson 2091 Array<float> gain_oncc;
454 iliev 2012 int xfin_lokey; int xfin_hikey;
455     int xfout_lokey; int xfout_hikey;
456     curve_t xf_keycurve;
457     int xfin_lovel; int xfin_hivel;
458     int xfout_lovel; int xfout_hivel;
459     curve_t xf_velcurve;
460 persson 2091 Array<int> xfin_locc; Array<int> xfin_hicc;
461     Array<int> xfout_locc; Array<int> xfout_hicc;
462 iliev 2012 curve_t xf_cccurve;
463    
464     // pitch
465     int transpose;
466     int tune;
467     int pitch_keycenter; int pitch_keytrack; int pitch_veltrack; int pitch_random;
468     int bend_up; int bend_down; int bend_step;
469    
470     // filter
471     filter_t fil_type; filter_t fil2_type;
472     optional<float> cutoff; optional<float> cutoff2;
473 persson 2091 Array<int> cutoff_oncc; Array<int> cutoff2_oncc;
474 persson 2175 int cutoff_cc; // TODO: this is just a temporary fix to avoid
475     // looping through the cutoff_oncc array
476 persson 2091 Array<int> cutoff_smoothcc; Array<int> cutoff2_smoothcc;
477     Array<int> cutoff_stepcc; Array<int> cutoff2_stepcc;
478     Array<int> cutoff_curvecc; Array<int> cutoff2_curvecc;
479 iliev 2012 int cutoff_chanaft; int cutoff2_chanaft;
480     int cutoff_polyaft; int cutoff2_polyaft;
481     float resonance; float resonance2;
482 persson 2091 Array<int> resonance_oncc; Array<int> resonance2_oncc;
483     Array<int> resonance_smoothcc; Array<int> resonance2_smoothcc;
484     Array<int> resonance_stepcc; Array<int> resonance2_stepcc;
485     Array<int> resonance_curvecc; Array<int> resonance2_curvecc;
486 iliev 2012 int fil_keytrack; int fil2_keytrack;
487     int fil_keycenter; int fil2_keycenter;
488     int fil_veltrack; int fil2_veltrack;
489     int fil_random; int fil2_random;
490    
491     // per voice equalizer
492     float eq1_freq; float eq2_freq; float eq3_freq;
493 persson 2091 Array<float> eq1_freq_oncc; Array<float> eq2_freq_oncc; Array<float> eq3_freq_oncc;
494 iliev 2012 float eq1_vel2freq; float eq2_vel2freq; float eq3_vel2freq;
495     float eq1_bw; float eq2_bw; float eq3_bw;
496 persson 2091 Array<float> eq1_bw_oncc; Array<float> eq2_bw_oncc; Array<float> eq3_bw_oncc;
497 iliev 2012 float eq1_gain; float eq2_gain; float eq3_gain;
498 persson 2091 Array<float> eq1_gain_oncc; Array<float> eq2_gain_oncc; Array<float> eq3_gain_oncc;
499 iliev 2012 float eq1_vel2gain; float eq2_vel2gain; float eq3_vel2gain;
500 iliev 2018
501     //Deprecated (from version 1)
502     float ampeg_delay, ampeg_start, ampeg_attack, ampeg_hold, ampeg_decay, ampeg_sustain, ampeg_release;
503 persson 2176 float ampeg_vel2delay, ampeg_vel2attack, ampeg_vel2hold, ampeg_vel2decay, ampeg_vel2sustain, ampeg_vel2release;
504 iliev 2229 LinuxSampler::ArrayList<CC> ampeg_delaycc, ampeg_startcc, ampeg_attackcc, ampeg_holdcc;
505     LinuxSampler::ArrayList<CC> ampeg_decaycc, ampeg_sustaincc, ampeg_releasecc;
506 iliev 2018 float fileg_delay, fileg_start, fileg_attack, fileg_hold, fileg_decay, fileg_sustain, fileg_release;
507 iliev 2222 float fileg_vel2delay, fileg_vel2attack, fileg_vel2hold, fileg_vel2decay, fileg_vel2sustain, fileg_vel2release;
508 iliev 2018 float pitcheg_delay, pitcheg_start, pitcheg_attack, pitcheg_hold, pitcheg_decay, pitcheg_sustain, pitcheg_release;
509 iliev 2220 float pitcheg_vel2delay, pitcheg_vel2attack, pitcheg_vel2hold, pitcheg_vel2decay, pitcheg_vel2sustain, pitcheg_vel2release;
510 iliev 2222 int fileg_depth, pitcheg_depth;
511 persson 2072 float amplfo_delay, amplfo_fade, amplfo_freq, amplfo_depth;
512     float fillfo_delay, fillfo_fade, fillfo_freq, fillfo_depth;
513     float pitchlfo_delay, pitchlfo_fade, pitchlfo_freq;
514     int pitchlfo_depth;
515 iliev 2224 Array<int> pitchlfo_depthcc;
516 iliev 2227
517     LinuxSampler::ArrayList<CC> pitchlfo_freqcc; // 0 to 20 Hz
518 iliev 2233 LinuxSampler::ArrayList<CC> fillfo_depthcc; // -1200 to 1200 cents
519     LinuxSampler::ArrayList<CC> fillfo_freqcc; // 0 to 20 Hz
520     LinuxSampler::ArrayList<CC> amplfo_depthcc; // -10 to 10 dB
521     LinuxSampler::ArrayList<CC> amplfo_freqcc; // 0 to 20 Hz
522 persson 2055
523     // envelope generators
524     LinuxSampler::ArrayList<EG> eg;
525 iliev 2218
526     // low frequency oscillators
527     LinuxSampler::ArrayList<LFO> lfos;
528 iliev 2230
529     LinuxSampler::ArrayList<CC> volume_oncc;
530     LinuxSampler::ArrayList<CC> volume_curvecc; // used only as temporary buffer during the parsing - values are then moved to volume_oncc
531 iliev 2232 LinuxSampler::ArrayList<CC> volume_smoothcc; // used only as temporary buffer during the parsing - values are then moved to volume_oncc
532 iliev 2012 };
533    
534 persson 2101 class Query {
535     public:
536     uint8_t chan; // MIDI channel
537 persson 2115 uint8_t key; // MIDI note
538 persson 2101 uint8_t vel; // MIDI velocity
539     int bend; // MIDI pitch bend
540     uint8_t bpm; // host BPM
541     uint8_t chanaft; // MIDI channel pressure
542     uint8_t polyaft; // MIDI polyphonic aftertouch
543     uint8_t prog; // MIDI program change
544     float rand; // generated random number
545     trigger_t trig; // how it was triggered
546     uint8_t* cc; // all 128 CC values
547     float timer; // time since previous region in the group was triggered
548     bool* sw; // state of region key switches, 128 possible values
549     uint8_t last_sw_key; // last key pressed in the key switch range
550     uint8_t prev_sw_key; // previous note value
551 persson 2106
552     void search(const Instrument* pInstrument);
553 persson 2115 void search(const Instrument* pInstrument, int triggercc);
554 persson 2106 Region* next();
555 persson 2101 private:
556 persson 2106 LinuxSampler::ArrayList<Region*>* pRegionList;
557     int regionIndex;
558 persson 2101 };
559    
560 iliev 2012 /////////////////////////////////////////////////////////////
561     // class Region
562    
563     /// Defines Region information of an Instrument
564     class Region :
565     public Definition
566     {
567     public:
568     Region();
569     virtual ~Region();
570    
571 iliev 2021 Sample* pSample;
572     Sample* GetSample(bool create = true);
573 iliev 2012 void DestroySampleIfNotUsed();
574    
575     Region* GetParent() { return this; }; // needed by EngineBase
576     Instrument* GetInstrument() { return pInstrument; }
577     void SetInstrument(Instrument* pInstrument) { this->pInstrument = pInstrument; }
578    
579 iliev 2021 bool HasLoop();
580     uint GetLoopStart();
581     uint GetLoopEnd();
582     uint GetLoopCount();
583    
584 persson 2106 /// Return true if region is triggered by key. Region is
585     /// assumed to come from a search in the lookup table.
586 persson 2101 bool OnKey(const Query& q);
587 iliev 2012
588     /// Return an articulation for the current state
589 persson 2101 Articulation* GetArticulation(int bend, uint8_t bpm, uint8_t chanaft, uint8_t polyaft, uint8_t* cc);
590 iliev 2012
591     // unique region id
592     int id;
593    
594     private:
595     Instrument* pInstrument;
596 persson 2072 int seq_counter;
597 iliev 2012 };
598 iliev 2230
599     class Curve {
600     public:
601     float v[128];
602     Curve() { for (int i = 0; i < 128; i++) v[i] = 0; }
603     Curve(const Curve& curve) { Copy(curve); }
604     void operator=(const Curve& curve) { Copy(curve); }
605     void Copy(const Curve& curve) { for (int i = 0; i < 128; i++) v[i] = curve.v[i]; }
606     };
607 iliev 2012
608     /////////////////////////////////////////////////////////////
609     // class Instrument
610    
611 iliev 2234 /// Provides all necessary information for the synthesis of an Instrument
612 iliev 2012 class Instrument : public SampleManager
613     {
614     public:
615     Instrument(std::string name = "Unknown", SampleManager* pSampleManager = NULL);
616     virtual ~Instrument();
617    
618     std::string GetName() { return name; }
619     SampleManager* GetSampleManager() { return pSampleManager; }
620    
621     bool DestroyRegion(Region* pRegion);
622     bool HasKeyBinding(uint8_t key);
623     bool HasKeySwitchBinding(uint8_t key);
624    
625     /// List of Regions belonging to this Instrument
626     std::vector<Region*> regions;
627 iliev 2230 ::LinuxSampler::ArrayList<Curve> curves;
628 iliev 2012
629 persson 2106 friend class File;
630     friend class Query;
631 iliev 2012
632     private:
633     std::string name;
634     std::vector<bool> KeyBindings;
635     std::vector<bool> KeySwitchBindings;
636     SampleManager* pSampleManager;
637 persson 2106 LookupTable* pLookupTable;
638 persson 2115 LookupTable* pLookupTableCC[128];
639 iliev 2012 };
640    
641     /////////////////////////////////////////////////////////////
642     // class Group
643    
644     /// A Group act just as a template containing Region default values
645     class Group :
646     public Definition
647     {
648     public:
649     Group();
650     virtual ~Group();
651    
652     /// Reset Group to default values
653     void Reset();
654    
655     /// Create a new Region
656     Region* RegionFactory();
657    
658     // id counter
659     int id;
660    
661     };
662    
663     /////////////////////////////////////////////////////////////
664     // class File
665    
666     /// Parses SFZ files and provides abstract access to the data
667     class File
668     {
669     public:
670     /// Load an existing SFZ file
671     File(std::string file, SampleManager* pSampleManager = NULL);
672     virtual ~File();
673    
674     /// Returns a pointer to the instrument object
675     Instrument* GetInstrument();
676    
677     private:
678     void push_header(std::string token);
679     void push_opcode(std::string token);
680 persson 2058 int parseKey(const std::string& value);
681 persson 2055 EG& eg(int x);
682     EGNode& egnode(int x, int y);
683 iliev 2218 LFO& lfo(int x);
684 iliev 2230 void copyCurves(LinuxSampler::ArrayList<CC>& curves, LinuxSampler::ArrayList<CC>& dest);
685 iliev 2232 void copySmoothValues(LinuxSampler::ArrayList<CC>& smooths, LinuxSampler::ArrayList<CC>& dest);
686 iliev 2012
687     std::string currentDir;
688     /// Pointer to the Instrument belonging to this file
689     Instrument* _instrument;
690    
691     // state variables
692 iliev 2230 enum section_t { UNKNOWN, GROUP, REGION, CONTROL, CURVE };
693 iliev 2012 section_t _current_section;
694     Region* _current_region;
695     Group* _current_group;
696 iliev 2230 Curve* _current_curve;
697 iliev 2012 Definition* pCurDef;
698    
699     // control header directives
700     std::string default_path;
701     int octave_offset;
702     int note_offset;
703     };
704    
705     } // !namespace sfz
706    
707     #endif // !LIBSFZ_SFZ_H

Properties

Name Value
svn:executable *

  ViewVC Help
Powered by ViewVC