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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1335 - (hide annotations) (download) (as text)
Sun Sep 9 21:22:58 2007 UTC (13 years, 2 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 26000 byte(s)
* added virtual method SetKeyRange() to the gig and DLS Region classes,
  which automatically take care that the "resized" Region is at the
  correct position and that the lookup table for
  gig::Instrument::GetRegion() is updated (moved code from gigedit)
* MoveRegion() method of DLS::Region class is now private
* bugfix: gig::Instrument::UpdateRegionKeyTable() did not reset unused
  areas

1 schoenebeck 2 /***************************************************************************
2     * *
3 schoenebeck 933 * libgig - C++ cross-platform Gigasampler format file access library *
4 schoenebeck 2 * *
5 schoenebeck 1050 * Copyright (C) 2003-2007 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 __DLS_H__
25     #define __DLS_H__
26    
27     #include "RIFF.h"
28    
29 schoenebeck 11 #if WORDS_BIGENDIAN
30 schoenebeck 802 # define RIFF_TYPE_DLS 0x444C5320
31 schoenebeck 2 # define LIST_TYPE_INFO 0x494E464F
32     # define LIST_TYPE_WVPL 0x7776706C
33     # define LIST_TYPE_DWPL 0x6477706C ///< Seen on some files instead of a wvpl list chunk.
34     # define LIST_TYPE_WAVE 0x77617665
35     # define LIST_TYPE_LINS 0X6C696E73
36     # define LIST_TYPE_INS 0X696E7320
37     # define LIST_TYPE_LRGN 0x6C72676E
38     # define LIST_TYPE_LART 0x6C617274
39     # define LIST_TYPE_LAR2 0x6C617232
40     # define LIST_TYPE_RGN 0x72676E20
41     # define LIST_TYPE_RGN2 0x72676E32
42     # define CHUNK_ID_IARL 0x4941524C
43     # define CHUNK_ID_IART 0x49415254
44     # define CHUNK_ID_ICMS 0x49434D53
45     # define CHUNK_ID_ICMT 0x49434D54
46     # define CHUNK_ID_ICOP 0x49434F50
47     # define CHUNK_ID_ICRD 0x49435244
48     # define CHUNK_ID_IENG 0x49454E47
49     # define CHUNK_ID_IGNR 0x49474E52
50     # define CHUNK_ID_IKEY 0x494B4559
51     # define CHUNK_ID_IMED 0x494D4544
52     # define CHUNK_ID_INAM 0x494E414D
53     # define CHUNK_ID_IPRD 0x49505244
54     # define CHUNK_ID_ISBJ 0x4953424A
55     # define CHUNK_ID_ISFT 0x49534654
56     # define CHUNK_ID_ISRC 0x49535243
57     # define CHUNK_ID_ISRF 0x49535246
58     # define CHUNK_ID_ITCH 0x49544348
59     # define CHUNK_ID_VERS 0x76657273
60     # define CHUNK_ID_DLID 0x646C6964
61     # define CHUNK_ID_FMT 0x666D7420
62     # define CHUNK_ID_DATA 0x64617461
63     # define CHUNK_ID_INSH 0x696E7368
64     # define CHUNK_ID_RGNH 0x72676E68
65     # define CHUNK_ID_WLNK 0x776C6E6B
66     # define CHUNK_ID_PTBL 0x7074626C
67     # define CHUNK_ID_WSMP 0x77736D70
68     # define CHUNK_ID_COLH 0x636F6C68
69 schoenebeck 800 # define CHUNK_ID_ARTL 0x6172746C
70     # define CHUNK_ID_ART2 0x61727432
71 schoenebeck 2 #else // little endian
72 schoenebeck 802 # define RIFF_TYPE_DLS 0x20534C44
73 schoenebeck 2 # define LIST_TYPE_INFO 0x4F464E49
74     # define LIST_TYPE_WVPL 0x6C707677
75     # define LIST_TYPE_DWPL 0x6C707764 ///< Seen on some files instead of a wvpl list chunk.
76     # define LIST_TYPE_WAVE 0x65766177
77     # define LIST_TYPE_LINS 0X736E696C
78     # define LIST_TYPE_INS 0X20736E69
79     # define LIST_TYPE_LRGN 0x6E67726C
80     # define LIST_TYPE_LART 0x7472616C
81     # define LIST_TYPE_LAR2 0x3272616C
82     # define LIST_TYPE_RGN 0x206E6772
83     # define LIST_TYPE_RGN2 0x326E6772
84     # define CHUNK_ID_IARL 0x4C524149
85     # define CHUNK_ID_IART 0x54524149
86     # define CHUNK_ID_ICMS 0x534D4349
87     # define CHUNK_ID_ICMT 0x544D4349
88     # define CHUNK_ID_ICOP 0x504F4349
89     # define CHUNK_ID_ICRD 0x44524349
90     # define CHUNK_ID_IENG 0x474E4549
91     # define CHUNK_ID_IGNR 0x524E4749
92     # define CHUNK_ID_IKEY 0x59454B49
93 persson 928 # define CHUNK_ID_IMED 0x44454D49
94 schoenebeck 2 # define CHUNK_ID_INAM 0x4D414E49
95     # define CHUNK_ID_IPRD 0x44525049
96     # define CHUNK_ID_ISBJ 0x4A425349
97     # define CHUNK_ID_ISFT 0x54465349
98     # define CHUNK_ID_ISRC 0x43525349
99     # define CHUNK_ID_ISRF 0x46525349
100     # define CHUNK_ID_ITCH 0x48435449
101     # define CHUNK_ID_VERS 0x73726576
102     # define CHUNK_ID_DLID 0x64696C64
103     # define CHUNK_ID_FMT 0x20746D66
104     # define CHUNK_ID_DATA 0x61746164
105     # define CHUNK_ID_INSH 0x68736E69
106     # define CHUNK_ID_RGNH 0x686E6772
107     # define CHUNK_ID_WLNK 0x6B6E6C77
108     # define CHUNK_ID_PTBL 0x6C627470
109     # define CHUNK_ID_WSMP 0x706D7377
110     # define CHUNK_ID_COLH 0x686C6F63
111 schoenebeck 800 # define CHUNK_ID_ARTL 0x6C747261
112     # define CHUNK_ID_ART2 0x32747261
113 schoenebeck 2 #endif // WORDS_BIGENDIAN
114    
115 schoenebeck 1050 #define DLS_WAVE_FORMAT_PCM 0x0001
116 schoenebeck 2
117     //TODO: no support for conditional chunks <cdl> yet
118    
119     /** DLS specific classes and definitions */
120     namespace DLS {
121    
122     typedef std::string String;
123    
124     /** Quadtuple version number ("major.minor.release.build"). */
125     struct version_t {
126     uint16_t minor;
127     uint16_t major;
128     uint16_t build;
129     uint16_t release;
130     };
131    
132     /** Every subject of an DLS file and the file itself can have an unique, computer generated ID. */
133     struct dlsid_t {
134     uint32_t ulData1;
135     uint16_t usData2;
136     uint16_t usData3;
137     uint8_t abData[8];
138     };
139    
140     /** Connection Sources */
141     typedef enum {
142     // Modulator Sources
143     conn_src_none = 0x0000,
144     conn_src_lfo = 0x0001,
145     conn_src_keyonvelocity = 0x0002,
146     conn_src_keynumber = 0x0003,
147     conn_src_eg1 = 0x0004,
148     conn_src_eg2 = 0x0005,
149     conn_src_pitchwheel = 0x0006,
150     conn_src_polypressure = 0x0007,
151     conn_src_channelpressure = 0x0008,
152     conn_src_vibrato = 0x0009,
153     // MIDI Controller Sources
154     conn_src_cc1 = 0x0081,
155     conn_src_cc7 = 0x0087,
156     conn_src_cc10 = 0x008A,
157     conn_src_cc11 = 0x008B,
158     conn_src_cc91 = 0x00DB,
159     conn_src_cc93 = 0x00DD,
160     // Registered Parameter Numbers
161     conn_src_rpn0 = 0x0100,
162     conn_src_rpn1 = 0x0101,
163     conn_src_rpn2 = 0x0102
164     } conn_src_t;
165    
166     /** Connection Destinations */
167     typedef enum {
168     // Generic Destinations
169     conn_dst_none = 0x0000,
170     conn_dst_gain = 0x0001,
171     conn_dst_reserved = 0x0002,
172     conn_dst_pitch = 0x0003,
173     conn_dst_pan = 0x0004,
174     conn_dst_keynumber = 0x0005,
175     // Channel Output Destinations
176     conn_dst_left = 0x0010,
177     conn_dst_right = 0x0011,
178     conn_dst_center = 0x0012,
179     conn_dst_lfe_channel = 0x0013,
180     conn_dst_leftrear = 0x0014,
181     conn_dst_rightrear = 0x0015,
182     conn_dst_chorus = 0x0080,
183     conn_dst_reverb = 0x0081,
184     // Modulator LFO Destinations
185     conn_dst_lfo_frequency = 0x0104,
186     conn_dst_lfo_startdelay = 0x0105,
187     // Vibrato LFO Destinations
188     conn_dst_vib_frequency = 0x0114,
189     conn_dst_vib_startdelay = 0x0115,
190     // EG Destinations
191     conn_dst_eg1_attacktime = 0x0206,
192     conn_dst_eg1_decaytime = 0x0207,
193     conn_dst_eg1_reserved = 0x0208,
194     conn_dst_eg1_releasetime = 0x0209,
195     conn_dst_eg1_sustainlevel = 0x020A,
196     conn_dst_eg1_delaytime = 0x020B,
197     conn_dst_eg1_holdtime = 0x020C,
198     conn_dst_eg1_shutdowntime = 0x020D,
199     conn_dst_eg2_attacktime = 0x030A,
200     conn_dst_eg2_decaytime = 0x030B,
201     conn_dst_eg2_reserved = 0x030C,
202     conn_dst_eg2_releasetime = 0x030D,
203     conn_dst_eg2_sustainlevel = 0x030E,
204     conn_dst_eg2_delaytime = 0x030F,
205     conn_dst_eg2_holdtime = 0x0310,
206     // Filter Destinations
207     conn_dst_filter_cutoff = 0x0500,
208     conn_dst_filter_q = 0x0501
209     } conn_dst_t;
210    
211     /** Connection Transforms */
212     typedef enum {
213     conn_trn_none = 0x0000,
214     conn_trn_concave = 0x0001,
215     conn_trn_convex = 0x0002,
216     conn_trn_switch = 0x0003
217     } conn_trn_t;
218    
219     /** Lower and upper limit of a range. */
220     struct range_t {
221     uint16_t low; ///< Low value of range.
222     uint16_t high; ///< High value of range.
223     };
224    
225     /** Defines Sample Loop Points. */
226     struct sample_loop_t {
227 schoenebeck 1154 uint32_t Size; ///< For internal usage only: usually reflects exactly @c sizeof(sample_loop_t), otherwise if the value is larger then the DLS format was extended!
228     uint32_t LoopType; ///< Defines how the waveform samples will be looped (appropriate loop types for the gig format are defined by gig::loop_type_t).
229     uint32_t LoopStart; ///< The start value specifies the offset (in sample points) in the waveform data of the first sample point to be played in the loop.
230     uint32_t LoopLength; ///< Length of the looping area (in sample points).
231 schoenebeck 2 };
232    
233     // just symbol prototyping
234     class File;
235     class Instrument;
236     class Region;
237     class Sample;
238    
239     /** Defines a connection within the synthesis model. */
240     class Connection {
241     public:
242     conn_src_t Source;
243     conn_trn_t SourceTransform;
244     bool SourceInvert;
245     bool SourceBipolar;
246     conn_src_t Control;
247     conn_trn_t ControlTransform;
248     bool ControlInvert;
249     bool ControlBipolar;
250     conn_dst_t Destination;
251     conn_trn_t DestinationTransform;
252     uint32_t Scale;
253     protected:
254     struct conn_block_t {
255     uint16_t source;
256     uint16_t control;
257     uint16_t destination;
258     uint16_t transform;
259     uint32_t scale;
260     };
261     Connection() {};
262     void Init(conn_block_t* Header);
263 schoenebeck 800 conn_block_t ToConnBlock();
264 schoenebeck 2 virtual ~Connection() {};
265     friend class Articulation;
266     };
267    
268     /** Provides access to the defined connections used for the synthesis model. */
269     class Articulation {
270     public:
271     Connection* pConnections; ///< Points to the beginning of a <i>Connection</i> array.
272     uint32_t Connections; ///< Reflects the number of Connections.
273 schoenebeck 800
274     Articulation(RIFF::Chunk* artl);
275 schoenebeck 384 virtual ~Articulation();
276 schoenebeck 800 virtual void UpdateChunks();
277     protected:
278     RIFF::Chunk* pArticulationCk;
279     uint32_t HeaderSize;
280 schoenebeck 2 };
281    
282     /** Abstract base class for classes that provide articulation information (thus for <i>Instrument</i> and <i>Region</i> class). */
283     class Articulator {
284     public:
285     Articulator(RIFF::List* ParentList);
286     Articulation* GetFirstArticulation();
287     Articulation* GetNextArticulation();
288 schoenebeck 800 virtual void UpdateChunks();
289 schoenebeck 2 protected:
290     typedef std::list<Articulation*> ArticulationList;
291     RIFF::List* pParentList;
292     ArticulationList* pArticulations;
293     ArticulationList::iterator ArticulationsIterator;
294    
295     void LoadArticulations();
296 schoenebeck 384 virtual ~Articulator();
297 schoenebeck 2 };
298    
299     /** Optional information for DLS files, instruments, samples, etc. */
300     class Info {
301     public:
302     String Name; ///< <INAM-ck>. Stores the title of the subject of the file, such as, Seattle From Above.
303     String ArchivalLocation; ///< <IARL-ck>. Indicates where the subject of the file is stored.
304     String CreationDate; ///< <ICRD-ck>. Specifies the date the subject of the file was created. List dates in yyyy-mm-dd format.
305     String Comments; ///< <ICMT-ck>. Provides general comments about the file or the subject of the file. Sentences might end with semicolon.
306     String Product; ///< <IPRD-ck>. Specifies the name of the title the file was originally intended for, such as World Ruler V.
307     String Copyright; ///< <ICOP-ck>. Records the copyright information for the file.
308     String Artists; ///< <IART-ck>. Lists the artist of the original subject of the file.
309     String Genre; ///< <IGNR-ck>. Descirbes the original work, such as, Jazz, Classic, Rock, Techno, Rave, etc.
310     String Keywords; ///< <IKEY-ck>. Provides a list of keywords that refer to the file or subject of the file. Keywords are separated with semicolon and blank, e.g., FX; death; murder.
311     String Engineer; ///< <IENG-ck>. Stores the name of the engineer who worked on the file. Multiple engineer names are separated by semicolon and blank, e.g, Smith, John; Adams, Joe.
312     String Technician; ///< <ITCH-ck>. Identifies the technician who sampled the subject file.
313     String Software; ///< <ISFT-ck>. Identifies the name of the sofware package used to create the file.
314     String Medium; ///< <IMED-ck>. Describes the original subject of the file, such as, record, CD, and so forth.
315     String Source; ///< <ISRC-ck>. Identifies the name of the person or organization who supplied the original subject of the file.
316     String SourceForm; ///< <ISRF-ck>. Identifies the original form of the material that was digitized, such as record, sampling CD, TV sound track. This is not neccessarily the same as <i>Medium</i>.
317     String Commissioned; ///< <ICMS-ck>. Lists the name of the person or organization that commissioned the subject of the file, e.g., Pope Julian II.
318 persson 928 String Subject; ///< <ISBJ-ck>. Describes the contents of the file.
319 persson 1183 bool UseFixedLengthStrings; ///< Deprecated. Use #FixedStringLengths instead.
320 schoenebeck 2
321 persson 1180 struct FixedStringLength {
322     uint32_t chunkId;
323     int length;
324     };
325     const FixedStringLength* FixedStringLengths; ///< List of IDs and string lengths for strings that should be stored in a fixed length format. This is used for gig files, not for ordinary DLS files.
326 schoenebeck 2 Info(RIFF::List* list);
327 schoenebeck 823 virtual ~Info();
328 schoenebeck 800 virtual void UpdateChunks();
329 schoenebeck 2 private:
330 schoenebeck 800 RIFF::List* pResourceListChunk;
331    
332 schoenebeck 929 static void LoadString(uint32_t ChunkID, RIFF::List* lstINFO, String& s);
333 persson 1180 void SaveString(uint32_t ChunkID, RIFF::List* lstINFO, const String& s, const String& sDefault);
334 schoenebeck 2 };
335    
336     /** Abstract base class which encapsulates data structures which all DLS resources are able to provide. */
337     class Resource {
338     public:
339 schoenebeck 800 Info* pInfo; ///< Points (in any case) to an <i>Info</i> object, providing additional, optional infos and comments.
340     dlsid_t* pDLSID; ///< Points to a <i>dlsid_t</i> structure if the file provided a DLS ID else is <i>NULL</i>.
341 schoenebeck 2
342     Resource* GetParent() { return pParent; };
343 schoenebeck 800 virtual void UpdateChunks();
344 persson 1209 void GenerateDLSID();
345 schoenebeck 2 protected:
346     Resource* pParent;
347 schoenebeck 800 RIFF::List* pResourceList;
348 schoenebeck 2
349     Resource(Resource* Parent, RIFF::List* lstResource);
350 schoenebeck 384 virtual ~Resource();
351 schoenebeck 2 };
352    
353     /** Abstract base class which provides mandatory informations about sample players in general. */
354     class Sampler {
355     public:
356     uint8_t UnityNote;
357     int16_t FineTune;
358     int32_t Gain;
359     bool NoSampleDepthTruncation;
360     bool NoSampleCompression;
361 schoenebeck 800 uint32_t SampleLoops; ///< Reflects the number of sample loops.
362     sample_loop_t* pSampleLoops; ///< Points to the beginning of a sample loop array, or is NULL if there are no loops defined.
363    
364 schoenebeck 1154 void AddSampleLoop(sample_loop_t* pLoopDef);
365     void DeleteSampleLoop(sample_loop_t* pLoopDef);
366 schoenebeck 800 virtual void UpdateChunks();
367 schoenebeck 2 protected:
368 schoenebeck 800 RIFF::List* pParentList;
369     uint32_t uiHeaderSize;
370 schoenebeck 2 uint32_t SamplerOptions;
371     Sampler(RIFF::List* ParentList);
372 schoenebeck 384 virtual ~Sampler();
373 schoenebeck 2 };
374    
375 schoenebeck 800 /** @brief Encapsulates sample waves used for playback.
376     *
377     * In case you created a new sample with File::AddSample(), you should
378 schoenebeck 806 * first update all attributes with the desired meta informations
379     * (amount of channels, bit depth, sample rate, etc.), then call
380     * Resize() with the desired sample size. The latter will create
381 schoenebeck 800 * the mandatory RIFF chunk which will hold the sample wave data.
382     */
383 schoenebeck 2 class Sample : public Resource {
384     public:
385 schoenebeck 1050 uint16_t FormatTag; ///< Format ID of the waveform data (should be DLS_WAVE_FORMAT_PCM for DLS1 compliant files, this is also the default value if Sample was created with Instrument::AddSample()).
386 schoenebeck 806 uint16_t Channels; ///< Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mono if Sample was created with Instrument::AddSample() previously).
387     uint32_t SamplesPerSecond; ///< Sampling rate at which each channel should be played (defaults to 44100 if Sample was created with Instrument::AddSample() previously).
388 schoenebeck 2 uint32_t AverageBytesPerSecond; ///< The average number of bytes per second at which the waveform data should be transferred (Playback software can estimate the buffer size using this value).
389     uint16_t BlockAlign; ///< The block alignment (in bytes) of the waveform data. Playback software needs to process a multiple of <i>BlockAlign</i> bytes of data at a time, so the value of <i>BlockAlign</i> can be used for buffer alignment.
390     uint16_t BitDepth; ///< Size of each sample per channel (only if known sample data format is used, 0 otherwise).
391 schoenebeck 800 unsigned long SamplesTotal; ///< Reflects total number of sample points (only if known sample data format is used, 0 otherwise), do not bother to change this value, it will not be saved.
392 schoenebeck 806 uint FrameSize; ///< Reflects the size (in bytes) of one single sample point (only if known sample data format is used, 0 otherwise). <b>Caution:</b> with the current version of libgig you have to upate this field by yourself whenever you change one of the following fields: Channels, BitDepth ! Ignoring this might lead to undesired behavior when i.e. calling Resize(), SetPos(), Write() or Read().
393 schoenebeck 2
394 schoenebeck 800 void* LoadSampleData();
395     void ReleaseSampleData();
396     unsigned long GetSize();
397     void Resize(int iNewSize);
398 schoenebeck 2 unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
399     unsigned long Read(void* pBuffer, unsigned long SampleCount);
400 schoenebeck 800 unsigned long Write(void* pBuffer, unsigned long SampleCount);
401     virtual void UpdateChunks();
402 schoenebeck 2 protected:
403 schoenebeck 800 RIFF::List* pWaveList;
404 schoenebeck 2 RIFF::Chunk* pCkData;
405     RIFF::Chunk* pCkFormat;
406     unsigned long ulWavePoolOffset; // needed for comparison with the wave pool link table, thus the link to instruments
407    
408     Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset);
409 schoenebeck 800 virtual ~Sample();
410 schoenebeck 2 friend class File;
411     friend class Region; // Region has to compare the wave pool offset to get its sample
412     };
413    
414     /** Defines <i>Region</i> information of an <i>Instrument</i>. */
415     class Region : public Resource, public Articulator, public Sampler {
416     public:
417 schoenebeck 1335 range_t KeyRange; ///< @deprecated Only read, don't write! Use SetKeyRange() instead.
418 schoenebeck 2 range_t VelocityRange;
419     uint16_t KeyGroup;
420     uint16_t Layer;
421     bool SelfNonExclusive;
422     bool PhaseMaster;
423     uint16_t PhaseGroup;
424     bool MultiChannel;
425     uint32_t Channel;
426    
427     Sample* GetSample();
428 schoenebeck 800 void SetSample(Sample* pSample);
429 schoenebeck 1335 virtual void SetKeyRange(uint16_t Low, uint16_t High);
430 schoenebeck 800 virtual void UpdateChunks();
431 schoenebeck 2 protected:
432     RIFF::List* pCkRegion;
433     uint32_t WavePoolTableIndex; // index in the wave pool table to the sample wave this region is linked to
434     Sample* pSample; // every region refers to exactly one sample
435 schoenebeck 800 uint16_t FormatOptionFlags;
436     uint16_t WaveLinkOptionFlags;
437 schoenebeck 2
438     Region(Instrument* pInstrument, RIFF::List* rgnList);
439 schoenebeck 384 virtual ~Region();
440 schoenebeck 2 friend class Instrument;
441     };
442    
443     /** Provides all neccessary information for the synthesis of a DLS <i>Instrument</i>. */
444     class Instrument : public Resource, public Articulator {
445     public:
446     bool IsDrum; ///< Indicates if the <i>Instrument</i> is a drum type, as they differ in the synthesis model of DLS from melodic instruments.
447 schoenebeck 800 uint16_t MIDIBank; ///< Reflects combination of <i>MIDIBankCoarse</i> and <i>MIDIBankFine</i> (bank 1 - bank 16384). Do not change this value, it will not be saved! Change MIDIBankCoarse and MIDIBankFine instead (we might change that in future).
448 schoenebeck 2 uint8_t MIDIBankCoarse; ///< Reflects the MIDI Bank number for MIDI Control Change 0 (bank 1 - 128).
449     uint8_t MIDIBankFine; ///< Reflects the MIDI Bank number for MIDI Control Change 32 (bank 1 - 128).
450     uint32_t MIDIProgram; ///< Specifies the MIDI Program Change Number this Instrument should be assigned to.
451     uint32_t Regions; ///< Reflects the number of <i>Region</i> defintions this Instrument has.
452    
453     Region* GetFirstRegion();
454     Region* GetNextRegion();
455 schoenebeck 800 Region* AddRegion();
456     void DeleteRegion(Region* pRegion);
457     virtual void UpdateChunks();
458 schoenebeck 2 protected:
459     typedef std::list<Region*> RegionList;
460     struct midi_locale_t {
461     uint32_t bank;
462     uint32_t instrument;
463     };
464    
465     RIFF::List* pCkInstrument;
466     RegionList* pRegions;
467     RegionList::iterator RegionsIterator;
468    
469     Instrument(File* pFile, RIFF::List* insList);
470 schoenebeck 823 virtual void LoadRegions();
471 schoenebeck 384 virtual ~Instrument();
472 schoenebeck 2 friend class File;
473 schoenebeck 1335 friend class Region;
474     private:
475     void MoveRegion(Region* pSrc, Region* pDst);
476 schoenebeck 2 };
477    
478     /** Parses DLS Level 1 and 2 compliant files and provides abstract access to the data. */
479     class File : public Resource {
480     public:
481     version_t* pVersion; ///< Points to a <i>version_t</i> structure if the file provided a version number else is set to <i>NULL</i>.
482     uint32_t Instruments; ///< Reflects the number of available <i>Instrument</i> objects.
483    
484 schoenebeck 800 File();
485 schoenebeck 2 File(RIFF::File* pRIFF);
486     Sample* GetFirstSample(); ///< Returns a pointer to the first <i>Sample</i> object of the file, <i>NULL</i> otherwise.
487     Sample* GetNextSample(); ///< Returns a pointer to the next <i>Sample</i> object of the file, <i>NULL</i> otherwise.
488 schoenebeck 800 Sample* AddSample();
489     void DeleteSample(Sample* pSample);
490 schoenebeck 2 Instrument* GetFirstInstrument(); ///< Returns a pointer to the first <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
491     Instrument* GetNextInstrument(); ///< Returns a pointer to the next <i>Instrument</i> object of the file, <i>NULL</i> otherwise.
492 schoenebeck 800 Instrument* AddInstrument();
493     void DeleteInstrument(Instrument* pInstrument);
494     virtual void UpdateChunks();
495     virtual void Save(const String& Path);
496     virtual void Save();
497 schoenebeck 384 virtual ~File();
498 schoenebeck 2 protected:
499     typedef std::list<Sample*> SampleList;
500     typedef std::list<Instrument*> InstrumentList;
501    
502     RIFF::File* pRIFF;
503 persson 834 std::list<RIFF::File*> ExtensionFiles;
504 schoenebeck 2 SampleList* pSamples;
505     SampleList::iterator SamplesIterator;
506     InstrumentList* pInstruments;
507     InstrumentList::iterator InstrumentsIterator;
508 schoenebeck 800 uint32_t WavePoolHeaderSize;
509 schoenebeck 2 uint32_t WavePoolCount;
510     uint32_t* pWavePoolTable;
511 persson 666 uint32_t* pWavePoolTableHi;
512 schoenebeck 800 bool b64BitWavePoolOffsets;
513 schoenebeck 2
514 schoenebeck 823 virtual void LoadSamples();
515     virtual void LoadInstruments();
516 schoenebeck 800 void __ensureMandatoryChunksExist();
517 schoenebeck 2 friend class Region; // Region has to look in the wave pool table to get its sample
518 schoenebeck 800 private:
519     void __UpdateWavePoolTableChunk();
520     void __UpdateWavePoolTable();
521 schoenebeck 2 };
522    
523 schoenebeck 1093 /**
524     * Will be thrown whenever a DLS specific error occurs while trying to
525     * access a DLS File. Note: In your application you should better catch
526     * for RIFF::Exception rather than this one, except you explicitly want
527     * to catch and handle DLS::Exception and RIFF::Exception independently,
528     * which usually shouldn't be necessary though.
529     */
530 schoenebeck 2 class Exception : public RIFF::Exception {
531     public:
532     Exception(String Message);
533     void PrintMessage();
534     };
535    
536 schoenebeck 518 String libraryName();
537     String libraryVersion();
538    
539 schoenebeck 2 } // namespace DLS
540    
541     #endif // __DLS_H__

  ViewVC Help
Powered by ViewVC