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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 352 - (hide annotations) (download)
Sat Jan 29 14:24:11 2005 UTC (14 years, 9 months ago) by schoenebeck
File size: 72985 byte(s)
* src/gig.cpp: fixed crash on patches which did not have a sample assigned
  to their region(s) or dimension region(s) (patch by Andreas Persson)

1 schoenebeck 2 /***************************************************************************
2     * *
3     * libgig - C++ cross-platform Gigasampler format file loader library *
4     * *
5 schoenebeck 55 * Copyright (C) 2003, 2004 by Christian Schoenebeck *
6     * <cuse@users.sourceforge.net> *
7 schoenebeck 2 * *
8     * This library is free software; you can redistribute it and/or modify *
9     * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13     * This library is distributed in the hope that it will be useful, *
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19     * along with this library; if not, write to the Free Software *
20     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #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 schoenebeck 21 FineTune = smpl->ReadInt32();
49 schoenebeck 2 smpl->Read(&SMPTEFormat, 1, 4);
50     SMPTEOffset = smpl->ReadInt32();
51     Loops = smpl->ReadInt32();
52 schoenebeck 21 uint32_t manufByt = smpl->ReadInt32();
53 schoenebeck 2 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 schoenebeck 317
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 schoenebeck 2 FrameOffset = 0; // just for streaming compressed samples
81 schoenebeck 21
82 schoenebeck 27 LoopSize = LoopEnd - LoopStart;
83 schoenebeck 2 }
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 schoenebeck 24 * 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 schoenebeck 2 * 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 schoenebeck 21 if (SampleCount == 0) return 0;
511 schoenebeck 317 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 schoenebeck 2 else { //FIXME: no support for mono compressed samples yet, are there any?
528 schoenebeck 11 if (this->SamplePos >= this->SamplesTotal) return 0;
529 schoenebeck 2 //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 schoenebeck 11 this->SamplePos = this->SamplesTotal;
558 schoenebeck 2 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 schoenebeck 11 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
678 schoenebeck 2 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 schoenebeck 16 uint DimensionRegion::Instances = 0;
695     DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
696    
697 schoenebeck 2 DimensionRegion::DimensionRegion(RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
698 schoenebeck 16 Instances++;
699    
700 schoenebeck 2 memcpy(&Crossfade, &SamplerOptions, 4);
701 schoenebeck 16 if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
702 schoenebeck 2
703     RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
704 schoenebeck 241 _3ewa->ReadInt32(); // unknown, always 0x0000008C ?
705 schoenebeck 2 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 schoenebeck 36 EG1Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
721 schoenebeck 2 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 schoenebeck 36 EG2Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
727 schoenebeck 2 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 schoenebeck 36 AttenuationControllerThreshold = _3ewa->ReadInt8();
789 schoenebeck 2 _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 schoenebeck 269 Pan = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
799 schoenebeck 2 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 schoenebeck 36 InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
805     AttenuationController = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
806 schoenebeck 2 uint8_t lfo2ctrl = _3ewa->ReadUint8();
807     LFO2Controller = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
808     LFO2FlipPhase = lfo2ctrl & 0x80; // bit 7
809     LFO2Sync = lfo2ctrl & 0x20; // bit 5
810     bool extResonanceCtrl = lfo2ctrl & 0x40; // bit 6
811     uint8_t lfo1ctrl = _3ewa->ReadUint8();
812     LFO1Controller = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
813     LFO1FlipPhase = lfo1ctrl & 0x80; // bit 7
814     LFO1Sync = lfo1ctrl & 0x40; // bit 6
815     VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
816     : vcf_res_ctrl_none;
817     uint16_t eg3depth = _3ewa->ReadUint16();
818     EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
819     : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */
820     _3ewa->ReadInt16(); // unknown
821     ChannelOffset = _3ewa->ReadUint8() / 4;
822     uint8_t regoptions = _3ewa->ReadUint8();
823     MSDecode = regoptions & 0x01; // bit 0
824     SustainDefeat = regoptions & 0x02; // bit 1
825     _3ewa->ReadInt16(); // unknown
826     VelocityUpperLimit = _3ewa->ReadInt8();
827     _3ewa->ReadInt8(); // unknown
828     _3ewa->ReadInt16(); // unknown
829     ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
830     _3ewa->ReadInt8(); // unknown
831     _3ewa->ReadInt8(); // unknown
832     EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
833     uint8_t vcfcutoff = _3ewa->ReadUint8();
834     VCFEnabled = vcfcutoff & 0x80; // bit 7
835     VCFCutoff = vcfcutoff & 0x7f; // lower 7 bits
836     VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
837     VCFVelocityScale = _3ewa->ReadUint8();
838     _3ewa->ReadInt8(); // unknown
839     uint8_t vcfresonance = _3ewa->ReadUint8();
840     VCFResonance = vcfresonance & 0x7f; // lower 7 bits
841     VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
842     uint8_t vcfbreakpoint = _3ewa->ReadUint8();
843     VCFKeyboardTracking = vcfbreakpoint & 0x80; // bit 7
844     VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
845     uint8_t vcfvelocity = _3ewa->ReadUint8();
846     VCFVelocityDynamicRange = vcfvelocity % 5;
847     VCFVelocityCurve = static_cast<curve_type_t>(vcfvelocity / 5);
848     VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
849 schoenebeck 345 if (VCFType == vcf_type_lowpass) {
850     if (lfo3ctrl & 0x40) // bit 6
851     VCFType = vcf_type_lowpassturbo;
852     }
853 schoenebeck 16
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 schoenebeck 317 pVelocityAttenuationTable =
861 schoenebeck 308 CreateVelocityTable(VelocityResponseCurve,
862     VelocityResponseDepth,
863     VelocityResponseCurveScaling);
864 schoenebeck 16 (*pVelocityTables)[tableKey] = pVelocityAttenuationTable; // put the new table into the tables map
865     }
866 schoenebeck 2 }
867 schoenebeck 55
868 schoenebeck 36 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 schoenebeck 55
885 schoenebeck 36 // 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 schoenebeck 55
979 schoenebeck 36 // unknown controller type
980     default:
981     throw gig::Exception("Unknown leverage controller type.");
982     }
983     return decodedcontroller;
984     }
985 schoenebeck 2
986 schoenebeck 16 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 schoenebeck 2
1001 schoenebeck 16 /**
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 schoenebeck 36 * @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
1010     * @returns amplitude factor (between 0.0 and 1.0)
1011 schoenebeck 16 */
1012     double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
1013     return pVelocityAttenuationTable[MIDIKeyVelocity];
1014     }
1015 schoenebeck 2
1016 schoenebeck 308 double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
1017 schoenebeck 317
1018 schoenebeck 308 // line-segment approximations of the 15 velocity curves
1019 schoenebeck 16
1020 schoenebeck 308 // 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 schoenebeck 16
1027 schoenebeck 308 // non-linear
1028     const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
1029 schoenebeck 317 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
1030 schoenebeck 308 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 schoenebeck 317
1037 schoenebeck 308 // special
1038 schoenebeck 317 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
1039 schoenebeck 308 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 schoenebeck 317 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
1043 schoenebeck 308 85, 90, 91, 127, 127, 127 };
1044 schoenebeck 317 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
1045 schoenebeck 308 117, 127, 127, 127 };
1046 schoenebeck 317 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
1047 schoenebeck 308 127, 127 };
1048 schoenebeck 317
1049 schoenebeck 308 const int* const curves[] = { non0, non1, non2, non3, non4,
1050 schoenebeck 317 lin0, lin1, lin2, lin3, lin4,
1051 schoenebeck 308 spe0, spe1, spe2, spe3, spe4 };
1052 schoenebeck 317
1053 schoenebeck 308 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 schoenebeck 317
1058 schoenebeck 308 table[0] = 0;
1059     for (int x = 1 ; x < 128 ; x++) {
1060    
1061     if (x > curve[2]) curve += 2;
1062 schoenebeck 317 double y = curve[1] + (x - curve[0]) *
1063 schoenebeck 308 (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 schoenebeck 2 // *************** Region ***************
1081     // *
1082    
1083     Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {
1084     // Initialization
1085     Dimensions = 0;
1086 schoenebeck 347 for (int i = 0; i < 256; i++) {
1087 schoenebeck 2 pDimensionRegions[i] = NULL;
1088     }
1089 schoenebeck 282 Layers = 1;
1090 schoenebeck 347 File* file = (File*) GetParent()->GetParent();
1091     int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
1092 schoenebeck 2
1093     // Actual Loading
1094    
1095     LoadDimensionRegions(rgnList);
1096    
1097     RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
1098     if (_3lnk) {
1099     DimensionRegions = _3lnk->ReadUint32();
1100 schoenebeck 347 for (int i = 0; i < dimensionBits; i++) {
1101 schoenebeck 2 dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
1102     uint8_t bits = _3lnk->ReadUint8();
1103     if (dimension == dimension_none) { // inactive dimension
1104     pDimensionDefinitions[i].dimension = dimension_none;
1105     pDimensionDefinitions[i].bits = 0;
1106     pDimensionDefinitions[i].zones = 0;
1107     pDimensionDefinitions[i].split_type = split_type_bit;
1108     pDimensionDefinitions[i].ranges = NULL;
1109     pDimensionDefinitions[i].zone_size = 0;
1110     }
1111     else { // active dimension
1112     pDimensionDefinitions[i].dimension = dimension;
1113     pDimensionDefinitions[i].bits = bits;
1114     pDimensionDefinitions[i].zones = 0x01 << bits; // = pow(2,bits)
1115     pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||
1116 schoenebeck 241 dimension == dimension_samplechannel ||
1117     dimension == dimension_releasetrigger) ? split_type_bit
1118     : split_type_normal;
1119 schoenebeck 2 pDimensionDefinitions[i].ranges = NULL; // it's not possible to check velocity dimensions for custom defined ranges at this point
1120     pDimensionDefinitions[i].zone_size =
1121     (pDimensionDefinitions[i].split_type == split_type_normal) ? 128 / pDimensionDefinitions[i].zones
1122     : 0;
1123     Dimensions++;
1124 schoenebeck 282
1125     // if this is a layer dimension, remember the amount of layers
1126     if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
1127 schoenebeck 2 }
1128     _3lnk->SetPos(6, RIFF::stream_curpos); // jump forward to next dimension definition
1129     }
1130    
1131     // check velocity dimension (if there is one) for custom defined zone ranges
1132     for (uint i = 0; i < Dimensions; i++) {
1133     dimension_def_t* pDimDef = pDimensionDefinitions + i;
1134     if (pDimDef->dimension == dimension_velocity) {
1135     if (pDimensionRegions[0]->VelocityUpperLimit == 0) {
1136     // no custom defined ranges
1137     pDimDef->split_type = split_type_normal;
1138     pDimDef->ranges = NULL;
1139     }
1140     else { // custom defined ranges
1141     pDimDef->split_type = split_type_customvelocity;
1142     pDimDef->ranges = new range_t[pDimDef->zones];
1143 schoenebeck 347 uint8_t bits[8] = { 0 };
1144 schoenebeck 2 int previousUpperLimit = -1;
1145     for (int velocityZone = 0; velocityZone < pDimDef->zones; velocityZone++) {
1146     bits[i] = velocityZone;
1147 schoenebeck 347 DimensionRegion* pDimRegion = GetDimensionRegionByBit(bits);
1148 schoenebeck 2
1149     pDimDef->ranges[velocityZone].low = previousUpperLimit + 1;
1150     pDimDef->ranges[velocityZone].high = pDimRegion->VelocityUpperLimit;
1151     previousUpperLimit = pDimDef->ranges[velocityZone].high;
1152     // fill velocity table
1153     for (int i = pDimDef->ranges[velocityZone].low; i <= pDimDef->ranges[velocityZone].high; i++) {
1154     VelocityTable[i] = velocityZone;
1155     }
1156     }
1157     }
1158     }
1159     }
1160    
1161 schoenebeck 317 // jump to start of the wave pool indices (if not already there)
1162     File* file = (File*) GetParent()->GetParent();
1163     if (file->pVersion && file->pVersion->major == 3)
1164     _3lnk->SetPos(68); // version 3 has a different 3lnk structure
1165     else
1166     _3lnk->SetPos(44);
1167    
1168 schoenebeck 2 // load sample references
1169     for (uint i = 0; i < DimensionRegions; i++) {
1170     uint32_t wavepoolindex = _3lnk->ReadUint32();
1171     pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
1172     }
1173     }
1174     else throw gig::Exception("Mandatory <3lnk> chunk not found.");
1175     }
1176    
1177     void Region::LoadDimensionRegions(RIFF::List* rgn) {
1178     RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);
1179     if (_3prg) {
1180     int dimensionRegionNr = 0;
1181     RIFF::List* _3ewl = _3prg->GetFirstSubList();
1182     while (_3ewl) {
1183     if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
1184     pDimensionRegions[dimensionRegionNr] = new DimensionRegion(_3ewl);
1185     dimensionRegionNr++;
1186     }
1187     _3ewl = _3prg->GetNextSubList();
1188     }
1189     if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");
1190     }
1191     }
1192    
1193     Region::~Region() {
1194     for (uint i = 0; i < Dimensions; i++) {
1195     if (pDimensionDefinitions[i].ranges) delete[] pDimensionDefinitions[i].ranges;
1196     }
1197 schoenebeck 350 for (int i = 0; i < 256; i++) {
1198 schoenebeck 2 if (pDimensionRegions[i]) delete pDimensionRegions[i];
1199     }
1200     }
1201    
1202     /**
1203     * Use this method in your audio engine to get the appropriate dimension
1204     * region with it's articulation data for the current situation. Just
1205     * call the method with the current MIDI controller values and you'll get
1206     * the DimensionRegion with the appropriate articulation data for the
1207     * current situation (for this Region of course only). To do that you'll
1208     * first have to look which dimensions with which controllers and in
1209     * which order are defined for this Region when you load the .gig file.
1210     * Special cases are e.g. layer or channel dimensions where you just put
1211     * in the index numbers instead of a MIDI controller value (means 0 for
1212     * left channel, 1 for right channel or 0 for layer 0, 1 for layer 1,
1213     * etc.).
1214     *
1215 schoenebeck 347 * @param DimValues MIDI controller values (0-127) for dimension 0 to 7
1216 schoenebeck 2 * @returns adress to the DimensionRegion for the given situation
1217     * @see pDimensionDefinitions
1218     * @see Dimensions
1219     */
1220 schoenebeck 347 DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
1221     uint8_t bits[8] = { 0 };
1222 schoenebeck 2 for (uint i = 0; i < Dimensions; i++) {
1223 schoenebeck 347 bits[i] = DimValues[i];
1224 schoenebeck 2 switch (pDimensionDefinitions[i].split_type) {
1225     case split_type_normal:
1226     bits[i] /= pDimensionDefinitions[i].zone_size;
1227     break;
1228     case split_type_customvelocity:
1229     bits[i] = VelocityTable[bits[i]];
1230     break;
1231 schoenebeck 241 case split_type_bit: // the value is already the sought dimension bit number
1232     const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
1233     bits[i] = bits[i] & limiter_mask; // just make sure the value don't uses more bits than allowed
1234     break;
1235 schoenebeck 2 }
1236     }
1237 schoenebeck 347 return GetDimensionRegionByBit(bits);
1238 schoenebeck 2 }
1239    
1240     /**
1241     * Returns the appropriate DimensionRegion for the given dimension bit
1242     * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>
1243     * instead of calling this method directly!
1244     *
1245 schoenebeck 347 * @param DimBits Bit numbers for dimension 0 to 7
1246 schoenebeck 2 * @returns adress to the DimensionRegion for the given dimension
1247     * bit numbers
1248     * @see GetDimensionRegionByValue()
1249     */
1250 schoenebeck 347 DimensionRegion* Region::GetDimensionRegionByBit(const uint8_t DimBits[8]) {
1251     return pDimensionRegions[((((((DimBits[7] << pDimensionDefinitions[6].bits | DimBits[6])
1252     << pDimensionDefinitions[5].bits | DimBits[5])
1253     << pDimensionDefinitions[4].bits | DimBits[4])
1254     << pDimensionDefinitions[3].bits | DimBits[3])
1255     << pDimensionDefinitions[2].bits | DimBits[2])
1256     << pDimensionDefinitions[1].bits | DimBits[1])
1257     << pDimensionDefinitions[0].bits | DimBits[0]];
1258 schoenebeck 2 }
1259    
1260     /**
1261     * Returns pointer address to the Sample referenced with this region.
1262     * This is the global Sample for the entire Region (not sure if this is
1263     * actually used by the Gigasampler engine - I would only use the Sample
1264     * referenced by the appropriate DimensionRegion instead of this sample).
1265     *
1266     * @returns address to Sample or NULL if there is no reference to a
1267     * sample saved in the .gig file
1268     */
1269     Sample* Region::GetSample() {
1270     if (pSample) return static_cast<gig::Sample*>(pSample);
1271     else return static_cast<gig::Sample*>(pSample = GetSampleFromWavePool(WavePoolTableIndex));
1272     }
1273    
1274     Sample* Region::GetSampleFromWavePool(unsigned int WavePoolTableIndex) {
1275 schoenebeck 352 if ((int32_t)WavePoolTableIndex == -1) return NULL;
1276 schoenebeck 2 File* file = (File*) GetParent()->GetParent();
1277     unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
1278     Sample* sample = file->GetFirstSample();
1279     while (sample) {
1280     if (sample->ulWavePoolOffset == soughtoffset) return static_cast<gig::Sample*>(pSample = sample);
1281     sample = file->GetNextSample();
1282     }
1283     return NULL;
1284     }
1285    
1286    
1287    
1288     // *************** Instrument ***************
1289     // *
1290    
1291     Instrument::Instrument(File* pFile, RIFF::List* insList) : DLS::Instrument((DLS::File*)pFile, insList) {
1292     // Initialization
1293     for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
1294     RegionIndex = -1;
1295    
1296     // Loading
1297     RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
1298     if (lart) {
1299     RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
1300     if (_3ewg) {
1301     EffectSend = _3ewg->ReadUint16();
1302     Attenuation = _3ewg->ReadInt32();
1303     FineTune = _3ewg->ReadInt16();
1304     PitchbendRange = _3ewg->ReadInt16();
1305     uint8_t dimkeystart = _3ewg->ReadUint8();
1306     PianoReleaseMode = dimkeystart & 0x01;
1307     DimensionKeyRange.low = dimkeystart >> 1;
1308     DimensionKeyRange.high = _3ewg->ReadUint8();
1309     }
1310     else throw gig::Exception("Mandatory <3ewg> chunk not found.");
1311     }
1312     else throw gig::Exception("Mandatory <lart> list chunk not found.");
1313    
1314     RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
1315     if (!lrgn) throw gig::Exception("Mandatory chunks in <ins > chunk not found.");
1316     pRegions = new Region*[Regions];
1317 schoenebeck 350 for (uint i = 0; i < Regions; i++) pRegions[i] = NULL;
1318 schoenebeck 2 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     }
1342 schoenebeck 350 if (pRegions) delete[] pRegions;
1343 schoenebeck 2 }
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 schoenebeck 350 File::~File() {
1399     // free samples
1400     if (pSamples) {
1401     SamplesIterator = pSamples->begin();
1402     while (SamplesIterator != pSamples->end() ) {
1403     delete (*SamplesIterator);
1404     SamplesIterator++;
1405     }
1406     pSamples->clear();
1407    
1408     }
1409     // free instruments
1410     if (pInstruments) {
1411     InstrumentsIterator = pInstruments->begin();
1412     while (InstrumentsIterator != pInstruments->end() ) {
1413     delete (*InstrumentsIterator);
1414     InstrumentsIterator++;
1415     }
1416     pInstruments->clear();
1417     }
1418     }
1419    
1420 schoenebeck 2 Sample* File::GetFirstSample() {
1421     if (!pSamples) LoadSamples();
1422     if (!pSamples) return NULL;
1423     SamplesIterator = pSamples->begin();
1424     return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
1425     }
1426    
1427     Sample* File::GetNextSample() {
1428     if (!pSamples) return NULL;
1429     SamplesIterator++;
1430     return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
1431     }
1432    
1433     void File::LoadSamples() {
1434     RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
1435     if (wvpl) {
1436     unsigned long wvplFileOffset = wvpl->GetFilePos();
1437     RIFF::List* wave = wvpl->GetFirstSubList();
1438     while (wave) {
1439     if (wave->GetListType() == LIST_TYPE_WAVE) {
1440     if (!pSamples) pSamples = new SampleList;
1441     unsigned long waveFileOffset = wave->GetFilePos();
1442     pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset));
1443     }
1444     wave = wvpl->GetNextSubList();
1445     }
1446     }
1447     else throw gig::Exception("Mandatory <wvpl> chunk not found.");
1448     }
1449    
1450     Instrument* File::GetFirstInstrument() {
1451     if (!pInstruments) LoadInstruments();
1452     if (!pInstruments) return NULL;
1453     InstrumentsIterator = pInstruments->begin();
1454     return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;
1455     }
1456    
1457     Instrument* File::GetNextInstrument() {
1458     if (!pInstruments) return NULL;
1459     InstrumentsIterator++;
1460     return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;
1461     }
1462    
1463 schoenebeck 21 /**
1464     * Returns the instrument with the given index.
1465     *
1466     * @returns sought instrument or NULL if there's no such instrument
1467     */
1468     Instrument* File::GetInstrument(uint index) {
1469     if (!pInstruments) LoadInstruments();
1470     if (!pInstruments) return NULL;
1471     InstrumentsIterator = pInstruments->begin();
1472     for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {
1473     if (i == index) return *InstrumentsIterator;
1474     InstrumentsIterator++;
1475     }
1476     return NULL;
1477     }
1478    
1479 schoenebeck 2 void File::LoadInstruments() {
1480     RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
1481     if (lstInstruments) {
1482     RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
1483     while (lstInstr) {
1484     if (lstInstr->GetListType() == LIST_TYPE_INS) {
1485     if (!pInstruments) pInstruments = new InstrumentList;
1486     pInstruments->push_back(new Instrument(this, lstInstr));
1487     }
1488     lstInstr = lstInstruments->GetNextSubList();
1489     }
1490     }
1491     else throw gig::Exception("Mandatory <lins> list chunk not found.");
1492     }
1493    
1494    
1495    
1496     // *************** Exception ***************
1497     // *
1498    
1499     Exception::Exception(String Message) : DLS::Exception(Message) {
1500     }
1501    
1502     void Exception::PrintMessage() {
1503     std::cout << "gig::Exception: " << Message << std::endl;
1504     }
1505    
1506     } // namespace gig

  ViewVC Help
Powered by ViewVC