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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 317 - (show annotations) (download)
Sat Dec 4 14:13:49 2004 UTC (15 years, 7 months ago) by schoenebeck
File size: 72425 byte(s)
* src/DLS.cpp, src/gig.cpp: experimental support for Gigasampler v3 format;
  64 bit file offsets are truncated to 32 bit, 24 bit samples are truncated
  to 16 bit and additional articulation informations are ignored at the
  moment, added some file format compatibility checks
  (patch by Andreas Persson)

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

  ViewVC Help
Powered by ViewVC