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

Contents of /libgig/trunk/src/gig.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 437 - (show annotations) (download)
Wed Mar 9 22:02:40 2005 UTC (14 years, 8 months ago) by persson
File size: 83738 byte(s)
* src/gig.h, src/gig.cpp: 24-bit decompression now supports the 20 and
  18 bit formats
* src/gig.h, src/gig.cpp: added "random" and "round robin" dimensions

1 /***************************************************************************
2 * *
3 * libgig - C++ cross-platform Gigasampler format file loader library *
4 * *
5 * Copyright (C) 2003-2005 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 #include "gig.h"
25
26 #include <iostream>
27
28 namespace gig { namespace {
29
30 // *************** Internal functions for sample decopmression ***************
31 // *
32
33 inline int get12lo(const unsigned char* pSrc)
34 {
35 const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
36 return x & 0x800 ? x - 0x1000 : x;
37 }
38
39 inline int get12hi(const unsigned char* pSrc)
40 {
41 const int x = pSrc[1] >> 4 | pSrc[2] << 4;
42 return x & 0x800 ? x - 0x1000 : x;
43 }
44
45 inline int16_t get16(const unsigned char* pSrc)
46 {
47 return int16_t(pSrc[0] | pSrc[1] << 8);
48 }
49
50 inline int get24(const unsigned char* pSrc)
51 {
52 const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
53 return x & 0x800000 ? x - 0x1000000 : x;
54 }
55
56 void Decompress16(int compressionmode, const unsigned char* params,
57 int srcStep, int dstStep,
58 const unsigned char* pSrc, int16_t* pDst,
59 unsigned long currentframeoffset,
60 unsigned long copysamples)
61 {
62 switch (compressionmode) {
63 case 0: // 16 bit uncompressed
64 pSrc += currentframeoffset * srcStep;
65 while (copysamples) {
66 *pDst = get16(pSrc);
67 pDst += dstStep;
68 pSrc += srcStep;
69 copysamples--;
70 }
71 break;
72
73 case 1: // 16 bit compressed to 8 bit
74 int y = get16(params);
75 int dy = get16(params + 2);
76 while (currentframeoffset) {
77 dy -= int8_t(*pSrc);
78 y -= dy;
79 pSrc += srcStep;
80 currentframeoffset--;
81 }
82 while (copysamples) {
83 dy -= int8_t(*pSrc);
84 y -= dy;
85 *pDst = y;
86 pDst += dstStep;
87 pSrc += srcStep;
88 copysamples--;
89 }
90 break;
91 }
92 }
93
94 void Decompress24(int compressionmode, const unsigned char* params,
95 int dstStep, const unsigned char* pSrc, int16_t* pDst,
96 unsigned long currentframeoffset,
97 unsigned long copysamples, int truncatedBits)
98 {
99 // Note: The 24 bits are truncated to 16 bits for now.
100
101 // Note: The calculation of the initial value of y is strange
102 // and not 100% correct. What should the first two parameters
103 // really be used for? Why are they two? The correct value for
104 // y seems to lie somewhere between the values of the first
105 // two parameters.
106 //
107 // Strange thing #2: The formula in SKIP_ONE gives values for
108 // y that are twice as high as they should be. That's why
109 // COPY_ONE shifts an extra step, and also why y is
110 // initialized with a sum instead of a mean value.
111
112 int y, dy, ddy;
113
114 const int shift = 8 - truncatedBits;
115 const int shift1 = shift + 1;
116
117 #define GET_PARAMS(params) \
118 y = (get24(params) + get24((params) + 3)); \
119 dy = get24((params) + 6); \
120 ddy = get24((params) + 9)
121
122 #define SKIP_ONE(x) \
123 ddy -= (x); \
124 dy -= ddy; \
125 y -= dy
126
127 #define COPY_ONE(x) \
128 SKIP_ONE(x); \
129 *pDst = y >> shift1; \
130 pDst += dstStep
131
132 switch (compressionmode) {
133 case 2: // 24 bit uncompressed
134 pSrc += currentframeoffset * 3;
135 while (copysamples) {
136 *pDst = get24(pSrc) >> shift;
137 pDst += dstStep;
138 pSrc += 3;
139 copysamples--;
140 }
141 break;
142
143 case 3: // 24 bit compressed to 16 bit
144 GET_PARAMS(params);
145 while (currentframeoffset) {
146 SKIP_ONE(get16(pSrc));
147 pSrc += 2;
148 currentframeoffset--;
149 }
150 while (copysamples) {
151 COPY_ONE(get16(pSrc));
152 pSrc += 2;
153 copysamples--;
154 }
155 break;
156
157 case 4: // 24 bit compressed to 12 bit
158 GET_PARAMS(params);
159 while (currentframeoffset > 1) {
160 SKIP_ONE(get12lo(pSrc));
161 SKIP_ONE(get12hi(pSrc));
162 pSrc += 3;
163 currentframeoffset -= 2;
164 }
165 if (currentframeoffset) {
166 SKIP_ONE(get12lo(pSrc));
167 currentframeoffset--;
168 if (copysamples) {
169 COPY_ONE(get12hi(pSrc));
170 pSrc += 3;
171 copysamples--;
172 }
173 }
174 while (copysamples > 1) {
175 COPY_ONE(get12lo(pSrc));
176 COPY_ONE(get12hi(pSrc));
177 pSrc += 3;
178 copysamples -= 2;
179 }
180 if (copysamples) {
181 COPY_ONE(get12lo(pSrc));
182 }
183 break;
184
185 case 5: // 24 bit compressed to 8 bit
186 GET_PARAMS(params);
187 while (currentframeoffset) {
188 SKIP_ONE(int8_t(*pSrc++));
189 currentframeoffset--;
190 }
191 while (copysamples) {
192 COPY_ONE(int8_t(*pSrc++));
193 copysamples--;
194 }
195 break;
196 }
197 }
198
199 const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
200 const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
201 const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
202 const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
203 }
204
205
206 // *************** Sample ***************
207 // *
208
209 unsigned int Sample::Instances = 0;
210 buffer_t Sample::InternalDecompressionBuffer;
211
212 Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
213 Instances++;
214
215 RIFF::Chunk* _3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
216 if (!_3gix) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");
217 SampleGroup = _3gix->ReadInt16();
218
219 RIFF::Chunk* smpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
220 if (!smpl) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");
221 Manufacturer = smpl->ReadInt32();
222 Product = smpl->ReadInt32();
223 SamplePeriod = smpl->ReadInt32();
224 MIDIUnityNote = smpl->ReadInt32();
225 FineTune = smpl->ReadInt32();
226 smpl->Read(&SMPTEFormat, 1, 4);
227 SMPTEOffset = smpl->ReadInt32();
228 Loops = smpl->ReadInt32();
229 smpl->ReadInt32(); // manufByt
230 LoopID = smpl->ReadInt32();
231 smpl->Read(&LoopType, 1, 4);
232 LoopStart = smpl->ReadInt32();
233 LoopEnd = smpl->ReadInt32();
234 LoopFraction = smpl->ReadInt32();
235 LoopPlayCount = smpl->ReadInt32();
236
237 FrameTable = NULL;
238 SamplePos = 0;
239 RAMCache.Size = 0;
240 RAMCache.pStart = NULL;
241 RAMCache.NullExtensionSize = 0;
242
243 if (BitDepth > 24) throw gig::Exception("Only samples up to 24 bit supported");
244
245 RIFF::Chunk* ewav = waveList->GetSubChunk(CHUNK_ID_EWAV);
246 Compressed = ewav;
247 Dithered = false;
248 TruncatedBits = 0;
249 if (Compressed) {
250 uint32_t version = ewav->ReadInt32();
251 if (version == 3 && BitDepth == 24) {
252 Dithered = ewav->ReadInt32();
253 ewav->SetPos(Channels == 2 ? 84 : 64);
254 TruncatedBits = ewav->ReadInt32();
255 }
256 ScanCompressedSample();
257 }
258
259 // we use a buffer for decompression and for truncating 24 bit samples to 16 bit
260 if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {
261 InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
262 InternalDecompressionBuffer.Size = INITIAL_SAMPLE_BUFFER_SIZE;
263 }
264 FrameOffset = 0; // just for streaming compressed samples
265
266 LoopSize = LoopEnd - LoopStart;
267 }
268
269 /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
270 void Sample::ScanCompressedSample() {
271 //TODO: we have to add some more scans here (e.g. determine compression rate)
272 this->SamplesTotal = 0;
273 std::list<unsigned long> frameOffsets;
274
275 SamplesPerFrame = BitDepth == 24 ? 256 : 2048;
276 WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag
277
278 // Scanning
279 pCkData->SetPos(0);
280 if (Channels == 2) { // Stereo
281 for (int i = 0 ; ; i++) {
282 // for 24 bit samples every 8:th frame offset is
283 // stored, to save some memory
284 if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
285
286 const int mode_l = pCkData->ReadUint8();
287 const int mode_r = pCkData->ReadUint8();
288 if (mode_l > 5 || mode_r > 5) throw gig::Exception("Unknown compression mode");
289 const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
290
291 if (pCkData->RemainingBytes() <= frameSize) {
292 SamplesInLastFrame =
293 ((pCkData->RemainingBytes() - headerSize[mode_l] - headerSize[mode_r]) << 3) /
294 (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
295 SamplesTotal += SamplesInLastFrame;
296 break;
297 }
298 SamplesTotal += SamplesPerFrame;
299 pCkData->SetPos(frameSize, RIFF::stream_curpos);
300 }
301 }
302 else { // Mono
303 for (int i = 0 ; ; i++) {
304 if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
305
306 const int mode = pCkData->ReadUint8();
307 if (mode > 5) throw gig::Exception("Unknown compression mode");
308 const unsigned long frameSize = bytesPerFrame[mode];
309
310 if (pCkData->RemainingBytes() <= frameSize) {
311 SamplesInLastFrame =
312 ((pCkData->RemainingBytes() - headerSize[mode]) << 3) / bitsPerSample[mode];
313 SamplesTotal += SamplesInLastFrame;
314 break;
315 }
316 SamplesTotal += SamplesPerFrame;
317 pCkData->SetPos(frameSize, RIFF::stream_curpos);
318 }
319 }
320 pCkData->SetPos(0);
321
322 // Build the frames table (which is used for fast resolving of a frame's chunk offset)
323 if (FrameTable) delete[] FrameTable;
324 FrameTable = new unsigned long[frameOffsets.size()];
325 std::list<unsigned long>::iterator end = frameOffsets.end();
326 std::list<unsigned long>::iterator iter = frameOffsets.begin();
327 for (int i = 0; iter != end; i++, iter++) {
328 FrameTable[i] = *iter;
329 }
330 }
331
332 /**
333 * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
334 * ReleaseSampleData() to free the memory if you don't need the cached
335 * sample data anymore.
336 *
337 * @returns buffer_t structure with start address and size of the buffer
338 * in bytes
339 * @see ReleaseSampleData(), Read(), SetPos()
340 */
341 buffer_t Sample::LoadSampleData() {
342 return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, 0); // 0 amount of NullSamples
343 }
344
345 /**
346 * Reads (uncompresses if needed) and caches the first \a SampleCount
347 * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
348 * memory space if you don't need the cached samples anymore. There is no
349 * guarantee that exactly \a SampleCount samples will be cached; this is
350 * not an error. The size will be eventually truncated e.g. to the
351 * beginning of a frame of a compressed sample. This is done for
352 * efficiency reasons while streaming the wave by your sampler engine
353 * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
354 * that will be returned to determine the actual cached samples, but note
355 * that the size is given in bytes! You get the number of actually cached
356 * samples by dividing it by the frame size of the sample:
357 * @code
358 * buffer_t buf = pSample->LoadSampleData(acquired_samples);
359 * long cachedsamples = buf.Size / pSample->FrameSize;
360 * @endcode
361 *
362 * @param SampleCount - number of sample points to load into RAM
363 * @returns buffer_t structure with start address and size of
364 * the cached sample data in bytes
365 * @see ReleaseSampleData(), Read(), SetPos()
366 */
367 buffer_t Sample::LoadSampleData(unsigned long SampleCount) {
368 return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
369 }
370
371 /**
372 * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
373 * ReleaseSampleData() to free the memory if you don't need the cached
374 * sample data anymore.
375 * The method will add \a NullSamplesCount silence samples past the
376 * official buffer end (this won't affect the 'Size' member of the
377 * buffer_t structure, that means 'Size' always reflects the size of the
378 * actual sample data, the buffer might be bigger though). Silence
379 * samples past the official buffer are needed for differential
380 * algorithms that always have to take subsequent samples into account
381 * (resampling/interpolation would be an important example) and avoids
382 * memory access faults in such cases.
383 *
384 * @param NullSamplesCount - number of silence samples the buffer should
385 * be extended past it's data end
386 * @returns buffer_t structure with start address and
387 * size of the buffer in bytes
388 * @see ReleaseSampleData(), Read(), SetPos()
389 */
390 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
391 return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, NullSamplesCount);
392 }
393
394 /**
395 * Reads (uncompresses if needed) and caches the first \a SampleCount
396 * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
397 * memory space if you don't need the cached samples anymore. There is no
398 * guarantee that exactly \a SampleCount samples will be cached; this is
399 * not an error. The size will be eventually truncated e.g. to the
400 * beginning of a frame of a compressed sample. This is done for
401 * efficiency reasons while streaming the wave by your sampler engine
402 * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
403 * that will be returned to determine the actual cached samples, but note
404 * that the size is given in bytes! You get the number of actually cached
405 * samples by dividing it by the frame size of the sample:
406 * @code
407 * buffer_t buf = pSample->LoadSampleDataWithNullSamplesExtension(acquired_samples, null_samples);
408 * long cachedsamples = buf.Size / pSample->FrameSize;
409 * @endcode
410 * The method will add \a NullSamplesCount silence samples past the
411 * official buffer end (this won't affect the 'Size' member of the
412 * buffer_t structure, that means 'Size' always reflects the size of the
413 * actual sample data, the buffer might be bigger though). Silence
414 * samples past the official buffer are needed for differential
415 * algorithms that always have to take subsequent samples into account
416 * (resampling/interpolation would be an important example) and avoids
417 * memory access faults in such cases.
418 *
419 * @param SampleCount - number of sample points to load into RAM
420 * @param NullSamplesCount - number of silence samples the buffer should
421 * be extended past it's data end
422 * @returns buffer_t structure with start address and
423 * size of the cached sample data in bytes
424 * @see ReleaseSampleData(), Read(), SetPos()
425 */
426 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount) {
427 if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
428 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
429 unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
430 RAMCache.pStart = new int8_t[allocationsize];
431 RAMCache.Size = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
432 RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
433 // fill the remaining buffer space with silence samples
434 memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
435 return GetCache();
436 }
437
438 /**
439 * Returns current cached sample points. A buffer_t structure will be
440 * returned which contains address pointer to the begin of the cache and
441 * the size of the cached sample data in bytes. Use
442 * <i>LoadSampleData()</i> to cache a specific amount of sample points in
443 * RAM.
444 *
445 * @returns buffer_t structure with current cached sample points
446 * @see LoadSampleData();
447 */
448 buffer_t Sample::GetCache() {
449 // return a copy of the buffer_t structure
450 buffer_t result;
451 result.Size = this->RAMCache.Size;
452 result.pStart = this->RAMCache.pStart;
453 result.NullExtensionSize = this->RAMCache.NullExtensionSize;
454 return result;
455 }
456
457 /**
458 * Frees the cached sample from RAM if loaded with
459 * <i>LoadSampleData()</i> previously.
460 *
461 * @see LoadSampleData();
462 */
463 void Sample::ReleaseSampleData() {
464 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
465 RAMCache.pStart = NULL;
466 RAMCache.Size = 0;
467 }
468
469 /**
470 * Sets the position within the sample (in sample points, not in
471 * bytes). Use this method and <i>Read()</i> if you don't want to load
472 * the sample into RAM, thus for disk streaming.
473 *
474 * Although the original Gigasampler engine doesn't allow positioning
475 * within compressed samples, I decided to implement it. Even though
476 * the Gigasampler format doesn't allow to define loops for compressed
477 * samples at the moment, positioning within compressed samples might be
478 * interesting for some sampler engines though. The only drawback about
479 * my decision is that it takes longer to load compressed gig Files on
480 * startup, because it's neccessary to scan the samples for some
481 * mandatory informations. But I think as it doesn't affect the runtime
482 * efficiency, nobody will have a problem with that.
483 *
484 * @param SampleCount number of sample points to jump
485 * @param Whence optional: to which relation \a SampleCount refers
486 * to, if omited <i>RIFF::stream_start</i> is assumed
487 * @returns the new sample position
488 * @see Read()
489 */
490 unsigned long Sample::SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence) {
491 if (Compressed) {
492 switch (Whence) {
493 case RIFF::stream_curpos:
494 this->SamplePos += SampleCount;
495 break;
496 case RIFF::stream_end:
497 this->SamplePos = this->SamplesTotal - 1 - SampleCount;
498 break;
499 case RIFF::stream_backward:
500 this->SamplePos -= SampleCount;
501 break;
502 case RIFF::stream_start: default:
503 this->SamplePos = SampleCount;
504 break;
505 }
506 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
507
508 unsigned long frame = this->SamplePos / 2048; // to which frame to jump
509 this->FrameOffset = this->SamplePos % 2048; // offset (in sample points) within that frame
510 pCkData->SetPos(FrameTable[frame]); // set chunk pointer to the start of sought frame
511 return this->SamplePos;
512 }
513 else { // not compressed
514 unsigned long orderedBytes = SampleCount * this->FrameSize;
515 unsigned long result = pCkData->SetPos(orderedBytes, Whence);
516 return (result == orderedBytes) ? SampleCount
517 : result / this->FrameSize;
518 }
519 }
520
521 /**
522 * Returns the current position in the sample (in sample points).
523 */
524 unsigned long Sample::GetPos() {
525 if (Compressed) return SamplePos;
526 else return pCkData->GetPos() / FrameSize;
527 }
528
529 /**
530 * Reads \a SampleCount number of sample points from the position stored
531 * in \a pPlaybackState into the buffer pointed by \a pBuffer and moves
532 * the position within the sample respectively, this method honors the
533 * looping informations of the sample (if any). The sample wave stream
534 * will be decompressed on the fly if using a compressed sample. Use this
535 * method if you don't want to load the sample into RAM, thus for disk
536 * streaming. All this methods needs to know to proceed with streaming
537 * for the next time you call this method is stored in \a pPlaybackState.
538 * You have to allocate and initialize the playback_state_t structure by
539 * yourself before you use it to stream a sample:
540 * @code
541 * gig::playback_state_t playbackstate;
542 * playbackstate.position = 0;
543 * playbackstate.reverse = false;
544 * playbackstate.loop_cycles_left = pSample->LoopPlayCount;
545 * @endcode
546 * You don't have to take care of things like if there is actually a loop
547 * defined or if the current read position is located within a loop area.
548 * The method already handles such cases by itself.
549 *
550 * <b>Caution:</b> If you are using more than one streaming thread, you
551 * have to use an external decompression buffer for <b>EACH</b>
552 * streaming thread to avoid race conditions and crashes!
553 *
554 * @param pBuffer destination buffer
555 * @param SampleCount number of sample points to read
556 * @param pPlaybackState will be used to store and reload the playback
557 * state for the next ReadAndLoop() call
558 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
559 * @returns number of successfully read sample points
560 * @see CreateDecompressionBuffer()
561 */
562 unsigned long Sample::ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, buffer_t* pExternalDecompressionBuffer) {
563 unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
564 uint8_t* pDst = (uint8_t*) pBuffer;
565
566 SetPos(pPlaybackState->position); // recover position from the last time
567
568 if (this->Loops && GetPos() <= this->LoopEnd) { // honor looping if there are loop points defined
569
570 switch (this->LoopType) {
571
572 case loop_type_bidirectional: { //TODO: not tested yet!
573 do {
574 // if not endless loop check if max. number of loop cycles have been passed
575 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
576
577 if (!pPlaybackState->reverse) { // forward playback
578 do {
579 samplestoloopend = this->LoopEnd - GetPos();
580 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
581 samplestoread -= readsamples;
582 totalreadsamples += readsamples;
583 if (readsamples == samplestoloopend) {
584 pPlaybackState->reverse = true;
585 break;
586 }
587 } while (samplestoread && readsamples);
588 }
589 else { // backward playback
590
591 // as we can only read forward from disk, we have to
592 // determine the end position within the loop first,
593 // read forward from that 'end' and finally after
594 // reading, swap all sample frames so it reflects
595 // backward playback
596
597 unsigned long swapareastart = totalreadsamples;
598 unsigned long loopoffset = GetPos() - this->LoopStart;
599 unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);
600 unsigned long reverseplaybackend = GetPos() - samplestoreadinloop;
601
602 SetPos(reverseplaybackend);
603
604 // read samples for backward playback
605 do {
606 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
607 samplestoreadinloop -= readsamples;
608 samplestoread -= readsamples;
609 totalreadsamples += readsamples;
610 } while (samplestoreadinloop && readsamples);
611
612 SetPos(reverseplaybackend); // pretend we really read backwards
613
614 if (reverseplaybackend == this->LoopStart) {
615 pPlaybackState->loop_cycles_left--;
616 pPlaybackState->reverse = false;
617 }
618
619 // reverse the sample frames for backward playback
620 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
621 }
622 } while (samplestoread && readsamples);
623 break;
624 }
625
626 case loop_type_backward: { // TODO: not tested yet!
627 // forward playback (not entered the loop yet)
628 if (!pPlaybackState->reverse) do {
629 samplestoloopend = this->LoopEnd - GetPos();
630 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
631 samplestoread -= readsamples;
632 totalreadsamples += readsamples;
633 if (readsamples == samplestoloopend) {
634 pPlaybackState->reverse = true;
635 break;
636 }
637 } while (samplestoread && readsamples);
638
639 if (!samplestoread) break;
640
641 // as we can only read forward from disk, we have to
642 // determine the end position within the loop first,
643 // read forward from that 'end' and finally after
644 // reading, swap all sample frames so it reflects
645 // backward playback
646
647 unsigned long swapareastart = totalreadsamples;
648 unsigned long loopoffset = GetPos() - this->LoopStart;
649 unsigned long samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * LoopSize - loopoffset)
650 : samplestoread;
651 unsigned long reverseplaybackend = this->LoopStart + Abs((loopoffset - samplestoreadinloop) % this->LoopSize);
652
653 SetPos(reverseplaybackend);
654
655 // read samples for backward playback
656 do {
657 // if not endless loop check if max. number of loop cycles have been passed
658 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
659 samplestoloopend = this->LoopEnd - GetPos();
660 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
661 samplestoreadinloop -= readsamples;
662 samplestoread -= readsamples;
663 totalreadsamples += readsamples;
664 if (readsamples == samplestoloopend) {
665 pPlaybackState->loop_cycles_left--;
666 SetPos(this->LoopStart);
667 }
668 } while (samplestoreadinloop && readsamples);
669
670 SetPos(reverseplaybackend); // pretend we really read backwards
671
672 // reverse the sample frames for backward playback
673 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
674 break;
675 }
676
677 default: case loop_type_normal: {
678 do {
679 // if not endless loop check if max. number of loop cycles have been passed
680 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
681 samplestoloopend = this->LoopEnd - GetPos();
682 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
683 samplestoread -= readsamples;
684 totalreadsamples += readsamples;
685 if (readsamples == samplestoloopend) {
686 pPlaybackState->loop_cycles_left--;
687 SetPos(this->LoopStart);
688 }
689 } while (samplestoread && readsamples);
690 break;
691 }
692 }
693 }
694
695 // read on without looping
696 if (samplestoread) do {
697 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoread, pExternalDecompressionBuffer);
698 samplestoread -= readsamples;
699 totalreadsamples += readsamples;
700 } while (readsamples && samplestoread);
701
702 // store current position
703 pPlaybackState->position = GetPos();
704
705 return totalreadsamples;
706 }
707
708 /**
709 * Reads \a SampleCount number of sample points from the current
710 * position into the buffer pointed by \a pBuffer and increments the
711 * position within the sample. The sample wave stream will be
712 * decompressed on the fly if using a compressed sample. Use this method
713 * and <i>SetPos()</i> if you don't want to load the sample into RAM,
714 * thus for disk streaming.
715 *
716 * <b>Caution:</b> If you are using more than one streaming thread, you
717 * have to use an external decompression buffer for <b>EACH</b>
718 * streaming thread to avoid race conditions and crashes!
719 *
720 * @param pBuffer destination buffer
721 * @param SampleCount number of sample points to read
722 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
723 * @returns number of successfully read sample points
724 * @see SetPos(), CreateDecompressionBuffer()
725 */
726 unsigned long Sample::Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer) {
727 if (SampleCount == 0) return 0;
728 if (!Compressed) {
729 if (BitDepth == 24) {
730 // 24 bit sample. For now just truncate to 16 bit.
731 unsigned char* pSrc = (unsigned char*) ((pExternalDecompressionBuffer) ? pExternalDecompressionBuffer->pStart : this->InternalDecompressionBuffer.pStart);
732 int16_t* pDst = static_cast<int16_t*>(pBuffer);
733 if (Channels == 2) { // Stereo
734 unsigned long readBytes = pCkData->Read(pSrc, SampleCount * 6, 1);
735 pSrc++;
736 for (unsigned long i = readBytes ; i > 0 ; i -= 3) {
737 *pDst++ = get16(pSrc);
738 pSrc += 3;
739 }
740 return (pDst - static_cast<int16_t*>(pBuffer)) >> 1;
741 }
742 else { // Mono
743 unsigned long readBytes = pCkData->Read(pSrc, SampleCount * 3, 1);
744 pSrc++;
745 for (unsigned long i = readBytes ; i > 0 ; i -= 3) {
746 *pDst++ = get16(pSrc);
747 pSrc += 3;
748 }
749 return pDst - static_cast<int16_t*>(pBuffer);
750 }
751 }
752 else { // 16 bit
753 // (pCkData->Read does endian correction)
754 return Channels == 2 ? pCkData->Read(pBuffer, SampleCount << 1, 2) >> 1
755 : pCkData->Read(pBuffer, SampleCount, 2);
756 }
757 }
758 else {
759 if (this->SamplePos >= this->SamplesTotal) return 0;
760 //TODO: efficiency: maybe we should test for an average compression rate
761 unsigned long assumedsize = GuessSize(SampleCount),
762 remainingbytes = 0, // remaining bytes in the local buffer
763 remainingsamples = SampleCount,
764 copysamples, skipsamples,
765 currentframeoffset = this->FrameOffset; // offset in current sample frame since last Read()
766 this->FrameOffset = 0;
767
768 buffer_t* pDecompressionBuffer = (pExternalDecompressionBuffer) ? pExternalDecompressionBuffer : &InternalDecompressionBuffer;
769
770 // if decompression buffer too small, then reduce amount of samples to read
771 if (pDecompressionBuffer->Size < assumedsize) {
772 std::cerr << "gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
773 SampleCount = WorstCaseMaxSamples(pDecompressionBuffer);
774 remainingsamples = SampleCount;
775 assumedsize = GuessSize(SampleCount);
776 }
777
778 unsigned char* pSrc = (unsigned char*) pDecompressionBuffer->pStart;
779 int16_t* pDst = static_cast<int16_t*>(pBuffer);
780 remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
781
782 while (remainingsamples && remainingbytes) {
783 unsigned long framesamples = SamplesPerFrame;
784 unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;
785
786 int mode_l = *pSrc++, mode_r = 0;
787
788 if (Channels == 2) {
789 mode_r = *pSrc++;
790 framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
791 rightChannelOffset = bytesPerFrameNoHdr[mode_l];
792 nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
793 if (remainingbytes < framebytes) { // last frame in sample
794 framesamples = SamplesInLastFrame;
795 if (mode_l == 4 && (framesamples & 1)) {
796 rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
797 }
798 else {
799 rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
800 }
801 }
802 }
803 else {
804 framebytes = bytesPerFrame[mode_l] + 1;
805 nextFrameOffset = bytesPerFrameNoHdr[mode_l];
806 if (remainingbytes < framebytes) {
807 framesamples = SamplesInLastFrame;
808 }
809 }
810
811 // determine how many samples in this frame to skip and read
812 if (currentframeoffset + remainingsamples >= framesamples) {
813 if (currentframeoffset <= framesamples) {
814 copysamples = framesamples - currentframeoffset;
815 skipsamples = currentframeoffset;
816 }
817 else {
818 copysamples = 0;
819 skipsamples = framesamples;
820 }
821 }
822 else {
823 // This frame has enough data for pBuffer, but not
824 // all of the frame is needed. Set file position
825 // to start of this frame for next call to Read.
826 copysamples = remainingsamples;
827 skipsamples = currentframeoffset;
828 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
829 this->FrameOffset = currentframeoffset + copysamples;
830 }
831 remainingsamples -= copysamples;
832
833 if (remainingbytes > framebytes) {
834 remainingbytes -= framebytes;
835 if (remainingsamples == 0 &&
836 currentframeoffset + copysamples == framesamples) {
837 // This frame has enough data for pBuffer, and
838 // all of the frame is needed. Set file
839 // position to start of next frame for next
840 // call to Read. FrameOffset is 0.
841 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
842 }
843 }
844 else remainingbytes = 0;
845
846 currentframeoffset -= skipsamples;
847
848 if (copysamples == 0) {
849 // skip this frame
850 pSrc += framebytes - Channels;
851 }
852 else {
853 const unsigned char* const param_l = pSrc;
854 if (BitDepth == 24) {
855 if (mode_l != 2) pSrc += 12;
856
857 if (Channels == 2) { // Stereo
858 const unsigned char* const param_r = pSrc;
859 if (mode_r != 2) pSrc += 12;
860
861 Decompress24(mode_l, param_l, 2, pSrc, pDst,
862 skipsamples, copysamples, TruncatedBits);
863 Decompress24(mode_r, param_r, 2, pSrc + rightChannelOffset, pDst + 1,
864 skipsamples, copysamples, TruncatedBits);
865 pDst += copysamples << 1;
866 }
867 else { // Mono
868 Decompress24(mode_l, param_l, 1, pSrc, pDst,
869 skipsamples, copysamples, TruncatedBits);
870 pDst += copysamples;
871 }
872 }
873 else { // 16 bit
874 if (mode_l) pSrc += 4;
875
876 int step;
877 if (Channels == 2) { // Stereo
878 const unsigned char* const param_r = pSrc;
879 if (mode_r) pSrc += 4;
880
881 step = (2 - mode_l) + (2 - mode_r);
882 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
883 Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
884 skipsamples, copysamples);
885 pDst += copysamples << 1;
886 }
887 else { // Mono
888 step = 2 - mode_l;
889 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
890 pDst += copysamples;
891 }
892 }
893 pSrc += nextFrameOffset;
894 }
895
896 // reload from disk to local buffer if needed
897 if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() == RIFF::stream_ready) {
898 assumedsize = GuessSize(remainingsamples);
899 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
900 if (pCkData->RemainingBytes() < assumedsize) assumedsize = pCkData->RemainingBytes();
901 remainingbytes = pCkData->Read(pDecompressionBuffer->pStart, assumedsize, 1);
902 pSrc = (unsigned char*) pDecompressionBuffer->pStart;
903 }
904 } // while
905
906 this->SamplePos += (SampleCount - remainingsamples);
907 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
908 return (SampleCount - remainingsamples);
909 }
910 }
911
912 /**
913 * Allocates a decompression buffer for streaming (compressed) samples
914 * with Sample::Read(). If you are using more than one streaming thread
915 * in your application you <b>HAVE</b> to create a decompression buffer
916 * for <b>EACH</b> of your streaming threads and provide it with the
917 * Sample::Read() call in order to avoid race conditions and crashes.
918 *
919 * You should free the memory occupied by the allocated buffer(s) once
920 * you don't need one of your streaming threads anymore by calling
921 * DestroyDecompressionBuffer().
922 *
923 * @param MaxReadSize - the maximum size (in sample points) you ever
924 * expect to read with one Read() call
925 * @returns allocated decompression buffer
926 * @see DestroyDecompressionBuffer()
927 */
928 buffer_t Sample::CreateDecompressionBuffer(unsigned long MaxReadSize) {
929 buffer_t result;
930 const double worstCaseHeaderOverhead =
931 (256.0 /*frame size*/ + 12.0 /*header*/ + 2.0 /*compression type flag (stereo)*/) / 256.0;
932 result.Size = (unsigned long) (double(MaxReadSize) * 3.0 /*(24 Bit)*/ * 2.0 /*stereo*/ * worstCaseHeaderOverhead);
933 result.pStart = new int8_t[result.Size];
934 result.NullExtensionSize = 0;
935 return result;
936 }
937
938 /**
939 * Free decompression buffer, previously created with
940 * CreateDecompressionBuffer().
941 *
942 * @param DecompressionBuffer - previously allocated decompression
943 * buffer to free
944 */
945 void Sample::DestroyDecompressionBuffer(buffer_t& DecompressionBuffer) {
946 if (DecompressionBuffer.Size && DecompressionBuffer.pStart) {
947 delete[] (int8_t*) DecompressionBuffer.pStart;
948 DecompressionBuffer.pStart = NULL;
949 DecompressionBuffer.Size = 0;
950 DecompressionBuffer.NullExtensionSize = 0;
951 }
952 }
953
954 Sample::~Sample() {
955 Instances--;
956 if (!Instances && InternalDecompressionBuffer.Size) {
957 delete[] (unsigned char*) InternalDecompressionBuffer.pStart;
958 InternalDecompressionBuffer.pStart = NULL;
959 InternalDecompressionBuffer.Size = 0;
960 }
961 if (FrameTable) delete[] FrameTable;
962 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
963 }
964
965
966
967 // *************** DimensionRegion ***************
968 // *
969
970 uint DimensionRegion::Instances = 0;
971 DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
972
973 DimensionRegion::DimensionRegion(RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
974 Instances++;
975
976 memcpy(&Crossfade, &SamplerOptions, 4);
977 if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
978
979 RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
980 _3ewa->ReadInt32(); // unknown, always 0x0000008C ?
981 LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
982 EG3Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
983 _3ewa->ReadInt16(); // unknown
984 LFO1InternalDepth = _3ewa->ReadUint16();
985 _3ewa->ReadInt16(); // unknown
986 LFO3InternalDepth = _3ewa->ReadInt16();
987 _3ewa->ReadInt16(); // unknown
988 LFO1ControlDepth = _3ewa->ReadUint16();
989 _3ewa->ReadInt16(); // unknown
990 LFO3ControlDepth = _3ewa->ReadInt16();
991 EG1Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
992 EG1Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
993 _3ewa->ReadInt16(); // unknown
994 EG1Sustain = _3ewa->ReadUint16();
995 EG1Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
996 EG1Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
997 uint8_t eg1ctrloptions = _3ewa->ReadUint8();
998 EG1ControllerInvert = eg1ctrloptions & 0x01;
999 EG1ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1000 EG1ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1001 EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1002 EG2Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1003 uint8_t eg2ctrloptions = _3ewa->ReadUint8();
1004 EG2ControllerInvert = eg2ctrloptions & 0x01;
1005 EG2ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1006 EG2ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1007 EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1008 LFO1Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1009 EG2Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1010 EG2Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1011 _3ewa->ReadInt16(); // unknown
1012 EG2Sustain = _3ewa->ReadUint16();
1013 EG2Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1014 _3ewa->ReadInt16(); // unknown
1015 LFO2ControlDepth = _3ewa->ReadUint16();
1016 LFO2Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1017 _3ewa->ReadInt16(); // unknown
1018 LFO2InternalDepth = _3ewa->ReadUint16();
1019 int32_t eg1decay2 = _3ewa->ReadInt32();
1020 EG1Decay2 = (double) GIG_EXP_DECODE(eg1decay2);
1021 EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1022 _3ewa->ReadInt16(); // unknown
1023 EG1PreAttack = _3ewa->ReadUint16();
1024 int32_t eg2decay2 = _3ewa->ReadInt32();
1025 EG2Decay2 = (double) GIG_EXP_DECODE(eg2decay2);
1026 EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1027 _3ewa->ReadInt16(); // unknown
1028 EG2PreAttack = _3ewa->ReadUint16();
1029 uint8_t velocityresponse = _3ewa->ReadUint8();
1030 if (velocityresponse < 5) {
1031 VelocityResponseCurve = curve_type_nonlinear;
1032 VelocityResponseDepth = velocityresponse;
1033 }
1034 else if (velocityresponse < 10) {
1035 VelocityResponseCurve = curve_type_linear;
1036 VelocityResponseDepth = velocityresponse - 5;
1037 }
1038 else if (velocityresponse < 15) {
1039 VelocityResponseCurve = curve_type_special;
1040 VelocityResponseDepth = velocityresponse - 10;
1041 }
1042 else {
1043 VelocityResponseCurve = curve_type_unknown;
1044 VelocityResponseDepth = 0;
1045 }
1046 uint8_t releasevelocityresponse = _3ewa->ReadUint8();
1047 if (releasevelocityresponse < 5) {
1048 ReleaseVelocityResponseCurve = curve_type_nonlinear;
1049 ReleaseVelocityResponseDepth = releasevelocityresponse;
1050 }
1051 else if (releasevelocityresponse < 10) {
1052 ReleaseVelocityResponseCurve = curve_type_linear;
1053 ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1054 }
1055 else if (releasevelocityresponse < 15) {
1056 ReleaseVelocityResponseCurve = curve_type_special;
1057 ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1058 }
1059 else {
1060 ReleaseVelocityResponseCurve = curve_type_unknown;
1061 ReleaseVelocityResponseDepth = 0;
1062 }
1063 VelocityResponseCurveScaling = _3ewa->ReadUint8();
1064 AttenuationControllerThreshold = _3ewa->ReadInt8();
1065 _3ewa->ReadInt32(); // unknown
1066 SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
1067 _3ewa->ReadInt16(); // unknown
1068 uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();
1069 PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1070 if (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1071 else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1072 else DimensionBypass = dim_bypass_ctrl_none;
1073 uint8_t pan = _3ewa->ReadUint8();
1074 Pan = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
1075 SelfMask = _3ewa->ReadInt8() & 0x01;
1076 _3ewa->ReadInt8(); // unknown
1077 uint8_t lfo3ctrl = _3ewa->ReadUint8();
1078 LFO3Controller = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
1079 LFO3Sync = lfo3ctrl & 0x20; // bit 5
1080 InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
1081 AttenuationController = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1082 uint8_t lfo2ctrl = _3ewa->ReadUint8();
1083 LFO2Controller = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
1084 LFO2FlipPhase = lfo2ctrl & 0x80; // bit 7
1085 LFO2Sync = lfo2ctrl & 0x20; // bit 5
1086 bool extResonanceCtrl = lfo2ctrl & 0x40; // bit 6
1087 uint8_t lfo1ctrl = _3ewa->ReadUint8();
1088 LFO1Controller = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
1089 LFO1FlipPhase = lfo1ctrl & 0x80; // bit 7
1090 LFO1Sync = lfo1ctrl & 0x40; // bit 6
1091 VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1092 : vcf_res_ctrl_none;
1093 uint16_t eg3depth = _3ewa->ReadUint16();
1094 EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1095 : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */
1096 _3ewa->ReadInt16(); // unknown
1097 ChannelOffset = _3ewa->ReadUint8() / 4;
1098 uint8_t regoptions = _3ewa->ReadUint8();
1099 MSDecode = regoptions & 0x01; // bit 0
1100 SustainDefeat = regoptions & 0x02; // bit 1
1101 _3ewa->ReadInt16(); // unknown
1102 VelocityUpperLimit = _3ewa->ReadInt8();
1103 _3ewa->ReadInt8(); // unknown
1104 _3ewa->ReadInt16(); // unknown
1105 ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
1106 _3ewa->ReadInt8(); // unknown
1107 _3ewa->ReadInt8(); // unknown
1108 EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
1109 uint8_t vcfcutoff = _3ewa->ReadUint8();
1110 VCFEnabled = vcfcutoff & 0x80; // bit 7
1111 VCFCutoff = vcfcutoff & 0x7f; // lower 7 bits
1112 VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
1113 VCFVelocityScale = _3ewa->ReadUint8();
1114 _3ewa->ReadInt8(); // unknown
1115 uint8_t vcfresonance = _3ewa->ReadUint8();
1116 VCFResonance = vcfresonance & 0x7f; // lower 7 bits
1117 VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
1118 uint8_t vcfbreakpoint = _3ewa->ReadUint8();
1119 VCFKeyboardTracking = vcfbreakpoint & 0x80; // bit 7
1120 VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
1121 uint8_t vcfvelocity = _3ewa->ReadUint8();
1122 VCFVelocityDynamicRange = vcfvelocity % 5;
1123 VCFVelocityCurve = static_cast<curve_type_t>(vcfvelocity / 5);
1124 VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
1125 if (VCFType == vcf_type_lowpass) {
1126 if (lfo3ctrl & 0x40) // bit 6
1127 VCFType = vcf_type_lowpassturbo;
1128 }
1129
1130 // get the corresponding velocity->volume table from the table map or create & calculate that table if it doesn't exist yet
1131 uint32_t tableKey = (VelocityResponseCurve<<16) | (VelocityResponseDepth<<8) | VelocityResponseCurveScaling;
1132 if (pVelocityTables->count(tableKey)) { // if key exists
1133 pVelocityAttenuationTable = (*pVelocityTables)[tableKey];
1134 }
1135 else {
1136 pVelocityAttenuationTable =
1137 CreateVelocityTable(VelocityResponseCurve,
1138 VelocityResponseDepth,
1139 VelocityResponseCurveScaling);
1140 (*pVelocityTables)[tableKey] = pVelocityAttenuationTable; // put the new table into the tables map
1141 }
1142
1143 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1144 }
1145
1146 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
1147 leverage_ctrl_t decodedcontroller;
1148 switch (EncodedController) {
1149 // special controller
1150 case _lev_ctrl_none:
1151 decodedcontroller.type = leverage_ctrl_t::type_none;
1152 decodedcontroller.controller_number = 0;
1153 break;
1154 case _lev_ctrl_velocity:
1155 decodedcontroller.type = leverage_ctrl_t::type_velocity;
1156 decodedcontroller.controller_number = 0;
1157 break;
1158 case _lev_ctrl_channelaftertouch:
1159 decodedcontroller.type = leverage_ctrl_t::type_channelaftertouch;
1160 decodedcontroller.controller_number = 0;
1161 break;
1162
1163 // ordinary MIDI control change controller
1164 case _lev_ctrl_modwheel:
1165 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1166 decodedcontroller.controller_number = 1;
1167 break;
1168 case _lev_ctrl_breath:
1169 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1170 decodedcontroller.controller_number = 2;
1171 break;
1172 case _lev_ctrl_foot:
1173 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1174 decodedcontroller.controller_number = 4;
1175 break;
1176 case _lev_ctrl_effect1:
1177 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1178 decodedcontroller.controller_number = 12;
1179 break;
1180 case _lev_ctrl_effect2:
1181 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1182 decodedcontroller.controller_number = 13;
1183 break;
1184 case _lev_ctrl_genpurpose1:
1185 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1186 decodedcontroller.controller_number = 16;
1187 break;
1188 case _lev_ctrl_genpurpose2:
1189 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1190 decodedcontroller.controller_number = 17;
1191 break;
1192 case _lev_ctrl_genpurpose3:
1193 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1194 decodedcontroller.controller_number = 18;
1195 break;
1196 case _lev_ctrl_genpurpose4:
1197 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1198 decodedcontroller.controller_number = 19;
1199 break;
1200 case _lev_ctrl_portamentotime:
1201 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1202 decodedcontroller.controller_number = 5;
1203 break;
1204 case _lev_ctrl_sustainpedal:
1205 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1206 decodedcontroller.controller_number = 64;
1207 break;
1208 case _lev_ctrl_portamento:
1209 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1210 decodedcontroller.controller_number = 65;
1211 break;
1212 case _lev_ctrl_sostenutopedal:
1213 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1214 decodedcontroller.controller_number = 66;
1215 break;
1216 case _lev_ctrl_softpedal:
1217 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1218 decodedcontroller.controller_number = 67;
1219 break;
1220 case _lev_ctrl_genpurpose5:
1221 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1222 decodedcontroller.controller_number = 80;
1223 break;
1224 case _lev_ctrl_genpurpose6:
1225 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1226 decodedcontroller.controller_number = 81;
1227 break;
1228 case _lev_ctrl_genpurpose7:
1229 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1230 decodedcontroller.controller_number = 82;
1231 break;
1232 case _lev_ctrl_genpurpose8:
1233 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1234 decodedcontroller.controller_number = 83;
1235 break;
1236 case _lev_ctrl_effect1depth:
1237 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1238 decodedcontroller.controller_number = 91;
1239 break;
1240 case _lev_ctrl_effect2depth:
1241 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1242 decodedcontroller.controller_number = 92;
1243 break;
1244 case _lev_ctrl_effect3depth:
1245 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1246 decodedcontroller.controller_number = 93;
1247 break;
1248 case _lev_ctrl_effect4depth:
1249 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1250 decodedcontroller.controller_number = 94;
1251 break;
1252 case _lev_ctrl_effect5depth:
1253 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1254 decodedcontroller.controller_number = 95;
1255 break;
1256
1257 // unknown controller type
1258 default:
1259 throw gig::Exception("Unknown leverage controller type.");
1260 }
1261 return decodedcontroller;
1262 }
1263
1264 DimensionRegion::~DimensionRegion() {
1265 Instances--;
1266 if (!Instances) {
1267 // delete the velocity->volume tables
1268 VelocityTableMap::iterator iter;
1269 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
1270 double* pTable = iter->second;
1271 if (pTable) delete[] pTable;
1272 }
1273 pVelocityTables->clear();
1274 delete pVelocityTables;
1275 pVelocityTables = NULL;
1276 }
1277 }
1278
1279 /**
1280 * Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
1281 * All involved parameters (VelocityResponseCurve, VelocityResponseDepth
1282 * and VelocityResponseCurveScaling) involved are taken into account to
1283 * calculate the amplitude factor. Use this method when a key was
1284 * triggered to get the volume with which the sample should be played
1285 * back.
1286 *
1287 * @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
1288 * @returns amplitude factor (between 0.0 and 1.0)
1289 */
1290 double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
1291 return pVelocityAttenuationTable[MIDIKeyVelocity];
1292 }
1293
1294 double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
1295
1296 // line-segment approximations of the 15 velocity curves
1297
1298 // linear
1299 const int lin0[] = { 1, 1, 127, 127 };
1300 const int lin1[] = { 1, 21, 127, 127 };
1301 const int lin2[] = { 1, 45, 127, 127 };
1302 const int lin3[] = { 1, 74, 127, 127 };
1303 const int lin4[] = { 1, 127, 127, 127 };
1304
1305 // non-linear
1306 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
1307 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
1308 127, 127 };
1309 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
1310 127, 127 };
1311 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
1312 127, 127 };
1313 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
1314
1315 // special
1316 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
1317 113, 127, 127, 127 };
1318 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
1319 118, 127, 127, 127 };
1320 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
1321 85, 90, 91, 127, 127, 127 };
1322 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
1323 117, 127, 127, 127 };
1324 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
1325 127, 127 };
1326
1327 const int* const curves[] = { non0, non1, non2, non3, non4,
1328 lin0, lin1, lin2, lin3, lin4,
1329 spe0, spe1, spe2, spe3, spe4 };
1330
1331 double* const table = new double[128];
1332
1333 const int* curve = curves[curveType * 5 + depth];
1334 const int s = scaling == 0 ? 20 : scaling; // 0 or 20 means no scaling
1335
1336 table[0] = 0;
1337 for (int x = 1 ; x < 128 ; x++) {
1338
1339 if (x > curve[2]) curve += 2;
1340 double y = curve[1] + (x - curve[0]) *
1341 (double(curve[3] - curve[1]) / (curve[2] - curve[0]));
1342 y = y / 127;
1343
1344 // Scale up for s > 20, down for s < 20. When
1345 // down-scaling, the curve still ends at 1.0.
1346 if (s < 20 && y >= 0.5)
1347 y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
1348 else
1349 y = y * (s / 20.0);
1350 if (y > 1) y = 1;
1351
1352 table[x] = y;
1353 }
1354 return table;
1355 }
1356
1357
1358 // *************** Region ***************
1359 // *
1360
1361 Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {
1362 // Initialization
1363 Dimensions = 0;
1364 for (int i = 0; i < 256; i++) {
1365 pDimensionRegions[i] = NULL;
1366 }
1367 Layers = 1;
1368 File* file = (File*) GetParent()->GetParent();
1369 int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
1370
1371 // Actual Loading
1372
1373 LoadDimensionRegions(rgnList);
1374
1375 RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
1376 if (_3lnk) {
1377 DimensionRegions = _3lnk->ReadUint32();
1378 for (int i = 0; i < dimensionBits; i++) {
1379 dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
1380 uint8_t bits = _3lnk->ReadUint8();
1381 if (dimension == dimension_none) { // inactive dimension
1382 pDimensionDefinitions[i].dimension = dimension_none;
1383 pDimensionDefinitions[i].bits = 0;
1384 pDimensionDefinitions[i].zones = 0;
1385 pDimensionDefinitions[i].split_type = split_type_bit;
1386 pDimensionDefinitions[i].ranges = NULL;
1387 pDimensionDefinitions[i].zone_size = 0;
1388 }
1389 else { // active dimension
1390 pDimensionDefinitions[i].dimension = dimension;
1391 pDimensionDefinitions[i].bits = bits;
1392 pDimensionDefinitions[i].zones = 0x01 << bits; // = pow(2,bits)
1393 pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||
1394 dimension == dimension_samplechannel ||
1395 dimension == dimension_releasetrigger ||
1396 dimension == dimension_roundrobin ||
1397 dimension == dimension_random) ? split_type_bit
1398 : split_type_normal;
1399 pDimensionDefinitions[i].ranges = NULL; // it's not possible to check velocity dimensions for custom defined ranges at this point
1400 pDimensionDefinitions[i].zone_size =
1401 (pDimensionDefinitions[i].split_type == split_type_normal) ? 128 / pDimensionDefinitions[i].zones
1402 : 0;
1403 Dimensions++;
1404
1405 // if this is a layer dimension, remember the amount of layers
1406 if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
1407 }
1408 _3lnk->SetPos(6, RIFF::stream_curpos); // jump forward to next dimension definition
1409 }
1410
1411 // check velocity dimension (if there is one) for custom defined zone ranges
1412 for (uint i = 0; i < Dimensions; i++) {
1413 dimension_def_t* pDimDef = pDimensionDefinitions + i;
1414 if (pDimDef->dimension == dimension_velocity) {
1415 if (pDimensionRegions[0]->VelocityUpperLimit == 0) {
1416 // no custom defined ranges
1417 pDimDef->split_type = split_type_normal;
1418 pDimDef->ranges = NULL;
1419 }
1420 else { // custom defined ranges
1421 pDimDef->split_type = split_type_customvelocity;
1422 pDimDef->ranges = new range_t[pDimDef->zones];
1423 uint8_t bits[8] = { 0 };
1424 int previousUpperLimit = -1;
1425 for (int velocityZone = 0; velocityZone < pDimDef->zones; velocityZone++) {
1426 bits[i] = velocityZone;
1427 DimensionRegion* pDimRegion = GetDimensionRegionByBit(bits);
1428
1429 pDimDef->ranges[velocityZone].low = previousUpperLimit + 1;
1430 pDimDef->ranges[velocityZone].high = pDimRegion->VelocityUpperLimit;
1431 previousUpperLimit = pDimDef->ranges[velocityZone].high;
1432 // fill velocity table
1433 for (int i = pDimDef->ranges[velocityZone].low; i <= pDimDef->ranges[velocityZone].high; i++) {
1434 VelocityTable[i] = velocityZone;
1435 }
1436 }
1437 }
1438 }
1439 }
1440
1441 // jump to start of the wave pool indices (if not already there)
1442 File* file = (File*) GetParent()->GetParent();
1443 if (file->pVersion && file->pVersion->major == 3)
1444 _3lnk->SetPos(68); // version 3 has a different 3lnk structure
1445 else
1446 _3lnk->SetPos(44);
1447
1448 // load sample references
1449 for (uint i = 0; i < DimensionRegions; i++) {
1450 uint32_t wavepoolindex = _3lnk->ReadUint32();
1451 pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
1452 }
1453 }
1454 else throw gig::Exception("Mandatory <3lnk> chunk not found.");
1455 }
1456
1457 void Region::LoadDimensionRegions(RIFF::List* rgn) {
1458 RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);
1459 if (_3prg) {
1460 int dimensionRegionNr = 0;
1461 RIFF::List* _3ewl = _3prg->GetFirstSubList();
1462 while (_3ewl) {
1463 if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
1464 pDimensionRegions[dimensionRegionNr] = new DimensionRegion(_3ewl);
1465 dimensionRegionNr++;
1466 }
1467 _3ewl = _3prg->GetNextSubList();
1468 }
1469 if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");
1470 }
1471 }
1472
1473 Region::~Region() {
1474 for (uint i = 0; i < Dimensions; i++) {
1475 if (pDimensionDefinitions[i].ranges) delete[] pDimensionDefinitions[i].ranges;
1476 }
1477 for (int i = 0; i < 256; i++) {
1478 if (pDimensionRegions[i]) delete pDimensionRegions[i];
1479 }
1480 }
1481
1482 /**
1483 * Use this method in your audio engine to get the appropriate dimension
1484 * region with it's articulation data for the current situation. Just
1485 * call the method with the current MIDI controller values and you'll get
1486 * the DimensionRegion with the appropriate articulation data for the
1487 * current situation (for this Region of course only). To do that you'll
1488 * first have to look which dimensions with which controllers and in
1489 * which order are defined for this Region when you load the .gig file.
1490 * Special cases are e.g. layer or channel dimensions where you just put
1491 * in the index numbers instead of a MIDI controller value (means 0 for
1492 * left channel, 1 for right channel or 0 for layer 0, 1 for layer 1,
1493 * etc.).
1494 *
1495 * @param DimValues MIDI controller values (0-127) for dimension 0 to 7
1496 * @returns adress to the DimensionRegion for the given situation
1497 * @see pDimensionDefinitions
1498 * @see Dimensions
1499 */
1500 DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
1501 uint8_t bits[8] = { 0 };
1502 for (uint i = 0; i < Dimensions; i++) {
1503 bits[i] = DimValues[i];
1504 switch (pDimensionDefinitions[i].split_type) {
1505 case split_type_normal:
1506 bits[i] /= pDimensionDefinitions[i].zone_size;
1507 break;
1508 case split_type_customvelocity:
1509 bits[i] = VelocityTable[bits[i]];
1510 break;
1511 case split_type_bit: // the value is already the sought dimension bit number
1512 const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
1513 bits[i] = bits[i] & limiter_mask; // just make sure the value don't uses more bits than allowed
1514 break;
1515 }
1516 }
1517 return GetDimensionRegionByBit(bits);
1518 }
1519
1520 /**
1521 * Returns the appropriate DimensionRegion for the given dimension bit
1522 * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>
1523 * instead of calling this method directly!
1524 *
1525 * @param DimBits Bit numbers for dimension 0 to 7
1526 * @returns adress to the DimensionRegion for the given dimension
1527 * bit numbers
1528 * @see GetDimensionRegionByValue()
1529 */
1530 DimensionRegion* Region::GetDimensionRegionByBit(const uint8_t DimBits[8]) {
1531 return pDimensionRegions[((((((DimBits[7] << pDimensionDefinitions[6].bits | DimBits[6])
1532 << pDimensionDefinitions[5].bits | DimBits[5])
1533 << pDimensionDefinitions[4].bits | DimBits[4])
1534 << pDimensionDefinitions[3].bits | DimBits[3])
1535 << pDimensionDefinitions[2].bits | DimBits[2])
1536 << pDimensionDefinitions[1].bits | DimBits[1])
1537 << pDimensionDefinitions[0].bits | DimBits[0]];
1538 }
1539
1540 /**
1541 * Returns pointer address to the Sample referenced with this region.
1542 * This is the global Sample for the entire Region (not sure if this is
1543 * actually used by the Gigasampler engine - I would only use the Sample
1544 * referenced by the appropriate DimensionRegion instead of this sample).
1545 *
1546 * @returns address to Sample or NULL if there is no reference to a
1547 * sample saved in the .gig file
1548 */
1549 Sample* Region::GetSample() {
1550 if (pSample) return static_cast<gig::Sample*>(pSample);
1551 else return static_cast<gig::Sample*>(pSample = GetSampleFromWavePool(WavePoolTableIndex));
1552 }
1553
1554 Sample* Region::GetSampleFromWavePool(unsigned int WavePoolTableIndex) {
1555 if ((int32_t)WavePoolTableIndex == -1) return NULL;
1556 File* file = (File*) GetParent()->GetParent();
1557 unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
1558 Sample* sample = file->GetFirstSample();
1559 while (sample) {
1560 if (sample->ulWavePoolOffset == soughtoffset) return static_cast<gig::Sample*>(pSample = sample);
1561 sample = file->GetNextSample();
1562 }
1563 return NULL;
1564 }
1565
1566
1567
1568 // *************** Instrument ***************
1569 // *
1570
1571 Instrument::Instrument(File* pFile, RIFF::List* insList) : DLS::Instrument((DLS::File*)pFile, insList) {
1572 // Initialization
1573 for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
1574 RegionIndex = -1;
1575
1576 // Loading
1577 RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
1578 if (lart) {
1579 RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
1580 if (_3ewg) {
1581 EffectSend = _3ewg->ReadUint16();
1582 Attenuation = _3ewg->ReadInt32();
1583 FineTune = _3ewg->ReadInt16();
1584 PitchbendRange = _3ewg->ReadInt16();
1585 uint8_t dimkeystart = _3ewg->ReadUint8();
1586 PianoReleaseMode = dimkeystart & 0x01;
1587 DimensionKeyRange.low = dimkeystart >> 1;
1588 DimensionKeyRange.high = _3ewg->ReadUint8();
1589 }
1590 else throw gig::Exception("Mandatory <3ewg> chunk not found.");
1591 }
1592 else throw gig::Exception("Mandatory <lart> list chunk not found.");
1593
1594 RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
1595 if (!lrgn) throw gig::Exception("Mandatory chunks in <ins > chunk not found.");
1596 pRegions = new Region*[Regions];
1597 for (uint i = 0; i < Regions; i++) pRegions[i] = NULL;
1598 RIFF::List* rgn = lrgn->GetFirstSubList();
1599 unsigned int iRegion = 0;
1600 while (rgn) {
1601 if (rgn->GetListType() == LIST_TYPE_RGN) {
1602 pRegions[iRegion] = new Region(this, rgn);
1603 iRegion++;
1604 }
1605 rgn = lrgn->GetNextSubList();
1606 }
1607
1608 // Creating Region Key Table for fast lookup
1609 for (uint iReg = 0; iReg < Regions; iReg++) {
1610 for (int iKey = pRegions[iReg]->KeyRange.low; iKey <= pRegions[iReg]->KeyRange.high; iKey++) {
1611 RegionKeyTable[iKey] = pRegions[iReg];
1612 }
1613 }
1614 }
1615
1616 Instrument::~Instrument() {
1617 for (uint i = 0; i < Regions; i++) {
1618 if (pRegions) {
1619 if (pRegions[i]) delete (pRegions[i]);
1620 }
1621 }
1622 if (pRegions) delete[] pRegions;
1623 }
1624
1625 /**
1626 * Returns the appropriate Region for a triggered note.
1627 *
1628 * @param Key MIDI Key number of triggered note / key (0 - 127)
1629 * @returns pointer adress to the appropriate Region or NULL if there
1630 * there is no Region defined for the given \a Key
1631 */
1632 Region* Instrument::GetRegion(unsigned int Key) {
1633 if (!pRegions || Key > 127) return NULL;
1634 return RegionKeyTable[Key];
1635 /*for (int i = 0; i < Regions; i++) {
1636 if (Key <= pRegions[i]->KeyRange.high &&
1637 Key >= pRegions[i]->KeyRange.low) return pRegions[i];
1638 }
1639 return NULL;*/
1640 }
1641
1642 /**
1643 * Returns the first Region of the instrument. You have to call this
1644 * method once before you use GetNextRegion().
1645 *
1646 * @returns pointer address to first region or NULL if there is none
1647 * @see GetNextRegion()
1648 */
1649 Region* Instrument::GetFirstRegion() {
1650 if (!Regions) return NULL;
1651 RegionIndex = 1;
1652 return pRegions[0];
1653 }
1654
1655 /**
1656 * Returns the next Region of the instrument. You have to call
1657 * GetFirstRegion() once before you can use this method. By calling this
1658 * method multiple times it iterates through the available Regions.
1659 *
1660 * @returns pointer address to the next region or NULL if end reached
1661 * @see GetFirstRegion()
1662 */
1663 Region* Instrument::GetNextRegion() {
1664 if (RegionIndex < 0 || uint32_t(RegionIndex) >= Regions) return NULL;
1665 return pRegions[RegionIndex++];
1666 }
1667
1668
1669
1670 // *************** File ***************
1671 // *
1672
1673 File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
1674 pSamples = NULL;
1675 pInstruments = NULL;
1676 }
1677
1678 File::~File() {
1679 // free samples
1680 if (pSamples) {
1681 SamplesIterator = pSamples->begin();
1682 while (SamplesIterator != pSamples->end() ) {
1683 delete (*SamplesIterator);
1684 SamplesIterator++;
1685 }
1686 pSamples->clear();
1687 delete pSamples;
1688
1689 }
1690 // free instruments
1691 if (pInstruments) {
1692 InstrumentsIterator = pInstruments->begin();
1693 while (InstrumentsIterator != pInstruments->end() ) {
1694 delete (*InstrumentsIterator);
1695 InstrumentsIterator++;
1696 }
1697 pInstruments->clear();
1698 delete pInstruments;
1699 }
1700 }
1701
1702 Sample* File::GetFirstSample() {
1703 if (!pSamples) LoadSamples();
1704 if (!pSamples) return NULL;
1705 SamplesIterator = pSamples->begin();
1706 return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
1707 }
1708
1709 Sample* File::GetNextSample() {
1710 if (!pSamples) return NULL;
1711 SamplesIterator++;
1712 return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
1713 }
1714
1715 void File::LoadSamples() {
1716 RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
1717 if (wvpl) {
1718 unsigned long wvplFileOffset = wvpl->GetFilePos();
1719 RIFF::List* wave = wvpl->GetFirstSubList();
1720 while (wave) {
1721 if (wave->GetListType() == LIST_TYPE_WAVE) {
1722 if (!pSamples) pSamples = new SampleList;
1723 unsigned long waveFileOffset = wave->GetFilePos();
1724 pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset));
1725 }
1726 wave = wvpl->GetNextSubList();
1727 }
1728 }
1729 else throw gig::Exception("Mandatory <wvpl> chunk not found.");
1730 }
1731
1732 Instrument* File::GetFirstInstrument() {
1733 if (!pInstruments) LoadInstruments();
1734 if (!pInstruments) return NULL;
1735 InstrumentsIterator = pInstruments->begin();
1736 return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;
1737 }
1738
1739 Instrument* File::GetNextInstrument() {
1740 if (!pInstruments) return NULL;
1741 InstrumentsIterator++;
1742 return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;
1743 }
1744
1745 /**
1746 * Returns the instrument with the given index.
1747 *
1748 * @returns sought instrument or NULL if there's no such instrument
1749 */
1750 Instrument* File::GetInstrument(uint index) {
1751 if (!pInstruments) LoadInstruments();
1752 if (!pInstruments) return NULL;
1753 InstrumentsIterator = pInstruments->begin();
1754 for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {
1755 if (i == index) return *InstrumentsIterator;
1756 InstrumentsIterator++;
1757 }
1758 return NULL;
1759 }
1760
1761 void File::LoadInstruments() {
1762 RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
1763 if (lstInstruments) {
1764 RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
1765 while (lstInstr) {
1766 if (lstInstr->GetListType() == LIST_TYPE_INS) {
1767 if (!pInstruments) pInstruments = new InstrumentList;
1768 pInstruments->push_back(new Instrument(this, lstInstr));
1769 }
1770 lstInstr = lstInstruments->GetNextSubList();
1771 }
1772 }
1773 else throw gig::Exception("Mandatory <lins> list chunk not found.");
1774 }
1775
1776
1777
1778 // *************** Exception ***************
1779 // *
1780
1781 Exception::Exception(String Message) : DLS::Exception(Message) {
1782 }
1783
1784 void Exception::PrintMessage() {
1785 std::cout << "gig::Exception: " << Message << std::endl;
1786 }
1787
1788 } // namespace gig

  ViewVC Help
Powered by ViewVC