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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1335 - (show annotations) (download) (as text)
Sun Sep 9 21:22:58 2007 UTC (13 years, 1 month 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 /***************************************************************************
2 * *
3 * libgig - C++ cross-platform Gigasampler format file access library *
4 * *
5 * Copyright (C) 2003-2007 by Christian Schoenebeck *
6 * <cuse@users.sourceforge.net> *
7 * *
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 #if WORDS_BIGENDIAN
30 # define RIFF_TYPE_DLS 0x444C5320
31 # 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 # define CHUNK_ID_ARTL 0x6172746C
70 # define CHUNK_ID_ART2 0x61727432
71 #else // little endian
72 # define RIFF_TYPE_DLS 0x20534C44
73 # 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 # define CHUNK_ID_IMED 0x44454D49
94 # 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 # define CHUNK_ID_ARTL 0x6C747261
112 # define CHUNK_ID_ART2 0x32747261
113 #endif // WORDS_BIGENDIAN
114
115 #define DLS_WAVE_FORMAT_PCM 0x0001
116
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 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 };
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 conn_block_t ToConnBlock();
264 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
274 Articulation(RIFF::Chunk* artl);
275 virtual ~Articulation();
276 virtual void UpdateChunks();
277 protected:
278 RIFF::Chunk* pArticulationCk;
279 uint32_t HeaderSize;
280 };
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 virtual void UpdateChunks();
289 protected:
290 typedef std::list<Articulation*> ArticulationList;
291 RIFF::List* pParentList;
292 ArticulationList* pArticulations;
293 ArticulationList::iterator ArticulationsIterator;
294
295 void LoadArticulations();
296 virtual ~Articulator();
297 };
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 String Subject; ///< <ISBJ-ck>. Describes the contents of the file.
319 bool UseFixedLengthStrings; ///< Deprecated. Use #FixedStringLengths instead.
320
321 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 Info(RIFF::List* list);
327 virtual ~Info();
328 virtual void UpdateChunks();
329 private:
330 RIFF::List* pResourceListChunk;
331
332 static void LoadString(uint32_t ChunkID, RIFF::List* lstINFO, String& s);
333 void SaveString(uint32_t ChunkID, RIFF::List* lstINFO, const String& s, const String& sDefault);
334 };
335
336 /** Abstract base class which encapsulates data structures which all DLS resources are able to provide. */
337 class Resource {
338 public:
339 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
342 Resource* GetParent() { return pParent; };
343 virtual void UpdateChunks();
344 void GenerateDLSID();
345 protected:
346 Resource* pParent;
347 RIFF::List* pResourceList;
348
349 Resource(Resource* Parent, RIFF::List* lstResource);
350 virtual ~Resource();
351 };
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 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 void AddSampleLoop(sample_loop_t* pLoopDef);
365 void DeleteSampleLoop(sample_loop_t* pLoopDef);
366 virtual void UpdateChunks();
367 protected:
368 RIFF::List* pParentList;
369 uint32_t uiHeaderSize;
370 uint32_t SamplerOptions;
371 Sampler(RIFF::List* ParentList);
372 virtual ~Sampler();
373 };
374
375 /** @brief Encapsulates sample waves used for playback.
376 *
377 * In case you created a new sample with File::AddSample(), you should
378 * 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 * the mandatory RIFF chunk which will hold the sample wave data.
382 */
383 class Sample : public Resource {
384 public:
385 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 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 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 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 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
394 void* LoadSampleData();
395 void ReleaseSampleData();
396 unsigned long GetSize();
397 void Resize(int iNewSize);
398 unsigned long SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence = RIFF::stream_start);
399 unsigned long Read(void* pBuffer, unsigned long SampleCount);
400 unsigned long Write(void* pBuffer, unsigned long SampleCount);
401 virtual void UpdateChunks();
402 protected:
403 RIFF::List* pWaveList;
404 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 virtual ~Sample();
410 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 range_t KeyRange; ///< @deprecated Only read, don't write! Use SetKeyRange() instead.
418 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 void SetSample(Sample* pSample);
429 virtual void SetKeyRange(uint16_t Low, uint16_t High);
430 virtual void UpdateChunks();
431 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 uint16_t FormatOptionFlags;
436 uint16_t WaveLinkOptionFlags;
437
438 Region(Instrument* pInstrument, RIFF::List* rgnList);
439 virtual ~Region();
440 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 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 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 Region* AddRegion();
456 void DeleteRegion(Region* pRegion);
457 virtual void UpdateChunks();
458 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 virtual void LoadRegions();
471 virtual ~Instrument();
472 friend class File;
473 friend class Region;
474 private:
475 void MoveRegion(Region* pSrc, Region* pDst);
476 };
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 File();
485 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 Sample* AddSample();
489 void DeleteSample(Sample* pSample);
490 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 Instrument* AddInstrument();
493 void DeleteInstrument(Instrument* pInstrument);
494 virtual void UpdateChunks();
495 virtual void Save(const String& Path);
496 virtual void Save();
497 virtual ~File();
498 protected:
499 typedef std::list<Sample*> SampleList;
500 typedef std::list<Instrument*> InstrumentList;
501
502 RIFF::File* pRIFF;
503 std::list<RIFF::File*> ExtensionFiles;
504 SampleList* pSamples;
505 SampleList::iterator SamplesIterator;
506 InstrumentList* pInstruments;
507 InstrumentList::iterator InstrumentsIterator;
508 uint32_t WavePoolHeaderSize;
509 uint32_t WavePoolCount;
510 uint32_t* pWavePoolTable;
511 uint32_t* pWavePoolTableHi;
512 bool b64BitWavePoolOffsets;
513
514 virtual void LoadSamples();
515 virtual void LoadInstruments();
516 void __ensureMandatoryChunksExist();
517 friend class Region; // Region has to look in the wave pool table to get its sample
518 private:
519 void __UpdateWavePoolTableChunk();
520 void __UpdateWavePoolTable();
521 };
522
523 /**
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 class Exception : public RIFF::Exception {
531 public:
532 Exception(String Message);
533 void PrintMessage();
534 };
535
536 String libraryName();
537 String libraryVersion();
538
539 } // namespace DLS
540
541 #endif // __DLS_H__

  ViewVC Help
Powered by ViewVC