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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 schoenebeck 2 /***************************************************************************
2     * *
3 schoenebeck 933 * libgig - C++ cross-platform Gigasampler format file access library *
4 schoenebeck 2 * *
5 schoenebeck 1050 * Copyright (C) 2003-2007 by Christian Schoenebeck *
6 schoenebeck 384 * <cuse@users.sourceforge.net> *
7 schoenebeck 2 * *
8     * This library is free software; you can redistribute it and/or modify *
9     * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13     * This library is distributed in the hope that it will be useful, *
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19     * along with this library; if not, write to the Free Software *
20     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #include "gig.h"
25    
26 schoenebeck 809 #include "helper.h"
27    
28     #include <math.h>
29 schoenebeck 384 #include <iostream>
30    
31 schoenebeck 809 /// Initial size of the sample buffer which is used for decompression of
32     /// compressed sample wave streams - this value should always be bigger than
33     /// the biggest sample piece expected to be read by the sampler engine,
34     /// otherwise the buffer size will be raised at runtime and thus the buffer
35     /// reallocated which is time consuming and unefficient.
36     #define INITIAL_SAMPLE_BUFFER_SIZE 512000 // 512 kB
37    
38     /** (so far) every exponential paramater in the gig format has a basis of 1.000000008813822 */
39     #define GIG_EXP_DECODE(x) (pow(1.000000008813822, x))
40     #define GIG_EXP_ENCODE(x) (log(x) / log(1.000000008813822))
41     #define GIG_PITCH_TRACK_EXTRACT(x) (!(x & 0x01))
42     #define GIG_PITCH_TRACK_ENCODE(x) ((x) ? 0x00 : 0x01)
43     #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x) ((x >> 4) & 0x03)
44     #define GIG_VCF_RESONANCE_CTRL_ENCODE(x) ((x & 0x03) << 4)
45     #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x) ((x >> 1) & 0x03)
46     #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x) ((x >> 3) & 0x03)
47     #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x) ((x >> 5) & 0x03)
48     #define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x) ((x & 0x03) << 1)
49     #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x) ((x & 0x03) << 3)
50     #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x) ((x & 0x03) << 5)
51    
52 schoenebeck 515 namespace gig {
53 schoenebeck 2
54 schoenebeck 515 // *************** progress_t ***************
55     // *
56    
57     progress_t::progress_t() {
58     callback = NULL;
59 schoenebeck 516 custom = NULL;
60 schoenebeck 515 __range_min = 0.0f;
61     __range_max = 1.0f;
62     }
63    
64     // private helper function to convert progress of a subprocess into the global progress
65     static void __notify_progress(progress_t* pProgress, float subprogress) {
66     if (pProgress && pProgress->callback) {
67     const float totalrange = pProgress->__range_max - pProgress->__range_min;
68     const float totalprogress = pProgress->__range_min + subprogress * totalrange;
69 schoenebeck 516 pProgress->factor = totalprogress;
70     pProgress->callback(pProgress); // now actually notify about the progress
71 schoenebeck 515 }
72     }
73    
74     // private helper function to divide a progress into subprogresses
75     static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress, float totalTasks, float currentTask) {
76     if (pParentProgress && pParentProgress->callback) {
77     const float totalrange = pParentProgress->__range_max - pParentProgress->__range_min;
78     pSubProgress->callback = pParentProgress->callback;
79 schoenebeck 516 pSubProgress->custom = pParentProgress->custom;
80 schoenebeck 515 pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;
81     pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;
82     }
83     }
84    
85    
86 schoenebeck 809 // *************** Internal functions for sample decompression ***************
87 persson 365 // *
88    
89 schoenebeck 515 namespace {
90    
91 persson 365 inline int get12lo(const unsigned char* pSrc)
92     {
93     const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
94     return x & 0x800 ? x - 0x1000 : x;
95     }
96    
97     inline int get12hi(const unsigned char* pSrc)
98     {
99     const int x = pSrc[1] >> 4 | pSrc[2] << 4;
100     return x & 0x800 ? x - 0x1000 : x;
101     }
102    
103     inline int16_t get16(const unsigned char* pSrc)
104     {
105     return int16_t(pSrc[0] | pSrc[1] << 8);
106     }
107    
108     inline int get24(const unsigned char* pSrc)
109     {
110     const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
111     return x & 0x800000 ? x - 0x1000000 : x;
112     }
113    
114 persson 902 inline void store24(unsigned char* pDst, int x)
115     {
116     pDst[0] = x;
117     pDst[1] = x >> 8;
118     pDst[2] = x >> 16;
119     }
120    
121 persson 365 void Decompress16(int compressionmode, const unsigned char* params,
122 persson 372 int srcStep, int dstStep,
123     const unsigned char* pSrc, int16_t* pDst,
124 persson 365 unsigned long currentframeoffset,
125     unsigned long copysamples)
126     {
127     switch (compressionmode) {
128     case 0: // 16 bit uncompressed
129     pSrc += currentframeoffset * srcStep;
130     while (copysamples) {
131     *pDst = get16(pSrc);
132 persson 372 pDst += dstStep;
133 persson 365 pSrc += srcStep;
134     copysamples--;
135     }
136     break;
137    
138     case 1: // 16 bit compressed to 8 bit
139     int y = get16(params);
140     int dy = get16(params + 2);
141     while (currentframeoffset) {
142     dy -= int8_t(*pSrc);
143     y -= dy;
144     pSrc += srcStep;
145     currentframeoffset--;
146     }
147     while (copysamples) {
148     dy -= int8_t(*pSrc);
149     y -= dy;
150     *pDst = y;
151 persson 372 pDst += dstStep;
152 persson 365 pSrc += srcStep;
153     copysamples--;
154     }
155     break;
156     }
157     }
158    
159     void Decompress24(int compressionmode, const unsigned char* params,
160 persson 902 int dstStep, const unsigned char* pSrc, uint8_t* pDst,
161 persson 365 unsigned long currentframeoffset,
162 persson 437 unsigned long copysamples, int truncatedBits)
163 persson 365 {
164 persson 695 int y, dy, ddy, dddy;
165 persson 437
166 persson 695 #define GET_PARAMS(params) \
167     y = get24(params); \
168     dy = y - get24((params) + 3); \
169     ddy = get24((params) + 6); \
170     dddy = get24((params) + 9)
171 persson 365
172     #define SKIP_ONE(x) \
173 persson 695 dddy -= (x); \
174     ddy -= dddy; \
175     dy = -dy - ddy; \
176     y += dy
177 persson 365
178     #define COPY_ONE(x) \
179     SKIP_ONE(x); \
180 persson 902 store24(pDst, y << truncatedBits); \
181 persson 372 pDst += dstStep
182 persson 365
183     switch (compressionmode) {
184     case 2: // 24 bit uncompressed
185     pSrc += currentframeoffset * 3;
186     while (copysamples) {
187 persson 902 store24(pDst, get24(pSrc) << truncatedBits);
188 persson 372 pDst += dstStep;
189 persson 365 pSrc += 3;
190     copysamples--;
191     }
192     break;
193    
194     case 3: // 24 bit compressed to 16 bit
195     GET_PARAMS(params);
196     while (currentframeoffset) {
197     SKIP_ONE(get16(pSrc));
198     pSrc += 2;
199     currentframeoffset--;
200     }
201     while (copysamples) {
202     COPY_ONE(get16(pSrc));
203     pSrc += 2;
204     copysamples--;
205     }
206     break;
207    
208     case 4: // 24 bit compressed to 12 bit
209     GET_PARAMS(params);
210     while (currentframeoffset > 1) {
211     SKIP_ONE(get12lo(pSrc));
212     SKIP_ONE(get12hi(pSrc));
213     pSrc += 3;
214     currentframeoffset -= 2;
215     }
216     if (currentframeoffset) {
217     SKIP_ONE(get12lo(pSrc));
218     currentframeoffset--;
219     if (copysamples) {
220     COPY_ONE(get12hi(pSrc));
221     pSrc += 3;
222     copysamples--;
223     }
224     }
225     while (copysamples > 1) {
226     COPY_ONE(get12lo(pSrc));
227     COPY_ONE(get12hi(pSrc));
228     pSrc += 3;
229     copysamples -= 2;
230     }
231     if (copysamples) {
232     COPY_ONE(get12lo(pSrc));
233     }
234     break;
235    
236     case 5: // 24 bit compressed to 8 bit
237     GET_PARAMS(params);
238     while (currentframeoffset) {
239     SKIP_ONE(int8_t(*pSrc++));
240     currentframeoffset--;
241     }
242     while (copysamples) {
243     COPY_ONE(int8_t(*pSrc++));
244     copysamples--;
245     }
246     break;
247     }
248     }
249    
250     const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
251     const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
252     const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
253     const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
254     }
255    
256    
257 schoenebeck 1113
258     // *************** Other Internal functions ***************
259     // *
260    
261     static split_type_t __resolveSplitType(dimension_t dimension) {
262     return (
263     dimension == dimension_layer ||
264     dimension == dimension_samplechannel ||
265     dimension == dimension_releasetrigger ||
266     dimension == dimension_keyboard ||
267     dimension == dimension_roundrobin ||
268     dimension == dimension_random ||
269     dimension == dimension_smartmidi ||
270     dimension == dimension_roundrobinkeyboard
271     ) ? split_type_bit : split_type_normal;
272     }
273    
274     static int __resolveZoneSize(dimension_def_t& dimension_definition) {
275     return (dimension_definition.split_type == split_type_normal)
276     ? int(128.0 / dimension_definition.zones) : 0;
277     }
278    
279    
280    
281 persson 1199 // *************** CRC ***************
282     // *
283    
284     const uint32_t* CRC::table(initTable());
285    
286     uint32_t* CRC::initTable() {
287     uint32_t* res = new uint32_t[256];
288    
289     for (int i = 0 ; i < 256 ; i++) {
290     uint32_t c = i;
291     for (int j = 0 ; j < 8 ; j++) {
292     c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
293     }
294     res[i] = c;
295     }
296     return res;
297     }
298    
299    
300    
301 schoenebeck 2 // *************** Sample ***************
302     // *
303    
304 schoenebeck 384 unsigned int Sample::Instances = 0;
305     buffer_t Sample::InternalDecompressionBuffer;
306 schoenebeck 2
307 schoenebeck 809 /** @brief Constructor.
308     *
309     * Load an existing sample or create a new one. A 'wave' list chunk must
310     * be given to this constructor. In case the given 'wave' list chunk
311     * contains a 'fmt', 'data' (and optionally a '3gix', 'smpl') chunk, the
312     * format and sample data will be loaded from there, otherwise default
313     * values will be used and those chunks will be created when
314     * File::Save() will be called later on.
315     *
316     * @param pFile - pointer to gig::File where this sample is
317     * located (or will be located)
318     * @param waveList - pointer to 'wave' list chunk which is (or
319     * will be) associated with this sample
320     * @param WavePoolOffset - offset of this sample data from wave pool
321     * ('wvpl') list chunk
322     * @param fileNo - number of an extension file where this sample
323     * is located, 0 otherwise
324     */
325 persson 666 Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
326 persson 1180 static const DLS::Info::FixedStringLength fixedStringLengths[] = {
327     { CHUNK_ID_INAM, 64 },
328     { 0, 0 }
329     };
330     pInfo->FixedStringLengths = fixedStringLengths;
331 schoenebeck 2 Instances++;
332 persson 666 FileNo = fileNo;
333 schoenebeck 2
334 schoenebeck 809 pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
335     if (pCk3gix) {
336 schoenebeck 929 uint16_t iSampleGroup = pCk3gix->ReadInt16();
337 schoenebeck 930 pGroup = pFile->GetGroup(iSampleGroup);
338 schoenebeck 809 } else { // '3gix' chunk missing
339 schoenebeck 930 // by default assigned to that mandatory "Default Group"
340     pGroup = pFile->GetGroup(0);
341 schoenebeck 809 }
342 schoenebeck 2
343 schoenebeck 809 pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
344     if (pCkSmpl) {
345     Manufacturer = pCkSmpl->ReadInt32();
346     Product = pCkSmpl->ReadInt32();
347     SamplePeriod = pCkSmpl->ReadInt32();
348     MIDIUnityNote = pCkSmpl->ReadInt32();
349     FineTune = pCkSmpl->ReadInt32();
350     pCkSmpl->Read(&SMPTEFormat, 1, 4);
351     SMPTEOffset = pCkSmpl->ReadInt32();
352     Loops = pCkSmpl->ReadInt32();
353     pCkSmpl->ReadInt32(); // manufByt
354     LoopID = pCkSmpl->ReadInt32();
355     pCkSmpl->Read(&LoopType, 1, 4);
356     LoopStart = pCkSmpl->ReadInt32();
357     LoopEnd = pCkSmpl->ReadInt32();
358     LoopFraction = pCkSmpl->ReadInt32();
359     LoopPlayCount = pCkSmpl->ReadInt32();
360     } else { // 'smpl' chunk missing
361     // use default values
362     Manufacturer = 0;
363     Product = 0;
364 persson 928 SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
365 persson 1218 MIDIUnityNote = 60;
366 schoenebeck 809 FineTune = 0;
367 persson 1182 SMPTEFormat = smpte_format_no_offset;
368 schoenebeck 809 SMPTEOffset = 0;
369     Loops = 0;
370     LoopID = 0;
371 persson 1182 LoopType = loop_type_normal;
372 schoenebeck 809 LoopStart = 0;
373     LoopEnd = 0;
374     LoopFraction = 0;
375     LoopPlayCount = 0;
376     }
377 schoenebeck 2
378     FrameTable = NULL;
379     SamplePos = 0;
380     RAMCache.Size = 0;
381     RAMCache.pStart = NULL;
382     RAMCache.NullExtensionSize = 0;
383    
384 persson 365 if (BitDepth > 24) throw gig::Exception("Only samples up to 24 bit supported");
385    
386 persson 437 RIFF::Chunk* ewav = waveList->GetSubChunk(CHUNK_ID_EWAV);
387     Compressed = ewav;
388     Dithered = false;
389     TruncatedBits = 0;
390 schoenebeck 2 if (Compressed) {
391 persson 437 uint32_t version = ewav->ReadInt32();
392     if (version == 3 && BitDepth == 24) {
393     Dithered = ewav->ReadInt32();
394     ewav->SetPos(Channels == 2 ? 84 : 64);
395     TruncatedBits = ewav->ReadInt32();
396     }
397 schoenebeck 2 ScanCompressedSample();
398     }
399 schoenebeck 317
400     // we use a buffer for decompression and for truncating 24 bit samples to 16 bit
401 schoenebeck 384 if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {
402     InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
403     InternalDecompressionBuffer.Size = INITIAL_SAMPLE_BUFFER_SIZE;
404 schoenebeck 317 }
405 persson 437 FrameOffset = 0; // just for streaming compressed samples
406 schoenebeck 21
407 persson 864 LoopSize = LoopEnd - LoopStart + 1;
408 schoenebeck 2 }
409    
410 schoenebeck 809 /**
411     * Apply sample and its settings to the respective RIFF chunks. You have
412     * to call File::Save() to make changes persistent.
413     *
414     * Usually there is absolutely no need to call this method explicitly.
415     * It will be called automatically when File::Save() was called.
416     *
417 schoenebeck 1050 * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
418 schoenebeck 809 * was provided yet
419     * @throws gig::Exception if there is any invalid sample setting
420     */
421     void Sample::UpdateChunks() {
422     // first update base class's chunks
423     DLS::Sample::UpdateChunks();
424    
425     // make sure 'smpl' chunk exists
426     pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
427 persson 1182 if (!pCkSmpl) {
428     pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);
429     memset(pCkSmpl->LoadChunkData(), 0, 60);
430     }
431 schoenebeck 809 // update 'smpl' chunk
432     uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();
433 persson 918 SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
434 persson 1179 store32(&pData[0], Manufacturer);
435     store32(&pData[4], Product);
436     store32(&pData[8], SamplePeriod);
437     store32(&pData[12], MIDIUnityNote);
438     store32(&pData[16], FineTune);
439     store32(&pData[20], SMPTEFormat);
440     store32(&pData[24], SMPTEOffset);
441     store32(&pData[28], Loops);
442 schoenebeck 809
443     // we skip 'manufByt' for now (4 bytes)
444    
445 persson 1179 store32(&pData[36], LoopID);
446     store32(&pData[40], LoopType);
447     store32(&pData[44], LoopStart);
448     store32(&pData[48], LoopEnd);
449     store32(&pData[52], LoopFraction);
450     store32(&pData[56], LoopPlayCount);
451 schoenebeck 809
452     // make sure '3gix' chunk exists
453     pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
454     if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
455 schoenebeck 929 // determine appropriate sample group index (to be stored in chunk)
456 schoenebeck 930 uint16_t iSampleGroup = 0; // 0 refers to default sample group
457 schoenebeck 929 File* pFile = static_cast<File*>(pParent);
458     if (pFile->pGroups) {
459     std::list<Group*>::iterator iter = pFile->pGroups->begin();
460     std::list<Group*>::iterator end = pFile->pGroups->end();
461 schoenebeck 930 for (int i = 0; iter != end; i++, iter++) {
462 schoenebeck 929 if (*iter == pGroup) {
463     iSampleGroup = i;
464     break; // found
465     }
466     }
467     }
468 schoenebeck 809 // update '3gix' chunk
469     pData = (uint8_t*) pCk3gix->LoadChunkData();
470 persson 1179 store16(&pData[0], iSampleGroup);
471 schoenebeck 809 }
472    
473 schoenebeck 2 /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
474     void Sample::ScanCompressedSample() {
475     //TODO: we have to add some more scans here (e.g. determine compression rate)
476     this->SamplesTotal = 0;
477     std::list<unsigned long> frameOffsets;
478    
479 persson 365 SamplesPerFrame = BitDepth == 24 ? 256 : 2048;
480 schoenebeck 384 WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag
481 persson 365
482 schoenebeck 2 // Scanning
483     pCkData->SetPos(0);
484 persson 365 if (Channels == 2) { // Stereo
485     for (int i = 0 ; ; i++) {
486     // for 24 bit samples every 8:th frame offset is
487     // stored, to save some memory
488     if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
489    
490     const int mode_l = pCkData->ReadUint8();
491     const int mode_r = pCkData->ReadUint8();
492     if (mode_l > 5 || mode_r > 5) throw gig::Exception("Unknown compression mode");
493     const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
494    
495     if (pCkData->RemainingBytes() <= frameSize) {
496     SamplesInLastFrame =
497     ((pCkData->RemainingBytes() - headerSize[mode_l] - headerSize[mode_r]) << 3) /
498     (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
499     SamplesTotal += SamplesInLastFrame;
500 schoenebeck 2 break;
501 persson 365 }
502     SamplesTotal += SamplesPerFrame;
503     pCkData->SetPos(frameSize, RIFF::stream_curpos);
504     }
505     }
506     else { // Mono
507     for (int i = 0 ; ; i++) {
508     if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
509    
510     const int mode = pCkData->ReadUint8();
511     if (mode > 5) throw gig::Exception("Unknown compression mode");
512     const unsigned long frameSize = bytesPerFrame[mode];
513    
514     if (pCkData->RemainingBytes() <= frameSize) {
515     SamplesInLastFrame =
516     ((pCkData->RemainingBytes() - headerSize[mode]) << 3) / bitsPerSample[mode];
517     SamplesTotal += SamplesInLastFrame;
518 schoenebeck 2 break;
519 persson 365 }
520     SamplesTotal += SamplesPerFrame;
521     pCkData->SetPos(frameSize, RIFF::stream_curpos);
522 schoenebeck 2 }
523     }
524     pCkData->SetPos(0);
525    
526     // Build the frames table (which is used for fast resolving of a frame's chunk offset)
527     if (FrameTable) delete[] FrameTable;
528     FrameTable = new unsigned long[frameOffsets.size()];
529     std::list<unsigned long>::iterator end = frameOffsets.end();
530     std::list<unsigned long>::iterator iter = frameOffsets.begin();
531     for (int i = 0; iter != end; i++, iter++) {
532     FrameTable[i] = *iter;
533     }
534     }
535    
536     /**
537     * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
538     * ReleaseSampleData() to free the memory if you don't need the cached
539     * sample data anymore.
540     *
541     * @returns buffer_t structure with start address and size of the buffer
542     * in bytes
543     * @see ReleaseSampleData(), Read(), SetPos()
544     */
545     buffer_t Sample::LoadSampleData() {
546     return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, 0); // 0 amount of NullSamples
547     }
548    
549     /**
550     * Reads (uncompresses if needed) and caches the first \a SampleCount
551     * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
552     * memory space if you don't need the cached samples anymore. There is no
553     * guarantee that exactly \a SampleCount samples will be cached; this is
554     * not an error. The size will be eventually truncated e.g. to the
555     * beginning of a frame of a compressed sample. This is done for
556     * efficiency reasons while streaming the wave by your sampler engine
557     * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
558     * that will be returned to determine the actual cached samples, but note
559     * that the size is given in bytes! You get the number of actually cached
560     * samples by dividing it by the frame size of the sample:
561 schoenebeck 384 * @code
562 schoenebeck 2 * buffer_t buf = pSample->LoadSampleData(acquired_samples);
563     * long cachedsamples = buf.Size / pSample->FrameSize;
564 schoenebeck 384 * @endcode
565 schoenebeck 2 *
566     * @param SampleCount - number of sample points to load into RAM
567     * @returns buffer_t structure with start address and size of
568     * the cached sample data in bytes
569     * @see ReleaseSampleData(), Read(), SetPos()
570     */
571     buffer_t Sample::LoadSampleData(unsigned long SampleCount) {
572     return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
573     }
574    
575     /**
576     * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
577     * ReleaseSampleData() to free the memory if you don't need the cached
578     * sample data anymore.
579     * The method will add \a NullSamplesCount silence samples past the
580     * official buffer end (this won't affect the 'Size' member of the
581     * buffer_t structure, that means 'Size' always reflects the size of the
582     * actual sample data, the buffer might be bigger though). Silence
583     * samples past the official buffer are needed for differential
584     * algorithms that always have to take subsequent samples into account
585     * (resampling/interpolation would be an important example) and avoids
586     * memory access faults in such cases.
587     *
588     * @param NullSamplesCount - number of silence samples the buffer should
589     * be extended past it's data end
590     * @returns buffer_t structure with start address and
591     * size of the buffer in bytes
592     * @see ReleaseSampleData(), Read(), SetPos()
593     */
594     buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
595     return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, NullSamplesCount);
596     }
597    
598     /**
599     * Reads (uncompresses if needed) and caches the first \a SampleCount
600     * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
601     * memory space if you don't need the cached samples anymore. There is no
602     * guarantee that exactly \a SampleCount samples will be cached; this is
603     * not an error. The size will be eventually truncated e.g. to the
604     * beginning of a frame of a compressed sample. This is done for
605     * efficiency reasons while streaming the wave by your sampler engine
606     * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
607     * that will be returned to determine the actual cached samples, but note
608     * that the size is given in bytes! You get the number of actually cached
609     * samples by dividing it by the frame size of the sample:
610 schoenebeck 384 * @code
611 schoenebeck 2 * buffer_t buf = pSample->LoadSampleDataWithNullSamplesExtension(acquired_samples, null_samples);
612     * long cachedsamples = buf.Size / pSample->FrameSize;
613 schoenebeck 384 * @endcode
614 schoenebeck 2 * The method will add \a NullSamplesCount silence samples past the
615     * official buffer end (this won't affect the 'Size' member of the
616     * buffer_t structure, that means 'Size' always reflects the size of the
617     * actual sample data, the buffer might be bigger though). Silence
618     * samples past the official buffer are needed for differential
619     * algorithms that always have to take subsequent samples into account
620     * (resampling/interpolation would be an important example) and avoids
621     * memory access faults in such cases.
622     *
623     * @param SampleCount - number of sample points to load into RAM
624     * @param NullSamplesCount - number of silence samples the buffer should
625     * be extended past it's data end
626     * @returns buffer_t structure with start address and
627     * size of the cached sample data in bytes
628     * @see ReleaseSampleData(), Read(), SetPos()
629     */
630     buffer_t Sample::LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount) {
631     if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
632     if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
633     unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
634     RAMCache.pStart = new int8_t[allocationsize];
635     RAMCache.Size = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
636     RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
637     // fill the remaining buffer space with silence samples
638     memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
639     return GetCache();
640     }
641    
642     /**
643     * Returns current cached sample points. A buffer_t structure will be
644     * returned which contains address pointer to the begin of the cache and
645     * the size of the cached sample data in bytes. Use
646     * <i>LoadSampleData()</i> to cache a specific amount of sample points in
647     * RAM.
648     *
649     * @returns buffer_t structure with current cached sample points
650     * @see LoadSampleData();
651     */
652     buffer_t Sample::GetCache() {
653     // return a copy of the buffer_t structure
654     buffer_t result;
655     result.Size = this->RAMCache.Size;
656     result.pStart = this->RAMCache.pStart;
657     result.NullExtensionSize = this->RAMCache.NullExtensionSize;
658     return result;
659     }
660    
661     /**
662     * Frees the cached sample from RAM if loaded with
663     * <i>LoadSampleData()</i> previously.
664     *
665     * @see LoadSampleData();
666     */
667     void Sample::ReleaseSampleData() {
668     if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
669     RAMCache.pStart = NULL;
670     RAMCache.Size = 0;
671     }
672    
673 schoenebeck 809 /** @brief Resize sample.
674     *
675     * Resizes the sample's wave form data, that is the actual size of
676     * sample wave data possible to be written for this sample. This call
677     * will return immediately and just schedule the resize operation. You
678     * should call File::Save() to actually perform the resize operation(s)
679     * "physically" to the file. As this can take a while on large files, it
680     * is recommended to call Resize() first on all samples which have to be
681     * resized and finally to call File::Save() to perform all those resize
682     * operations in one rush.
683     *
684     * The actual size (in bytes) is dependant to the current FrameSize
685     * value. You may want to set FrameSize before calling Resize().
686     *
687     * <b>Caution:</b> You cannot directly write (i.e. with Write()) to
688     * enlarged samples before calling File::Save() as this might exceed the
689     * current sample's boundary!
690     *
691 schoenebeck 1050 * Also note: only DLS_WAVE_FORMAT_PCM is currently supported, that is
692     * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
693 schoenebeck 809 * other formats will fail!
694     *
695     * @param iNewSize - new sample wave data size in sample points (must be
696     * greater than zero)
697 schoenebeck 1050 * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
698 schoenebeck 809 * or if \a iNewSize is less than 1
699     * @throws gig::Exception if existing sample is compressed
700     * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
701     * DLS::Sample::FormatTag, File::Save()
702     */
703     void Sample::Resize(int iNewSize) {
704     if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
705     DLS::Sample::Resize(iNewSize);
706     }
707    
708 schoenebeck 2 /**
709     * Sets the position within the sample (in sample points, not in
710     * bytes). Use this method and <i>Read()</i> if you don't want to load
711     * the sample into RAM, thus for disk streaming.
712     *
713     * Although the original Gigasampler engine doesn't allow positioning
714     * within compressed samples, I decided to implement it. Even though
715     * the Gigasampler format doesn't allow to define loops for compressed
716     * samples at the moment, positioning within compressed samples might be
717     * interesting for some sampler engines though. The only drawback about
718     * my decision is that it takes longer to load compressed gig Files on
719     * startup, because it's neccessary to scan the samples for some
720     * mandatory informations. But I think as it doesn't affect the runtime
721     * efficiency, nobody will have a problem with that.
722     *
723     * @param SampleCount number of sample points to jump
724     * @param Whence optional: to which relation \a SampleCount refers
725     * to, if omited <i>RIFF::stream_start</i> is assumed
726     * @returns the new sample position
727     * @see Read()
728     */
729     unsigned long Sample::SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence) {
730     if (Compressed) {
731     switch (Whence) {
732     case RIFF::stream_curpos:
733     this->SamplePos += SampleCount;
734     break;
735     case RIFF::stream_end:
736     this->SamplePos = this->SamplesTotal - 1 - SampleCount;
737     break;
738     case RIFF::stream_backward:
739     this->SamplePos -= SampleCount;
740     break;
741     case RIFF::stream_start: default:
742     this->SamplePos = SampleCount;
743     break;
744     }
745     if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
746    
747     unsigned long frame = this->SamplePos / 2048; // to which frame to jump
748     this->FrameOffset = this->SamplePos % 2048; // offset (in sample points) within that frame
749     pCkData->SetPos(FrameTable[frame]); // set chunk pointer to the start of sought frame
750     return this->SamplePos;
751     }
752     else { // not compressed
753     unsigned long orderedBytes = SampleCount * this->FrameSize;
754     unsigned long result = pCkData->SetPos(orderedBytes, Whence);
755     return (result == orderedBytes) ? SampleCount
756     : result / this->FrameSize;
757     }
758     }
759    
760     /**
761     * Returns the current position in the sample (in sample points).
762     */
763     unsigned long Sample::GetPos() {
764     if (Compressed) return SamplePos;
765     else return pCkData->GetPos() / FrameSize;
766     }
767    
768     /**
769 schoenebeck 24 * Reads \a SampleCount number of sample points from the position stored
770     * in \a pPlaybackState into the buffer pointed by \a pBuffer and moves
771     * the position within the sample respectively, this method honors the
772     * looping informations of the sample (if any). The sample wave stream
773     * will be decompressed on the fly if using a compressed sample. Use this
774     * method if you don't want to load the sample into RAM, thus for disk
775     * streaming. All this methods needs to know to proceed with streaming
776     * for the next time you call this method is stored in \a pPlaybackState.
777     * You have to allocate and initialize the playback_state_t structure by
778     * yourself before you use it to stream a sample:
779 schoenebeck 384 * @code
780     * gig::playback_state_t playbackstate;
781     * playbackstate.position = 0;
782     * playbackstate.reverse = false;
783     * playbackstate.loop_cycles_left = pSample->LoopPlayCount;
784     * @endcode
785 schoenebeck 24 * You don't have to take care of things like if there is actually a loop
786     * defined or if the current read position is located within a loop area.
787     * The method already handles such cases by itself.
788     *
789 schoenebeck 384 * <b>Caution:</b> If you are using more than one streaming thread, you
790     * have to use an external decompression buffer for <b>EACH</b>
791     * streaming thread to avoid race conditions and crashes!
792     *
793 schoenebeck 24 * @param pBuffer destination buffer
794     * @param SampleCount number of sample points to read
795     * @param pPlaybackState will be used to store and reload the playback
796     * state for the next ReadAndLoop() call
797 persson 864 * @param pDimRgn dimension region with looping information
798 schoenebeck 384 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
799 schoenebeck 24 * @returns number of successfully read sample points
800 schoenebeck 384 * @see CreateDecompressionBuffer()
801 schoenebeck 24 */
802 persson 864 unsigned long Sample::ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState,
803     DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
804 schoenebeck 24 unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
805     uint8_t* pDst = (uint8_t*) pBuffer;
806    
807     SetPos(pPlaybackState->position); // recover position from the last time
808    
809 persson 864 if (pDimRgn->SampleLoops) { // honor looping if there are loop points defined
810 schoenebeck 24
811 persson 864 const DLS::sample_loop_t& loop = pDimRgn->pSampleLoops[0];
812     const uint32_t loopEnd = loop.LoopStart + loop.LoopLength;
813 schoenebeck 24
814 persson 864 if (GetPos() <= loopEnd) {
815     switch (loop.LoopType) {
816 schoenebeck 24
817 persson 864 case loop_type_bidirectional: { //TODO: not tested yet!
818     do {
819     // if not endless loop check if max. number of loop cycles have been passed
820     if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
821 schoenebeck 24
822 persson 864 if (!pPlaybackState->reverse) { // forward playback
823     do {
824     samplestoloopend = loopEnd - GetPos();
825     readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
826     samplestoread -= readsamples;
827     totalreadsamples += readsamples;
828     if (readsamples == samplestoloopend) {
829     pPlaybackState->reverse = true;
830     break;
831     }
832     } while (samplestoread && readsamples);
833     }
834     else { // backward playback
835 schoenebeck 24
836 persson 864 // as we can only read forward from disk, we have to
837     // determine the end position within the loop first,
838     // read forward from that 'end' and finally after
839     // reading, swap all sample frames so it reflects
840     // backward playback
841 schoenebeck 24
842 persson 864 unsigned long swapareastart = totalreadsamples;
843     unsigned long loopoffset = GetPos() - loop.LoopStart;
844     unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);
845     unsigned long reverseplaybackend = GetPos() - samplestoreadinloop;
846 schoenebeck 24
847 persson 864 SetPos(reverseplaybackend);
848 schoenebeck 24
849 persson 864 // read samples for backward playback
850     do {
851     readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
852     samplestoreadinloop -= readsamples;
853     samplestoread -= readsamples;
854     totalreadsamples += readsamples;
855     } while (samplestoreadinloop && readsamples);
856 schoenebeck 24
857 persson 864 SetPos(reverseplaybackend); // pretend we really read backwards
858    
859     if (reverseplaybackend == loop.LoopStart) {
860     pPlaybackState->loop_cycles_left--;
861     pPlaybackState->reverse = false;
862     }
863    
864     // reverse the sample frames for backward playback
865     SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
866 schoenebeck 24 }
867 persson 864 } while (samplestoread && readsamples);
868     break;
869     }
870 schoenebeck 24
871 persson 864 case loop_type_backward: { // TODO: not tested yet!
872     // forward playback (not entered the loop yet)
873     if (!pPlaybackState->reverse) do {
874     samplestoloopend = loopEnd - GetPos();
875     readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
876     samplestoread -= readsamples;
877     totalreadsamples += readsamples;
878     if (readsamples == samplestoloopend) {
879     pPlaybackState->reverse = true;
880     break;
881     }
882     } while (samplestoread && readsamples);
883 schoenebeck 24
884 persson 864 if (!samplestoread) break;
885 schoenebeck 24
886 persson 864 // as we can only read forward from disk, we have to
887     // determine the end position within the loop first,
888     // read forward from that 'end' and finally after
889     // reading, swap all sample frames so it reflects
890     // backward playback
891 schoenebeck 24
892 persson 864 unsigned long swapareastart = totalreadsamples;
893     unsigned long loopoffset = GetPos() - loop.LoopStart;
894     unsigned long samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.LoopLength - loopoffset)
895     : samplestoread;
896     unsigned long reverseplaybackend = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);
897 schoenebeck 24
898 persson 864 SetPos(reverseplaybackend);
899 schoenebeck 24
900 persson 864 // read samples for backward playback
901     do {
902     // if not endless loop check if max. number of loop cycles have been passed
903     if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
904     samplestoloopend = loopEnd - GetPos();
905     readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
906     samplestoreadinloop -= readsamples;
907     samplestoread -= readsamples;
908     totalreadsamples += readsamples;
909     if (readsamples == samplestoloopend) {
910     pPlaybackState->loop_cycles_left--;
911     SetPos(loop.LoopStart);
912     }
913     } while (samplestoreadinloop && readsamples);
914 schoenebeck 24
915 persson 864 SetPos(reverseplaybackend); // pretend we really read backwards
916 schoenebeck 24
917 persson 864 // reverse the sample frames for backward playback
918     SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
919     break;
920     }
921 schoenebeck 24
922 persson 864 default: case loop_type_normal: {
923     do {
924     // if not endless loop check if max. number of loop cycles have been passed
925     if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
926     samplestoloopend = loopEnd - GetPos();
927     readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
928     samplestoread -= readsamples;
929     totalreadsamples += readsamples;
930     if (readsamples == samplestoloopend) {
931     pPlaybackState->loop_cycles_left--;
932     SetPos(loop.LoopStart);
933     }
934     } while (samplestoread && readsamples);
935     break;
936     }
937 schoenebeck 24 }
938     }
939     }
940    
941     // read on without looping
942     if (samplestoread) do {
943 schoenebeck 384 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoread, pExternalDecompressionBuffer);
944 schoenebeck 24 samplestoread -= readsamples;
945     totalreadsamples += readsamples;
946     } while (readsamples && samplestoread);
947    
948     // store current position
949     pPlaybackState->position = GetPos();
950    
951     return totalreadsamples;
952     }
953    
954     /**
955 schoenebeck 2 * Reads \a SampleCount number of sample points from the current
956     * position into the buffer pointed by \a pBuffer and increments the
957     * position within the sample. The sample wave stream will be
958     * decompressed on the fly if using a compressed sample. Use this method
959     * and <i>SetPos()</i> if you don't want to load the sample into RAM,
960     * thus for disk streaming.
961     *
962 schoenebeck 384 * <b>Caution:</b> If you are using more than one streaming thread, you
963     * have to use an external decompression buffer for <b>EACH</b>
964     * streaming thread to avoid race conditions and crashes!
965     *
966 persson 902 * For 16 bit samples, the data in the buffer will be int16_t
967     * (using native endianness). For 24 bit, the buffer will
968     * contain three bytes per sample, little-endian.
969     *
970 schoenebeck 2 * @param pBuffer destination buffer
971     * @param SampleCount number of sample points to read
972 schoenebeck 384 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
973 schoenebeck 2 * @returns number of successfully read sample points
974 schoenebeck 384 * @see SetPos(), CreateDecompressionBuffer()
975 schoenebeck 2 */
976 schoenebeck 384 unsigned long Sample::Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer) {
977 schoenebeck 21 if (SampleCount == 0) return 0;
978 schoenebeck 317 if (!Compressed) {
979     if (BitDepth == 24) {
980 persson 902 return pCkData->Read(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
981 schoenebeck 317 }
982 persson 365 else { // 16 bit
983     // (pCkData->Read does endian correction)
984     return Channels == 2 ? pCkData->Read(pBuffer, SampleCount << 1, 2) >> 1
985     : pCkData->Read(pBuffer, SampleCount, 2);
986     }
987 schoenebeck 317 }
988 persson 365 else {
989 schoenebeck 11 if (this->SamplePos >= this->SamplesTotal) return 0;
990 persson 365 //TODO: efficiency: maybe we should test for an average compression rate
991     unsigned long assumedsize = GuessSize(SampleCount),
992 schoenebeck 2 remainingbytes = 0, // remaining bytes in the local buffer
993     remainingsamples = SampleCount,
994 persson 365 copysamples, skipsamples,
995     currentframeoffset = this->FrameOffset; // offset in current sample frame since last Read()
996 schoenebeck 2 this->FrameOffset = 0;
997    
998 schoenebeck 384 buffer_t* pDecompressionBuffer = (pExternalDecompressionBuffer) ? pExternalDecompressionBuffer : &InternalDecompressionBuffer;
999    
1000     // if decompression buffer too small, then reduce amount of samples to read
1001     if (pDecompressionBuffer->Size < assumedsize) {
1002     std::cerr << "gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
1003     SampleCount = WorstCaseMaxSamples(pDecompressionBuffer);
1004     remainingsamples = SampleCount;
1005     assumedsize = GuessSize(SampleCount);
1006 schoenebeck 2 }
1007    
1008 schoenebeck 384 unsigned char* pSrc = (unsigned char*) pDecompressionBuffer->pStart;
1009 persson 365 int16_t* pDst = static_cast<int16_t*>(pBuffer);
1010 persson 902 uint8_t* pDst24 = static_cast<uint8_t*>(pBuffer);
1011 schoenebeck 2 remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
1012    
1013 persson 365 while (remainingsamples && remainingbytes) {
1014     unsigned long framesamples = SamplesPerFrame;
1015     unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;
1016 schoenebeck 2
1017 persson 365 int mode_l = *pSrc++, mode_r = 0;
1018    
1019     if (Channels == 2) {
1020     mode_r = *pSrc++;
1021     framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
1022     rightChannelOffset = bytesPerFrameNoHdr[mode_l];
1023     nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
1024     if (remainingbytes < framebytes) { // last frame in sample
1025     framesamples = SamplesInLastFrame;
1026     if (mode_l == 4 && (framesamples & 1)) {
1027     rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
1028     }
1029     else {
1030     rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
1031     }
1032 schoenebeck 2 }
1033     }
1034 persson 365 else {
1035     framebytes = bytesPerFrame[mode_l] + 1;
1036     nextFrameOffset = bytesPerFrameNoHdr[mode_l];
1037     if (remainingbytes < framebytes) {
1038     framesamples = SamplesInLastFrame;
1039     }
1040     }
1041 schoenebeck 2
1042     // determine how many samples in this frame to skip and read
1043 persson 365 if (currentframeoffset + remainingsamples >= framesamples) {
1044     if (currentframeoffset <= framesamples) {
1045     copysamples = framesamples - currentframeoffset;
1046     skipsamples = currentframeoffset;
1047     }
1048     else {
1049     copysamples = 0;
1050     skipsamples = framesamples;
1051     }
1052 schoenebeck 2 }
1053     else {
1054 persson 365 // This frame has enough data for pBuffer, but not
1055     // all of the frame is needed. Set file position
1056     // to start of this frame for next call to Read.
1057 schoenebeck 2 copysamples = remainingsamples;
1058 persson 365 skipsamples = currentframeoffset;
1059     pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1060     this->FrameOffset = currentframeoffset + copysamples;
1061     }
1062     remainingsamples -= copysamples;
1063    
1064     if (remainingbytes > framebytes) {
1065     remainingbytes -= framebytes;
1066     if (remainingsamples == 0 &&
1067     currentframeoffset + copysamples == framesamples) {
1068     // This frame has enough data for pBuffer, and
1069     // all of the frame is needed. Set file
1070     // position to start of next frame for next
1071     // call to Read. FrameOffset is 0.
1072 schoenebeck 2 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1073     }
1074     }
1075 persson 365 else remainingbytes = 0;
1076 schoenebeck 2
1077 persson 365 currentframeoffset -= skipsamples;
1078 schoenebeck 2
1079 persson 365 if (copysamples == 0) {
1080     // skip this frame
1081     pSrc += framebytes - Channels;
1082     }
1083     else {
1084     const unsigned char* const param_l = pSrc;
1085     if (BitDepth == 24) {
1086     if (mode_l != 2) pSrc += 12;
1087 schoenebeck 2
1088 persson 365 if (Channels == 2) { // Stereo
1089     const unsigned char* const param_r = pSrc;
1090     if (mode_r != 2) pSrc += 12;
1091    
1092 persson 902 Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1093 persson 437 skipsamples, copysamples, TruncatedBits);
1094 persson 902 Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1095 persson 437 skipsamples, copysamples, TruncatedBits);
1096 persson 902 pDst24 += copysamples * 6;
1097 schoenebeck 2 }
1098 persson 365 else { // Mono
1099 persson 902 Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1100 persson 437 skipsamples, copysamples, TruncatedBits);
1101 persson 902 pDst24 += copysamples * 3;
1102 schoenebeck 2 }
1103 persson 365 }
1104     else { // 16 bit
1105     if (mode_l) pSrc += 4;
1106 schoenebeck 2
1107 persson 365 int step;
1108     if (Channels == 2) { // Stereo
1109     const unsigned char* const param_r = pSrc;
1110     if (mode_r) pSrc += 4;
1111    
1112     step = (2 - mode_l) + (2 - mode_r);
1113 persson 372 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
1114     Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
1115 persson 365 skipsamples, copysamples);
1116     pDst += copysamples << 1;
1117 schoenebeck 2 }
1118 persson 365 else { // Mono
1119     step = 2 - mode_l;
1120 persson 372 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
1121 persson 365 pDst += copysamples;
1122 schoenebeck 2 }
1123 persson 365 }
1124     pSrc += nextFrameOffset;
1125     }
1126 schoenebeck 2
1127 persson 365 // reload from disk to local buffer if needed
1128     if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() == RIFF::stream_ready) {
1129     assumedsize = GuessSize(remainingsamples);
1130     pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1131     if (pCkData->RemainingBytes() < assumedsize) assumedsize = pCkData->RemainingBytes();
1132 schoenebeck 384 remainingbytes = pCkData->Read(pDecompressionBuffer->pStart, assumedsize, 1);
1133     pSrc = (unsigned char*) pDecompressionBuffer->pStart;
1134 schoenebeck 2 }
1135 persson 365 } // while
1136    
1137 schoenebeck 2 this->SamplePos += (SampleCount - remainingsamples);
1138 schoenebeck 11 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
1139 schoenebeck 2 return (SampleCount - remainingsamples);
1140     }
1141     }
1142    
1143 schoenebeck 809 /** @brief Write sample wave data.
1144     *
1145     * Writes \a SampleCount number of sample points from the buffer pointed
1146     * by \a pBuffer and increments the position within the sample. Use this
1147     * method to directly write the sample data to disk, i.e. if you don't
1148     * want or cannot load the whole sample data into RAM.
1149     *
1150     * You have to Resize() the sample to the desired size and call
1151     * File::Save() <b>before</b> using Write().
1152     *
1153     * Note: there is currently no support for writing compressed samples.
1154     *
1155 persson 1264 * For 16 bit samples, the data in the source buffer should be
1156     * int16_t (using native endianness). For 24 bit, the buffer
1157     * should contain three bytes per sample, little-endian.
1158     *
1159 schoenebeck 809 * @param pBuffer - source buffer
1160     * @param SampleCount - number of sample points to write
1161     * @throws DLS::Exception if current sample size is too small
1162     * @throws gig::Exception if sample is compressed
1163     * @see DLS::LoadSampleData()
1164     */
1165     unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {
1166     if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1167 persson 1207
1168     // if this is the first write in this sample, reset the
1169     // checksum calculator
1170 persson 1199 if (pCkData->GetPos() == 0) {
1171     crc.reset();
1172     }
1173 persson 1264 if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");
1174     unsigned long res;
1175     if (BitDepth == 24) {
1176     res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1177     } else { // 16 bit
1178     res = Channels == 2 ? pCkData->Write(pBuffer, SampleCount << 1, 2) >> 1
1179     : pCkData->Write(pBuffer, SampleCount, 2);
1180     }
1181 persson 1199 crc.update((unsigned char *)pBuffer, SampleCount * FrameSize);
1182    
1183 persson 1207 // if this is the last write, update the checksum chunk in the
1184     // file
1185 persson 1199 if (pCkData->GetPos() == pCkData->GetSize()) {
1186     File* pFile = static_cast<File*>(GetParent());
1187     pFile->SetSampleChecksum(this, crc.getValue());
1188     }
1189     return res;
1190 schoenebeck 809 }
1191    
1192 schoenebeck 384 /**
1193     * Allocates a decompression buffer for streaming (compressed) samples
1194     * with Sample::Read(). If you are using more than one streaming thread
1195     * in your application you <b>HAVE</b> to create a decompression buffer
1196     * for <b>EACH</b> of your streaming threads and provide it with the
1197     * Sample::Read() call in order to avoid race conditions and crashes.
1198     *
1199     * You should free the memory occupied by the allocated buffer(s) once
1200     * you don't need one of your streaming threads anymore by calling
1201     * DestroyDecompressionBuffer().
1202     *
1203     * @param MaxReadSize - the maximum size (in sample points) you ever
1204     * expect to read with one Read() call
1205     * @returns allocated decompression buffer
1206     * @see DestroyDecompressionBuffer()
1207     */
1208     buffer_t Sample::CreateDecompressionBuffer(unsigned long MaxReadSize) {
1209     buffer_t result;
1210     const double worstCaseHeaderOverhead =
1211     (256.0 /*frame size*/ + 12.0 /*header*/ + 2.0 /*compression type flag (stereo)*/) / 256.0;
1212     result.Size = (unsigned long) (double(MaxReadSize) * 3.0 /*(24 Bit)*/ * 2.0 /*stereo*/ * worstCaseHeaderOverhead);
1213     result.pStart = new int8_t[result.Size];
1214     result.NullExtensionSize = 0;
1215     return result;
1216     }
1217    
1218     /**
1219     * Free decompression buffer, previously created with
1220     * CreateDecompressionBuffer().
1221     *
1222     * @param DecompressionBuffer - previously allocated decompression
1223     * buffer to free
1224     */
1225     void Sample::DestroyDecompressionBuffer(buffer_t& DecompressionBuffer) {
1226     if (DecompressionBuffer.Size && DecompressionBuffer.pStart) {
1227     delete[] (int8_t*) DecompressionBuffer.pStart;
1228     DecompressionBuffer.pStart = NULL;
1229     DecompressionBuffer.Size = 0;
1230     DecompressionBuffer.NullExtensionSize = 0;
1231     }
1232     }
1233    
1234 schoenebeck 930 /**
1235     * Returns pointer to the Group this Sample belongs to. In the .gig
1236     * format a sample always belongs to one group. If it wasn't explicitly
1237     * assigned to a certain group, it will be automatically assigned to a
1238     * default group.
1239     *
1240     * @returns Sample's Group (never NULL)
1241     */
1242     Group* Sample::GetGroup() const {
1243     return pGroup;
1244     }
1245    
1246 schoenebeck 2 Sample::~Sample() {
1247     Instances--;
1248 schoenebeck 384 if (!Instances && InternalDecompressionBuffer.Size) {
1249     delete[] (unsigned char*) InternalDecompressionBuffer.pStart;
1250     InternalDecompressionBuffer.pStart = NULL;
1251     InternalDecompressionBuffer.Size = 0;
1252 schoenebeck 355 }
1253 schoenebeck 2 if (FrameTable) delete[] FrameTable;
1254     if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
1255     }
1256    
1257    
1258    
1259     // *************** DimensionRegion ***************
1260     // *
1261    
1262 schoenebeck 16 uint DimensionRegion::Instances = 0;
1263     DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1264    
1265 schoenebeck 1316 DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
1266 schoenebeck 16 Instances++;
1267    
1268 schoenebeck 823 pSample = NULL;
1269 schoenebeck 1316 pRegion = pParent;
1270 schoenebeck 823
1271 persson 1247 if (_3ewl->GetSubChunk(CHUNK_ID_WSMP)) memcpy(&Crossfade, &SamplerOptions, 4);
1272     else memset(&Crossfade, 0, 4);
1273    
1274 schoenebeck 16 if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1275 schoenebeck 2
1276     RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
1277 schoenebeck 809 if (_3ewa) { // if '3ewa' chunk exists
1278 persson 918 _3ewa->ReadInt32(); // unknown, always == chunk size ?
1279 schoenebeck 809 LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1280     EG3Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1281     _3ewa->ReadInt16(); // unknown
1282     LFO1InternalDepth = _3ewa->ReadUint16();
1283     _3ewa->ReadInt16(); // unknown
1284     LFO3InternalDepth = _3ewa->ReadInt16();
1285     _3ewa->ReadInt16(); // unknown
1286     LFO1ControlDepth = _3ewa->ReadUint16();
1287     _3ewa->ReadInt16(); // unknown
1288     LFO3ControlDepth = _3ewa->ReadInt16();
1289     EG1Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1290     EG1Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1291     _3ewa->ReadInt16(); // unknown
1292     EG1Sustain = _3ewa->ReadUint16();
1293     EG1Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1294     EG1Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1295     uint8_t eg1ctrloptions = _3ewa->ReadUint8();
1296     EG1ControllerInvert = eg1ctrloptions & 0x01;
1297     EG1ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1298     EG1ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1299     EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1300     EG2Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1301     uint8_t eg2ctrloptions = _3ewa->ReadUint8();
1302     EG2ControllerInvert = eg2ctrloptions & 0x01;
1303     EG2ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1304     EG2ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1305     EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1306     LFO1Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1307     EG2Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1308     EG2Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1309     _3ewa->ReadInt16(); // unknown
1310     EG2Sustain = _3ewa->ReadUint16();
1311     EG2Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1312     _3ewa->ReadInt16(); // unknown
1313     LFO2ControlDepth = _3ewa->ReadUint16();
1314     LFO2Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1315     _3ewa->ReadInt16(); // unknown
1316     LFO2InternalDepth = _3ewa->ReadUint16();
1317     int32_t eg1decay2 = _3ewa->ReadInt32();
1318     EG1Decay2 = (double) GIG_EXP_DECODE(eg1decay2);
1319     EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1320     _3ewa->ReadInt16(); // unknown
1321     EG1PreAttack = _3ewa->ReadUint16();
1322     int32_t eg2decay2 = _3ewa->ReadInt32();
1323     EG2Decay2 = (double) GIG_EXP_DECODE(eg2decay2);
1324     EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1325     _3ewa->ReadInt16(); // unknown
1326     EG2PreAttack = _3ewa->ReadUint16();
1327     uint8_t velocityresponse = _3ewa->ReadUint8();
1328     if (velocityresponse < 5) {
1329     VelocityResponseCurve = curve_type_nonlinear;
1330     VelocityResponseDepth = velocityresponse;
1331     } else if (velocityresponse < 10) {
1332     VelocityResponseCurve = curve_type_linear;
1333     VelocityResponseDepth = velocityresponse - 5;
1334     } else if (velocityresponse < 15) {
1335     VelocityResponseCurve = curve_type_special;
1336     VelocityResponseDepth = velocityresponse - 10;
1337     } else {
1338     VelocityResponseCurve = curve_type_unknown;
1339     VelocityResponseDepth = 0;
1340     }
1341     uint8_t releasevelocityresponse = _3ewa->ReadUint8();
1342     if (releasevelocityresponse < 5) {
1343     ReleaseVelocityResponseCurve = curve_type_nonlinear;
1344     ReleaseVelocityResponseDepth = releasevelocityresponse;
1345     } else if (releasevelocityresponse < 10) {
1346     ReleaseVelocityResponseCurve = curve_type_linear;
1347     ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1348     } else if (releasevelocityresponse < 15) {
1349     ReleaseVelocityResponseCurve = curve_type_special;
1350     ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1351     } else {
1352     ReleaseVelocityResponseCurve = curve_type_unknown;
1353     ReleaseVelocityResponseDepth = 0;
1354     }
1355     VelocityResponseCurveScaling = _3ewa->ReadUint8();
1356     AttenuationControllerThreshold = _3ewa->ReadInt8();
1357     _3ewa->ReadInt32(); // unknown
1358     SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
1359     _3ewa->ReadInt16(); // unknown
1360     uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();
1361     PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1362     if (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1363     else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1364     else DimensionBypass = dim_bypass_ctrl_none;
1365     uint8_t pan = _3ewa->ReadUint8();
1366     Pan = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
1367     SelfMask = _3ewa->ReadInt8() & 0x01;
1368     _3ewa->ReadInt8(); // unknown
1369     uint8_t lfo3ctrl = _3ewa->ReadUint8();
1370     LFO3Controller = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
1371     LFO3Sync = lfo3ctrl & 0x20; // bit 5
1372     InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
1373     AttenuationController = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1374     uint8_t lfo2ctrl = _3ewa->ReadUint8();
1375     LFO2Controller = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
1376     LFO2FlipPhase = lfo2ctrl & 0x80; // bit 7
1377     LFO2Sync = lfo2ctrl & 0x20; // bit 5
1378     bool extResonanceCtrl = lfo2ctrl & 0x40; // bit 6
1379     uint8_t lfo1ctrl = _3ewa->ReadUint8();
1380     LFO1Controller = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
1381     LFO1FlipPhase = lfo1ctrl & 0x80; // bit 7
1382     LFO1Sync = lfo1ctrl & 0x40; // bit 6
1383     VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1384     : vcf_res_ctrl_none;
1385     uint16_t eg3depth = _3ewa->ReadUint16();
1386     EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1387     : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */
1388     _3ewa->ReadInt16(); // unknown
1389     ChannelOffset = _3ewa->ReadUint8() / 4;
1390     uint8_t regoptions = _3ewa->ReadUint8();
1391     MSDecode = regoptions & 0x01; // bit 0
1392     SustainDefeat = regoptions & 0x02; // bit 1
1393     _3ewa->ReadInt16(); // unknown
1394     VelocityUpperLimit = _3ewa->ReadInt8();
1395     _3ewa->ReadInt8(); // unknown
1396     _3ewa->ReadInt16(); // unknown
1397     ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
1398     _3ewa->ReadInt8(); // unknown
1399     _3ewa->ReadInt8(); // unknown
1400     EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
1401     uint8_t vcfcutoff = _3ewa->ReadUint8();
1402     VCFEnabled = vcfcutoff & 0x80; // bit 7
1403     VCFCutoff = vcfcutoff & 0x7f; // lower 7 bits
1404     VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
1405     uint8_t vcfvelscale = _3ewa->ReadUint8();
1406     VCFCutoffControllerInvert = vcfvelscale & 0x80; // bit 7
1407     VCFVelocityScale = vcfvelscale & 0x7f; // lower 7 bits
1408     _3ewa->ReadInt8(); // unknown
1409     uint8_t vcfresonance = _3ewa->ReadUint8();
1410     VCFResonance = vcfresonance & 0x7f; // lower 7 bits
1411     VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
1412     uint8_t vcfbreakpoint = _3ewa->ReadUint8();
1413     VCFKeyboardTracking = vcfbreakpoint & 0x80; // bit 7
1414     VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
1415     uint8_t vcfvelocity = _3ewa->ReadUint8();
1416     VCFVelocityDynamicRange = vcfvelocity % 5;
1417     VCFVelocityCurve = static_cast<curve_type_t>(vcfvelocity / 5);
1418     VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
1419     if (VCFType == vcf_type_lowpass) {
1420     if (lfo3ctrl & 0x40) // bit 6
1421     VCFType = vcf_type_lowpassturbo;
1422     }
1423 persson 1070 if (_3ewa->RemainingBytes() >= 8) {
1424     _3ewa->Read(DimensionUpperLimits, 1, 8);
1425     } else {
1426     memset(DimensionUpperLimits, 0, 8);
1427     }
1428 schoenebeck 809 } else { // '3ewa' chunk does not exist yet
1429     // use default values
1430     LFO3Frequency = 1.0;
1431     EG3Attack = 0.0;
1432     LFO1InternalDepth = 0;
1433     LFO3InternalDepth = 0;
1434     LFO1ControlDepth = 0;
1435     LFO3ControlDepth = 0;
1436     EG1Attack = 0.0;
1437 persson 1218 EG1Decay1 = 0.005;
1438     EG1Sustain = 1000;
1439     EG1Release = 0.3;
1440 schoenebeck 809 EG1Controller.type = eg1_ctrl_t::type_none;
1441     EG1Controller.controller_number = 0;
1442     EG1ControllerInvert = false;
1443     EG1ControllerAttackInfluence = 0;
1444     EG1ControllerDecayInfluence = 0;
1445     EG1ControllerReleaseInfluence = 0;
1446     EG2Controller.type = eg2_ctrl_t::type_none;
1447     EG2Controller.controller_number = 0;
1448     EG2ControllerInvert = false;
1449     EG2ControllerAttackInfluence = 0;
1450     EG2ControllerDecayInfluence = 0;
1451     EG2ControllerReleaseInfluence = 0;
1452     LFO1Frequency = 1.0;
1453     EG2Attack = 0.0;
1454 persson 1218 EG2Decay1 = 0.005;
1455     EG2Sustain = 1000;
1456     EG2Release = 0.3;
1457 schoenebeck 809 LFO2ControlDepth = 0;
1458     LFO2Frequency = 1.0;
1459     LFO2InternalDepth = 0;
1460     EG1Decay2 = 0.0;
1461 persson 1218 EG1InfiniteSustain = true;
1462     EG1PreAttack = 0;
1463 schoenebeck 809 EG2Decay2 = 0.0;
1464 persson 1218 EG2InfiniteSustain = true;
1465     EG2PreAttack = 0;
1466 schoenebeck 809 VelocityResponseCurve = curve_type_nonlinear;
1467     VelocityResponseDepth = 3;
1468     ReleaseVelocityResponseCurve = curve_type_nonlinear;
1469     ReleaseVelocityResponseDepth = 3;
1470     VelocityResponseCurveScaling = 32;
1471     AttenuationControllerThreshold = 0;
1472     SampleStartOffset = 0;
1473     PitchTrack = true;
1474     DimensionBypass = dim_bypass_ctrl_none;
1475     Pan = 0;
1476     SelfMask = true;
1477     LFO3Controller = lfo3_ctrl_modwheel;
1478     LFO3Sync = false;
1479     InvertAttenuationController = false;
1480     AttenuationController.type = attenuation_ctrl_t::type_none;
1481     AttenuationController.controller_number = 0;
1482     LFO2Controller = lfo2_ctrl_internal;
1483     LFO2FlipPhase = false;
1484     LFO2Sync = false;
1485     LFO1Controller = lfo1_ctrl_internal;
1486     LFO1FlipPhase = false;
1487     LFO1Sync = false;
1488     VCFResonanceController = vcf_res_ctrl_none;
1489     EG3Depth = 0;
1490     ChannelOffset = 0;
1491     MSDecode = false;
1492     SustainDefeat = false;
1493     VelocityUpperLimit = 0;
1494     ReleaseTriggerDecay = 0;
1495     EG1Hold = false;
1496     VCFEnabled = false;
1497     VCFCutoff = 0;
1498     VCFCutoffController = vcf_cutoff_ctrl_none;
1499     VCFCutoffControllerInvert = false;
1500     VCFVelocityScale = 0;
1501     VCFResonance = 0;
1502     VCFResonanceDynamic = false;
1503     VCFKeyboardTracking = false;
1504     VCFKeyboardTrackingBreakpoint = 0;
1505     VCFVelocityDynamicRange = 0x04;
1506     VCFVelocityCurve = curve_type_linear;
1507     VCFType = vcf_type_lowpass;
1508 persson 1247 memset(DimensionUpperLimits, 127, 8);
1509 schoenebeck 2 }
1510 schoenebeck 16
1511 persson 613 pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1512     VelocityResponseDepth,
1513     VelocityResponseCurveScaling);
1514    
1515     curve_type_t curveType = ReleaseVelocityResponseCurve;
1516     uint8_t depth = ReleaseVelocityResponseDepth;
1517    
1518     // this models a strange behaviour or bug in GSt: two of the
1519     // velocity response curves for release time are not used even
1520     // if specified, instead another curve is chosen.
1521     if ((curveType == curve_type_nonlinear && depth == 0) ||
1522     (curveType == curve_type_special && depth == 4)) {
1523     curveType = curve_type_nonlinear;
1524     depth = 3;
1525     }
1526     pVelocityReleaseTable = GetVelocityTable(curveType, depth, 0);
1527    
1528 persson 728 curveType = VCFVelocityCurve;
1529     depth = VCFVelocityDynamicRange;
1530    
1531     // even stranger GSt: two of the velocity response curves for
1532     // filter cutoff are not used, instead another special curve
1533     // is chosen. This curve is not used anywhere else.
1534     if ((curveType == curve_type_nonlinear && depth == 0) ||
1535     (curveType == curve_type_special && depth == 4)) {
1536     curveType = curve_type_special;
1537     depth = 5;
1538     }
1539     pVelocityCutoffTable = GetVelocityTable(curveType, depth,
1540 persson 773 VCFCutoffController <= vcf_cutoff_ctrl_none2 ? VCFVelocityScale : 0);
1541 persson 728
1542 persson 613 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1543 persson 858 VelocityTable = 0;
1544 persson 613 }
1545    
1546 persson 1301 /*
1547     * Constructs a DimensionRegion by copying all parameters from
1548     * another DimensionRegion
1549     */
1550     DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {
1551     Instances++;
1552     *this = src; // default memberwise shallow copy of all parameters
1553     pParentList = _3ewl; // restore the chunk pointer
1554    
1555     // deep copy of owned structures
1556     if (src.VelocityTable) {
1557     VelocityTable = new uint8_t[128];
1558     for (int k = 0 ; k < 128 ; k++)
1559     VelocityTable[k] = src.VelocityTable[k];
1560     }
1561     if (src.pSampleLoops) {
1562     pSampleLoops = new DLS::sample_loop_t[src.SampleLoops];
1563     for (int k = 0 ; k < src.SampleLoops ; k++)
1564     pSampleLoops[k] = src.pSampleLoops[k];
1565     }
1566     }
1567    
1568 schoenebeck 809 /**
1569     * Apply dimension region settings to the respective RIFF chunks. You
1570     * have to call File::Save() to make changes persistent.
1571     *
1572     * Usually there is absolutely no need to call this method explicitly.
1573     * It will be called automatically when File::Save() was called.
1574     */
1575     void DimensionRegion::UpdateChunks() {
1576     // first update base class's chunk
1577     DLS::Sampler::UpdateChunks();
1578    
1579 persson 1247 RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1580     uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
1581     pData[12] = Crossfade.in_start;
1582     pData[13] = Crossfade.in_end;
1583     pData[14] = Crossfade.out_start;
1584     pData[15] = Crossfade.out_end;
1585    
1586 schoenebeck 809 // make sure '3ewa' chunk exists
1587     RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1588 persson 1317 if (!_3ewa) {
1589     File* pFile = (File*) GetParent()->GetParent()->GetParent();
1590     bool version3 = pFile->pVersion && pFile->pVersion->major == 3;
1591     _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);
1592 persson 1264 }
1593 persson 1247 pData = (uint8_t*) _3ewa->LoadChunkData();
1594 schoenebeck 809
1595     // update '3ewa' chunk with DimensionRegion's current settings
1596    
1597 persson 1182 const uint32_t chunksize = _3ewa->GetNewSize();
1598 persson 1179 store32(&pData[0], chunksize); // unknown, always chunk size?
1599 schoenebeck 809
1600     const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
1601 persson 1179 store32(&pData[4], lfo3freq);
1602 schoenebeck 809
1603     const int32_t eg3attack = (int32_t) GIG_EXP_ENCODE(EG3Attack);
1604 persson 1179 store32(&pData[8], eg3attack);
1605 schoenebeck 809
1606     // next 2 bytes unknown
1607    
1608 persson 1179 store16(&pData[14], LFO1InternalDepth);
1609 schoenebeck 809
1610     // next 2 bytes unknown
1611    
1612 persson 1179 store16(&pData[18], LFO3InternalDepth);
1613 schoenebeck 809
1614     // next 2 bytes unknown
1615    
1616 persson 1179 store16(&pData[22], LFO1ControlDepth);
1617 schoenebeck 809
1618     // next 2 bytes unknown
1619    
1620 persson 1179 store16(&pData[26], LFO3ControlDepth);
1621 schoenebeck 809
1622     const int32_t eg1attack = (int32_t) GIG_EXP_ENCODE(EG1Attack);
1623 persson 1179 store32(&pData[28], eg1attack);
1624 schoenebeck 809
1625     const int32_t eg1decay1 = (int32_t) GIG_EXP_ENCODE(EG1Decay1);
1626 persson 1179 store32(&pData[32], eg1decay1);
1627 schoenebeck 809
1628     // next 2 bytes unknown
1629    
1630 persson 1179 store16(&pData[38], EG1Sustain);
1631 schoenebeck 809
1632     const int32_t eg1release = (int32_t) GIG_EXP_ENCODE(EG1Release);
1633 persson 1179 store32(&pData[40], eg1release);
1634 schoenebeck 809
1635     const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(EG1Controller);
1636 persson 1179 pData[44] = eg1ctl;
1637 schoenebeck 809
1638     const uint8_t eg1ctrloptions =
1639 persson 1266 (EG1ControllerInvert ? 0x01 : 0x00) |
1640 schoenebeck 809 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
1641     GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
1642     GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
1643 persson 1179 pData[45] = eg1ctrloptions;
1644 schoenebeck 809
1645     const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(EG2Controller);
1646 persson 1179 pData[46] = eg2ctl;
1647 schoenebeck 809
1648     const uint8_t eg2ctrloptions =
1649 persson 1266 (EG2ControllerInvert ? 0x01 : 0x00) |
1650 schoenebeck 809 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
1651     GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
1652     GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
1653 persson 1179 pData[47] = eg2ctrloptions;
1654 schoenebeck 809
1655     const int32_t lfo1freq = (int32_t) GIG_EXP_ENCODE(LFO1Frequency);
1656 persson 1179 store32(&pData[48], lfo1freq);
1657 schoenebeck 809
1658     const int32_t eg2attack = (int32_t) GIG_EXP_ENCODE(EG2Attack);
1659 persson 1179 store32(&pData[52], eg2attack);
1660 schoenebeck 809
1661     const int32_t eg2decay1 = (int32_t) GIG_EXP_ENCODE(EG2Decay1);
1662 persson 1179 store32(&pData[56], eg2decay1);
1663 schoenebeck 809
1664     // next 2 bytes unknown
1665    
1666 persson 1179 store16(&pData[62], EG2Sustain);
1667 schoenebeck 809
1668     const int32_t eg2release = (int32_t) GIG_EXP_ENCODE(EG2Release);
1669 persson 1179 store32(&pData[64], eg2release);
1670 schoenebeck 809
1671     // next 2 bytes unknown
1672    
1673 persson 1179 store16(&pData[70], LFO2ControlDepth);
1674 schoenebeck 809
1675     const int32_t lfo2freq = (int32_t) GIG_EXP_ENCODE(LFO2Frequency);
1676 persson 1179 store32(&pData[72], lfo2freq);
1677 schoenebeck 809
1678     // next 2 bytes unknown
1679    
1680 persson 1179 store16(&pData[78], LFO2InternalDepth);
1681 schoenebeck 809
1682     const int32_t eg1decay2 = (int32_t) (EG1InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG1Decay2);
1683 persson 1179 store32(&pData[80], eg1decay2);
1684 schoenebeck 809
1685     // next 2 bytes unknown
1686    
1687 persson 1179 store16(&pData[86], EG1PreAttack);
1688 schoenebeck 809
1689     const int32_t eg2decay2 = (int32_t) (EG2InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG2Decay2);
1690 persson 1179 store32(&pData[88], eg2decay2);
1691 schoenebeck 809
1692     // next 2 bytes unknown
1693    
1694 persson 1179 store16(&pData[94], EG2PreAttack);
1695 schoenebeck 809
1696     {
1697     if (VelocityResponseDepth > 4) throw Exception("VelocityResponseDepth must be between 0 and 4");
1698     uint8_t velocityresponse = VelocityResponseDepth;
1699     switch (VelocityResponseCurve) {
1700     case curve_type_nonlinear:
1701     break;
1702     case curve_type_linear:
1703     velocityresponse += 5;
1704     break;
1705     case curve_type_special:
1706     velocityresponse += 10;
1707     break;
1708     case curve_type_unknown:
1709     default:
1710     throw Exception("Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
1711     }
1712 persson 1179 pData[96] = velocityresponse;
1713 schoenebeck 809 }
1714    
1715     {
1716     if (ReleaseVelocityResponseDepth > 4) throw Exception("ReleaseVelocityResponseDepth must be between 0 and 4");
1717     uint8_t releasevelocityresponse = ReleaseVelocityResponseDepth;
1718     switch (ReleaseVelocityResponseCurve) {
1719     case curve_type_nonlinear:
1720     break;
1721     case curve_type_linear:
1722     releasevelocityresponse += 5;
1723     break;
1724     case curve_type_special:
1725     releasevelocityresponse += 10;
1726     break;
1727     case curve_type_unknown:
1728     default:
1729     throw Exception("Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
1730     }
1731 persson 1179 pData[97] = releasevelocityresponse;
1732 schoenebeck 809 }
1733    
1734 persson 1179 pData[98] = VelocityResponseCurveScaling;
1735 schoenebeck 809
1736 persson 1179 pData[99] = AttenuationControllerThreshold;
1737 schoenebeck 809
1738     // next 4 bytes unknown
1739    
1740 persson 1179 store16(&pData[104], SampleStartOffset);
1741 schoenebeck 809
1742     // next 2 bytes unknown
1743    
1744     {
1745     uint8_t pitchTrackDimensionBypass = GIG_PITCH_TRACK_ENCODE(PitchTrack);
1746     switch (DimensionBypass) {
1747     case dim_bypass_ctrl_94:
1748     pitchTrackDimensionBypass |= 0x10;
1749     break;
1750     case dim_bypass_ctrl_95:
1751     pitchTrackDimensionBypass |= 0x20;
1752     break;
1753     case dim_bypass_ctrl_none:
1754     //FIXME: should we set anything here?
1755     break;
1756     default:
1757     throw Exception("Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
1758     }
1759 persson 1179 pData[108] = pitchTrackDimensionBypass;
1760 schoenebeck 809 }
1761    
1762     const uint8_t pan = (Pan >= 0) ? Pan : ((-Pan) + 63); // signed 8 bit -> signed 7 bit
1763 persson 1179 pData[109] = pan;
1764 schoenebeck 809
1765     const uint8_t selfmask = (SelfMask) ? 0x01 : 0x00;
1766 persson 1179 pData[110] = selfmask;
1767 schoenebeck 809
1768     // next byte unknown
1769    
1770     {
1771     uint8_t lfo3ctrl = LFO3Controller & 0x07; // lower 3 bits
1772     if (LFO3Sync) lfo3ctrl |= 0x20; // bit 5
1773     if (InvertAttenuationController) lfo3ctrl |= 0x80; // bit 7
1774     if (VCFType == vcf_type_lowpassturbo) lfo3ctrl |= 0x40; // bit 6
1775 persson 1179 pData[112] = lfo3ctrl;
1776 schoenebeck 809 }
1777    
1778     const uint8_t attenctl = EncodeLeverageController(AttenuationController);
1779 persson 1179 pData[113] = attenctl;
1780 schoenebeck 809
1781     {
1782     uint8_t lfo2ctrl = LFO2Controller & 0x07; // lower 3 bits
1783     if (LFO2FlipPhase) lfo2ctrl |= 0x80; // bit 7
1784     if (LFO2Sync) lfo2ctrl |= 0x20; // bit 5
1785     if (VCFResonanceController != vcf_res_ctrl_none) lfo2ctrl |= 0x40; // bit 6
1786 persson 1179 pData[114] = lfo2ctrl;
1787 schoenebeck 809 }
1788    
1789     {
1790     uint8_t lfo1ctrl = LFO1Controller & 0x07; // lower 3 bits
1791     if (LFO1FlipPhase) lfo1ctrl |= 0x80; // bit 7
1792     if (LFO1Sync) lfo1ctrl |= 0x40; // bit 6
1793     if (VCFResonanceController != vcf_res_ctrl_none)
1794     lfo1ctrl |= GIG_VCF_RESONANCE_CTRL_ENCODE(VCFResonanceController);
1795 persson 1179 pData[115] = lfo1ctrl;
1796 schoenebeck 809 }
1797    
1798     const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
1799     : uint16_t(((-EG3Depth) - 1) ^ 0xffff); /* binary complementary for negatives */
1800 persson 1179 pData[116] = eg3depth;
1801 schoenebeck 809
1802     // next 2 bytes unknown
1803    
1804     const uint8_t channeloffset = ChannelOffset * 4;
1805 persson 1179 pData[120] = channeloffset;
1806 schoenebeck 809
1807     {
1808     uint8_t regoptions = 0;
1809     if (MSDecode) regoptions |= 0x01; // bit 0
1810     if (SustainDefeat) regoptions |= 0x02; // bit 1
1811 persson 1179 pData[121] = regoptions;
1812 schoenebeck 809 }
1813    
1814     // next 2 bytes unknown
1815    
1816 persson 1179 pData[124] = VelocityUpperLimit;
1817 schoenebeck 809
1818     // next 3 bytes unknown
1819    
1820 persson 1179 pData[128] = ReleaseTriggerDecay;
1821 schoenebeck 809
1822     // next 2 bytes unknown
1823    
1824     const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7
1825 persson 1179 pData[131] = eg1hold;
1826 schoenebeck 809
1827 persson 1266 const uint8_t vcfcutoff = (VCFEnabled ? 0x80 : 0x00) | /* bit 7 */
1828 persson 918 (VCFCutoff & 0x7f); /* lower 7 bits */
1829 persson 1179 pData[132] = vcfcutoff;
1830 schoenebeck 809
1831 persson 1179 pData[133] = VCFCutoffController;
1832 schoenebeck 809
1833 persson 1266 const uint8_t vcfvelscale = (VCFCutoffControllerInvert ? 0x80 : 0x00) | /* bit 7 */
1834 persson 918 (VCFVelocityScale & 0x7f); /* lower 7 bits */
1835 persson 1179 pData[134] = vcfvelscale;
1836 schoenebeck 809
1837     // next byte unknown
1838    
1839 persson 1266 const uint8_t vcfresonance = (VCFResonanceDynamic ? 0x00 : 0x80) | /* bit 7 */
1840 persson 918 (VCFResonance & 0x7f); /* lower 7 bits */
1841 persson 1179 pData[136] = vcfresonance;
1842 schoenebeck 809
1843 persson 1266 const uint8_t vcfbreakpoint = (VCFKeyboardTracking ? 0x80 : 0x00) | /* bit 7 */
1844 persson 918 (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
1845 persson 1179 pData[137] = vcfbreakpoint;
1846 schoenebeck 809
1847     const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 |
1848     VCFVelocityCurve * 5;
1849 persson 1179 pData[138] = vcfvelocity;
1850 schoenebeck 809
1851     const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
1852 persson 1179 pData[139] = vcftype;
1853 persson 1070
1854     if (chunksize >= 148) {
1855     memcpy(&pData[140], DimensionUpperLimits, 8);
1856     }
1857 schoenebeck 809 }
1858    
1859 persson 613 // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
1860     double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
1861     {
1862     double* table;
1863     uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
1864 schoenebeck 16 if (pVelocityTables->count(tableKey)) { // if key exists
1865 persson 613 table = (*pVelocityTables)[tableKey];
1866 schoenebeck 16 }
1867     else {
1868 persson 613 table = CreateVelocityTable(curveType, depth, scaling);
1869     (*pVelocityTables)[tableKey] = table; // put the new table into the tables map
1870 schoenebeck 16 }
1871 persson 613 return table;
1872 schoenebeck 2 }
1873 schoenebeck 55
1874 schoenebeck 1316 Region* DimensionRegion::GetParent() const {
1875     return pRegion;
1876     }
1877    
1878 schoenebeck 36 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
1879     leverage_ctrl_t decodedcontroller;
1880     switch (EncodedController) {
1881     // special controller
1882     case _lev_ctrl_none:
1883     decodedcontroller.type = leverage_ctrl_t::type_none;
1884     decodedcontroller.controller_number = 0;
1885     break;
1886     case _lev_ctrl_velocity:
1887     decodedcontroller.type = leverage_ctrl_t::type_velocity;
1888     decodedcontroller.controller_number = 0;
1889     break;
1890     case _lev_ctrl_channelaftertouch:
1891     decodedcontroller.type = leverage_ctrl_t::type_channelaftertouch;
1892     decodedcontroller.controller_number = 0;
1893     break;
1894 schoenebeck 55
1895 schoenebeck 36 // ordinary MIDI control change controller
1896     case _lev_ctrl_modwheel:
1897     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1898     decodedcontroller.controller_number = 1;
1899     break;
1900     case _lev_ctrl_breath:
1901     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1902     decodedcontroller.controller_number = 2;
1903     break;
1904     case _lev_ctrl_foot:
1905     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1906     decodedcontroller.controller_number = 4;
1907     break;
1908     case _lev_ctrl_effect1:
1909     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1910     decodedcontroller.controller_number = 12;
1911     break;
1912     case _lev_ctrl_effect2:
1913     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1914     decodedcontroller.controller_number = 13;
1915     break;
1916     case _lev_ctrl_genpurpose1:
1917     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1918     decodedcontroller.controller_number = 16;
1919     break;
1920     case _lev_ctrl_genpurpose2:
1921     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1922     decodedcontroller.controller_number = 17;
1923     break;
1924     case _lev_ctrl_genpurpose3:
1925     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1926     decodedcontroller.controller_number = 18;
1927     break;
1928     case _lev_ctrl_genpurpose4:
1929     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1930     decodedcontroller.controller_number = 19;
1931     break;
1932     case _lev_ctrl_portamentotime:
1933     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1934     decodedcontroller.controller_number = 5;
1935     break;
1936     case _lev_ctrl_sustainpedal:
1937     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1938     decodedcontroller.controller_number = 64;
1939     break;
1940     case _lev_ctrl_portamento:
1941     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1942     decodedcontroller.controller_number = 65;
1943     break;
1944     case _lev_ctrl_sostenutopedal:
1945     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1946     decodedcontroller.controller_number = 66;
1947     break;
1948     case _lev_ctrl_softpedal:
1949     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1950     decodedcontroller.controller_number = 67;
1951     break;
1952     case _lev_ctrl_genpurpose5:
1953     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1954     decodedcontroller.controller_number = 80;
1955     break;
1956     case _lev_ctrl_genpurpose6:
1957     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1958     decodedcontroller.controller_number = 81;
1959     break;
1960     case _lev_ctrl_genpurpose7:
1961     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1962     decodedcontroller.controller_number = 82;
1963     break;
1964     case _lev_ctrl_genpurpose8:
1965     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1966     decodedcontroller.controller_number = 83;
1967     break;
1968     case _lev_ctrl_effect1depth:
1969     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1970     decodedcontroller.controller_number = 91;
1971     break;
1972     case _lev_ctrl_effect2depth:
1973     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1974     decodedcontroller.controller_number = 92;
1975     break;
1976     case _lev_ctrl_effect3depth:
1977     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1978     decodedcontroller.controller_number = 93;
1979     break;
1980     case _lev_ctrl_effect4depth:
1981     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1982     decodedcontroller.controller_number = 94;
1983     break;
1984     case _lev_ctrl_effect5depth:
1985     decodedcontroller.type = leverage_ctrl_t::type_controlchange;
1986     decodedcontroller.controller_number = 95;
1987     break;
1988 schoenebeck 55
1989 schoenebeck 36 // unknown controller type
1990     default:
1991     throw gig::Exception("Unknown leverage controller type.");
1992     }
1993     return decodedcontroller;
1994     }
1995 schoenebeck 2
1996 schoenebeck 809 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
1997     _lev_ctrl_t encodedcontroller;
1998     switch (DecodedController.type) {
1999     // special controller
2000     case leverage_ctrl_t::type_none:
2001     encodedcontroller = _lev_ctrl_none;
2002     break;
2003     case leverage_ctrl_t::type_velocity:
2004     encodedcontroller = _lev_ctrl_velocity;
2005     break;
2006     case leverage_ctrl_t::type_channelaftertouch:
2007     encodedcontroller = _lev_ctrl_channelaftertouch;
2008     break;
2009    
2010     // ordinary MIDI control change controller
2011     case leverage_ctrl_t::type_controlchange:
2012     switch (DecodedController.controller_number) {
2013     case 1:
2014     encodedcontroller = _lev_ctrl_modwheel;
2015     break;
2016     case 2:
2017     encodedcontroller = _lev_ctrl_breath;
2018     break;
2019     case 4:
2020     encodedcontroller = _lev_ctrl_foot;
2021     break;
2022     case 12:
2023     encodedcontroller = _lev_ctrl_effect1;
2024     break;
2025     case 13:
2026     encodedcontroller = _lev_ctrl_effect2;
2027     break;
2028     case 16:
2029     encodedcontroller = _lev_ctrl_genpurpose1;
2030     break;
2031     case 17:
2032     encodedcontroller = _lev_ctrl_genpurpose2;
2033     break;
2034     case 18:
2035     encodedcontroller = _lev_ctrl_genpurpose3;
2036     break;
2037     case 19:
2038     encodedcontroller = _lev_ctrl_genpurpose4;
2039     break;
2040     case 5:
2041     encodedcontroller = _lev_ctrl_portamentotime;
2042     break;
2043     case 64:
2044     encodedcontroller = _lev_ctrl_sustainpedal;
2045     break;
2046     case 65:
2047     encodedcontroller = _lev_ctrl_portamento;
2048     break;
2049     case 66:
2050     encodedcontroller = _lev_ctrl_sostenutopedal;
2051     break;
2052     case 67:
2053     encodedcontroller = _lev_ctrl_softpedal;
2054     break;
2055     case 80:
2056     encodedcontroller = _lev_ctrl_genpurpose5;
2057     break;
2058     case 81:
2059     encodedcontroller = _lev_ctrl_genpurpose6;
2060     break;
2061     case 82:
2062     encodedcontroller = _lev_ctrl_genpurpose7;
2063     break;
2064     case 83:
2065     encodedcontroller = _lev_ctrl_genpurpose8;
2066     break;
2067     case 91:
2068     encodedcontroller = _lev_ctrl_effect1depth;
2069     break;
2070     case 92:
2071     encodedcontroller = _lev_ctrl_effect2depth;
2072     break;
2073     case 93:
2074     encodedcontroller = _lev_ctrl_effect3depth;
2075     break;
2076     case 94:
2077     encodedcontroller = _lev_ctrl_effect4depth;
2078     break;
2079     case 95:
2080     encodedcontroller = _lev_ctrl_effect5depth;
2081     break;
2082     default:
2083     throw gig::Exception("leverage controller number is not supported by the gig format");
2084     }
2085 persson 1182 break;
2086 schoenebeck 809 default:
2087     throw gig::Exception("Unknown leverage controller type.");
2088     }
2089     return encodedcontroller;
2090     }
2091    
2092 schoenebeck 16 DimensionRegion::~DimensionRegion() {
2093     Instances--;
2094     if (!Instances) {
2095     // delete the velocity->volume tables
2096     VelocityTableMap::iterator iter;
2097     for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
2098     double* pTable = iter->second;
2099     if (pTable) delete[] pTable;
2100     }
2101     pVelocityTables->clear();
2102     delete pVelocityTables;
2103     pVelocityTables = NULL;
2104     }
2105 persson 858 if (VelocityTable) delete[] VelocityTable;
2106 schoenebeck 16 }
2107 schoenebeck 2
2108 schoenebeck 16 /**
2109     * Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
2110     * All involved parameters (VelocityResponseCurve, VelocityResponseDepth
2111     * and VelocityResponseCurveScaling) involved are taken into account to
2112     * calculate the amplitude factor. Use this method when a key was
2113     * triggered to get the volume with which the sample should be played
2114     * back.
2115     *
2116 schoenebeck 36 * @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
2117     * @returns amplitude factor (between 0.0 and 1.0)
2118 schoenebeck 16 */
2119     double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
2120     return pVelocityAttenuationTable[MIDIKeyVelocity];
2121     }
2122 schoenebeck 2
2123 persson 613 double DimensionRegion::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
2124     return pVelocityReleaseTable[MIDIKeyVelocity];
2125     }
2126    
2127 persson 728 double DimensionRegion::GetVelocityCutoff(uint8_t MIDIKeyVelocity) {
2128     return pVelocityCutoffTable[MIDIKeyVelocity];
2129     }
2130    
2131 schoenebeck 308 double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2132 schoenebeck 317
2133 schoenebeck 308 // line-segment approximations of the 15 velocity curves
2134 schoenebeck 16
2135 schoenebeck 308 // linear
2136     const int lin0[] = { 1, 1, 127, 127 };
2137     const int lin1[] = { 1, 21, 127, 127 };
2138     const int lin2[] = { 1, 45, 127, 127 };
2139     const int lin3[] = { 1, 74, 127, 127 };
2140     const int lin4[] = { 1, 127, 127, 127 };
2141 schoenebeck 16
2142 schoenebeck 308 // non-linear
2143     const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
2144 schoenebeck 317 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
2145 schoenebeck 308 127, 127 };
2146     const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
2147     127, 127 };
2148     const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
2149     127, 127 };
2150     const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
2151 schoenebeck 317
2152 schoenebeck 308 // special
2153 schoenebeck 317 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
2154 schoenebeck 308 113, 127, 127, 127 };
2155     const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
2156     118, 127, 127, 127 };
2157 schoenebeck 317 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
2158 schoenebeck 308 85, 90, 91, 127, 127, 127 };
2159 schoenebeck 317 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
2160 schoenebeck 308 117, 127, 127, 127 };
2161 schoenebeck 317 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
2162 schoenebeck 308 127, 127 };
2163 schoenebeck 317
2164 persson 728 // this is only used by the VCF velocity curve
2165     const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
2166     91, 127, 127, 127 };
2167    
2168 schoenebeck 308 const int* const curves[] = { non0, non1, non2, non3, non4,
2169 schoenebeck 317 lin0, lin1, lin2, lin3, lin4,
2170 persson 728 spe0, spe1, spe2, spe3, spe4, spe5 };
2171 schoenebeck 317
2172 schoenebeck 308 double* const table = new double[128];
2173    
2174     const int* curve = curves[curveType * 5 + depth];
2175     const int s = scaling == 0 ? 20 : scaling; // 0 or 20 means no scaling
2176 schoenebeck 317
2177 schoenebeck 308 table[0] = 0;
2178     for (int x = 1 ; x < 128 ; x++) {
2179    
2180     if (x > curve[2]) curve += 2;
2181 schoenebeck 317 double y = curve[1] + (x - curve[0]) *
2182 schoenebeck 308 (double(curve[3] - curve[1]) / (curve[2] - curve[0]));
2183     y = y / 127;
2184    
2185     // Scale up for s > 20, down for s < 20. When
2186     // down-scaling, the curve still ends at 1.0.
2187     if (s < 20 && y >= 0.5)
2188     y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
2189     else
2190     y = y * (s / 20.0);
2191     if (y > 1) y = 1;
2192    
2193     table[x] = y;
2194     }
2195     return table;
2196     }
2197    
2198    
2199 schoenebeck 2 // *************** Region ***************
2200     // *
2201    
2202     Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {
2203     // Initialization
2204     Dimensions = 0;
2205 schoenebeck 347 for (int i = 0; i < 256; i++) {
2206 schoenebeck 2 pDimensionRegions[i] = NULL;
2207     }
2208 schoenebeck 282 Layers = 1;
2209 schoenebeck 347 File* file = (File*) GetParent()->GetParent();
2210     int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
2211 schoenebeck 2
2212     // Actual Loading
2213    
2214     LoadDimensionRegions(rgnList);
2215    
2216     RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
2217     if (_3lnk) {
2218     DimensionRegions = _3lnk->ReadUint32();
2219 schoenebeck 347 for (int i = 0; i < dimensionBits; i++) {
2220 schoenebeck 2 dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
2221     uint8_t bits = _3lnk->ReadUint8();
2222 persson 1199 _3lnk->ReadUint8(); // bit position of the dimension (bits[0] + bits[1] + ... + bits[i-1])
2223     _3lnk->ReadUint8(); // (1 << bit position of next dimension) - (1 << bit position of this dimension)
2224 persson 774 uint8_t zones = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)
2225 schoenebeck 2 if (dimension == dimension_none) { // inactive dimension
2226     pDimensionDefinitions[i].dimension = dimension_none;
2227     pDimensionDefinitions[i].bits = 0;
2228     pDimensionDefinitions[i].zones = 0;
2229     pDimensionDefinitions[i].split_type = split_type_bit;
2230     pDimensionDefinitions[i].zone_size = 0;
2231     }
2232     else { // active dimension
2233     pDimensionDefinitions[i].dimension = dimension;
2234     pDimensionDefinitions[i].bits = bits;
2235 persson 774 pDimensionDefinitions[i].zones = zones ? zones : 0x01 << bits; // = pow(2,bits)
2236 schoenebeck 1113 pDimensionDefinitions[i].split_type = __resolveSplitType(dimension);
2237     pDimensionDefinitions[i].zone_size = __resolveZoneSize(pDimensionDefinitions[i]);
2238 schoenebeck 2 Dimensions++;
2239 schoenebeck 282
2240     // if this is a layer dimension, remember the amount of layers
2241     if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
2242 schoenebeck 2 }
2243 persson 774 _3lnk->SetPos(3, RIFF::stream_curpos); // jump forward to next dimension definition
2244 schoenebeck 2 }
2245 persson 834 for (int i = dimensionBits ; i < 8 ; i++) pDimensionDefinitions[i].bits = 0;
2246 schoenebeck 2
2247 persson 858 // if there's a velocity dimension and custom velocity zone splits are used,
2248     // update the VelocityTables in the dimension regions
2249     UpdateVelocityTable();
2250 schoenebeck 2
2251 schoenebeck 317 // jump to start of the wave pool indices (if not already there)
2252     if (file->pVersion && file->pVersion->major == 3)
2253     _3lnk->SetPos(68); // version 3 has a different 3lnk structure
2254     else
2255     _3lnk->SetPos(44);
2256    
2257 schoenebeck 2 // load sample references
2258     for (uint i = 0; i < DimensionRegions; i++) {
2259     uint32_t wavepoolindex = _3lnk->ReadUint32();
2260 persson 902 if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
2261 schoenebeck 2 }
2262 persson 918 GetSample(); // load global region sample reference
2263 persson 1102 } else {
2264     DimensionRegions = 0;
2265 persson 1182 for (int i = 0 ; i < 8 ; i++) {
2266     pDimensionDefinitions[i].dimension = dimension_none;
2267     pDimensionDefinitions[i].bits = 0;
2268     pDimensionDefinitions[i].zones = 0;
2269     }
2270 schoenebeck 2 }
2271 schoenebeck 823
2272     // make sure there is at least one dimension region
2273     if (!DimensionRegions) {
2274     RIFF::List* _3prg = rgnList->GetSubList(LIST_TYPE_3PRG);
2275     if (!_3prg) _3prg = rgnList->AddSubList(LIST_TYPE_3PRG);
2276     RIFF::List* _3ewl = _3prg->AddSubList(LIST_TYPE_3EWL);
2277 schoenebeck 1316 pDimensionRegions[0] = new DimensionRegion(this, _3ewl);
2278 schoenebeck 823 DimensionRegions = 1;
2279     }
2280 schoenebeck 2 }
2281    
2282 schoenebeck 809 /**
2283     * Apply Region settings and all its DimensionRegions to the respective
2284     * RIFF chunks. You have to call File::Save() to make changes persistent.
2285     *
2286     * Usually there is absolutely no need to call this method explicitly.
2287     * It will be called automatically when File::Save() was called.
2288     *
2289     * @throws gig::Exception if samples cannot be dereferenced
2290     */
2291     void Region::UpdateChunks() {
2292 schoenebeck 1106 // in the gig format we don't care about the Region's sample reference
2293     // but we still have to provide some existing one to not corrupt the
2294     // file, so to avoid the latter we simply always assign the sample of
2295     // the first dimension region of this region
2296     pSample = pDimensionRegions[0]->pSample;
2297    
2298 schoenebeck 809 // first update base class's chunks
2299     DLS::Region::UpdateChunks();
2300    
2301     // update dimension region's chunks
2302 schoenebeck 823 for (int i = 0; i < DimensionRegions; i++) {
2303 persson 1317 pDimensionRegions[i]->UpdateChunks();
2304 schoenebeck 823 }
2305 schoenebeck 809
2306 persson 1317 File* pFile = (File*) GetParent()->GetParent();
2307     bool version3 = pFile->pVersion && pFile->pVersion->major == 3;
2308 persson 1247 const int iMaxDimensions = version3 ? 8 : 5;
2309     const int iMaxDimensionRegions = version3 ? 256 : 32;
2310 schoenebeck 809
2311     // make sure '3lnk' chunk exists
2312     RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
2313     if (!_3lnk) {
2314 persson 1247 const int _3lnkChunkSize = version3 ? 1092 : 172;
2315 schoenebeck 809 _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
2316 persson 1182 memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
2317 persson 1192
2318     // move 3prg to last position
2319     pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), 0);
2320 schoenebeck 809 }
2321    
2322     // update dimension definitions in '3lnk' chunk
2323     uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
2324 persson 1179 store32(&pData[0], DimensionRegions);
2325 persson 1199 int shift = 0;
2326 schoenebeck 809 for (int i = 0; i < iMaxDimensions; i++) {
2327 persson 918 pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
2328     pData[5 + i * 8] = pDimensionDefinitions[i].bits;
2329 persson 1266 pData[6 + i * 8] = pDimensionDefinitions[i].dimension == dimension_none ? 0 : shift;
2330 persson 1199 pData[7 + i * 8] = (1 << (shift + pDimensionDefinitions[i].bits)) - (1 << shift);
2331 persson 918 pData[8 + i * 8] = pDimensionDefinitions[i].zones;
2332 persson 1199 // next 3 bytes unknown, always zero?
2333    
2334     shift += pDimensionDefinitions[i].bits;
2335 schoenebeck 809 }
2336    
2337