/[svn]/libgig/trunk/src/gig.h
ViewVC logotype

Annotation of /libgig/trunk/src/gig.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2609 - (hide annotations) (download) (as text)
Sun Jun 8 19:00:30 2014 UTC (9 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 75805 byte(s)
* gig: Fixed instrument script slot saving/loading.
* gigdump tool: Show scripts and script slots.
* Bumped version (3.3.0.svn17).

1 schoenebeck 2 /***************************************************************************
2     * *
3 schoenebeck 933 * libgig - C++ cross-platform Gigasampler format file access library *
4 schoenebeck 2 * *
5 schoenebeck 2540 * Copyright (C) 2003-2014 by Christian Schoenebeck *
6 schoenebeck 384 * <cuse@users.sourceforge.net> *
7 schoenebeck 2 * *
8     * This library 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 library 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 library; 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 __GIG_H__
25     #define __GIG_H__
26    
27     #include "DLS.h"
28 schoenebeck 2584 #include <vector>
29 schoenebeck 2
30 schoenebeck 11 #if WORDS_BIGENDIAN
31 schoenebeck 2 # define LIST_TYPE_3PRG 0x33707267
32     # define LIST_TYPE_3EWL 0x3365776C
33 schoenebeck 929 # define LIST_TYPE_3GRI 0x33677269
34     # define LIST_TYPE_3GNL 0x33676E6C
35 schoenebeck 2584 # define LIST_TYPE_3LS 0x334c5320 // own gig format extension
36     # define LIST_TYPE_RTIS 0x52544953 // own gig format extension
37 schoenebeck 2 # define CHUNK_ID_3GIX 0x33676978
38     # define CHUNK_ID_3EWA 0x33657761
39     # define CHUNK_ID_3LNK 0x336C6E6B
40     # define CHUNK_ID_3EWG 0x33657767
41     # define CHUNK_ID_EWAV 0x65776176
42 schoenebeck 929 # define CHUNK_ID_3GNM 0x33676E6D
43 persson 1199 # define CHUNK_ID_EINF 0x65696E66
44     # define CHUNK_ID_3CRC 0x33637263
45 schoenebeck 2584 # define CHUNK_ID_SCRI 0x53637269 // own gig format extension
46     # define CHUNK_ID_LSNM 0x4c534e4d // own gig format extension
47     # define CHUNK_ID_SCSL 0x5343534c // own gig format extension
48 schoenebeck 2 #else // little endian
49     # define LIST_TYPE_3PRG 0x67727033
50     # define LIST_TYPE_3EWL 0x6C776533
51 schoenebeck 929 # define LIST_TYPE_3GRI 0x69726733
52     # define LIST_TYPE_3GNL 0x6C6E6733
53 schoenebeck 2584 # define LIST_TYPE_3LS 0x20534c33 // own gig format extension
54     # define LIST_TYPE_RTIS 0x53495452 // own gig format extension
55 schoenebeck 2 # define CHUNK_ID_3GIX 0x78696733
56     # define CHUNK_ID_3EWA 0x61776533
57     # define CHUNK_ID_3LNK 0x6B6E6C33
58     # define CHUNK_ID_3EWG 0x67776533
59     # define CHUNK_ID_EWAV 0x76617765
60 schoenebeck 929 # define CHUNK_ID_3GNM 0x6D6E6733
61 persson 1199 # define CHUNK_ID_EINF 0x666E6965
62     # define CHUNK_ID_3CRC 0x63726333
63 schoenebeck 2584 # define CHUNK_ID_SCRI 0x69726353 // own gig format extension
64     # define CHUNK_ID_LSNM 0x4d4e534c // own gig format extension
65     # define CHUNK_ID_SCSL 0x4c534353 // own gig format extension
66 schoenebeck 2 #endif // WORDS_BIGENDIAN
67    
68     /** Gigasampler specific classes and definitions */
69     namespace gig {
70    
71     typedef std::string String;
72    
73     /** Lower and upper limit of a range. */
74     struct range_t {
75     uint8_t low; ///< Low value of range.
76     uint8_t high; ///< High value of range.
77     };
78    
79     /** Pointer address and size of a buffer. */
80     struct buffer_t {
81     void* pStart; ///< Points to the beginning of the buffer.
82     unsigned long Size; ///< Size of the actual data in the buffer in bytes.
83     unsigned long NullExtensionSize; ///< The buffer might be bigger than the actual data, if that's the case that unused space at the end of the buffer is filled with NULLs and NullExtensionSize reflects that unused buffer space in bytes. Those NULL extensions are mandatory for differential algorithms that have to take the following data words into account, thus have to access past the buffer's boundary. If you don't know what I'm talking about, just forget this variable. :)
84 schoenebeck 384 buffer_t() {
85     pStart = NULL;
86     Size = 0;
87     NullExtensionSize = 0;
88     }
89 schoenebeck 2 };
90    
91     /** Standard types of sample loops. */
92     typedef enum {
93     loop_type_normal = 0x00000000, ///< Loop forward (normal)
94     loop_type_bidirectional = 0x00000001, ///< Alternating loop (forward/backward, also known as Ping Pong)
95     loop_type_backward = 0x00000002 ///< Loop backward (reverse)
96     } loop_type_t;
97    
98     /** Society of Motion Pictures and Television E time format. */
99     typedef enum {
100     smpte_format_no_offset = 0x00000000, ///< no SMPTE offset
101     smpte_format_24_frames = 0x00000018, ///< 24 frames per second
102     smpte_format_25_frames = 0x00000019, ///< 25 frames per second
103     smpte_format_30_frames_dropping = 0x0000001D, ///< 30 frames per second with frame dropping (30 drop)
104     smpte_format_30_frames = 0x0000001E ///< 30 frames per second
105     } smpte_format_t;
106    
107     /** Defines the shape of a function graph. */
108     typedef enum {
109     curve_type_nonlinear = 0,
110     curve_type_linear = 1,
111     curve_type_special = 2,
112     curve_type_unknown = 0xffffffff
113     } curve_type_t;
114    
115     /** Dimensions allow to bypass one of the following controllers. */
116     typedef enum {
117     dim_bypass_ctrl_none,
118     dim_bypass_ctrl_94, ///< Effect 4 Depth (MIDI Controller 94)
119     dim_bypass_ctrl_95 ///< Effect 5 Depth (MIDI Controller 95)
120     } dim_bypass_ctrl_t;
121    
122     /** Defines how LFO3 is controlled by. */
123     typedef enum {
124     lfo3_ctrl_internal = 0x00, ///< Only internally controlled.
125     lfo3_ctrl_modwheel = 0x01, ///< Only controlled by external modulation wheel.
126     lfo3_ctrl_aftertouch = 0x02, ///< Only controlled by aftertouch controller.
127     lfo3_ctrl_internal_modwheel = 0x03, ///< Controlled internally and by external modulation wheel.
128     lfo3_ctrl_internal_aftertouch = 0x04 ///< Controlled internally and by aftertouch controller.
129     } lfo3_ctrl_t;
130    
131     /** Defines how LFO2 is controlled by. */
132     typedef enum {
133     lfo2_ctrl_internal = 0x00, ///< Only internally controlled.
134     lfo2_ctrl_modwheel = 0x01, ///< Only controlled by external modulation wheel.
135     lfo2_ctrl_foot = 0x02, ///< Only controlled by external foot controller.
136     lfo2_ctrl_internal_modwheel = 0x03, ///< Controlled internally and by external modulation wheel.
137     lfo2_ctrl_internal_foot = 0x04 ///< Controlled internally and by external foot controller.
138     } lfo2_ctrl_t;
139    
140     /** Defines how LFO1 is controlled by. */
141     typedef enum {
142     lfo1_ctrl_internal = 0x00, ///< Only internally controlled.
143     lfo1_ctrl_modwheel = 0x01, ///< Only controlled by external modulation wheel.
144     lfo1_ctrl_breath = 0x02, ///< Only controlled by external breath controller.
145     lfo1_ctrl_internal_modwheel = 0x03, ///< Controlled internally and by external modulation wheel.
146     lfo1_ctrl_internal_breath = 0x04 ///< Controlled internally and by external breath controller.
147     } lfo1_ctrl_t;
148    
149     /** Defines how the filter cutoff frequency is controlled by. */
150     typedef enum {
151     vcf_cutoff_ctrl_none = 0x00,
152 persson 834 vcf_cutoff_ctrl_none2 = 0x01, ///< The difference between none and none2 is unknown
153 schoenebeck 2 vcf_cutoff_ctrl_modwheel = 0x81, ///< Modulation Wheel (MIDI Controller 1)
154     vcf_cutoff_ctrl_effect1 = 0x8c, ///< Effect Controller 1 (Coarse, MIDI Controller 12)
155     vcf_cutoff_ctrl_effect2 = 0x8d, ///< Effect Controller 2 (Coarse, MIDI Controller 13)
156     vcf_cutoff_ctrl_breath = 0x82, ///< Breath Controller (Coarse, MIDI Controller 2)
157     vcf_cutoff_ctrl_foot = 0x84, ///< Foot Pedal (Coarse, MIDI Controller 4)
158     vcf_cutoff_ctrl_sustainpedal = 0xc0, ///< Sustain Pedal (MIDI Controller 64)
159     vcf_cutoff_ctrl_softpedal = 0xc3, ///< Soft Pedal (MIDI Controller 67)
160     vcf_cutoff_ctrl_genpurpose7 = 0xd2, ///< General Purpose Controller 7 (Button, MIDI Controller 82)
161     vcf_cutoff_ctrl_genpurpose8 = 0xd3, ///< General Purpose Controller 8 (Button, MIDI Controller 83)
162     vcf_cutoff_ctrl_aftertouch = 0x80 ///< Key Pressure
163     } vcf_cutoff_ctrl_t;
164    
165     /** Defines how the filter resonance is controlled by. */
166     typedef enum {
167     vcf_res_ctrl_none = 0xffffffff,
168     vcf_res_ctrl_genpurpose3 = 0, ///< General Purpose Controller 3 (Slider, MIDI Controller 18)
169     vcf_res_ctrl_genpurpose4 = 1, ///< General Purpose Controller 4 (Slider, MIDI Controller 19)
170     vcf_res_ctrl_genpurpose5 = 2, ///< General Purpose Controller 5 (Button, MIDI Controller 80)
171     vcf_res_ctrl_genpurpose6 = 3 ///< General Purpose Controller 6 (Button, MIDI Controller 81)
172     } vcf_res_ctrl_t;
173 schoenebeck 55
174 schoenebeck 36 /**
175     * Defines a controller that has a certain contrained influence on a
176     * particular synthesis parameter (used to define attenuation controller,
177     * EG1 controller and EG2 controller).
178     *
179     * You should use the respective <i>typedef</i> (means either
180     * attenuation_ctrl_t, eg1_ctrl_t or eg2_ctrl_t) in your code!
181     */
182     struct leverage_ctrl_t {
183     typedef enum {
184     type_none = 0x00, ///< No controller defined
185     type_channelaftertouch = 0x2f, ///< Channel Key Pressure
186     type_velocity = 0xff, ///< Key Velocity
187     type_controlchange = 0xfe ///< Ordinary MIDI control change controller, see field 'controller_number'
188     } type_t;
189 schoenebeck 55
190 schoenebeck 36 type_t type; ///< Controller type
191     uint controller_number; ///< MIDI controller number if this controller is a control change controller, 0 otherwise
192     };
193 schoenebeck 55
194 schoenebeck 36 /**
195     * Defines controller influencing attenuation.
196     *
197     * @see leverage_ctrl_t
198     */
199     typedef leverage_ctrl_t attenuation_ctrl_t;
200 schoenebeck 55
201 schoenebeck 36 /**
202     * Defines controller influencing envelope generator 1.
203     *
204     * @see leverage_ctrl_t
205     */
206     typedef leverage_ctrl_t eg1_ctrl_t;
207 schoenebeck 55
208 schoenebeck 36 /**
209     * Defines controller influencing envelope generator 2.
210     *
211     * @see leverage_ctrl_t
212     */
213     typedef leverage_ctrl_t eg2_ctrl_t;
214 schoenebeck 2
215     /**
216     * Defines the type of dimension, that is how the dimension zones (and
217     * thus how the dimension regions are selected by. The number of
218     * dimension zones is always a power of two. All dimensions can have up
219     * to 32 zones (except the layer dimension with only up to 8 zones and
220     * the samplechannel dimension which currently allows only 2 zones).
221     */
222     typedef enum {
223     dimension_none = 0x00, ///< Dimension not in use.
224     dimension_samplechannel = 0x80, ///< If used sample has more than one channel (thus is not mono).
225     dimension_layer = 0x81, ///< For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers).
226 persson 1076 dimension_velocity = 0x82, ///< Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined).
227 schoenebeck 2 dimension_channelaftertouch = 0x83, ///< Channel Key Pressure
228     dimension_releasetrigger = 0x84, ///< Special dimension for triggering samples on releasing a key.
229 schoenebeck 353 dimension_keyboard = 0x85, ///< Dimension for keyswitching
230 persson 437 dimension_roundrobin = 0x86, ///< Different samples triggered each time a note is played, dimension regions selected in sequence
231     dimension_random = 0x87, ///< Different samples triggered each time a note is played, random order
232 persson 1076 dimension_smartmidi = 0x88, ///< For MIDI tools like legato and repetition mode
233     dimension_roundrobinkeyboard = 0x89, ///< Different samples triggered each time a note is played, any key advances the counter
234 schoenebeck 2 dimension_modwheel = 0x01, ///< Modulation Wheel (MIDI Controller 1)
235     dimension_breath = 0x02, ///< Breath Controller (Coarse, MIDI Controller 2)
236     dimension_foot = 0x04, ///< Foot Pedal (Coarse, MIDI Controller 4)
237     dimension_portamentotime = 0x05, ///< Portamento Time (Coarse, MIDI Controller 5)
238     dimension_effect1 = 0x0c, ///< Effect Controller 1 (Coarse, MIDI Controller 12)
239     dimension_effect2 = 0x0d, ///< Effect Controller 2 (Coarse, MIDI Controller 13)
240     dimension_genpurpose1 = 0x10, ///< General Purpose Controller 1 (Slider, MIDI Controller 16)
241     dimension_genpurpose2 = 0x11, ///< General Purpose Controller 2 (Slider, MIDI Controller 17)
242     dimension_genpurpose3 = 0x12, ///< General Purpose Controller 3 (Slider, MIDI Controller 18)
243     dimension_genpurpose4 = 0x13, ///< General Purpose Controller 4 (Slider, MIDI Controller 19)
244     dimension_sustainpedal = 0x40, ///< Sustain Pedal (MIDI Controller 64)
245     dimension_portamento = 0x41, ///< Portamento (MIDI Controller 65)
246     dimension_sostenutopedal = 0x42, ///< Sostenuto Pedal (MIDI Controller 66)
247     dimension_softpedal = 0x43, ///< Soft Pedal (MIDI Controller 67)
248     dimension_genpurpose5 = 0x30, ///< General Purpose Controller 5 (Button, MIDI Controller 80)
249     dimension_genpurpose6 = 0x31, ///< General Purpose Controller 6 (Button, MIDI Controller 81)
250     dimension_genpurpose7 = 0x32, ///< General Purpose Controller 7 (Button, MIDI Controller 82)
251     dimension_genpurpose8 = 0x33, ///< General Purpose Controller 8 (Button, MIDI Controller 83)
252     dimension_effect1depth = 0x5b, ///< Effect 1 Depth (MIDI Controller 91)
253     dimension_effect2depth = 0x5c, ///< Effect 2 Depth (MIDI Controller 92)
254     dimension_effect3depth = 0x5d, ///< Effect 3 Depth (MIDI Controller 93)
255     dimension_effect4depth = 0x5e, ///< Effect 4 Depth (MIDI Controller 94)
256     dimension_effect5depth = 0x5f ///< Effect 5 Depth (MIDI Controller 95)
257     } dimension_t;
258    
259     /**
260     * Intended for internal usage: will be used to convert a dimension value
261     * into the corresponding dimension bit number.
262     */
263     typedef enum {
264 persson 858 split_type_normal, ///< dimension value between 0-127
265 schoenebeck 2 split_type_bit ///< dimension values are already the sought bit number
266     } split_type_t;
267    
268     /** General dimension definition. */
269     struct dimension_def_t {
270     dimension_t dimension; ///< Specifies which source (usually a MIDI controller) is associated with the dimension.
271     uint8_t bits; ///< Number of "bits" (1 bit = 2 splits/zones, 2 bit = 4 splits/zones, 3 bit = 8 splits/zones,...).
272     uint8_t zones; ///< Number of zones the dimension has.
273     split_type_t split_type; ///< Intended for internal usage: will be used to convert a dimension value into the corresponding dimension bit number.
274 persson 774 float zone_size; ///< Intended for internal usage: reflects the size of each zone (128/zones) for normal split types only, 0 otherwise.
275 schoenebeck 2 };
276    
277     /** Defines which frequencies are filtered by the VCF. */
278     typedef enum {
279     vcf_type_lowpass = 0x00,
280     vcf_type_lowpassturbo = 0xff, ///< More poles than normal lowpass
281     vcf_type_bandpass = 0x01,
282     vcf_type_highpass = 0x02,
283     vcf_type_bandreject = 0x03
284     } vcf_type_t;
285    
286 schoenebeck 345 /**
287     * Defines the envelope of a crossfade.
288     *
289     * Note: The default value for crossfade points is 0,0,0,0. Layers with
290     * such a default value should be treated as if they would not have a
291 schoenebeck 353 * crossfade.
292 schoenebeck 345 */
293 schoenebeck 2 struct crossfade_t {
294     #if WORDS_BIGENDIAN
295 schoenebeck 345 uint8_t out_end; ///< End postition of fade out.
296     uint8_t out_start; ///< Start position of fade out.
297     uint8_t in_end; ///< End position of fade in.
298 schoenebeck 2 uint8_t in_start; ///< Start position of fade in.
299 schoenebeck 345 #else // little endian
300     uint8_t in_start; ///< Start position of fade in.
301 schoenebeck 2 uint8_t in_end; ///< End position of fade in.
302     uint8_t out_start; ///< Start position of fade out.
303     uint8_t out_end; ///< End postition of fade out.
304     #endif // WORDS_BIGENDIAN
305     };
306    
307 schoenebeck 24 /** Reflects the current playback state for a sample. */
308     struct playback_state_t {
309     unsigned long position; ///< Current position within the sample.
310     bool reverse; ///< If playback direction is currently backwards (in case there is a pingpong or reverse loop defined).
311     unsigned long loop_cycles_left; ///< How many times the loop has still to be passed, this value will be decremented with each loop cycle.
312     };
313    
314 schoenebeck 515 /**
315     * @brief Used for indicating the progress of a certain task.
316     *
317     * The function pointer argument has to be supplied with a valid
318     * function of the given signature which will then be called on
319 schoenebeck 516 * progress changes. An equivalent progress_t structure will be passed
320     * back as argument to the callback function on each progress change.
321     * The factor field of the supplied progress_t structure will then
322     * reflect the current progress as value between 0.0 and 1.0. You might
323     * want to use the custom field for data needed in your callback
324     * function.
325 schoenebeck 515 */
326     struct progress_t {
327 schoenebeck 516 void (*callback)(progress_t*); ///< Callback function pointer which has to be assigned to a function for progress notification.
328     float factor; ///< Reflects current progress as value between 0.0 and 1.0.
329     void* custom; ///< This pointer can be used for arbitrary data.
330     float __range_min; ///< Only for internal usage, do not modify!
331     float __range_max; ///< Only for internal usage, do not modify!
332 schoenebeck 515 progress_t();
333     };
334    
335 schoenebeck 2 // just symbol prototyping
336     class File;
337     class Instrument;
338     class Sample;
339 capela 310 class Region;
340 schoenebeck 929 class Group;
341 schoenebeck 2584 class Script;
342     class ScriptGroup;
343 schoenebeck 2
344 schoenebeck 1093 /** @brief Encapsulates articulation information of a dimension region.
345 schoenebeck 2 *
346     * Every Gigasampler Instrument has at least one dimension region
347     * (exactly then when it has no dimension defined).
348     *
349     * Gigasampler provides three Envelope Generators and Low Frequency
350     * Oscillators:
351     *
352     * - EG1 and LFO1, both controlling sample amplitude
353     * - EG2 and LFO2, both controlling filter cutoff frequency
354     * - EG3 and LFO3, both controlling sample pitch
355     */
356     class DimensionRegion : protected DLS::Sampler {
357     public:
358 schoenebeck 2543 uint8_t VelocityUpperLimit; ///< Defines the upper velocity value limit of a velocity split (only if an user defined limit was set, thus a value not equal to 128/NumberOfSplits, else this value is 0). Only for gig2, for gig3 and above the DimensionUpperLimits are used instead.
359 schoenebeck 2 Sample* pSample; ///< Points to the Sample which is assigned to the dimension region.
360     // Sample Amplitude EG/LFO
361     uint16_t EG1PreAttack; ///< Preattack value of the sample amplitude EG (0 - 1000 permille).
362     double EG1Attack; ///< Attack time of the sample amplitude EG (0.000 - 60.000s).
363     double EG1Decay1; ///< Decay time of the sample amplitude EG (0.000 - 60.000s).
364     double EG1Decay2; ///< Only if <i>EG1InfiniteSustain == false</i>: 2nd decay stage time of the sample amplitude EG (0.000 - 60.000s).
365     bool EG1InfiniteSustain; ///< If <i>true</i>, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
366     uint16_t EG1Sustain; ///< Sustain value of the sample amplitude EG (0 - 1000 permille).
367     double EG1Release; ///< Release time of the sample amplitude EG (0.000 - 60.000s).
368     bool EG1Hold; ///< If <i>true</i>, Decay1 stage should be postponed until the sample reached the sample loop start.
369     eg1_ctrl_t EG1Controller; ///< MIDI Controller which has influence on sample amplitude EG parameters (attack, decay, release).
370     bool EG1ControllerInvert; ///< Invert values coming from defined EG1 controller.
371 schoenebeck 36 uint8_t EG1ControllerAttackInfluence; ///< Amount EG1 Controller has influence on the EG1 Attack time (0 - 3, where 0 means off).
372     uint8_t EG1ControllerDecayInfluence; ///< Amount EG1 Controller has influence on the EG1 Decay time (0 - 3, where 0 means off).
373     uint8_t EG1ControllerReleaseInfluence; ///< Amount EG1 Controller has influence on the EG1 Release time (0 - 3, where 0 means off).
374 schoenebeck 2 double LFO1Frequency; ///< Frequency of the sample amplitude LFO (0.10 - 10.00 Hz).
375     uint16_t LFO1InternalDepth; ///< Firm pitch of the sample amplitude LFO (0 - 1200 cents).
376     uint16_t LFO1ControlDepth; ///< Controller depth influencing sample amplitude LFO pitch (0 - 1200 cents).
377     lfo1_ctrl_t LFO1Controller; ///< MIDI Controller which controls sample amplitude LFO.
378     bool LFO1FlipPhase; ///< Inverts phase of the sample amplitude LFO wave.
379     bool LFO1Sync; ///< If set to <i>true</i> only one LFO should be used for all voices.
380     // Filter Cutoff Frequency EG/LFO
381     uint16_t EG2PreAttack; ///< Preattack value of the filter cutoff EG (0 - 1000 permille).
382     double EG2Attack; ///< Attack time of the filter cutoff EG (0.000 - 60.000s).
383     double EG2Decay1; ///< Decay time of the filter cutoff EG (0.000 - 60.000s).
384     double EG2Decay2; ///< Only if <i>EG2InfiniteSustain == false</i>: 2nd stage decay time of the filter cutoff EG (0.000 - 60.000s).
385     bool EG2InfiniteSustain; ///< If <i>true</i>, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
386     uint16_t EG2Sustain; ///< Sustain value of the filter cutoff EG (0 - 1000 permille).
387     double EG2Release; ///< Release time of the filter cutoff EG (0.000 - 60.000s).
388     eg2_ctrl_t EG2Controller; ///< MIDI Controller which has influence on filter cutoff EG parameters (attack, decay, release).
389     bool EG2ControllerInvert; ///< Invert values coming from defined EG2 controller.
390 schoenebeck 36 uint8_t EG2ControllerAttackInfluence; ///< Amount EG2 Controller has influence on the EG2 Attack time (0 - 3, where 0 means off).
391     uint8_t EG2ControllerDecayInfluence; ///< Amount EG2 Controller has influence on the EG2 Decay time (0 - 3, where 0 means off).
392     uint8_t EG2ControllerReleaseInfluence; ///< Amount EG2 Controller has influence on the EG2 Release time (0 - 3, where 0 means off).
393 schoenebeck 2 double LFO2Frequency; ///< Frequency of the filter cutoff LFO (0.10 - 10.00 Hz).
394     uint16_t LFO2InternalDepth; ///< Firm pitch of the filter cutoff LFO (0 - 1200 cents).
395     uint16_t LFO2ControlDepth; ///< Controller depth influencing filter cutoff LFO pitch (0 - 1200).
396     lfo2_ctrl_t LFO2Controller; ///< MIDI Controlle which controls the filter cutoff LFO.
397     bool LFO2FlipPhase; ///< Inverts phase of the filter cutoff LFO wave.
398     bool LFO2Sync; ///< If set to <i>true</i> only one LFO should be used for all voices.
399     // Sample Pitch EG/LFO
400     double EG3Attack; ///< Attack time of the sample pitch EG (0.000 - 10.000s).
401     int16_t EG3Depth; ///< Depth of the sample pitch EG (-1200 - +1200).
402     double LFO3Frequency; ///< Frequency of the sample pitch LFO (0.10 - 10.00 Hz).
403     int16_t LFO3InternalDepth; ///< Firm depth of the sample pitch LFO (-1200 - +1200 cents).
404     int16_t LFO3ControlDepth; ///< Controller depth of the sample pitch LFO (-1200 - +1200 cents).
405     lfo3_ctrl_t LFO3Controller; ///< MIDI Controller which controls the sample pitch LFO.
406     bool LFO3Sync; ///< If set to <i>true</i> only one LFO should be used for all voices.
407     // Filter
408     bool VCFEnabled; ///< If filter should be used.
409     vcf_type_t VCFType; ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
410 schoenebeck 1358 vcf_cutoff_ctrl_t VCFCutoffController; ///< Specifies which external controller has influence on the filter cutoff frequency. @deprecated Don't alter directly, use SetVCFCutoffController() instead!
411 persson 728 bool VCFCutoffControllerInvert; ///< Inverts values coming from the defined cutoff controller
412 schoenebeck 2 uint8_t VCFCutoff; ///< Max. cutoff frequency.
413 schoenebeck 1358 curve_type_t VCFVelocityCurve; ///< Defines a transformation curve for the incoming velocity values, affecting the VCF. @deprecated Don't alter directly, use SetVCFVelocityCurve() instead!
414     uint8_t VCFVelocityScale; ///< (0-127) Amount velocity controls VCF cutoff frequency (only if no other VCF cutoff controller is defined, otherwise this is the minimum cutoff). @deprecated Don't alter directly, use SetVCFVelocityScale() instead!
415     uint8_t VCFVelocityDynamicRange; ///< 0x04 = lowest, 0x00 = highest . @deprecated Don't alter directly, use SetVCFVelocityDynamicRange() instead!
416 schoenebeck 2 uint8_t VCFResonance; ///< Firm internal filter resonance weight.
417     bool VCFResonanceDynamic; ///< If <i>true</i>: Increases the resonance Q according to changes of controllers that actually control the VCF cutoff frequency (EG2, ext. VCF MIDI controller).
418     vcf_res_ctrl_t VCFResonanceController; ///< Specifies which external controller has influence on the filter resonance Q.
419     bool VCFKeyboardTracking; ///< If <i>true</i>: VCF cutoff frequence will be dependend to the note key position relative to the defined breakpoint value.
420     uint8_t VCFKeyboardTrackingBreakpoint; ///< See VCFKeyboardTracking (0 - 127).
421     // Key Velocity Transformations
422 schoenebeck 1358 curve_type_t VelocityResponseCurve; ///< Defines a transformation curve to the incoming velocity values affecting amplitude (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseCurve() instead!
423     uint8_t VelocityResponseDepth; ///< Dynamic range of velocity affecting amplitude (0 - 4) (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseDepth() instead!
424     uint8_t VelocityResponseCurveScaling; ///< 0 - 127 (usually you don't have to interpret this parameter, use GetVelocityAttenuation() instead). @deprecated Don't alter directly, use SetVelocityResponseCurveScaling() instead!
425     curve_type_t ReleaseVelocityResponseCurve; ///< Defines a transformation curve to the incoming release veloctiy values affecting envelope times. @deprecated Don't alter directly, use SetReleaseVelocityResponseCurve() instead!
426     uint8_t ReleaseVelocityResponseDepth; ///< Dynamic range of release velocity affecting envelope time (0 - 4). @deprecated Don't alter directly, use SetReleaseVelocityResponseDepth() instead!
427 schoenebeck 2 uint8_t ReleaseTriggerDecay; ///< 0 - 8
428     // Mix / Layer
429     crossfade_t Crossfade;
430     bool PitchTrack; ///< If <i>true</i>: sample will be pitched according to the key position (this will be disabled for drums for example).
431     dim_bypass_ctrl_t DimensionBypass; ///< If defined, the MIDI controller can switch on/off the dimension in realtime.
432     int8_t Pan; ///< Panorama / Balance (-64..0..63 <-> left..middle..right)
433     bool SelfMask; ///< If <i>true</i>: high velocity notes will stop low velocity notes at the same note, with that you can save voices that wouldn't be audible anyway.
434 schoenebeck 36 attenuation_ctrl_t AttenuationController; ///< MIDI Controller which has influence on the volume level of the sample (or entire sample group).
435     bool InvertAttenuationController; ///< Inverts the values coming from the defined Attenuation Controller.
436     uint8_t AttenuationControllerThreshold;///< 0-127
437 schoenebeck 2 uint8_t ChannelOffset; ///< Audio output where the audio signal of the dimension region should be routed to (0 - 9).
438     bool SustainDefeat; ///< If <i>true</i>: Sustain pedal will not hold a note.
439     bool MSDecode; ///< Gigastudio flag: defines if Mid Side Recordings should be decoded.
440     uint16_t SampleStartOffset; ///< Number of samples the sample start should be moved (0 - 2000).
441 persson 406 double SampleAttenuation; ///< Sample volume (calculated from DLS::Sampler::Gain)
442 schoenebeck 2547 uint8_t DimensionUpperLimits[8]; ///< gig3: defines the upper limit of the dimension values for this dimension region. In case you wondered why this is defined on DimensionRegion level and not on Region level: the zone sizes (upper limits) of the velocity dimension can indeed differ in the individual dimension regions, depending on which zones of the other dimension types are currently selected. So this is exceptional for the velocity dimension only. All other dimension types have the same dimension zone sizes for every single DimensionRegion (of the sample Region).
443 persson 406
444 schoenebeck 2 // derived attributes from DLS::Sampler
445 persson 2334 using DLS::Sampler::UnityNote;
446     using DLS::Sampler::FineTune;
447     using DLS::Sampler::Gain;
448     using DLS::Sampler::SampleLoops;
449     using DLS::Sampler::pSampleLoops;
450 schoenebeck 2
451 schoenebeck 809 // own methods
452 schoenebeck 16 double GetVelocityAttenuation(uint8_t MIDIKeyVelocity);
453 persson 613 double GetVelocityRelease(uint8_t MIDIKeyVelocity);
454 persson 728 double GetVelocityCutoff(uint8_t MIDIKeyVelocity);
455 schoenebeck 1358 void SetVelocityResponseCurve(curve_type_t curve);
456     void SetVelocityResponseDepth(uint8_t depth);
457     void SetVelocityResponseCurveScaling(uint8_t scaling);
458     void SetReleaseVelocityResponseCurve(curve_type_t curve);
459     void SetReleaseVelocityResponseDepth(uint8_t depth);
460     void SetVCFCutoffController(vcf_cutoff_ctrl_t controller);
461     void SetVCFVelocityCurve(curve_type_t curve);
462     void SetVCFVelocityDynamicRange(uint8_t range);
463     void SetVCFVelocityScale(uint8_t scaling);
464 schoenebeck 1316 Region* GetParent() const;
465 schoenebeck 1155 // derived methods
466 persson 2334 using DLS::Sampler::AddSampleLoop;
467     using DLS::Sampler::DeleteSampleLoop;
468 schoenebeck 809 // overridden methods
469 schoenebeck 1358 virtual void SetGain(int32_t gain);
470 schoenebeck 809 virtual void UpdateChunks();
471 schoenebeck 2394 virtual void CopyAssign(const DimensionRegion* orig);
472 schoenebeck 16 protected:
473 persson 858 uint8_t* VelocityTable; ///< For velocity dimensions with custom defined zone ranges only: used for fast converting from velocity MIDI value to dimension bit number.
474 schoenebeck 1316 DimensionRegion(Region* pParent, RIFF::List* _3ewl);
475 persson 1301 DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src);
476 schoenebeck 16 ~DimensionRegion();
477 schoenebeck 2482 void CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples);
478 schoenebeck 16 friend class Region;
479     private:
480 schoenebeck 36 typedef enum { ///< Used to decode attenuation, EG1 and EG2 controller
481 schoenebeck 2540 // official leverage controllers as they were defined in the original Gigasampler/GigaStudio format:
482 schoenebeck 36 _lev_ctrl_none = 0x00,
483     _lev_ctrl_modwheel = 0x03, ///< Modulation Wheel (MIDI Controller 1)
484     _lev_ctrl_breath = 0x05, ///< Breath Controller (Coarse, MIDI Controller 2)
485     _lev_ctrl_foot = 0x07, ///< Foot Pedal (Coarse, MIDI Controller 4)
486     _lev_ctrl_effect1 = 0x0d, ///< Effect Controller 1 (Coarse, MIDI Controller 12)
487     _lev_ctrl_effect2 = 0x0f, ///< Effect Controller 2 (Coarse, MIDI Controller 13)
488     _lev_ctrl_genpurpose1 = 0x11, ///< General Purpose Controller 1 (Slider, MIDI Controller 16)
489     _lev_ctrl_genpurpose2 = 0x13, ///< General Purpose Controller 2 (Slider, MIDI Controller 17)
490     _lev_ctrl_genpurpose3 = 0x15, ///< General Purpose Controller 3 (Slider, MIDI Controller 18)
491     _lev_ctrl_genpurpose4 = 0x17, ///< General Purpose Controller 4 (Slider, MIDI Controller 19)
492     _lev_ctrl_portamentotime = 0x0b, ///< Portamento Time (Coarse, MIDI Controller 5)
493     _lev_ctrl_sustainpedal = 0x01, ///< Sustain Pedal (MIDI Controller 64)
494     _lev_ctrl_portamento = 0x19, ///< Portamento (MIDI Controller 65)
495     _lev_ctrl_sostenutopedal = 0x1b, ///< Sostenuto Pedal (MIDI Controller 66)
496     _lev_ctrl_softpedal = 0x09, ///< Soft Pedal (MIDI Controller 67)
497     _lev_ctrl_genpurpose5 = 0x1d, ///< General Purpose Controller 5 (Button, MIDI Controller 80)
498     _lev_ctrl_genpurpose6 = 0x1f, ///< General Purpose Controller 6 (Button, MIDI Controller 81)
499     _lev_ctrl_genpurpose7 = 0x21, ///< General Purpose Controller 7 (Button, MIDI Controller 82)
500     _lev_ctrl_genpurpose8 = 0x23, ///< General Purpose Controller 8 (Button, MIDI Controller 83)
501     _lev_ctrl_effect1depth = 0x25, ///< Effect 1 Depth (MIDI Controller 91)
502     _lev_ctrl_effect2depth = 0x27, ///< Effect 2 Depth (MIDI Controller 92)
503     _lev_ctrl_effect3depth = 0x29, ///< Effect 3 Depth (MIDI Controller 93)
504     _lev_ctrl_effect4depth = 0x2b, ///< Effect 4 Depth (MIDI Controller 94)
505     _lev_ctrl_effect5depth = 0x2d, ///< Effect 5 Depth (MIDI Controller 95)
506     _lev_ctrl_channelaftertouch = 0x2f, ///< Channel Key Pressure
507 schoenebeck 2540 _lev_ctrl_velocity = 0xff, ///< Key Velocity
508    
509     // format extension (these controllers are so far only supported by LinuxSampler & gigedit) they will *NOT* work with Gigasampler/GigaStudio !
510     // (the assigned values here are their official MIDI CC number plus the highest bit set):
511     _lev_ctrl_CC3_EXT = 0x83, ///< MIDI Controller 3 [gig format extension]
512    
513     _lev_ctrl_CC6_EXT = 0x86, ///< Data Entry MSB (MIDI Controller 6) [gig format extension]
514     _lev_ctrl_CC7_EXT = 0x87, ///< Channel Volume (MIDI Controller 7) [gig format extension]
515     _lev_ctrl_CC8_EXT = 0x88, ///< Balance (MIDI Controller 8) [gig format extension]
516     _lev_ctrl_CC9_EXT = 0x89, ///< MIDI Controller 9 [gig format extension]
517     _lev_ctrl_CC10_EXT = 0x8a, ///< Pan (MIDI Controller 10) [gig format extension]
518     _lev_ctrl_CC11_EXT = 0x8b, ///< Expression Controller (MIDI Controller 11) [gig format extension]
519    
520     _lev_ctrl_CC14_EXT = 0x8e, ///< MIDI Controller 14 [gig format extension]
521     _lev_ctrl_CC15_EXT = 0x8f, ///< MIDI Controller 15 [gig format extension]
522    
523     _lev_ctrl_CC20_EXT = 0x94, ///< MIDI Controller 20 [gig format extension]
524     _lev_ctrl_CC21_EXT = 0x95, ///< MIDI Controller 21 [gig format extension]
525     _lev_ctrl_CC22_EXT = 0x96, ///< MIDI Controller 22 [gig format extension]
526     _lev_ctrl_CC23_EXT = 0x97, ///< MIDI Controller 23 [gig format extension]
527     _lev_ctrl_CC24_EXT = 0x98, ///< MIDI Controller 24 [gig format extension]
528     _lev_ctrl_CC25_EXT = 0x99, ///< MIDI Controller 25 [gig format extension]
529     _lev_ctrl_CC26_EXT = 0x9a, ///< MIDI Controller 26 [gig format extension]
530     _lev_ctrl_CC27_EXT = 0x9b, ///< MIDI Controller 27 [gig format extension]
531     _lev_ctrl_CC28_EXT = 0x9c, ///< MIDI Controller 28 [gig format extension]
532     _lev_ctrl_CC29_EXT = 0x9d, ///< MIDI Controller 29 [gig format extension]
533     _lev_ctrl_CC30_EXT = 0x9e, ///< MIDI Controller 30 [gig format extension]
534     _lev_ctrl_CC31_EXT = 0x9f, ///< MIDI Controller 31 [gig format extension]
535    
536     _lev_ctrl_CC68_EXT = 0xc4, ///< Legato Footswitch (MIDI Controller 68) [gig format extension]
537     _lev_ctrl_CC69_EXT = 0xc5, ///< Hold 2 (MIDI Controller 69) [gig format extension]
538     _lev_ctrl_CC70_EXT = 0xc6, ///< Sound Ctrl. 1 - Sound Variation (MIDI Controller 70) [gig format extension]
539     _lev_ctrl_CC71_EXT = 0xc7, ///< Sound Ctrl. 2 - Timbre (MIDI Controller 71) [gig format extension]
540     _lev_ctrl_CC72_EXT = 0xc8, ///< Sound Ctrl. 3 - Release Time (MIDI Controller 72) [gig format extension]
541     _lev_ctrl_CC73_EXT = 0xc9, ///< Sound Ctrl. 4 - Attack Time (MIDI Controller 73) [gig format extension]
542     _lev_ctrl_CC74_EXT = 0xca, ///< Sound Ctrl. 5 - Brightness (MIDI Controller 74) [gig format extension]
543     _lev_ctrl_CC75_EXT = 0xcb, ///< Sound Ctrl. 6 - Decay Time (MIDI Controller 75) [gig format extension]
544     _lev_ctrl_CC76_EXT = 0xcc, ///< Sound Ctrl. 7 - Vibrato Rate (MIDI Controller 76) [gig format extension]
545     _lev_ctrl_CC77_EXT = 0xcd, ///< Sound Ctrl. 8 - Vibrato Depth (MIDI Controller 77) [gig format extension]
546     _lev_ctrl_CC78_EXT = 0xce, ///< Sound Ctrl. 9 - Vibrato Delay (MIDI Controller 78) [gig format extension]
547     _lev_ctrl_CC79_EXT = 0xcf, ///< Sound Ctrl. 10 (MIDI Controller 79) [gig format extension]
548    
549     _lev_ctrl_CC84_EXT = 0xd4, ///< Portamento Control (MIDI Controller 84) [gig format extension]
550     _lev_ctrl_CC85_EXT = 0xd5, ///< MIDI Controller 85 [gig format extension]
551     _lev_ctrl_CC86_EXT = 0xd6, ///< MIDI Controller 86 [gig format extension]
552     _lev_ctrl_CC87_EXT = 0xd7, ///< MIDI Controller 87 [gig format extension]
553    
554     _lev_ctrl_CC89_EXT = 0xd9, ///< MIDI Controller 89 [gig format extension]
555     _lev_ctrl_CC90_EXT = 0xda, ///< MIDI Controller 90 [gig format extension]
556    
557     _lev_ctrl_CC96_EXT = 0xe0, ///< Data Increment (MIDI Controller 96) [gig format extension]
558     _lev_ctrl_CC97_EXT = 0xe1, ///< Data Decrement (MIDI Controller 97) [gig format extension]
559    
560     _lev_ctrl_CC102_EXT = 0xe6, ///< MIDI Controller 102 [gig format extension]
561     _lev_ctrl_CC103_EXT = 0xe7, ///< MIDI Controller 103 [gig format extension]
562     _lev_ctrl_CC104_EXT = 0xe8, ///< MIDI Controller 104 [gig format extension]
563     _lev_ctrl_CC105_EXT = 0xe9, ///< MIDI Controller 105 [gig format extension]
564     _lev_ctrl_CC106_EXT = 0xea, ///< MIDI Controller 106 [gig format extension]
565     _lev_ctrl_CC107_EXT = 0xeb, ///< MIDI Controller 107 [gig format extension]
566     _lev_ctrl_CC108_EXT = 0xec, ///< MIDI Controller 108 [gig format extension]
567     _lev_ctrl_CC109_EXT = 0xed, ///< MIDI Controller 109 [gig format extension]
568     _lev_ctrl_CC110_EXT = 0xee, ///< MIDI Controller 110 [gig format extension]
569     _lev_ctrl_CC111_EXT = 0xef, ///< MIDI Controller 111 [gig format extension]
570     _lev_ctrl_CC112_EXT = 0xf0, ///< MIDI Controller 112 [gig format extension]
571     _lev_ctrl_CC113_EXT = 0xf1, ///< MIDI Controller 113 [gig format extension]
572     _lev_ctrl_CC114_EXT = 0xf2, ///< MIDI Controller 114 [gig format extension]
573     _lev_ctrl_CC115_EXT = 0xf3, ///< MIDI Controller 115 [gig format extension]
574     _lev_ctrl_CC116_EXT = 0xf4, ///< MIDI Controller 116 [gig format extension]
575     _lev_ctrl_CC117_EXT = 0xf5, ///< MIDI Controller 117 [gig format extension]
576     _lev_ctrl_CC118_EXT = 0xf6, ///< MIDI Controller 118 [gig format extension]
577     _lev_ctrl_CC119_EXT = 0xf7 ///< MIDI Controller 119 [gig format extension]
578 schoenebeck 55 } _lev_ctrl_t;
579 schoenebeck 16 typedef std::map<uint32_t, double*> VelocityTableMap;
580    
581     static uint Instances; ///< Number of DimensionRegion instances.
582     static VelocityTableMap* pVelocityTables; ///< Contains the tables corresponding to the various velocity parameters (VelocityResponseCurve and VelocityResponseDepth).
583     double* pVelocityAttenuationTable; ///< Points to the velocity table corresponding to the velocity parameters of this DimensionRegion.
584 persson 613 double* pVelocityReleaseTable; ///< Points to the velocity table corresponding to the release velocity parameters of this DimensionRegion
585 persson 728 double* pVelocityCutoffTable; ///< Points to the velocity table corresponding to the filter velocity parameters of this DimensionRegion
586 schoenebeck 1316 Region* pRegion;
587 schoenebeck 55
588 schoenebeck 36 leverage_ctrl_t DecodeLeverageController(_lev_ctrl_t EncodedController);
589 schoenebeck 809 _lev_ctrl_t EncodeLeverageController(leverage_ctrl_t DecodedController);
590 schoenebeck 1358 double* GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth);
591     double* GetCutoffVelocityTable(curve_type_t vcfVelocityCurve, uint8_t vcfVelocityDynamicRange, uint8_t vcfVelocityScale, vcf_cutoff_ctrl_t vcfCutoffController);
592 persson 613 double* GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
593 schoenebeck 308 double* CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling);
594 schoenebeck 2 };
595    
596 schoenebeck 809 /** @brief Encapsulates sample waves used for playback.
597     *
598     * In case you created a new sample with File::AddSample(), you should
599     * first update all attributes with the desired meta informations
600     * (amount of channels, bit depth, sample rate, etc.), then call
601     * Resize() with the desired sample size, followed by File::Save(), this
602     * will create the mandatory RIFF chunk which will hold the sample wave
603     * data and / or resize the file so you will be able to Write() the
604     * sample data directly to disk.
605 schoenebeck 1154 *
606     * @e Caution: for gig synthesis, most looping relevant information are
607     * retrieved from the respective DimensionRegon instead from the Sample
608     * itself. This was made for allowing different loop definitions for the
609     * same sample under different conditions.
610 schoenebeck 809 */
611 schoenebeck 2 class Sample : public DLS::Sample {
612     public:
613     uint32_t Manufacturer; ///< Specifies the MIDI Manufacturer's Association (MMA) Manufacturer code for the sampler intended to receive this file's waveform. If no particular manufacturer is to be specified, a value of 0 should be used.
614     uint32_t Product; ///< Specifies the MIDI model ID defined by the manufacturer corresponding to the Manufacturer field. If no particular manufacturer's product is to be specified, a value of 0 should be used.
615 schoenebeck 809 uint32_t SamplePeriod; ///< Specifies the duration of time that passes during the playback of one sample in nanoseconds (normally equal to 1 / Samples Per Second, where Samples Per Second is the value found in the format chunk), don't bother to update this attribute, it won't be saved.
616 schoenebeck 2 uint32_t MIDIUnityNote; ///< Specifies the musical note at which the sample will be played at it's original sample rate.
617 schoenebeck 21 uint32_t FineTune; ///< Specifies the fraction of a semitone up from the specified MIDI unity note field. A value of 0x80000000 means 1/2 semitone (50 cents) and a value of 0x00000000 means no fine tuning between semitones.
618 schoenebeck 2 smpte_format_t SMPTEFormat; ///< Specifies the Society of Motion Pictures and Television E time format used in the following <i>SMPTEOffset</i> field. If a value of 0 is set, <i>SMPTEOffset</i> should also be set to 0.
619     uint32_t SMPTEOffset; ///< The SMPTE Offset value specifies the time offset to be used for the synchronization / calibration to the first sample in the waveform. This value uses a format of 0xhhmmssff where hh is a signed value that specifies the number of hours (-23 to 23), mm is an unsigned value that specifies the number of minutes (0 to 59), ss is an unsigned value that specifies the number of seconds (0 to 59) and ff is an unsigned value that specifies the number of frames (0 to -1).
620 schoenebeck 1154 uint32_t Loops; ///< @e Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: Number of defined sample loops. So far only seen single loops in gig files - please report if you encounter more!)
621 schoenebeck 21 uint32_t LoopID; ///< Specifies the unique ID that corresponds to one of the defined cue points in the cue point list (only if Loops > 0), as the Gigasampler format only allows one loop definition at the moment, this attribute isn't really useful for anything.
622 schoenebeck 1154 loop_type_t LoopType; ///< @e Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The type field defines how the waveform samples will be looped.)
623     uint32_t LoopStart; ///< @e Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The start value specifies the offset [in sample points] in the waveform data of the first sample to be played in the loop [only if Loops > 0].)
624     uint32_t LoopEnd; ///< @e Caution: Use the respective field in the DimensionRegion instead of this one! (Intended purpose: The end value specifies the offset [in sample points] in the waveform data which represents the end of the loop [only if Loops > 0].)
625     uint32_t LoopSize; ///< @e Caution: Use the respective fields in the DimensionRegion instead of this one! (Intended purpose: Length of the looping area [in sample points] which is equivalent to @code LoopEnd - LoopStart @endcode.)
626     uint32_t LoopFraction; ///< The fractional value specifies a fraction of a sample at which to loop. This allows a loop to be fine tuned at a resolution greater than one sample. A value of 0 means no fraction, a value of 0x80000000 means 1/2 of a sample length. 0xFFFFFFFF is the smallest fraction of a sample that can be represented.
627     uint32_t LoopPlayCount; ///< Number of times the loop should be played (a value of 0 = infinite).
628 schoenebeck 2 bool Compressed; ///< If the sample wave is compressed (probably just interesting for instrument and sample editors, as this library already handles the decompression in it's sample access methods anyway).
629 persson 437 uint32_t TruncatedBits; ///< For 24-bit compressed samples only: number of bits truncated during compression (0, 4 or 6)
630     bool Dithered; ///< For 24-bit compressed samples only: if dithering was used during compression with bit reduction
631 schoenebeck 2
632     // own methods
633     buffer_t LoadSampleData();
634     buffer_t LoadSampleData(unsigned long SampleCount);
635     buffer_t LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount);
636     buffer_t LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount);
637     buffer_t GetCache();
638 schoenebeck 384 // own static methods
639     static buffer_t CreateDecompressionBuffer(unsigned long MaxReadSize);
640     static void DestroyDecompressionBuffer(buffer_t& DecompressionBuffer);
641 schoenebeck 2 // overridden methods
642     void ReleaseSampleData();
643 schoenebeck 809 void Resize(int iNewSize);
644 schoenebeck 2 unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
645 schoenebeck 2482 unsigned long GetPos() const;
646 schoenebeck 384 unsigned long Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer = NULL);
647 persson 864 unsigned long ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer = NULL);
648 schoenebeck 809 unsigned long Write(void* pBuffer, unsigned long SampleCount);
649 schoenebeck 930 Group* GetGroup() const;
650 schoenebeck 809 virtual void UpdateChunks();
651 schoenebeck 2482 void CopyAssignMeta(const Sample* orig);
652     void CopyAssignWave(const Sample* orig);
653 schoenebeck 2 protected:
654     static unsigned int Instances; ///< Number of instances of class Sample.
655 schoenebeck 384 static buffer_t InternalDecompressionBuffer; ///< Buffer used for decompression as well as for truncation of 24 Bit -> 16 Bit samples.
656 schoenebeck 930 Group* pGroup; ///< pointer to the Group this sample belongs to (always not-NULL)
657 schoenebeck 2 unsigned long FrameOffset; ///< Current offset (sample points) in current sample frame (for decompression only).
658     unsigned long* FrameTable; ///< For positioning within compressed samples only: stores the offset values for each frame.
659     unsigned long SamplePos; ///< For compressed samples only: stores the current position (in sample points).
660 persson 365 unsigned long SamplesInLastFrame; ///< For compressed samples only: length of the last sample frame.
661     unsigned long WorstCaseFrameSize; ///< For compressed samples only: size (in bytes) of the largest possible sample frame.
662     unsigned long SamplesPerFrame; ///< For compressed samples only: number of samples in a full sample frame.
663 schoenebeck 2 buffer_t RAMCache; ///< Buffers samples (already uncompressed) in RAM.
664 persson 666 unsigned long FileNo; ///< File number (> 0 when sample is stored in an extension file, 0 when it's in the gig)
665 schoenebeck 809 RIFF::Chunk* pCk3gix;
666     RIFF::Chunk* pCkSmpl;
667 schoenebeck 1381 uint32_t crc; ///< CRC-32 checksum of the raw sample data
668 schoenebeck 2
669 persson 666 Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo = 0);
670 schoenebeck 2 ~Sample();
671 persson 365
672     // Guess size (in bytes) of a compressed sample
673     inline unsigned long GuessSize(unsigned long samples) {
674     // 16 bit: assume all frames are compressed - 1 byte
675     // per sample and 5 bytes header per 2048 samples
676    
677     // 24 bit: assume next best compression rate - 1.5
678     // bytes per sample and 13 bytes header per 256
679     // samples
680     const unsigned long size =
681     BitDepth == 24 ? samples + (samples >> 1) + (samples >> 8) * 13
682     : samples + (samples >> 10) * 5;
683     // Double for stereo and add one worst case sample
684     // frame
685     return (Channels == 2 ? size << 1 : size) + WorstCaseFrameSize;
686     }
687 schoenebeck 384
688     // Worst case amount of sample points that can be read with the
689     // given decompression buffer.
690     inline unsigned long WorstCaseMaxSamples(buffer_t* pDecompressionBuffer) {
691     return (unsigned long) ((float)pDecompressionBuffer->Size / (float)WorstCaseFrameSize * (float)SamplesPerFrame);
692     }
693 schoenebeck 2 private:
694     void ScanCompressedSample();
695     friend class File;
696     friend class Region;
697 schoenebeck 930 friend class Group; // allow to modify protected member pGroup
698 schoenebeck 2 };
699    
700     // TODO: <3dnl> list not used yet - not important though (just contains optional descriptions for the dimensions)
701 schoenebeck 2547 /** @brief Defines Region information of an Instrument.
702     *
703     * A Region reflects a consecutive area on the keyboard. The individual
704     * regions in the gig format may not overlap with other regions (of the same
705     * instrument). Further, in the gig format a Region is merely a container
706     * for DimensionRegions (a.k.a. "Cases"). The Region itself does not provide
707     * the sample mapping or articulation informations used, even though the
708     * data structures indeed provide such informations. The latter is however
709     * just of historical nature, because the gig format was derived from the
710     * DLS format.
711     *
712     * Each Region consists of at least one or more DimensionRegions. The actual
713     * amount of DimensionRegions depends on which kind of "dimensions" are
714     * defined for this region, and on the split / zone amount for each of those
715     * dimensions.
716     */
717 schoenebeck 2 class Region : public DLS::Region {
718     public:
719 schoenebeck 809 unsigned int Dimensions; ///< Number of defined dimensions, do not alter!
720 schoenebeck 926 dimension_def_t pDimensionDefinitions[8]; ///< Defines the five (gig2) or eight (gig3) possible dimensions (the dimension's controller and number of bits/splits). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one.
721 schoenebeck 809 uint32_t DimensionRegions; ///< Total number of DimensionRegions this Region contains, do not alter!
722 schoenebeck 926 DimensionRegion* pDimensionRegions[256]; ///< Pointer array to the 32 (gig2) or 256 (gig3) possible dimension regions (reflects NULL for dimension regions not in use). Avoid to access the array directly and better use GetDimensionRegionByValue() instead, but of course in some cases it makes sense to use the array (e.g. iterating through all DimensionRegions). Use AddDimension() and DeleteDimension() to create a new dimension or delete an existing one (which will create or delete the respective dimension region(s) automatically).
723 schoenebeck 809 unsigned int Layers; ///< Amount of defined layers (1 - 32). A value of 1 actually means no layering, a value > 1 means there is Layer dimension. The same information can of course also be obtained by accessing pDimensionDefinitions. Do not alter this value!
724 schoenebeck 2
725 schoenebeck 1335 // own methods
726 schoenebeck 347 DimensionRegion* GetDimensionRegionByValue(const uint DimValues[8]);
727     DimensionRegion* GetDimensionRegionByBit(const uint8_t DimBits[8]);
728 schoenebeck 2599 int GetDimensionRegionIndexByValue(const uint DimValues[8]);
729 schoenebeck 2 Sample* GetSample();
730 schoenebeck 809 void AddDimension(dimension_def_t* pDimDef);
731     void DeleteDimension(dimension_def_t* pDimDef);
732 schoenebeck 2547 dimension_def_t* GetDimensionDefinition(dimension_t type);
733 schoenebeck 2555 void DeleteDimensionZone(dimension_t type, int zone);
734     void SplitDimensionZone(dimension_t type, int zone);
735 schoenebeck 1335 // overridden methods
736     virtual void SetKeyRange(uint16_t Low, uint16_t High);
737 schoenebeck 809 virtual void UpdateChunks();
738 schoenebeck 2394 virtual void CopyAssign(const Region* orig);
739 schoenebeck 2 protected:
740     Region(Instrument* pInstrument, RIFF::List* rgnList);
741     void LoadDimensionRegions(RIFF::List* rgn);
742 persson 858 void UpdateVelocityTable();
743 schoenebeck 515 Sample* GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress = NULL);
744 schoenebeck 2482 void CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples);
745 schoenebeck 2555 DimensionRegion* GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase);
746 schoenebeck 2 ~Region();
747     friend class Instrument;
748     };
749    
750 persson 1627 /** Abstract base class for all MIDI rules. */
751     class MidiRule {
752     public:
753     virtual ~MidiRule() { }
754 persson 2450 protected:
755     virtual void UpdateChunks(uint8_t* pData) const = 0;
756     friend class Instrument;
757 persson 1627 };
758    
759     /** MIDI rule for triggering notes by control change events. */
760     class MidiRuleCtrlTrigger : public MidiRule {
761     public:
762     uint8_t ControllerNumber; ///< MIDI controller number.
763     uint8_t Triggers; ///< Number of triggers.
764     struct trigger_t {
765     uint8_t TriggerPoint; ///< The CC value to pass for the note to be triggered.
766     bool Descending; ///< If the change in CC value should be downwards.
767     uint8_t VelSensitivity; ///< How sensitive the velocity should be to the speed of the controller change.
768     uint8_t Key; ///< Key to trigger.
769     bool NoteOff; ///< If a note off should be triggered instead of a note on.
770     uint8_t Velocity; ///< Velocity of the note to trigger. 255 means that velocity should depend on the speed of the controller change.
771     bool OverridePedal; ///< If a note off should be triggered even if the sustain pedal is down.
772     } pTriggers[32];
773    
774     protected:
775     MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
776 persson 2450 MidiRuleCtrlTrigger();
777     void UpdateChunks(uint8_t* pData) const;
778 persson 1627 friend class Instrument;
779     };
780    
781 persson 2450 /** MIDI rule for instruments with legato samples. */
782     class MidiRuleLegato : public MidiRule {
783     public:
784     uint8_t LegatoSamples; ///< Number of legato samples per key in each direction (always 12)
785     bool BypassUseController; ///< If a controller should be used to bypass the sustain note
786     uint8_t BypassKey; ///< Key to be used to bypass the sustain note
787     uint8_t BypassController; ///< Controller to be used to bypass the sustain note
788     uint16_t ThresholdTime; ///< Maximum time (ms) between two notes that should be played legato
789     uint16_t ReleaseTime; ///< Release time
790     range_t KeyRange; ///< Key range for legato notes
791     uint8_t ReleaseTriggerKey; ///< Key triggering release samples
792     uint8_t AltSustain1Key; ///< Key triggering alternate sustain samples
793     uint8_t AltSustain2Key; ///< Key triggering a second set of alternate sustain samples
794    
795     protected:
796     MidiRuleLegato(RIFF::Chunk* _3ewg);
797     MidiRuleLegato();
798     void UpdateChunks(uint8_t* pData) const;
799     friend class Instrument;
800     };
801    
802     /** MIDI rule to automatically cycle through specified sequences of different articulations. The instrument must be using the smartmidi dimension. */
803     class MidiRuleAlternator : public MidiRule {
804     public:
805     uint8_t Articulations; ///< Number of articulations in the instrument
806     String pArticulations[32]; ///< Names of the articulations
807    
808     range_t PlayRange; ///< Key range of the playable keys in the instrument
809    
810     uint8_t Patterns; ///< Number of alternator patterns
811     struct pattern_t {
812     String Name; ///< Name of the pattern
813     int Size; ///< Number of steps in the pattern
814     const uint8_t& operator[](int i) const { /// Articulation to play
815     return data[i];
816     }
817     uint8_t& operator[](int i) {
818     return data[i];
819     }
820     private:
821     uint8_t data[32];
822     } pPatterns[32]; ///< A pattern is a sequence of articulation numbers
823    
824     typedef enum {
825     selector_none,
826     selector_key_switch,
827     selector_controller
828     } selector_t;
829     selector_t Selector; ///< Method by which pattern is chosen
830     range_t KeySwitchRange; ///< Key range for key switch selector
831     uint8_t Controller; ///< CC number for controller selector
832    
833     bool Polyphonic; ///< If alternator should step forward only when all notes are off
834     bool Chained; ///< If all patterns should be chained together
835    
836     protected:
837     MidiRuleAlternator(RIFF::Chunk* _3ewg);
838     MidiRuleAlternator();
839     void UpdateChunks(uint8_t* pData) const;
840     friend class Instrument;
841     };
842    
843     /** A MIDI rule not yet implemented by libgig. */
844     class MidiRuleUnknown : public MidiRule {
845     protected:
846     MidiRuleUnknown() { }
847     void UpdateChunks(uint8_t* pData) const { }
848     friend class Instrument;
849     };
850    
851 schoenebeck 2584 /** @brief Real-time instrument script (gig format extension).
852     *
853     * Real-time instrument scripts are user supplied small programs which can
854     * be used by instrument designers to create custom behaviors and features
855     * not available in the stock sampler engine. Features which might be very
856     * exotic or specific for the respective instrument.
857     *
858     * This is an extension of the GigaStudio format, thus a feature which was
859     * not available in the GigaStudio 4 software. It is currently only
860     * supported by LinuxSampler and gigedit.
861     */
862     class Script {
863     public:
864     enum Encoding_t {
865     ENCODING_ASCII = 0 ///< Standard 8 bit US ASCII character encoding (default).
866     };
867     enum Compression_t {
868     COMPRESSION_NONE = 0 ///< Is not compressed at all (default).
869     };
870     enum Language_t {
871     LANGUAGE_NKSP = 0 ///< NKSP stands for "Is Not KSP" (default).
872     };
873    
874     String Name; ///< Arbitrary name of the script, which may be displayed i.e. in an instrument editor.
875     Compression_t Compression; ///< Whether the script was/should be compressed, and if so, which compression algorithm shall be used.
876     Encoding_t Encoding; ///< Format the script's source code text is encoded with.
877     Language_t Language; ///< Programming language and dialect the script is written in.
878     bool Bypass; ///< Global bypass: if enabled, this script shall not be executed by the sampler for any instrument.
879    
880     String GetScriptAsText();
881     void SetScriptAsText(const String& text);
882     void SetGroup(ScriptGroup* pGroup);
883 schoenebeck 2601 ScriptGroup* GetGroup() const;
884 schoenebeck 2584 protected:
885     Script(ScriptGroup* group, RIFF::Chunk* ckScri);
886     virtual ~Script();
887     void UpdateChunks();
888     void RemoveAllScriptReferences();
889     friend class ScriptGroup;
890     friend class Instrument;
891     private:
892     ScriptGroup* pGroup;
893     RIFF::Chunk* pChunk; ///< 'Scri' chunk
894     std::vector<uint8_t> data;
895     uint32_t crc; ///< CRC-32 checksum of the raw script data
896     };
897    
898     /** @brief Group of instrument scripts (gig format extension).
899     *
900     * This class is simply used to sort a bunch of real-time instrument scripts
901     * into individual groups. This allows instrument designers and script
902     * developers to keep scripts in a certain order while working with a larger
903     * amount of scripts in an instrument editor.
904     *
905     * This is an extension of the GigaStudio format, thus a feature which was
906     * not available in the GigaStudio 4 software. It is currently only
907     * supported by LinuxSampler and gigedit.
908     */
909     class ScriptGroup {
910     public:
911     String Name; ///< Name of this script group. For example to be displayed in an instrument editor.
912    
913     Script* GetScript(uint index);
914     Script* AddScript();
915     void DeleteScript(Script* pScript);
916     protected:
917     ScriptGroup(File* file, RIFF::List* lstRTIS);
918     virtual ~ScriptGroup();
919     void LoadScripts();
920     void UpdateChunks();
921     friend class Script;
922     friend class File;
923     private:
924     File* pFile;
925     RIFF::List* pList; ///< 'RTIS' list chunk
926     std::list<Script*>* pScripts;
927     };
928    
929 schoenebeck 2 /** Provides all neccessary information for the synthesis of an <i>Instrument</i>. */
930     class Instrument : protected DLS::Instrument {
931     public:
932     // derived attributes from DLS::Resource
933 persson 2334 using DLS::Resource::pInfo;
934     using DLS::Resource::pDLSID;
935 schoenebeck 2 // derived attributes from DLS::Instrument
936 persson 2334 using DLS::Instrument::IsDrum;
937     using DLS::Instrument::MIDIBank;
938     using DLS::Instrument::MIDIBankCoarse;
939     using DLS::Instrument::MIDIBankFine;
940     using DLS::Instrument::MIDIProgram;
941     using DLS::Instrument::Regions;
942 schoenebeck 2 // own attributes
943     int32_t Attenuation; ///< in dB
944     uint16_t EffectSend;
945     int16_t FineTune; ///< in cents
946     uint16_t PitchbendRange; ///< Number of semitones pitchbend controller can pitch (default is 2).
947     bool PianoReleaseMode;
948     range_t DimensionKeyRange; ///< 0-127 (where 0 means C1 and 127 means G9)
949    
950    
951     // derived methods from DLS::Resource
952 persson 2334 using DLS::Resource::GetParent;
953 schoenebeck 2 // overridden methods
954     Region* GetFirstRegion();
955     Region* GetNextRegion();
956 schoenebeck 809 Region* AddRegion();
957     void DeleteRegion(Region* pRegion);
958     virtual void UpdateChunks();
959 schoenebeck 2394 virtual void CopyAssign(const Instrument* orig);
960 schoenebeck 2 // own methods
961     Region* GetRegion(unsigned int Key);
962 persson 1678 MidiRule* GetMidiRule(int i);
963 persson 2450 MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
964     MidiRuleLegato* AddMidiRuleLegato();
965     MidiRuleAlternator* AddMidiRuleAlternator();
966     void DeleteMidiRule(int i);
967 schoenebeck 2584 // real-time instrument script methods
968     Script* GetScriptOfSlot(uint index);
969     void AddScriptSlot(Script* pScript, bool bypass = false);
970     void SwapScriptSlots(uint index1, uint index2);
971     void RemoveScriptSlot(uint index);
972     void RemoveScript(Script* pScript);
973     uint ScriptSlotCount() const;
974     bool IsScriptSlotBypassed(uint index);
975     void SetScriptSlotBypassed(uint index, bool bBypass);
976 schoenebeck 2 protected:
977     Region* RegionKeyTable[128]; ///< fast lookup for the corresponding Region of a MIDI key
978    
979 schoenebeck 515 Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress = NULL);
980 schoenebeck 2 ~Instrument();
981 schoenebeck 2482 void CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples);
982 schoenebeck 809 void UpdateRegionKeyTable();
983 schoenebeck 2584 void LoadScripts();
984 schoenebeck 2609 void UpdateScriptFileOffsets();
985 schoenebeck 2 friend class File;
986 schoenebeck 1335 friend class Region; // so Region can call UpdateRegionKeyTable()
987 persson 1627 private:
988 schoenebeck 2584 struct _ScriptPooolEntry {
989     uint32_t fileOffset;
990     bool bypass;
991     };
992     struct _ScriptPooolRef {
993     Script* script;
994     bool bypass;
995     };
996 persson 1678 MidiRule** pMidiRules;
997 schoenebeck 2584 std::vector<_ScriptPooolEntry> scriptPoolFileOffsets;
998     std::vector<_ScriptPooolRef>* pScriptRefs;
999 schoenebeck 2 };
1000    
1001 schoenebeck 929 /** @brief Group of Gigasampler objects
1002     *
1003     * Groups help to organize a huge collection of Gigasampler objects.
1004     * Groups are not concerned at all for the synthesis, but they help
1005     * sound library developers when working on complex instruments with an
1006     * instrument editor (as long as that instrument editor supports it ;-).
1007     *
1008     * At the moment, it seems as only samples can be grouped together in
1009     * the Gigasampler format yet. If this is false in the meantime, please
1010     * tell us !
1011 schoenebeck 930 *
1012     * A sample is always assigned to exactly one Group. This also means
1013     * there is always at least one Group in a .gig file, no matter if you
1014     * created one yet or not.
1015 schoenebeck 929 */
1016     class Group {
1017     public:
1018     String Name; ///< Stores the name of this Group.
1019 schoenebeck 930
1020     Sample* GetFirstSample();
1021     Sample* GetNextSample();
1022     void AddSample(Sample* pSample);
1023 schoenebeck 929 protected:
1024 schoenebeck 930 Group(File* file, RIFF::Chunk* ck3gnm);
1025 schoenebeck 929 virtual ~Group();
1026     virtual void UpdateChunks();
1027 schoenebeck 930 void MoveAll();
1028 schoenebeck 929 friend class File;
1029     private:
1030 schoenebeck 930 File* pFile;
1031 schoenebeck 2467 RIFF::Chunk* pNameChunk; ///< '3gnm' chunk
1032 schoenebeck 929 };
1033    
1034 schoenebeck 2 /** Parses Gigasampler files and provides abstract access to the data. */
1035     class File : protected DLS::File {
1036     public:
1037 persson 1199 static const DLS::version_t VERSION_2;
1038     static const DLS::version_t VERSION_3;
1039    
1040 schoenebeck 2 // derived attributes from DLS::Resource
1041 persson 2334 using DLS::Resource::pInfo;
1042     using DLS::Resource::pDLSID;
1043 schoenebeck 2 // derived attributes from DLS::File
1044 persson 2334 using DLS::File::pVersion;
1045     using DLS::File::Instruments;
1046 schoenebeck 2
1047     // derived methods from DLS::Resource
1048 persson 2334 using DLS::Resource::GetParent;
1049 schoenebeck 809 // derived methods from DLS::File
1050 persson 2334 using DLS::File::Save;
1051     using DLS::File::GetFileName;
1052 schoenebeck 2482 using DLS::File::SetFileName;
1053 schoenebeck 2 // overridden methods
1054 schoenebeck 809 File();
1055 schoenebeck 2 File(RIFF::File* pRIFF);
1056 schoenebeck 515 Sample* GetFirstSample(progress_t* pProgress = NULL); ///< Returns a pointer to the first <i>Sample</i> object of the file, <i>NULL</i> otherwise.
1057 schoenebeck 2 Sample* GetNextSample(); ///< Returns a pointer to the next <i>Sample</i> object of the file, <i>NULL</i> otherwise.
1058 schoenebeck 2482 Sample* GetSample(uint index);
1059 schoenebeck 809 Sample* AddSample();
1060     void DeleteSample(Sample* pSample);
1061 schoenebeck 929 Instrument* GetFirstInstrument(); ///< Returns a pointer to the first <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
1062 schoenebeck 2 Instrument* GetNextInstrument(); ///< Returns a pointer to the next <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
1063 schoenebeck 515 Instrument* GetInstrument(uint index, progress_t* pProgress = NULL);
1064 schoenebeck 809 Instrument* AddInstrument();
1065 schoenebeck 2394 Instrument* AddDuplicateInstrument(const Instrument* orig);
1066 schoenebeck 809 void DeleteInstrument(Instrument* pInstrument);
1067 schoenebeck 929 Group* GetFirstGroup(); ///< Returns a pointer to the first <i>Group</i> object of the file, <i>NULL</i> otherwise.
1068     Group* GetNextGroup(); ///< Returns a pointer to the next <i>Group</i> object of the file, <i>NULL</i> otherwise.
1069     Group* GetGroup(uint index);
1070 schoenebeck 2543 Group* GetGroup(String name);
1071 schoenebeck 929 Group* AddGroup();
1072     void DeleteGroup(Group* pGroup);
1073 schoenebeck 1081 void DeleteGroupOnly(Group* pGroup);
1074 schoenebeck 1524 void SetAutoLoad(bool b);
1075     bool GetAutoLoad();
1076 schoenebeck 2482 void AddContentOf(File* pFile);
1077 schoenebeck 2584 ScriptGroup* GetScriptGroup(uint index);
1078     ScriptGroup* GetScriptGroup(const String& name);
1079     ScriptGroup* AddScriptGroup();
1080     void DeleteScriptGroup(ScriptGroup* pGroup);
1081 schoenebeck 929 virtual ~File();
1082 schoenebeck 1098 virtual void UpdateChunks();
1083 schoenebeck 2 protected:
1084 schoenebeck 823 // overridden protected methods from DLS::File
1085     virtual void LoadSamples();
1086     virtual void LoadInstruments();
1087 schoenebeck 929 virtual void LoadGroups();
1088 schoenebeck 2609 virtual void UpdateFileOffsets();
1089 schoenebeck 823 // own protected methods
1090     virtual void LoadSamples(progress_t* pProgress);
1091     virtual void LoadInstruments(progress_t* pProgress);
1092 schoenebeck 2584 virtual void LoadScriptGroups();
1093 persson 1199 void SetSampleChecksum(Sample* pSample, uint32_t crc);
1094 schoenebeck 2 friend class Region;
1095 schoenebeck 929 friend class Sample;
1096 schoenebeck 930 friend class Group; // so Group can access protected member pRIFF
1097 schoenebeck 2584 friend class ScriptGroup; // so ScriptGroup can access protected member pRIFF
1098 schoenebeck 929 private:
1099     std::list<Group*>* pGroups;
1100     std::list<Group*>::iterator GroupsIterator;
1101 schoenebeck 1524 bool bAutoLoad;
1102 schoenebeck 2584 std::list<ScriptGroup*>* pScriptGroups;
1103 schoenebeck 2 };
1104    
1105 schoenebeck 1093 /**
1106     * Will be thrown whenever a gig specific error occurs while trying to
1107     * access a Gigasampler File. Note: In your application you should
1108     * better catch for RIFF::Exception rather than this one, except you
1109     * explicitly want to catch and handle gig::Exception, DLS::Exception
1110     * and RIFF::Exception independently, which usually shouldn't be
1111     * necessary though.
1112     */
1113 schoenebeck 2 class Exception : public DLS::Exception {
1114     public:
1115     Exception(String Message);
1116     void PrintMessage();
1117     };
1118    
1119 schoenebeck 518 String libraryName();
1120     String libraryVersion();
1121    
1122 schoenebeck 2 } // namespace gig
1123    
1124     #endif // __GIG_H__

  ViewVC Help
Powered by ViewVC