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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3475 - (show annotations) (download)
Wed Feb 20 17:06:11 2019 UTC (2 years, 8 months ago) by schoenebeck
File size: 290776 byte(s)
- Fixed compiler error with older compilers.

1 /***************************************************************************
2 * *
3 * libgig - C++ cross-platform Gigasampler format file access library *
4 * *
5 * Copyright (C) 2003-2019 by Christian Schoenebeck *
6 * <cuse@users.sourceforge.net> *
7 * *
8 * This library is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #include "gig.h"
25
26 #include "helper.h"
27 #include "Serialization.h"
28
29 #include <algorithm>
30 #include <math.h>
31 #include <iostream>
32 #include <assert.h>
33
34 /// libgig's current file format version (for extending the original Giga file
35 /// format with libgig's own custom data / custom features).
36 #define GIG_FILE_EXT_VERSION 2
37
38 /// Initial size of the sample buffer which is used for decompression of
39 /// compressed sample wave streams - this value should always be bigger than
40 /// the biggest sample piece expected to be read by the sampler engine,
41 /// otherwise the buffer size will be raised at runtime and thus the buffer
42 /// reallocated which is time consuming and unefficient.
43 #define INITIAL_SAMPLE_BUFFER_SIZE 512000 // 512 kB
44
45 /** (so far) every exponential paramater in the gig format has a basis of 1.000000008813822 */
46 #define GIG_EXP_DECODE(x) (pow(1.000000008813822, x))
47 #define GIG_EXP_ENCODE(x) (log(x) / log(1.000000008813822))
48 #define GIG_PITCH_TRACK_EXTRACT(x) (!(x & 0x01))
49 #define GIG_PITCH_TRACK_ENCODE(x) ((x) ? 0x00 : 0x01)
50 #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x) ((x >> 4) & 0x03)
51 #define GIG_VCF_RESONANCE_CTRL_ENCODE(x) ((x & 0x03) << 4)
52 #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x) ((x >> 1) & 0x03)
53 #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x) ((x >> 3) & 0x03)
54 #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x) ((x >> 5) & 0x03)
55 #define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x) ((x & 0x03) << 1)
56 #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x) ((x & 0x03) << 3)
57 #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x) ((x & 0x03) << 5)
58
59 #define SRLZ(member) \
60 archive->serializeMember(*this, member, #member);
61
62 namespace gig {
63
64 // *************** Internal functions for sample decompression ***************
65 // *
66
67 namespace {
68
69 inline int get12lo(const unsigned char* pSrc)
70 {
71 const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
72 return x & 0x800 ? x - 0x1000 : x;
73 }
74
75 inline int get12hi(const unsigned char* pSrc)
76 {
77 const int x = pSrc[1] >> 4 | pSrc[2] << 4;
78 return x & 0x800 ? x - 0x1000 : x;
79 }
80
81 inline int16_t get16(const unsigned char* pSrc)
82 {
83 return int16_t(pSrc[0] | pSrc[1] << 8);
84 }
85
86 inline int get24(const unsigned char* pSrc)
87 {
88 const int x = pSrc[0] | pSrc[1] << 8 | pSrc[2] << 16;
89 return x & 0x800000 ? x - 0x1000000 : x;
90 }
91
92 inline void store24(unsigned char* pDst, int x)
93 {
94 pDst[0] = x;
95 pDst[1] = x >> 8;
96 pDst[2] = x >> 16;
97 }
98
99 void Decompress16(int compressionmode, const unsigned char* params,
100 int srcStep, int dstStep,
101 const unsigned char* pSrc, int16_t* pDst,
102 file_offset_t currentframeoffset,
103 file_offset_t copysamples)
104 {
105 switch (compressionmode) {
106 case 0: // 16 bit uncompressed
107 pSrc += currentframeoffset * srcStep;
108 while (copysamples) {
109 *pDst = get16(pSrc);
110 pDst += dstStep;
111 pSrc += srcStep;
112 copysamples--;
113 }
114 break;
115
116 case 1: // 16 bit compressed to 8 bit
117 int y = get16(params);
118 int dy = get16(params + 2);
119 while (currentframeoffset) {
120 dy -= int8_t(*pSrc);
121 y -= dy;
122 pSrc += srcStep;
123 currentframeoffset--;
124 }
125 while (copysamples) {
126 dy -= int8_t(*pSrc);
127 y -= dy;
128 *pDst = y;
129 pDst += dstStep;
130 pSrc += srcStep;
131 copysamples--;
132 }
133 break;
134 }
135 }
136
137 void Decompress24(int compressionmode, const unsigned char* params,
138 int dstStep, const unsigned char* pSrc, uint8_t* pDst,
139 file_offset_t currentframeoffset,
140 file_offset_t copysamples, int truncatedBits)
141 {
142 int y, dy, ddy, dddy;
143
144 #define GET_PARAMS(params) \
145 y = get24(params); \
146 dy = y - get24((params) + 3); \
147 ddy = get24((params) + 6); \
148 dddy = get24((params) + 9)
149
150 #define SKIP_ONE(x) \
151 dddy -= (x); \
152 ddy -= dddy; \
153 dy = -dy - ddy; \
154 y += dy
155
156 #define COPY_ONE(x) \
157 SKIP_ONE(x); \
158 store24(pDst, y << truncatedBits); \
159 pDst += dstStep
160
161 switch (compressionmode) {
162 case 2: // 24 bit uncompressed
163 pSrc += currentframeoffset * 3;
164 while (copysamples) {
165 store24(pDst, get24(pSrc) << truncatedBits);
166 pDst += dstStep;
167 pSrc += 3;
168 copysamples--;
169 }
170 break;
171
172 case 3: // 24 bit compressed to 16 bit
173 GET_PARAMS(params);
174 while (currentframeoffset) {
175 SKIP_ONE(get16(pSrc));
176 pSrc += 2;
177 currentframeoffset--;
178 }
179 while (copysamples) {
180 COPY_ONE(get16(pSrc));
181 pSrc += 2;
182 copysamples--;
183 }
184 break;
185
186 case 4: // 24 bit compressed to 12 bit
187 GET_PARAMS(params);
188 while (currentframeoffset > 1) {
189 SKIP_ONE(get12lo(pSrc));
190 SKIP_ONE(get12hi(pSrc));
191 pSrc += 3;
192 currentframeoffset -= 2;
193 }
194 if (currentframeoffset) {
195 SKIP_ONE(get12lo(pSrc));
196 currentframeoffset--;
197 if (copysamples) {
198 COPY_ONE(get12hi(pSrc));
199 pSrc += 3;
200 copysamples--;
201 }
202 }
203 while (copysamples > 1) {
204 COPY_ONE(get12lo(pSrc));
205 COPY_ONE(get12hi(pSrc));
206 pSrc += 3;
207 copysamples -= 2;
208 }
209 if (copysamples) {
210 COPY_ONE(get12lo(pSrc));
211 }
212 break;
213
214 case 5: // 24 bit compressed to 8 bit
215 GET_PARAMS(params);
216 while (currentframeoffset) {
217 SKIP_ONE(int8_t(*pSrc++));
218 currentframeoffset--;
219 }
220 while (copysamples) {
221 COPY_ONE(int8_t(*pSrc++));
222 copysamples--;
223 }
224 break;
225 }
226 }
227
228 const int bytesPerFrame[] = { 4096, 2052, 768, 524, 396, 268 };
229 const int bytesPerFrameNoHdr[] = { 4096, 2048, 768, 512, 384, 256 };
230 const int headerSize[] = { 0, 4, 0, 12, 12, 12 };
231 const int bitsPerSample[] = { 16, 8, 24, 16, 12, 8 };
232 }
233
234
235
236 // *************** Internal CRC-32 (Cyclic Redundancy Check) functions ***************
237 // *
238
239 static uint32_t* __initCRCTable() {
240 static uint32_t res[256];
241
242 for (int i = 0 ; i < 256 ; i++) {
243 uint32_t c = i;
244 for (int j = 0 ; j < 8 ; j++) {
245 c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
246 }
247 res[i] = c;
248 }
249 return res;
250 }
251
252 static const uint32_t* __CRCTable = __initCRCTable();
253
254 /**
255 * Initialize a CRC variable.
256 *
257 * @param crc - variable to be initialized
258 */
259 inline static void __resetCRC(uint32_t& crc) {
260 crc = 0xffffffff;
261 }
262
263 /**
264 * Used to calculate checksums of the sample data in a gig file. The
265 * checksums are stored in the 3crc chunk of the gig file and
266 * automatically updated when a sample is written with Sample::Write().
267 *
268 * One should call __resetCRC() to initialize the CRC variable to be
269 * used before calling this function the first time.
270 *
271 * After initializing the CRC variable one can call this function
272 * arbitrary times, i.e. to split the overall CRC calculation into
273 * steps.
274 *
275 * Once the whole data was processed by __calculateCRC(), one should
276 * call __finalizeCRC() to get the final CRC result.
277 *
278 * @param buf - pointer to data the CRC shall be calculated of
279 * @param bufSize - size of the data to be processed
280 * @param crc - variable the CRC sum shall be stored to
281 */
282 static void __calculateCRC(unsigned char* buf, size_t bufSize, uint32_t& crc) {
283 for (size_t i = 0 ; i < bufSize ; i++) {
284 crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
285 }
286 }
287
288 /**
289 * Returns the final CRC result.
290 *
291 * @param crc - variable previously passed to __calculateCRC()
292 */
293 inline static void __finalizeCRC(uint32_t& crc) {
294 crc ^= 0xffffffff;
295 }
296
297
298
299 // *************** Other Internal functions ***************
300 // *
301
302 static split_type_t __resolveSplitType(dimension_t dimension) {
303 return (
304 dimension == dimension_layer ||
305 dimension == dimension_samplechannel ||
306 dimension == dimension_releasetrigger ||
307 dimension == dimension_keyboard ||
308 dimension == dimension_roundrobin ||
309 dimension == dimension_random ||
310 dimension == dimension_smartmidi ||
311 dimension == dimension_roundrobinkeyboard
312 ) ? split_type_bit : split_type_normal;
313 }
314
315 static int __resolveZoneSize(dimension_def_t& dimension_definition) {
316 return (dimension_definition.split_type == split_type_normal)
317 ? int(128.0 / dimension_definition.zones) : 0;
318 }
319
320
321
322 // *************** leverage_ctrl_t ***************
323 // *
324
325 void leverage_ctrl_t::serialize(Serialization::Archive* archive) {
326 SRLZ(type);
327 SRLZ(controller_number);
328 }
329
330
331
332 // *************** crossfade_t ***************
333 // *
334
335 void crossfade_t::serialize(Serialization::Archive* archive) {
336 SRLZ(in_start);
337 SRLZ(in_end);
338 SRLZ(out_start);
339 SRLZ(out_end);
340 }
341
342
343
344 // *************** eg_opt_t ***************
345 // *
346
347 eg_opt_t::eg_opt_t() {
348 AttackCancel = true;
349 AttackHoldCancel = true;
350 Decay1Cancel = true;
351 Decay2Cancel = true;
352 ReleaseCancel = true;
353 }
354
355 void eg_opt_t::serialize(Serialization::Archive* archive) {
356 SRLZ(AttackCancel);
357 SRLZ(AttackHoldCancel);
358 SRLZ(Decay1Cancel);
359 SRLZ(Decay2Cancel);
360 SRLZ(ReleaseCancel);
361 }
362
363
364
365 // *************** Sample ***************
366 // *
367
368 size_t Sample::Instances = 0;
369 buffer_t Sample::InternalDecompressionBuffer;
370
371 /** @brief Constructor.
372 *
373 * Load an existing sample or create a new one. A 'wave' list chunk must
374 * be given to this constructor. In case the given 'wave' list chunk
375 * contains a 'fmt', 'data' (and optionally a '3gix', 'smpl') chunk, the
376 * format and sample data will be loaded from there, otherwise default
377 * values will be used and those chunks will be created when
378 * File::Save() will be called later on.
379 *
380 * @param pFile - pointer to gig::File where this sample is
381 * located (or will be located)
382 * @param waveList - pointer to 'wave' list chunk which is (or
383 * will be) associated with this sample
384 * @param WavePoolOffset - offset of this sample data from wave pool
385 * ('wvpl') list chunk
386 * @param fileNo - number of an extension file where this sample
387 * is located, 0 otherwise
388 * @param index - wave pool index of sample (may be -1 on new sample)
389 */
390 Sample::Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo, int index)
391 : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset)
392 {
393 static const DLS::Info::string_length_t fixedStringLengths[] = {
394 { CHUNK_ID_INAM, 64 },
395 { 0, 0 }
396 };
397 pInfo->SetFixedStringLengths(fixedStringLengths);
398 Instances++;
399 FileNo = fileNo;
400
401 __resetCRC(crc);
402 // if this is not a new sample, try to get the sample's already existing
403 // CRC32 checksum from disk, this checksum will reflect the sample's CRC32
404 // checksum of the time when the sample was consciously modified by the
405 // user for the last time (by calling Sample::Write() that is).
406 if (index >= 0) { // not a new file ...
407 try {
408 uint32_t crc = pFile->GetSampleChecksumByIndex(index);
409 this->crc = crc;
410 } catch (...) {}
411 }
412
413 pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
414 if (pCk3gix) {
415 uint16_t iSampleGroup = pCk3gix->ReadInt16();
416 pGroup = pFile->GetGroup(iSampleGroup);
417 } else { // '3gix' chunk missing
418 // by default assigned to that mandatory "Default Group"
419 pGroup = pFile->GetGroup(0);
420 }
421
422 pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
423 if (pCkSmpl) {
424 Manufacturer = pCkSmpl->ReadInt32();
425 Product = pCkSmpl->ReadInt32();
426 SamplePeriod = pCkSmpl->ReadInt32();
427 MIDIUnityNote = pCkSmpl->ReadInt32();
428 FineTune = pCkSmpl->ReadInt32();
429 pCkSmpl->Read(&SMPTEFormat, 1, 4);
430 SMPTEOffset = pCkSmpl->ReadInt32();
431 Loops = pCkSmpl->ReadInt32();
432 pCkSmpl->ReadInt32(); // manufByt
433 LoopID = pCkSmpl->ReadInt32();
434 pCkSmpl->Read(&LoopType, 1, 4);
435 LoopStart = pCkSmpl->ReadInt32();
436 LoopEnd = pCkSmpl->ReadInt32();
437 LoopFraction = pCkSmpl->ReadInt32();
438 LoopPlayCount = pCkSmpl->ReadInt32();
439 } else { // 'smpl' chunk missing
440 // use default values
441 Manufacturer = 0;
442 Product = 0;
443 SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
444 MIDIUnityNote = 60;
445 FineTune = 0;
446 SMPTEFormat = smpte_format_no_offset;
447 SMPTEOffset = 0;
448 Loops = 0;
449 LoopID = 0;
450 LoopType = loop_type_normal;
451 LoopStart = 0;
452 LoopEnd = 0;
453 LoopFraction = 0;
454 LoopPlayCount = 0;
455 }
456
457 FrameTable = NULL;
458 SamplePos = 0;
459 RAMCache.Size = 0;
460 RAMCache.pStart = NULL;
461 RAMCache.NullExtensionSize = 0;
462
463 if (BitDepth > 24) throw gig::Exception("Only samples up to 24 bit supported");
464
465 RIFF::Chunk* ewav = waveList->GetSubChunk(CHUNK_ID_EWAV);
466 Compressed = ewav;
467 Dithered = false;
468 TruncatedBits = 0;
469 if (Compressed) {
470 uint32_t version = ewav->ReadInt32();
471 if (version > 2 && BitDepth == 24) {
472 Dithered = ewav->ReadInt32();
473 ewav->SetPos(Channels == 2 ? 84 : 64);
474 TruncatedBits = ewav->ReadInt32();
475 }
476 ScanCompressedSample();
477 }
478
479 // we use a buffer for decompression and for truncating 24 bit samples to 16 bit
480 if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {
481 InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
482 InternalDecompressionBuffer.Size = INITIAL_SAMPLE_BUFFER_SIZE;
483 }
484 FrameOffset = 0; // just for streaming compressed samples
485
486 LoopSize = LoopEnd - LoopStart + 1;
487 }
488
489 /**
490 * Make a (semi) deep copy of the Sample object given by @a orig (without
491 * the actual waveform data) and assign it to this object.
492 *
493 * Discussion: copying .gig samples is a bit tricky. It requires three
494 * steps:
495 * 1. Copy sample's meta informations (done by CopyAssignMeta()) including
496 * its new sample waveform data size.
497 * 2. Saving the file (done by File::Save()) so that it gains correct size
498 * and layout for writing the actual wave form data directly to disc
499 * in next step.
500 * 3. Copy the waveform data with disk streaming (done by CopyAssignWave()).
501 *
502 * @param orig - original Sample object to be copied from
503 */
504 void Sample::CopyAssignMeta(const Sample* orig) {
505 // handle base classes
506 DLS::Sample::CopyAssignCore(orig);
507
508 // handle actual own attributes of this class
509 Manufacturer = orig->Manufacturer;
510 Product = orig->Product;
511 SamplePeriod = orig->SamplePeriod;
512 MIDIUnityNote = orig->MIDIUnityNote;
513 FineTune = orig->FineTune;
514 SMPTEFormat = orig->SMPTEFormat;
515 SMPTEOffset = orig->SMPTEOffset;
516 Loops = orig->Loops;
517 LoopID = orig->LoopID;
518 LoopType = orig->LoopType;
519 LoopStart = orig->LoopStart;
520 LoopEnd = orig->LoopEnd;
521 LoopSize = orig->LoopSize;
522 LoopFraction = orig->LoopFraction;
523 LoopPlayCount = orig->LoopPlayCount;
524
525 // schedule resizing this sample to the given sample's size
526 Resize(orig->GetSize());
527 }
528
529 /**
530 * Should be called after CopyAssignMeta() and File::Save() sequence.
531 * Read more about it in the discussion of CopyAssignMeta(). This method
532 * copies the actual waveform data by disk streaming.
533 *
534 * @e CAUTION: this method is currently not thread safe! During this
535 * operation the sample must not be used for other purposes by other
536 * threads!
537 *
538 * @param orig - original Sample object to be copied from
539 */
540 void Sample::CopyAssignWave(const Sample* orig) {
541 const int iReadAtOnce = 32*1024;
542 char* buf = new char[iReadAtOnce * orig->FrameSize];
543 Sample* pOrig = (Sample*) orig; //HACK: remove constness for now
544 file_offset_t restorePos = pOrig->GetPos();
545 pOrig->SetPos(0);
546 SetPos(0);
547 for (file_offset_t n = pOrig->Read(buf, iReadAtOnce); n;
548 n = pOrig->Read(buf, iReadAtOnce))
549 {
550 Write(buf, n);
551 }
552 pOrig->SetPos(restorePos);
553 delete [] buf;
554 }
555
556 /**
557 * Apply sample and its settings to the respective RIFF chunks. You have
558 * to call File::Save() to make changes persistent.
559 *
560 * Usually there is absolutely no need to call this method explicitly.
561 * It will be called automatically when File::Save() was called.
562 *
563 * @param pProgress - callback function for progress notification
564 * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
565 * was provided yet
566 * @throws gig::Exception if there is any invalid sample setting
567 */
568 void Sample::UpdateChunks(progress_t* pProgress) {
569 // first update base class's chunks
570 DLS::Sample::UpdateChunks(pProgress);
571
572 // make sure 'smpl' chunk exists
573 pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
574 if (!pCkSmpl) {
575 pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);
576 memset(pCkSmpl->LoadChunkData(), 0, 60);
577 }
578 // update 'smpl' chunk
579 uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();
580 SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
581 store32(&pData[0], Manufacturer);
582 store32(&pData[4], Product);
583 store32(&pData[8], SamplePeriod);
584 store32(&pData[12], MIDIUnityNote);
585 store32(&pData[16], FineTune);
586 store32(&pData[20], SMPTEFormat);
587 store32(&pData[24], SMPTEOffset);
588 store32(&pData[28], Loops);
589
590 // we skip 'manufByt' for now (4 bytes)
591
592 store32(&pData[36], LoopID);
593 store32(&pData[40], LoopType);
594 store32(&pData[44], LoopStart);
595 store32(&pData[48], LoopEnd);
596 store32(&pData[52], LoopFraction);
597 store32(&pData[56], LoopPlayCount);
598
599 // make sure '3gix' chunk exists
600 pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
601 if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
602 // determine appropriate sample group index (to be stored in chunk)
603 uint16_t iSampleGroup = 0; // 0 refers to default sample group
604 File* pFile = static_cast<File*>(pParent);
605 if (pFile->pGroups) {
606 std::list<Group*>::iterator iter = pFile->pGroups->begin();
607 std::list<Group*>::iterator end = pFile->pGroups->end();
608 for (int i = 0; iter != end; i++, iter++) {
609 if (*iter == pGroup) {
610 iSampleGroup = i;
611 break; // found
612 }
613 }
614 }
615 // update '3gix' chunk
616 pData = (uint8_t*) pCk3gix->LoadChunkData();
617 store16(&pData[0], iSampleGroup);
618
619 // if the library user toggled the "Compressed" attribute from true to
620 // false, then the EWAV chunk associated with compressed samples needs
621 // to be deleted
622 RIFF::Chunk* ewav = pWaveList->GetSubChunk(CHUNK_ID_EWAV);
623 if (ewav && !Compressed) {
624 pWaveList->DeleteSubChunk(ewav);
625 }
626 }
627
628 /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
629 void Sample::ScanCompressedSample() {
630 //TODO: we have to add some more scans here (e.g. determine compression rate)
631 this->SamplesTotal = 0;
632 std::list<file_offset_t> frameOffsets;
633
634 SamplesPerFrame = BitDepth == 24 ? 256 : 2048;
635 WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag
636
637 // Scanning
638 pCkData->SetPos(0);
639 if (Channels == 2) { // Stereo
640 for (int i = 0 ; ; i++) {
641 // for 24 bit samples every 8:th frame offset is
642 // stored, to save some memory
643 if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
644
645 const int mode_l = pCkData->ReadUint8();
646 const int mode_r = pCkData->ReadUint8();
647 if (mode_l > 5 || mode_r > 5) throw gig::Exception("Unknown compression mode");
648 const file_offset_t frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
649
650 if (pCkData->RemainingBytes() <= frameSize) {
651 SamplesInLastFrame =
652 ((pCkData->RemainingBytes() - headerSize[mode_l] - headerSize[mode_r]) << 3) /
653 (bitsPerSample[mode_l] + bitsPerSample[mode_r]);
654 SamplesTotal += SamplesInLastFrame;
655 break;
656 }
657 SamplesTotal += SamplesPerFrame;
658 pCkData->SetPos(frameSize, RIFF::stream_curpos);
659 }
660 }
661 else { // Mono
662 for (int i = 0 ; ; i++) {
663 if (BitDepth != 24 || (i & 7) == 0) frameOffsets.push_back(pCkData->GetPos());
664
665 const int mode = pCkData->ReadUint8();
666 if (mode > 5) throw gig::Exception("Unknown compression mode");
667 const file_offset_t frameSize = bytesPerFrame[mode];
668
669 if (pCkData->RemainingBytes() <= frameSize) {
670 SamplesInLastFrame =
671 ((pCkData->RemainingBytes() - headerSize[mode]) << 3) / bitsPerSample[mode];
672 SamplesTotal += SamplesInLastFrame;
673 break;
674 }
675 SamplesTotal += SamplesPerFrame;
676 pCkData->SetPos(frameSize, RIFF::stream_curpos);
677 }
678 }
679 pCkData->SetPos(0);
680
681 // Build the frames table (which is used for fast resolving of a frame's chunk offset)
682 if (FrameTable) delete[] FrameTable;
683 FrameTable = new file_offset_t[frameOffsets.size()];
684 std::list<file_offset_t>::iterator end = frameOffsets.end();
685 std::list<file_offset_t>::iterator iter = frameOffsets.begin();
686 for (int i = 0; iter != end; i++, iter++) {
687 FrameTable[i] = *iter;
688 }
689 }
690
691 /**
692 * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
693 * ReleaseSampleData() to free the memory if you don't need the cached
694 * sample data anymore.
695 *
696 * @returns buffer_t structure with start address and size of the buffer
697 * in bytes
698 * @see ReleaseSampleData(), Read(), SetPos()
699 */
700 buffer_t Sample::LoadSampleData() {
701 return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, 0); // 0 amount of NullSamples
702 }
703
704 /**
705 * Reads (uncompresses if needed) and caches the first \a SampleCount
706 * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
707 * memory space if you don't need the cached samples anymore. There is no
708 * guarantee that exactly \a SampleCount samples will be cached; this is
709 * not an error. The size will be eventually truncated e.g. to the
710 * beginning of a frame of a compressed sample. This is done for
711 * efficiency reasons while streaming the wave by your sampler engine
712 * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
713 * that will be returned to determine the actual cached samples, but note
714 * that the size is given in bytes! You get the number of actually cached
715 * samples by dividing it by the frame size of the sample:
716 * @code
717 * buffer_t buf = pSample->LoadSampleData(acquired_samples);
718 * long cachedsamples = buf.Size / pSample->FrameSize;
719 * @endcode
720 *
721 * @param SampleCount - number of sample points to load into RAM
722 * @returns buffer_t structure with start address and size of
723 * the cached sample data in bytes
724 * @see ReleaseSampleData(), Read(), SetPos()
725 */
726 buffer_t Sample::LoadSampleData(file_offset_t SampleCount) {
727 return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
728 }
729
730 /**
731 * Loads (and uncompresses if needed) the whole sample wave into RAM. Use
732 * ReleaseSampleData() to free the memory if you don't need the cached
733 * sample data anymore.
734 * The method will add \a NullSamplesCount silence samples past the
735 * official buffer end (this won't affect the 'Size' member of the
736 * buffer_t structure, that means 'Size' always reflects the size of the
737 * actual sample data, the buffer might be bigger though). Silence
738 * samples past the official buffer are needed for differential
739 * algorithms that always have to take subsequent samples into account
740 * (resampling/interpolation would be an important example) and avoids
741 * memory access faults in such cases.
742 *
743 * @param NullSamplesCount - number of silence samples the buffer should
744 * be extended past it's data end
745 * @returns buffer_t structure with start address and
746 * size of the buffer in bytes
747 * @see ReleaseSampleData(), Read(), SetPos()
748 */
749 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
750 return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, NullSamplesCount);
751 }
752
753 /**
754 * Reads (uncompresses if needed) and caches the first \a SampleCount
755 * numbers of SamplePoints in RAM. Use ReleaseSampleData() to free the
756 * memory space if you don't need the cached samples anymore. There is no
757 * guarantee that exactly \a SampleCount samples will be cached; this is
758 * not an error. The size will be eventually truncated e.g. to the
759 * beginning of a frame of a compressed sample. This is done for
760 * efficiency reasons while streaming the wave by your sampler engine
761 * later. Read the <i>Size</i> member of the <i>buffer_t</i> structure
762 * that will be returned to determine the actual cached samples, but note
763 * that the size is given in bytes! You get the number of actually cached
764 * samples by dividing it by the frame size of the sample:
765 * @code
766 * buffer_t buf = pSample->LoadSampleDataWithNullSamplesExtension(acquired_samples, null_samples);
767 * long cachedsamples = buf.Size / pSample->FrameSize;
768 * @endcode
769 * The method will add \a NullSamplesCount silence samples past the
770 * official buffer end (this won't affect the 'Size' member of the
771 * buffer_t structure, that means 'Size' always reflects the size of the
772 * actual sample data, the buffer might be bigger though). Silence
773 * samples past the official buffer are needed for differential
774 * algorithms that always have to take subsequent samples into account
775 * (resampling/interpolation would be an important example) and avoids
776 * memory access faults in such cases.
777 *
778 * @param SampleCount - number of sample points to load into RAM
779 * @param NullSamplesCount - number of silence samples the buffer should
780 * be extended past it's data end
781 * @returns buffer_t structure with start address and
782 * size of the cached sample data in bytes
783 * @see ReleaseSampleData(), Read(), SetPos()
784 */
785 buffer_t Sample::LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount) {
786 if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
787 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
788 file_offset_t allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
789 SetPos(0); // reset read position to begin of sample
790 RAMCache.pStart = new int8_t[allocationsize];
791 RAMCache.Size = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
792 RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
793 // fill the remaining buffer space with silence samples
794 memset((int8_t*)RAMCache.pStart + RAMCache.Size, 0, RAMCache.NullExtensionSize);
795 return GetCache();
796 }
797
798 /**
799 * Returns current cached sample points. A buffer_t structure will be
800 * returned which contains address pointer to the begin of the cache and
801 * the size of the cached sample data in bytes. Use
802 * <i>LoadSampleData()</i> to cache a specific amount of sample points in
803 * RAM.
804 *
805 * @returns buffer_t structure with current cached sample points
806 * @see LoadSampleData();
807 */
808 buffer_t Sample::GetCache() {
809 // return a copy of the buffer_t structure
810 buffer_t result;
811 result.Size = this->RAMCache.Size;
812 result.pStart = this->RAMCache.pStart;
813 result.NullExtensionSize = this->RAMCache.NullExtensionSize;
814 return result;
815 }
816
817 /**
818 * Frees the cached sample from RAM if loaded with
819 * <i>LoadSampleData()</i> previously.
820 *
821 * @see LoadSampleData();
822 */
823 void Sample::ReleaseSampleData() {
824 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
825 RAMCache.pStart = NULL;
826 RAMCache.Size = 0;
827 RAMCache.NullExtensionSize = 0;
828 }
829
830 /** @brief Resize sample.
831 *
832 * Resizes the sample's wave form data, that is the actual size of
833 * sample wave data possible to be written for this sample. This call
834 * will return immediately and just schedule the resize operation. You
835 * should call File::Save() to actually perform the resize operation(s)
836 * "physically" to the file. As this can take a while on large files, it
837 * is recommended to call Resize() first on all samples which have to be
838 * resized and finally to call File::Save() to perform all those resize
839 * operations in one rush.
840 *
841 * The actual size (in bytes) is dependant to the current FrameSize
842 * value. You may want to set FrameSize before calling Resize().
843 *
844 * <b>Caution:</b> You cannot directly write (i.e. with Write()) to
845 * enlarged samples before calling File::Save() as this might exceed the
846 * current sample's boundary!
847 *
848 * Also note: only DLS_WAVE_FORMAT_PCM is currently supported, that is
849 * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
850 * other formats will fail!
851 *
852 * @param NewSize - new sample wave data size in sample points (must be
853 * greater than zero)
854 * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
855 * @throws DLS::Exception if \a NewSize is less than 1 or unrealistic large
856 * @throws gig::Exception if existing sample is compressed
857 * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
858 * DLS::Sample::FormatTag, File::Save()
859 */
860 void Sample::Resize(file_offset_t NewSize) {
861 if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
862 DLS::Sample::Resize(NewSize);
863 }
864
865 /**
866 * Sets the position within the sample (in sample points, not in
867 * bytes). Use this method and <i>Read()</i> if you don't want to load
868 * the sample into RAM, thus for disk streaming.
869 *
870 * Although the original Gigasampler engine doesn't allow positioning
871 * within compressed samples, I decided to implement it. Even though
872 * the Gigasampler format doesn't allow to define loops for compressed
873 * samples at the moment, positioning within compressed samples might be
874 * interesting for some sampler engines though. The only drawback about
875 * my decision is that it takes longer to load compressed gig Files on
876 * startup, because it's neccessary to scan the samples for some
877 * mandatory informations. But I think as it doesn't affect the runtime
878 * efficiency, nobody will have a problem with that.
879 *
880 * @param SampleCount number of sample points to jump
881 * @param Whence optional: to which relation \a SampleCount refers
882 * to, if omited <i>RIFF::stream_start</i> is assumed
883 * @returns the new sample position
884 * @see Read()
885 */
886 file_offset_t Sample::SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence) {
887 if (Compressed) {
888 switch (Whence) {
889 case RIFF::stream_curpos:
890 this->SamplePos += SampleCount;
891 break;
892 case RIFF::stream_end:
893 this->SamplePos = this->SamplesTotal - 1 - SampleCount;
894 break;
895 case RIFF::stream_backward:
896 this->SamplePos -= SampleCount;
897 break;
898 case RIFF::stream_start: default:
899 this->SamplePos = SampleCount;
900 break;
901 }
902 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
903
904 file_offset_t frame = this->SamplePos / 2048; // to which frame to jump
905 this->FrameOffset = this->SamplePos % 2048; // offset (in sample points) within that frame
906 pCkData->SetPos(FrameTable[frame]); // set chunk pointer to the start of sought frame
907 return this->SamplePos;
908 }
909 else { // not compressed
910 file_offset_t orderedBytes = SampleCount * this->FrameSize;
911 file_offset_t result = pCkData->SetPos(orderedBytes, Whence);
912 return (result == orderedBytes) ? SampleCount
913 : result / this->FrameSize;
914 }
915 }
916
917 /**
918 * Returns the current position in the sample (in sample points).
919 */
920 file_offset_t Sample::GetPos() const {
921 if (Compressed) return SamplePos;
922 else return pCkData->GetPos() / FrameSize;
923 }
924
925 /**
926 * Reads \a SampleCount number of sample points from the position stored
927 * in \a pPlaybackState into the buffer pointed by \a pBuffer and moves
928 * the position within the sample respectively, this method honors the
929 * looping informations of the sample (if any). The sample wave stream
930 * will be decompressed on the fly if using a compressed sample. Use this
931 * method if you don't want to load the sample into RAM, thus for disk
932 * streaming. All this methods needs to know to proceed with streaming
933 * for the next time you call this method is stored in \a pPlaybackState.
934 * You have to allocate and initialize the playback_state_t structure by
935 * yourself before you use it to stream a sample:
936 * @code
937 * gig::playback_state_t playbackstate;
938 * playbackstate.position = 0;
939 * playbackstate.reverse = false;
940 * playbackstate.loop_cycles_left = pSample->LoopPlayCount;
941 * @endcode
942 * You don't have to take care of things like if there is actually a loop
943 * defined or if the current read position is located within a loop area.
944 * The method already handles such cases by itself.
945 *
946 * <b>Caution:</b> If you are using more than one streaming thread, you
947 * have to use an external decompression buffer for <b>EACH</b>
948 * streaming thread to avoid race conditions and crashes!
949 *
950 * @param pBuffer destination buffer
951 * @param SampleCount number of sample points to read
952 * @param pPlaybackState will be used to store and reload the playback
953 * state for the next ReadAndLoop() call
954 * @param pDimRgn dimension region with looping information
955 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
956 * @returns number of successfully read sample points
957 * @see CreateDecompressionBuffer()
958 */
959 file_offset_t Sample::ReadAndLoop(void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState,
960 DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
961 file_offset_t samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
962 uint8_t* pDst = (uint8_t*) pBuffer;
963
964 SetPos(pPlaybackState->position); // recover position from the last time
965
966 if (pDimRgn->SampleLoops) { // honor looping if there are loop points defined
967
968 const DLS::sample_loop_t& loop = pDimRgn->pSampleLoops[0];
969 const uint32_t loopEnd = loop.LoopStart + loop.LoopLength;
970
971 if (GetPos() <= loopEnd) {
972 switch (loop.LoopType) {
973
974 case loop_type_bidirectional: { //TODO: not tested yet!
975 do {
976 // if not endless loop check if max. number of loop cycles have been passed
977 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
978
979 if (!pPlaybackState->reverse) { // forward playback
980 do {
981 samplestoloopend = loopEnd - GetPos();
982 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
983 samplestoread -= readsamples;
984 totalreadsamples += readsamples;
985 if (readsamples == samplestoloopend) {
986 pPlaybackState->reverse = true;
987 break;
988 }
989 } while (samplestoread && readsamples);
990 }
991 else { // backward playback
992
993 // as we can only read forward from disk, we have to
994 // determine the end position within the loop first,
995 // read forward from that 'end' and finally after
996 // reading, swap all sample frames so it reflects
997 // backward playback
998
999 file_offset_t swapareastart = totalreadsamples;
1000 file_offset_t loopoffset = GetPos() - loop.LoopStart;
1001 file_offset_t samplestoreadinloop = Min(samplestoread, loopoffset);
1002 file_offset_t reverseplaybackend = GetPos() - samplestoreadinloop;
1003
1004 SetPos(reverseplaybackend);
1005
1006 // read samples for backward playback
1007 do {
1008 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
1009 samplestoreadinloop -= readsamples;
1010 samplestoread -= readsamples;
1011 totalreadsamples += readsamples;
1012 } while (samplestoreadinloop && readsamples);
1013
1014 SetPos(reverseplaybackend); // pretend we really read backwards
1015
1016 if (reverseplaybackend == loop.LoopStart) {
1017 pPlaybackState->loop_cycles_left--;
1018 pPlaybackState->reverse = false;
1019 }
1020
1021 // reverse the sample frames for backward playback
1022 if (totalreadsamples > swapareastart) //FIXME: this if() is just a crash workaround for now (#102), but totalreadsamples <= swapareastart should never be the case, so there's probably still a bug above!
1023 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1024 }
1025 } while (samplestoread && readsamples);
1026 break;
1027 }
1028
1029 case loop_type_backward: { // TODO: not tested yet!
1030 // forward playback (not entered the loop yet)
1031 if (!pPlaybackState->reverse) do {
1032 samplestoloopend = loopEnd - GetPos();
1033 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1034 samplestoread -= readsamples;
1035 totalreadsamples += readsamples;
1036 if (readsamples == samplestoloopend) {
1037 pPlaybackState->reverse = true;
1038 break;
1039 }
1040 } while (samplestoread && readsamples);
1041
1042 if (!samplestoread) break;
1043
1044 // as we can only read forward from disk, we have to
1045 // determine the end position within the loop first,
1046 // read forward from that 'end' and finally after
1047 // reading, swap all sample frames so it reflects
1048 // backward playback
1049
1050 file_offset_t swapareastart = totalreadsamples;
1051 file_offset_t loopoffset = GetPos() - loop.LoopStart;
1052 file_offset_t samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.LoopLength - loopoffset)
1053 : samplestoread;
1054 file_offset_t reverseplaybackend = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);
1055
1056 SetPos(reverseplaybackend);
1057
1058 // read samples for backward playback
1059 do {
1060 // if not endless loop check if max. number of loop cycles have been passed
1061 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
1062 samplestoloopend = loopEnd - GetPos();
1063 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
1064 samplestoreadinloop -= readsamples;
1065 samplestoread -= readsamples;
1066 totalreadsamples += readsamples;
1067 if (readsamples == samplestoloopend) {
1068 pPlaybackState->loop_cycles_left--;
1069 SetPos(loop.LoopStart);
1070 }
1071 } while (samplestoreadinloop && readsamples);
1072
1073 SetPos(reverseplaybackend); // pretend we really read backwards
1074
1075 // reverse the sample frames for backward playback
1076 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
1077 break;
1078 }
1079
1080 default: case loop_type_normal: {
1081 do {
1082 // if not endless loop check if max. number of loop cycles have been passed
1083 if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
1084 samplestoloopend = loopEnd - GetPos();
1085 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
1086 samplestoread -= readsamples;
1087 totalreadsamples += readsamples;
1088 if (readsamples == samplestoloopend) {
1089 pPlaybackState->loop_cycles_left--;
1090 SetPos(loop.LoopStart);
1091 }
1092 } while (samplestoread && readsamples);
1093 break;
1094 }
1095 }
1096 }
1097 }
1098
1099 // read on without looping
1100 if (samplestoread) do {
1101 readsamples = Read(&pDst[totalreadsamples * this->FrameSize], samplestoread, pExternalDecompressionBuffer);
1102 samplestoread -= readsamples;
1103 totalreadsamples += readsamples;
1104 } while (readsamples && samplestoread);
1105
1106 // store current position
1107 pPlaybackState->position = GetPos();
1108
1109 return totalreadsamples;
1110 }
1111
1112 /**
1113 * Reads \a SampleCount number of sample points from the current
1114 * position into the buffer pointed by \a pBuffer and increments the
1115 * position within the sample. The sample wave stream will be
1116 * decompressed on the fly if using a compressed sample. Use this method
1117 * and <i>SetPos()</i> if you don't want to load the sample into RAM,
1118 * thus for disk streaming.
1119 *
1120 * <b>Caution:</b> If you are using more than one streaming thread, you
1121 * have to use an external decompression buffer for <b>EACH</b>
1122 * streaming thread to avoid race conditions and crashes!
1123 *
1124 * For 16 bit samples, the data in the buffer will be int16_t
1125 * (using native endianness). For 24 bit, the buffer will
1126 * contain three bytes per sample, little-endian.
1127 *
1128 * @param pBuffer destination buffer
1129 * @param SampleCount number of sample points to read
1130 * @param pExternalDecompressionBuffer (optional) external buffer to use for decompression
1131 * @returns number of successfully read sample points
1132 * @see SetPos(), CreateDecompressionBuffer()
1133 */
1134 file_offset_t Sample::Read(void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer) {
1135 if (SampleCount == 0) return 0;
1136 if (!Compressed) {
1137 if (BitDepth == 24) {
1138 return pCkData->Read(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1139 }
1140 else { // 16 bit
1141 // (pCkData->Read does endian correction)
1142 return Channels == 2 ? pCkData->Read(pBuffer, SampleCount << 1, 2) >> 1
1143 : pCkData->Read(pBuffer, SampleCount, 2);
1144 }
1145 }
1146 else {
1147 if (this->SamplePos >= this->SamplesTotal) return 0;
1148 //TODO: efficiency: maybe we should test for an average compression rate
1149 file_offset_t assumedsize = GuessSize(SampleCount),
1150 remainingbytes = 0, // remaining bytes in the local buffer
1151 remainingsamples = SampleCount,
1152 copysamples, skipsamples,
1153 currentframeoffset = this->FrameOffset; // offset in current sample frame since last Read()
1154 this->FrameOffset = 0;
1155
1156 buffer_t* pDecompressionBuffer = (pExternalDecompressionBuffer) ? pExternalDecompressionBuffer : &InternalDecompressionBuffer;
1157
1158 // if decompression buffer too small, then reduce amount of samples to read
1159 if (pDecompressionBuffer->Size < assumedsize) {
1160 std::cerr << "gig::Read(): WARNING - decompression buffer size too small!" << std::endl;
1161 SampleCount = WorstCaseMaxSamples(pDecompressionBuffer);
1162 remainingsamples = SampleCount;
1163 assumedsize = GuessSize(SampleCount);
1164 }
1165
1166 unsigned char* pSrc = (unsigned char*) pDecompressionBuffer->pStart;
1167 int16_t* pDst = static_cast<int16_t*>(pBuffer);
1168 uint8_t* pDst24 = static_cast<uint8_t*>(pBuffer);
1169 remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
1170
1171 while (remainingsamples && remainingbytes) {
1172 file_offset_t framesamples = SamplesPerFrame;
1173 file_offset_t framebytes, rightChannelOffset = 0, nextFrameOffset;
1174
1175 int mode_l = *pSrc++, mode_r = 0;
1176
1177 if (Channels == 2) {
1178 mode_r = *pSrc++;
1179 framebytes = bytesPerFrame[mode_l] + bytesPerFrame[mode_r] + 2;
1180 rightChannelOffset = bytesPerFrameNoHdr[mode_l];
1181 nextFrameOffset = rightChannelOffset + bytesPerFrameNoHdr[mode_r];
1182 if (remainingbytes < framebytes) { // last frame in sample
1183 framesamples = SamplesInLastFrame;
1184 if (mode_l == 4 && (framesamples & 1)) {
1185 rightChannelOffset = ((framesamples + 1) * bitsPerSample[mode_l]) >> 3;
1186 }
1187 else {
1188 rightChannelOffset = (framesamples * bitsPerSample[mode_l]) >> 3;
1189 }
1190 }
1191 }
1192 else {
1193 framebytes = bytesPerFrame[mode_l] + 1;
1194 nextFrameOffset = bytesPerFrameNoHdr[mode_l];
1195 if (remainingbytes < framebytes) {
1196 framesamples = SamplesInLastFrame;
1197 }
1198 }
1199
1200 // determine how many samples in this frame to skip and read
1201 if (currentframeoffset + remainingsamples >= framesamples) {
1202 if (currentframeoffset <= framesamples) {
1203 copysamples = framesamples - currentframeoffset;
1204 skipsamples = currentframeoffset;
1205 }
1206 else {
1207 copysamples = 0;
1208 skipsamples = framesamples;
1209 }
1210 }
1211 else {
1212 // This frame has enough data for pBuffer, but not
1213 // all of the frame is needed. Set file position
1214 // to start of this frame for next call to Read.
1215 copysamples = remainingsamples;
1216 skipsamples = currentframeoffset;
1217 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1218 this->FrameOffset = currentframeoffset + copysamples;
1219 }
1220 remainingsamples -= copysamples;
1221
1222 if (remainingbytes > framebytes) {
1223 remainingbytes -= framebytes;
1224 if (remainingsamples == 0 &&
1225 currentframeoffset + copysamples == framesamples) {
1226 // This frame has enough data for pBuffer, and
1227 // all of the frame is needed. Set file
1228 // position to start of next frame for next
1229 // call to Read. FrameOffset is 0.
1230 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1231 }
1232 }
1233 else remainingbytes = 0;
1234
1235 currentframeoffset -= skipsamples;
1236
1237 if (copysamples == 0) {
1238 // skip this frame
1239 pSrc += framebytes - Channels;
1240 }
1241 else {
1242 const unsigned char* const param_l = pSrc;
1243 if (BitDepth == 24) {
1244 if (mode_l != 2) pSrc += 12;
1245
1246 if (Channels == 2) { // Stereo
1247 const unsigned char* const param_r = pSrc;
1248 if (mode_r != 2) pSrc += 12;
1249
1250 Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1251 skipsamples, copysamples, TruncatedBits);
1252 Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1253 skipsamples, copysamples, TruncatedBits);
1254 pDst24 += copysamples * 6;
1255 }
1256 else { // Mono
1257 Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1258 skipsamples, copysamples, TruncatedBits);
1259 pDst24 += copysamples * 3;
1260 }
1261 }
1262 else { // 16 bit
1263 if (mode_l) pSrc += 4;
1264
1265 int step;
1266 if (Channels == 2) { // Stereo
1267 const unsigned char* const param_r = pSrc;
1268 if (mode_r) pSrc += 4;
1269
1270 step = (2 - mode_l) + (2 - mode_r);
1271 Decompress16(mode_l, param_l, step, 2, pSrc, pDst, skipsamples, copysamples);
1272 Decompress16(mode_r, param_r, step, 2, pSrc + (2 - mode_l), pDst + 1,
1273 skipsamples, copysamples);
1274 pDst += copysamples << 1;
1275 }
1276 else { // Mono
1277 step = 2 - mode_l;
1278 Decompress16(mode_l, param_l, step, 1, pSrc, pDst, skipsamples, copysamples);
1279 pDst += copysamples;
1280 }
1281 }
1282 pSrc += nextFrameOffset;
1283 }
1284
1285 // reload from disk to local buffer if needed
1286 if (remainingsamples && remainingbytes < WorstCaseFrameSize && pCkData->GetState() == RIFF::stream_ready) {
1287 assumedsize = GuessSize(remainingsamples);
1288 pCkData->SetPos(remainingbytes, RIFF::stream_backward);
1289 if (pCkData->RemainingBytes() < assumedsize) assumedsize = pCkData->RemainingBytes();
1290 remainingbytes = pCkData->Read(pDecompressionBuffer->pStart, assumedsize, 1);
1291 pSrc = (unsigned char*) pDecompressionBuffer->pStart;
1292 }
1293 } // while
1294
1295 this->SamplePos += (SampleCount - remainingsamples);
1296 if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
1297 return (SampleCount - remainingsamples);
1298 }
1299 }
1300
1301 /** @brief Write sample wave data.
1302 *
1303 * Writes \a SampleCount number of sample points from the buffer pointed
1304 * by \a pBuffer and increments the position within the sample. Use this
1305 * method to directly write the sample data to disk, i.e. if you don't
1306 * want or cannot load the whole sample data into RAM.
1307 *
1308 * You have to Resize() the sample to the desired size and call
1309 * File::Save() <b>before</b> using Write().
1310 *
1311 * Note: there is currently no support for writing compressed samples.
1312 *
1313 * For 16 bit samples, the data in the source buffer should be
1314 * int16_t (using native endianness). For 24 bit, the buffer
1315 * should contain three bytes per sample, little-endian.
1316 *
1317 * @param pBuffer - source buffer
1318 * @param SampleCount - number of sample points to write
1319 * @throws DLS::Exception if current sample size is too small
1320 * @throws gig::Exception if sample is compressed
1321 * @see DLS::LoadSampleData()
1322 */
1323 file_offset_t Sample::Write(void* pBuffer, file_offset_t SampleCount) {
1324 if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1325
1326 // if this is the first write in this sample, reset the
1327 // checksum calculator
1328 if (pCkData->GetPos() == 0) {
1329 __resetCRC(crc);
1330 }
1331 if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");
1332 file_offset_t res;
1333 if (BitDepth == 24) {
1334 res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1335 } else { // 16 bit
1336 res = Channels == 2 ? pCkData->Write(pBuffer, SampleCount << 1, 2) >> 1
1337 : pCkData->Write(pBuffer, SampleCount, 2);
1338 }
1339 __calculateCRC((unsigned char *)pBuffer, SampleCount * FrameSize, crc);
1340
1341 // if this is the last write, update the checksum chunk in the
1342 // file
1343 if (pCkData->GetPos() == pCkData->GetSize()) {
1344 __finalizeCRC(crc);
1345 File* pFile = static_cast<File*>(GetParent());
1346 pFile->SetSampleChecksum(this, crc);
1347 }
1348 return res;
1349 }
1350
1351 /**
1352 * Allocates a decompression buffer for streaming (compressed) samples
1353 * with Sample::Read(). If you are using more than one streaming thread
1354 * in your application you <b>HAVE</b> to create a decompression buffer
1355 * for <b>EACH</b> of your streaming threads and provide it with the
1356 * Sample::Read() call in order to avoid race conditions and crashes.
1357 *
1358 * You should free the memory occupied by the allocated buffer(s) once
1359 * you don't need one of your streaming threads anymore by calling
1360 * DestroyDecompressionBuffer().
1361 *
1362 * @param MaxReadSize - the maximum size (in sample points) you ever
1363 * expect to read with one Read() call
1364 * @returns allocated decompression buffer
1365 * @see DestroyDecompressionBuffer()
1366 */
1367 buffer_t Sample::CreateDecompressionBuffer(file_offset_t MaxReadSize) {
1368 buffer_t result;
1369 const double worstCaseHeaderOverhead =
1370 (256.0 /*frame size*/ + 12.0 /*header*/ + 2.0 /*compression type flag (stereo)*/) / 256.0;
1371 result.Size = (file_offset_t) (double(MaxReadSize) * 3.0 /*(24 Bit)*/ * 2.0 /*stereo*/ * worstCaseHeaderOverhead);
1372 result.pStart = new int8_t[result.Size];
1373 result.NullExtensionSize = 0;
1374 return result;
1375 }
1376
1377 /**
1378 * Free decompression buffer, previously created with
1379 * CreateDecompressionBuffer().
1380 *
1381 * @param DecompressionBuffer - previously allocated decompression
1382 * buffer to free
1383 */
1384 void Sample::DestroyDecompressionBuffer(buffer_t& DecompressionBuffer) {
1385 if (DecompressionBuffer.Size && DecompressionBuffer.pStart) {
1386 delete[] (int8_t*) DecompressionBuffer.pStart;
1387 DecompressionBuffer.pStart = NULL;
1388 DecompressionBuffer.Size = 0;
1389 DecompressionBuffer.NullExtensionSize = 0;
1390 }
1391 }
1392
1393 /**
1394 * Returns pointer to the Group this Sample belongs to. In the .gig
1395 * format a sample always belongs to one group. If it wasn't explicitly
1396 * assigned to a certain group, it will be automatically assigned to a
1397 * default group.
1398 *
1399 * @returns Sample's Group (never NULL)
1400 */
1401 Group* Sample::GetGroup() const {
1402 return pGroup;
1403 }
1404
1405 /**
1406 * Returns the CRC-32 checksum of the sample's raw wave form data at the
1407 * time when this sample's wave form data was modified for the last time
1408 * by calling Write(). This checksum only covers the raw wave form data,
1409 * not any meta informations like i.e. bit depth or loop points. Since
1410 * this method just returns the checksum stored for this sample i.e. when
1411 * the gig file was loaded, this method returns immediately. So it does no
1412 * recalcuation of the checksum with the currently available sample wave
1413 * form data.
1414 *
1415 * @see VerifyWaveData()
1416 */
1417 uint32_t Sample::GetWaveDataCRC32Checksum() {
1418 return crc;
1419 }
1420
1421 /**
1422 * Checks the integrity of this sample's raw audio wave data. Whenever a
1423 * Sample's raw wave data is intentionally modified (i.e. by calling
1424 * Write() and supplying the new raw audio wave form data) a CRC32 checksum
1425 * is calculated and stored/updated for this sample, along to the sample's
1426 * meta informations.
1427 *
1428 * Now by calling this method the current raw audio wave data is checked
1429 * against the already stored CRC32 check sum in order to check whether the
1430 * sample data had been damaged unintentionally for some reason. Since by
1431 * calling this method always the entire raw audio wave data has to be
1432 * read, verifying all samples this way may take a long time accordingly.
1433 * And that's also the reason why the sample integrity is not checked by
1434 * default whenever a gig file is loaded. So this method must be called
1435 * explicitly to fulfill this task.
1436 *
1437 * @param pActually - (optional) if provided, will be set to the actually
1438 * calculated checksum of the current raw wave form data,
1439 * you can get the expected checksum instead by calling
1440 * GetWaveDataCRC32Checksum()
1441 * @returns true if sample is OK or false if the sample is damaged
1442 * @throws Exception if no checksum had been stored to disk for this
1443 * sample yet, or on I/O issues
1444 * @see GetWaveDataCRC32Checksum()
1445 */
1446 bool Sample::VerifyWaveData(uint32_t* pActually) {
1447 //File* pFile = static_cast<File*>(GetParent());
1448 uint32_t crc = CalculateWaveDataChecksum();
1449 if (pActually) *pActually = crc;
1450 return crc == this->crc;
1451 }
1452
1453 uint32_t Sample::CalculateWaveDataChecksum() {
1454 const size_t sz = 20*1024; // 20kB buffer size
1455 std::vector<uint8_t> buffer(sz);
1456 buffer.resize(sz);
1457
1458 const size_t n = sz / FrameSize;
1459 SetPos(0);
1460 uint32_t crc = 0;
1461 __resetCRC(crc);
1462 while (true) {
1463 file_offset_t nRead = Read(&buffer[0], n);
1464 if (nRead <= 0) break;
1465 __calculateCRC(&buffer[0], nRead * FrameSize, crc);
1466 }
1467 __finalizeCRC(crc);
1468 return crc;
1469 }
1470
1471 Sample::~Sample() {
1472 Instances--;
1473 if (!Instances && InternalDecompressionBuffer.Size) {
1474 delete[] (unsigned char*) InternalDecompressionBuffer.pStart;
1475 InternalDecompressionBuffer.pStart = NULL;
1476 InternalDecompressionBuffer.Size = 0;
1477 }
1478 if (FrameTable) delete[] FrameTable;
1479 if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
1480 }
1481
1482
1483
1484 // *************** DimensionRegion ***************
1485 // *
1486
1487 size_t DimensionRegion::Instances = 0;
1488 DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1489
1490 DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
1491 Instances++;
1492
1493 pSample = NULL;
1494 pRegion = pParent;
1495
1496 if (_3ewl->GetSubChunk(CHUNK_ID_WSMP)) memcpy(&Crossfade, &SamplerOptions, 4);
1497 else memset(&Crossfade, 0, 4);
1498
1499 if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1500
1501 RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
1502 if (_3ewa) { // if '3ewa' chunk exists
1503 _3ewa->ReadInt32(); // unknown, always == chunk size ?
1504 LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1505 EG3Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1506 _3ewa->ReadInt16(); // unknown
1507 LFO1InternalDepth = _3ewa->ReadUint16();
1508 _3ewa->ReadInt16(); // unknown
1509 LFO3InternalDepth = _3ewa->ReadInt16();
1510 _3ewa->ReadInt16(); // unknown
1511 LFO1ControlDepth = _3ewa->ReadUint16();
1512 _3ewa->ReadInt16(); // unknown
1513 LFO3ControlDepth = _3ewa->ReadInt16();
1514 EG1Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1515 EG1Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1516 _3ewa->ReadInt16(); // unknown
1517 EG1Sustain = _3ewa->ReadUint16();
1518 EG1Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1519 EG1Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1520 uint8_t eg1ctrloptions = _3ewa->ReadUint8();
1521 EG1ControllerInvert = eg1ctrloptions & 0x01;
1522 EG1ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1523 EG1ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1524 EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1525 EG2Controller = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1526 uint8_t eg2ctrloptions = _3ewa->ReadUint8();
1527 EG2ControllerInvert = eg2ctrloptions & 0x01;
1528 EG2ControllerAttackInfluence = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1529 EG2ControllerDecayInfluence = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1530 EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1531 LFO1Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1532 EG2Attack = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1533 EG2Decay1 = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1534 _3ewa->ReadInt16(); // unknown
1535 EG2Sustain = _3ewa->ReadUint16();
1536 EG2Release = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1537 _3ewa->ReadInt16(); // unknown
1538 LFO2ControlDepth = _3ewa->ReadUint16();
1539 LFO2Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1540 _3ewa->ReadInt16(); // unknown
1541 LFO2InternalDepth = _3ewa->ReadUint16();
1542 int32_t eg1decay2 = _3ewa->ReadInt32();
1543 EG1Decay2 = (double) GIG_EXP_DECODE(eg1decay2);
1544 EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1545 _3ewa->ReadInt16(); // unknown
1546 EG1PreAttack = _3ewa->ReadUint16();
1547 int32_t eg2decay2 = _3ewa->ReadInt32();
1548 EG2Decay2 = (double) GIG_EXP_DECODE(eg2decay2);
1549 EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1550 _3ewa->ReadInt16(); // unknown
1551 EG2PreAttack = _3ewa->ReadUint16();
1552 uint8_t velocityresponse = _3ewa->ReadUint8();
1553 if (velocityresponse < 5) {
1554 VelocityResponseCurve = curve_type_nonlinear;
1555 VelocityResponseDepth = velocityresponse;
1556 } else if (velocityresponse < 10) {
1557 VelocityResponseCurve = curve_type_linear;
1558 VelocityResponseDepth = velocityresponse - 5;
1559 } else if (velocityresponse < 15) {
1560 VelocityResponseCurve = curve_type_special;
1561 VelocityResponseDepth = velocityresponse - 10;
1562 } else {
1563 VelocityResponseCurve = curve_type_unknown;
1564 VelocityResponseDepth = 0;
1565 }
1566 uint8_t releasevelocityresponse = _3ewa->ReadUint8();
1567 if (releasevelocityresponse < 5) {
1568 ReleaseVelocityResponseCurve = curve_type_nonlinear;
1569 ReleaseVelocityResponseDepth = releasevelocityresponse;
1570 } else if (releasevelocityresponse < 10) {
1571 ReleaseVelocityResponseCurve = curve_type_linear;
1572 ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1573 } else if (releasevelocityresponse < 15) {
1574 ReleaseVelocityResponseCurve = curve_type_special;
1575 ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1576 } else {
1577 ReleaseVelocityResponseCurve = curve_type_unknown;
1578 ReleaseVelocityResponseDepth = 0;
1579 }
1580 VelocityResponseCurveScaling = _3ewa->ReadUint8();
1581 AttenuationControllerThreshold = _3ewa->ReadInt8();
1582 _3ewa->ReadInt32(); // unknown
1583 SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
1584 _3ewa->ReadInt16(); // unknown
1585 uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();
1586 PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1587 if (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1588 else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1589 else DimensionBypass = dim_bypass_ctrl_none;
1590 uint8_t pan = _3ewa->ReadUint8();
1591 Pan = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
1592 SelfMask = _3ewa->ReadInt8() & 0x01;
1593 _3ewa->ReadInt8(); // unknown
1594 uint8_t lfo3ctrl = _3ewa->ReadUint8();
1595 LFO3Controller = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
1596 LFO3Sync = lfo3ctrl & 0x20; // bit 5
1597 InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
1598 AttenuationController = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1599 uint8_t lfo2ctrl = _3ewa->ReadUint8();
1600 LFO2Controller = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
1601 LFO2FlipPhase = lfo2ctrl & 0x80; // bit 7
1602 LFO2Sync = lfo2ctrl & 0x20; // bit 5
1603 bool extResonanceCtrl = lfo2ctrl & 0x40; // bit 6
1604 uint8_t lfo1ctrl = _3ewa->ReadUint8();
1605 LFO1Controller = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
1606 LFO1FlipPhase = lfo1ctrl & 0x80; // bit 7
1607 LFO1Sync = lfo1ctrl & 0x40; // bit 6
1608 VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1609 : vcf_res_ctrl_none;
1610 uint16_t eg3depth = _3ewa->ReadUint16();
1611 EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1612 : (-1) * (int16_t) ((eg3depth ^ 0xfff) + 1); /* binary complementary for negatives */
1613 _3ewa->ReadInt16(); // unknown
1614 ChannelOffset = _3ewa->ReadUint8() / 4;
1615 uint8_t regoptions = _3ewa->ReadUint8();
1616 MSDecode = regoptions & 0x01; // bit 0
1617 SustainDefeat = regoptions & 0x02; // bit 1
1618 _3ewa->ReadInt16(); // unknown
1619 VelocityUpperLimit = _3ewa->ReadInt8();
1620 _3ewa->ReadInt8(); // unknown
1621 _3ewa->ReadInt16(); // unknown
1622 ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
1623 _3ewa->ReadInt8(); // unknown
1624 _3ewa->ReadInt8(); // unknown
1625 EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
1626 uint8_t vcfcutoff = _3ewa->ReadUint8();
1627 VCFEnabled = vcfcutoff & 0x80; // bit 7
1628 VCFCutoff = vcfcutoff & 0x7f; // lower 7 bits
1629 VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
1630 uint8_t vcfvelscale = _3ewa->ReadUint8();
1631 VCFCutoffControllerInvert = vcfvelscale & 0x80; // bit 7
1632 VCFVelocityScale = vcfvelscale & 0x7f; // lower 7 bits
1633 _3ewa->ReadInt8(); // unknown
1634 uint8_t vcfresonance = _3ewa->ReadUint8();
1635 VCFResonance = vcfresonance & 0x7f; // lower 7 bits
1636 VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
1637 uint8_t vcfbreakpoint = _3ewa->ReadUint8();
1638 VCFKeyboardTracking = vcfbreakpoint & 0x80; // bit 7
1639 VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
1640 uint8_t vcfvelocity = _3ewa->ReadUint8();
1641 VCFVelocityDynamicRange = vcfvelocity % 5;
1642 VCFVelocityCurve = static_cast<curve_type_t>(vcfvelocity / 5);
1643 VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
1644 if (VCFType == vcf_type_lowpass) {
1645 if (lfo3ctrl & 0x40) // bit 6
1646 VCFType = vcf_type_lowpassturbo;
1647 }
1648 if (_3ewa->RemainingBytes() >= 8) {
1649 _3ewa->Read(DimensionUpperLimits, 1, 8);
1650 } else {
1651 memset(DimensionUpperLimits, 0, 8);
1652 }
1653 } else { // '3ewa' chunk does not exist yet
1654 // use default values
1655 LFO3Frequency = 1.0;
1656 EG3Attack = 0.0;
1657 LFO1InternalDepth = 0;
1658 LFO3InternalDepth = 0;
1659 LFO1ControlDepth = 0;
1660 LFO3ControlDepth = 0;
1661 EG1Attack = 0.0;
1662 EG1Decay1 = 0.005;
1663 EG1Sustain = 1000;
1664 EG1Release = 0.3;
1665 EG1Controller.type = eg1_ctrl_t::type_none;
1666 EG1Controller.controller_number = 0;
1667 EG1ControllerInvert = false;
1668 EG1ControllerAttackInfluence = 0;
1669 EG1ControllerDecayInfluence = 0;
1670 EG1ControllerReleaseInfluence = 0;
1671 EG2Controller.type = eg2_ctrl_t::type_none;
1672 EG2Controller.controller_number = 0;
1673 EG2ControllerInvert = false;
1674 EG2ControllerAttackInfluence = 0;
1675 EG2ControllerDecayInfluence = 0;
1676 EG2ControllerReleaseInfluence = 0;
1677 LFO1Frequency = 1.0;
1678 EG2Attack = 0.0;
1679 EG2Decay1 = 0.005;
1680 EG2Sustain = 1000;
1681 EG2Release = 60;
1682 LFO2ControlDepth = 0;
1683 LFO2Frequency = 1.0;
1684 LFO2InternalDepth = 0;
1685 EG1Decay2 = 0.0;
1686 EG1InfiniteSustain = true;
1687 EG1PreAttack = 0;
1688 EG2Decay2 = 0.0;
1689 EG2InfiniteSustain = true;
1690 EG2PreAttack = 0;
1691 VelocityResponseCurve = curve_type_nonlinear;
1692 VelocityResponseDepth = 3;
1693 ReleaseVelocityResponseCurve = curve_type_nonlinear;
1694 ReleaseVelocityResponseDepth = 3;
1695 VelocityResponseCurveScaling = 32;
1696 AttenuationControllerThreshold = 0;
1697 SampleStartOffset = 0;
1698 PitchTrack = true;
1699 DimensionBypass = dim_bypass_ctrl_none;
1700 Pan = 0;
1701 SelfMask = true;
1702 LFO3Controller = lfo3_ctrl_modwheel;
1703 LFO3Sync = false;
1704 InvertAttenuationController = false;
1705 AttenuationController.type = attenuation_ctrl_t::type_none;
1706 AttenuationController.controller_number = 0;
1707 LFO2Controller = lfo2_ctrl_internal;
1708 LFO2FlipPhase = false;
1709 LFO2Sync = false;
1710 LFO1Controller = lfo1_ctrl_internal;
1711 LFO1FlipPhase = false;
1712 LFO1Sync = false;
1713 VCFResonanceController = vcf_res_ctrl_none;
1714 EG3Depth = 0;
1715 ChannelOffset = 0;
1716 MSDecode = false;
1717 SustainDefeat = false;
1718 VelocityUpperLimit = 0;
1719 ReleaseTriggerDecay = 0;
1720 EG1Hold = false;
1721 VCFEnabled = false;
1722 VCFCutoff = 0;
1723 VCFCutoffController = vcf_cutoff_ctrl_none;
1724 VCFCutoffControllerInvert = false;
1725 VCFVelocityScale = 0;
1726 VCFResonance = 0;
1727 VCFResonanceDynamic = false;
1728 VCFKeyboardTracking = false;
1729 VCFKeyboardTrackingBreakpoint = 0;
1730 VCFVelocityDynamicRange = 0x04;
1731 VCFVelocityCurve = curve_type_linear;
1732 VCFType = vcf_type_lowpass;
1733 memset(DimensionUpperLimits, 127, 8);
1734 }
1735 // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1736 RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1737 if (lsde) { // format extension for EG behavior options
1738 eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1739 for (int i = 0; i < 2; ++i) { // NOTE: we reserved a 3rd byte for a potential future EG3 option
1740 unsigned char byte = lsde->ReadUint8();
1741 pEGOpts[i]->AttackCancel = byte & 1;
1742 pEGOpts[i]->AttackHoldCancel = byte & (1 << 1);
1743 pEGOpts[i]->Decay1Cancel = byte & (1 << 2);
1744 pEGOpts[i]->Decay2Cancel = byte & (1 << 3);
1745 pEGOpts[i]->ReleaseCancel = byte & (1 << 4);
1746 }
1747 }
1748 // format extension for sustain pedal up effect on release trigger samples
1749 if (lsde && lsde->GetSize() > 3) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
1750 lsde->SetPos(3);
1751 uint8_t byte = lsde->ReadUint8();
1752 SustainReleaseTrigger = static_cast<sust_rel_trg_t>(byte & 0x03);
1753 NoNoteOffReleaseTrigger = byte >> 7;
1754 } else {
1755 SustainReleaseTrigger = sust_rel_trg_none;
1756 NoNoteOffReleaseTrigger = false;
1757 }
1758
1759 pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1760 VelocityResponseDepth,
1761 VelocityResponseCurveScaling);
1762
1763 pVelocityReleaseTable = GetReleaseVelocityTable(
1764 ReleaseVelocityResponseCurve,
1765 ReleaseVelocityResponseDepth
1766 );
1767
1768 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve,
1769 VCFVelocityDynamicRange,
1770 VCFVelocityScale,
1771 VCFCutoffController);
1772
1773 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1774 VelocityTable = 0;
1775 }
1776
1777 /*
1778 * Constructs a DimensionRegion by copying all parameters from
1779 * another DimensionRegion
1780 */
1781 DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {
1782 Instances++;
1783 //NOTE: I think we cannot call CopyAssign() here (in a constructor) as long as its a virtual method
1784 *this = src; // default memberwise shallow copy of all parameters
1785 pParentList = _3ewl; // restore the chunk pointer
1786
1787 // deep copy of owned structures
1788 if (src.VelocityTable) {
1789 VelocityTable = new uint8_t[128];
1790 for (int k = 0 ; k < 128 ; k++)
1791 VelocityTable[k] = src.VelocityTable[k];
1792 }
1793 if (src.pSampleLoops) {
1794 pSampleLoops = new DLS::sample_loop_t[src.SampleLoops];
1795 for (int k = 0 ; k < src.SampleLoops ; k++)
1796 pSampleLoops[k] = src.pSampleLoops[k];
1797 }
1798 }
1799
1800 /**
1801 * Make a (semi) deep copy of the DimensionRegion object given by @a orig
1802 * and assign it to this object.
1803 *
1804 * Note that all sample pointers referenced by @a orig are simply copied as
1805 * memory address. Thus the respective samples are shared, not duplicated!
1806 *
1807 * @param orig - original DimensionRegion object to be copied from
1808 */
1809 void DimensionRegion::CopyAssign(const DimensionRegion* orig) {
1810 CopyAssign(orig, NULL);
1811 }
1812
1813 /**
1814 * Make a (semi) deep copy of the DimensionRegion object given by @a orig
1815 * and assign it to this object.
1816 *
1817 * @param orig - original DimensionRegion object to be copied from
1818 * @param mSamples - crosslink map between the foreign file's samples and
1819 * this file's samples
1820 */
1821 void DimensionRegion::CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples) {
1822 // delete all allocated data first
1823 if (VelocityTable) delete [] VelocityTable;
1824 if (pSampleLoops) delete [] pSampleLoops;
1825
1826 // backup parent list pointer
1827 RIFF::List* p = pParentList;
1828
1829 gig::Sample* pOriginalSample = pSample;
1830 gig::Region* pOriginalRegion = pRegion;
1831
1832 //NOTE: copy code copied from assignment constructor above, see comment there as well
1833
1834 *this = *orig; // default memberwise shallow copy of all parameters
1835
1836 // restore members that shall not be altered
1837 pParentList = p; // restore the chunk pointer
1838 pRegion = pOriginalRegion;
1839
1840 // only take the raw sample reference reference if the
1841 // two DimensionRegion objects are part of the same file
1842 if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {
1843 pSample = pOriginalSample;
1844 }
1845
1846 if (mSamples && mSamples->count(orig->pSample)) {
1847 pSample = mSamples->find(orig->pSample)->second;
1848 }
1849
1850 // deep copy of owned structures
1851 if (orig->VelocityTable) {
1852 VelocityTable = new uint8_t[128];
1853 for (int k = 0 ; k < 128 ; k++)
1854 VelocityTable[k] = orig->VelocityTable[k];
1855 }
1856 if (orig->pSampleLoops) {
1857 pSampleLoops = new DLS::sample_loop_t[orig->SampleLoops];
1858 for (int k = 0 ; k < orig->SampleLoops ; k++)
1859 pSampleLoops[k] = orig->pSampleLoops[k];
1860 }
1861 }
1862
1863 void DimensionRegion::serialize(Serialization::Archive* archive) {
1864 // in case this class will become backward incompatible one day,
1865 // then set a version and minimum version for this class like:
1866 //archive->setVersion(*this, 2);
1867 //archive->setMinVersion(*this, 1);
1868
1869 SRLZ(VelocityUpperLimit);
1870 SRLZ(EG1PreAttack);
1871 SRLZ(EG1Attack);
1872 SRLZ(EG1Decay1);
1873 SRLZ(EG1Decay2);
1874 SRLZ(EG1InfiniteSustain);
1875 SRLZ(EG1Sustain);
1876 SRLZ(EG1Release);
1877 SRLZ(EG1Hold);
1878 SRLZ(EG1Controller);
1879 SRLZ(EG1ControllerInvert);
1880 SRLZ(EG1ControllerAttackInfluence);
1881 SRLZ(EG1ControllerDecayInfluence);
1882 SRLZ(EG1ControllerReleaseInfluence);
1883 SRLZ(LFO1Frequency);
1884 SRLZ(LFO1InternalDepth);
1885 SRLZ(LFO1ControlDepth);
1886 SRLZ(LFO1Controller);
1887 SRLZ(LFO1FlipPhase);
1888 SRLZ(LFO1Sync);
1889 SRLZ(EG2PreAttack);
1890 SRLZ(EG2Attack);
1891 SRLZ(EG2Decay1);
1892 SRLZ(EG2Decay2);
1893 SRLZ(EG2InfiniteSustain);
1894 SRLZ(EG2Sustain);
1895 SRLZ(EG2Release);
1896 SRLZ(EG2Controller);
1897 SRLZ(EG2ControllerInvert);
1898 SRLZ(EG2ControllerAttackInfluence);
1899 SRLZ(EG2ControllerDecayInfluence);
1900 SRLZ(EG2ControllerReleaseInfluence);
1901 SRLZ(LFO2Frequency);
1902 SRLZ(LFO2InternalDepth);
1903 SRLZ(LFO2ControlDepth);
1904 SRLZ(LFO2Controller);
1905 SRLZ(LFO2FlipPhase);
1906 SRLZ(LFO2Sync);
1907 SRLZ(EG3Attack);
1908 SRLZ(EG3Depth);
1909 SRLZ(LFO3Frequency);
1910 SRLZ(LFO3InternalDepth);
1911 SRLZ(LFO3ControlDepth);
1912 SRLZ(LFO3Controller);
1913 SRLZ(LFO3Sync);
1914 SRLZ(VCFEnabled);
1915 SRLZ(VCFType);
1916 SRLZ(VCFCutoffController);
1917 SRLZ(VCFCutoffControllerInvert);
1918 SRLZ(VCFCutoff);
1919 SRLZ(VCFVelocityCurve);
1920 SRLZ(VCFVelocityScale);
1921 SRLZ(VCFVelocityDynamicRange);
1922 SRLZ(VCFResonance);
1923 SRLZ(VCFResonanceDynamic);
1924 SRLZ(VCFResonanceController);
1925 SRLZ(VCFKeyboardTracking);
1926 SRLZ(VCFKeyboardTrackingBreakpoint);
1927 SRLZ(VelocityResponseCurve);
1928 SRLZ(VelocityResponseDepth);
1929 SRLZ(VelocityResponseCurveScaling);
1930 SRLZ(ReleaseVelocityResponseCurve);
1931 SRLZ(ReleaseVelocityResponseDepth);
1932 SRLZ(ReleaseTriggerDecay);
1933 SRLZ(Crossfade);
1934 SRLZ(PitchTrack);
1935 SRLZ(DimensionBypass);
1936 SRLZ(Pan);
1937 SRLZ(SelfMask);
1938 SRLZ(AttenuationController);
1939 SRLZ(InvertAttenuationController);
1940 SRLZ(AttenuationControllerThreshold);
1941 SRLZ(ChannelOffset);
1942 SRLZ(SustainDefeat);
1943 SRLZ(MSDecode);
1944 //SRLZ(SampleStartOffset);
1945 SRLZ(SampleAttenuation);
1946 SRLZ(EG1Options);
1947 SRLZ(EG2Options);
1948 SRLZ(SustainReleaseTrigger);
1949 SRLZ(NoNoteOffReleaseTrigger);
1950
1951 // derived attributes from DLS::Sampler
1952 SRLZ(FineTune);
1953 SRLZ(Gain);
1954 }
1955
1956 /**
1957 * Updates the respective member variable and updates @c SampleAttenuation
1958 * which depends on this value.
1959 */
1960 void DimensionRegion::SetGain(int32_t gain) {
1961 DLS::Sampler::SetGain(gain);
1962 SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1963 }
1964
1965 /**
1966 * Apply dimension region settings to the respective RIFF chunks. You
1967 * have to call File::Save() to make changes persistent.
1968 *
1969 * Usually there is absolutely no need to call this method explicitly.
1970 * It will be called automatically when File::Save() was called.
1971 *
1972 * @param pProgress - callback function for progress notification
1973 */
1974 void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1975 // first update base class's chunk
1976 DLS::Sampler::UpdateChunks(pProgress);
1977
1978 RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1979 uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
1980 pData[12] = Crossfade.in_start;
1981 pData[13] = Crossfade.in_end;
1982 pData[14] = Crossfade.out_start;
1983 pData[15] = Crossfade.out_end;
1984
1985 // make sure '3ewa' chunk exists
1986 RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1987 if (!_3ewa) {
1988 File* pFile = (File*) GetParent()->GetParent()->GetParent();
1989 bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
1990 _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, versiongt2 ? 148 : 140);
1991 }
1992 pData = (uint8_t*) _3ewa->LoadChunkData();
1993
1994 // update '3ewa' chunk with DimensionRegion's current settings
1995
1996 const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
1997 store32(&pData[0], chunksize); // unknown, always chunk size?
1998
1999 const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
2000 store32(&pData[4], lfo3freq);
2001
2002 const int32_t eg3attack = (int32_t) GIG_EXP_ENCODE(EG3Attack);
2003 store32(&pData[8], eg3attack);
2004
2005 // next 2 bytes unknown
2006
2007 store16(&pData[14], LFO1InternalDepth);
2008
2009 // next 2 bytes unknown
2010
2011 store16(&pData[18], LFO3InternalDepth);
2012
2013 // next 2 bytes unknown
2014
2015 store16(&pData[22], LFO1ControlDepth);
2016
2017 // next 2 bytes unknown
2018
2019 store16(&pData[26], LFO3ControlDepth);
2020
2021 const int32_t eg1attack = (int32_t) GIG_EXP_ENCODE(EG1Attack);
2022 store32(&pData[28], eg1attack);
2023
2024 const int32_t eg1decay1 = (int32_t) GIG_EXP_ENCODE(EG1Decay1);
2025 store32(&pData[32], eg1decay1);
2026
2027 // next 2 bytes unknown
2028
2029 store16(&pData[38], EG1Sustain);
2030
2031 const int32_t eg1release = (int32_t) GIG_EXP_ENCODE(EG1Release);
2032 store32(&pData[40], eg1release);
2033
2034 const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(EG1Controller);
2035 pData[44] = eg1ctl;
2036
2037 const uint8_t eg1ctrloptions =
2038 (EG1ControllerInvert ? 0x01 : 0x00) |
2039 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
2040 GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
2041 GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
2042 pData[45] = eg1ctrloptions;
2043
2044 const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(EG2Controller);
2045 pData[46] = eg2ctl;
2046
2047 const uint8_t eg2ctrloptions =
2048 (EG2ControllerInvert ? 0x01 : 0x00) |
2049 GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
2050 GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
2051 GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
2052 pData[47] = eg2ctrloptions;
2053
2054 const int32_t lfo1freq = (int32_t) GIG_EXP_ENCODE(LFO1Frequency);
2055 store32(&pData[48], lfo1freq);
2056
2057 const int32_t eg2attack = (int32_t) GIG_EXP_ENCODE(EG2Attack);
2058 store32(&pData[52], eg2attack);
2059
2060 const int32_t eg2decay1 = (int32_t) GIG_EXP_ENCODE(EG2Decay1);
2061 store32(&pData[56], eg2decay1);
2062
2063 // next 2 bytes unknown
2064
2065 store16(&pData[62], EG2Sustain);
2066
2067 const int32_t eg2release = (int32_t) GIG_EXP_ENCODE(EG2Release);
2068 store32(&pData[64], eg2release);
2069
2070 // next 2 bytes unknown
2071
2072 store16(&pData[70], LFO2ControlDepth);
2073
2074 const int32_t lfo2freq = (int32_t) GIG_EXP_ENCODE(LFO2Frequency);
2075 store32(&pData[72], lfo2freq);
2076
2077 // next 2 bytes unknown
2078
2079 store16(&pData[78], LFO2InternalDepth);
2080
2081 const int32_t eg1decay2 = (int32_t) (EG1InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG1Decay2);
2082 store32(&pData[80], eg1decay2);
2083
2084 // next 2 bytes unknown
2085
2086 store16(&pData[86], EG1PreAttack);
2087
2088 const int32_t eg2decay2 = (int32_t) (EG2InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG2Decay2);
2089 store32(&pData[88], eg2decay2);
2090
2091 // next 2 bytes unknown
2092
2093 store16(&pData[94], EG2PreAttack);
2094
2095 {
2096 if (VelocityResponseDepth > 4) throw Exception("VelocityResponseDepth must be between 0 and 4");
2097 uint8_t velocityresponse = VelocityResponseDepth;
2098 switch (VelocityResponseCurve) {
2099 case curve_type_nonlinear:
2100 break;
2101 case curve_type_linear:
2102 velocityresponse += 5;
2103 break;
2104 case curve_type_special:
2105 velocityresponse += 10;
2106 break;
2107 case curve_type_unknown:
2108 default:
2109 throw Exception("Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
2110 }
2111 pData[96] = velocityresponse;
2112 }
2113
2114 {
2115 if (ReleaseVelocityResponseDepth > 4) throw Exception("ReleaseVelocityResponseDepth must be between 0 and 4");
2116 uint8_t releasevelocityresponse = ReleaseVelocityResponseDepth;
2117 switch (ReleaseVelocityResponseCurve) {
2118 case curve_type_nonlinear:
2119 break;
2120 case curve_type_linear:
2121 releasevelocityresponse += 5;
2122 break;
2123 case curve_type_special:
2124 releasevelocityresponse += 10;
2125 break;
2126 case curve_type_unknown:
2127 default:
2128 throw Exception("Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
2129 }
2130 pData[97] = releasevelocityresponse;
2131 }
2132
2133 pData[98] = VelocityResponseCurveScaling;
2134
2135 pData[99] = AttenuationControllerThreshold;
2136
2137 // next 4 bytes unknown
2138
2139 store16(&pData[104], SampleStartOffset);
2140
2141 // next 2 bytes unknown
2142
2143 {
2144 uint8_t pitchTrackDimensionBypass = GIG_PITCH_TRACK_ENCODE(PitchTrack);
2145 switch (DimensionBypass) {
2146 case dim_bypass_ctrl_94:
2147 pitchTrackDimensionBypass |= 0x10;
2148 break;
2149 case dim_bypass_ctrl_95:
2150 pitchTrackDimensionBypass |= 0x20;
2151 break;
2152 case dim_bypass_ctrl_none:
2153 //FIXME: should we set anything here?
2154 break;
2155 default:
2156 throw Exception("Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
2157 }
2158 pData[108] = pitchTrackDimensionBypass;
2159 }
2160
2161 const uint8_t pan = (Pan >= 0) ? Pan : ((-Pan) + 63); // signed 8 bit -> signed 7 bit
2162 pData[109] = pan;
2163
2164 const uint8_t selfmask = (SelfMask) ? 0x01 : 0x00;
2165 pData[110] = selfmask;
2166
2167 // next byte unknown
2168
2169 {
2170 uint8_t lfo3ctrl = LFO3Controller & 0x07; // lower 3 bits
2171 if (LFO3Sync) lfo3ctrl |= 0x20; // bit 5
2172 if (InvertAttenuationController) lfo3ctrl |= 0x80; // bit 7
2173 if (VCFType == vcf_type_lowpassturbo) lfo3ctrl |= 0x40; // bit 6
2174 pData[112] = lfo3ctrl;
2175 }
2176
2177 const uint8_t attenctl = EncodeLeverageController(AttenuationController);
2178 pData[113] = attenctl;
2179
2180 {
2181 uint8_t lfo2ctrl = LFO2Controller & 0x07; // lower 3 bits
2182 if (LFO2FlipPhase) lfo2ctrl |= 0x80; // bit 7
2183 if (LFO2Sync) lfo2ctrl |= 0x20; // bit 5
2184 if (VCFResonanceController != vcf_res_ctrl_none) lfo2ctrl |= 0x40; // bit 6
2185 pData[114] = lfo2ctrl;
2186 }
2187
2188 {
2189 uint8_t lfo1ctrl = LFO1Controller & 0x07; // lower 3 bits
2190 if (LFO1FlipPhase) lfo1ctrl |= 0x80; // bit 7
2191 if (LFO1Sync) lfo1ctrl |= 0x40; // bit 6
2192 if (VCFResonanceController != vcf_res_ctrl_none)
2193 lfo1ctrl |= GIG_VCF_RESONANCE_CTRL_ENCODE(VCFResonanceController);
2194 pData[115] = lfo1ctrl;
2195 }
2196
2197 const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
2198 : uint16_t(((-EG3Depth) - 1) ^ 0xfff); /* binary complementary for negatives */
2199 store16(&pData[116], eg3depth);
2200
2201 // next 2 bytes unknown
2202
2203 const uint8_t channeloffset = ChannelOffset * 4;
2204 pData[120] = channeloffset;
2205
2206 {
2207 uint8_t regoptions = 0;
2208 if (MSDecode) regoptions |= 0x01; // bit 0
2209 if (SustainDefeat) regoptions |= 0x02; // bit 1
2210 pData[121] = regoptions;
2211 }
2212
2213 // next 2 bytes unknown
2214
2215 pData[124] = VelocityUpperLimit;
2216
2217 // next 3 bytes unknown
2218
2219 pData[128] = ReleaseTriggerDecay;
2220
2221 // next 2 bytes unknown
2222
2223 const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7
2224 pData[131] = eg1hold;
2225
2226 const uint8_t vcfcutoff = (VCFEnabled ? 0x80 : 0x00) | /* bit 7 */
2227 (VCFCutoff & 0x7f); /* lower 7 bits */
2228 pData[132] = vcfcutoff;
2229
2230 pData[133] = VCFCutoffController;
2231
2232 const uint8_t vcfvelscale = (VCFCutoffControllerInvert ? 0x80 : 0x00) | /* bit 7 */
2233 (VCFVelocityScale & 0x7f); /* lower 7 bits */
2234 pData[134] = vcfvelscale;
2235
2236 // next byte unknown
2237
2238 const uint8_t vcfresonance = (VCFResonanceDynamic ? 0x00 : 0x80) | /* bit 7 */
2239 (VCFResonance & 0x7f); /* lower 7 bits */
2240 pData[136] = vcfresonance;
2241
2242 const uint8_t vcfbreakpoint = (VCFKeyboardTracking ? 0x80 : 0x00) | /* bit 7 */
2243 (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
2244 pData[137] = vcfbreakpoint;
2245
2246 const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 +
2247 VCFVelocityCurve * 5;
2248 pData[138] = vcfvelocity;
2249
2250 const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
2251 pData[139] = vcftype;
2252
2253 if (chunksize >= 148) {
2254 memcpy(&pData[140], DimensionUpperLimits, 8);
2255 }
2256
2257 // chunk for own format extensions, these will *NOT* work with
2258 // Gigasampler/GigaStudio !
2259 RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2260 const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option
2261 if (!lsde) {
2262 // only add this "LSDE" chunk if either EG options or release
2263 // trigger options deviate from their default behaviour
2264 eg_opt_t defaultOpt;
2265 if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2266 memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||
2267 SustainReleaseTrigger || NoNoteOffReleaseTrigger)
2268 {
2269 lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2270 // move LSDE chunk to the end of parent list
2271 pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
2272 }
2273 }
2274 if (lsde) {
2275 if (lsde->GetNewSize() < lsdeSize)
2276 lsde->Resize(lsdeSize);
2277 // format extension for EG behavior options
2278 unsigned char* pData = (unsigned char*) lsde->LoadChunkData();
2279 eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
2280 for (int i = 0; i < 2; ++i) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
2281 pData[i] =
2282 (pEGOpts[i]->AttackCancel ? 1 : 0) |
2283 (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) |
2284 (pEGOpts[i]->Decay1Cancel ? (1<<2) : 0) |
2285 (pEGOpts[i]->Decay2Cancel ? (1<<3) : 0) |
2286 (pEGOpts[i]->ReleaseCancel ? (1<<4) : 0);
2287 }
2288 // format extension for release trigger options
2289 pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2290 }
2291 }
2292
2293 double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
2294 curve_type_t curveType = releaseVelocityResponseCurve;
2295 uint8_t depth = releaseVelocityResponseDepth;
2296 // this models a strange behaviour or bug in GSt: two of the
2297 // velocity response curves for release time are not used even
2298 // if specified, instead another curve is chosen.
2299 if ((curveType == curve_type_nonlinear && depth == 0) ||
2300 (curveType == curve_type_special && depth == 4)) {
2301 curveType = curve_type_nonlinear;
2302 depth = 3;
2303 }
2304 return GetVelocityTable(curveType, depth, 0);
2305 }
2306
2307 double* DimensionRegion::GetCutoffVelocityTable(curve_type_t vcfVelocityCurve,
2308 uint8_t vcfVelocityDynamicRange,
2309 uint8_t vcfVelocityScale,
2310 vcf_cutoff_ctrl_t vcfCutoffController)
2311 {
2312 curve_type_t curveType = vcfVelocityCurve;
2313 uint8_t depth = vcfVelocityDynamicRange;
2314 // even stranger GSt: two of the velocity response curves for
2315 // filter cutoff are not used, instead another special curve
2316 // is chosen. This curve is not used anywhere else.
2317 if ((curveType == curve_type_nonlinear && depth == 0) ||
2318 (curveType == curve_type_special && depth == 4)) {
2319 curveType = curve_type_special;
2320 depth = 5;
2321 }
2322 return GetVelocityTable(curveType, depth,
2323 (vcfCutoffController <= vcf_cutoff_ctrl_none2)
2324 ? vcfVelocityScale : 0);
2325 }
2326
2327 // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
2328 double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
2329 {
2330 // sanity check input parameters
2331 // (fallback to some default parameters on ill input)
2332 switch (curveType) {
2333 case curve_type_nonlinear:
2334 case curve_type_linear:
2335 if (depth > 4) {
2336 printf("Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2337 depth = 0;
2338 scaling = 0;
2339 }
2340 break;
2341 case curve_type_special:
2342 if (depth > 5) {
2343 printf("Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2344 depth = 0;
2345 scaling = 0;
2346 }
2347 break;
2348 case curve_type_unknown:
2349 default:
2350 printf("Warning: Unknown velocity curve type (0x%x).\n", curveType);
2351 curveType = curve_type_linear;
2352 depth = 0;
2353 scaling = 0;
2354 break;
2355 }
2356
2357 double* table;
2358 uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2359 if (pVelocityTables->count(tableKey)) { // if key exists
2360 table = (*pVelocityTables)[tableKey];
2361 }
2362 else {
2363 table = CreateVelocityTable(curveType, depth, scaling);
2364 (*pVelocityTables)[tableKey] = table; // put the new table into the tables map
2365 }
2366 return table;
2367 }
2368
2369 Region* DimensionRegion::GetParent() const {
2370 return pRegion;
2371 }
2372
2373 // show error if some _lev_ctrl_* enum entry is not listed in the following function
2374 // (commented out for now, because "diagnostic push" not supported prior GCC 4.6)
2375 // TODO: uncomment and add a GCC version check (see also commented "#pragma GCC diagnostic pop" below)
2376 //#pragma GCC diagnostic push
2377 //#pragma GCC diagnostic error "-Wswitch"
2378
2379 leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2380 leverage_ctrl_t decodedcontroller;
2381 switch (EncodedController) {
2382 // special controller
2383 case _lev_ctrl_none:
2384 decodedcontroller.type = leverage_ctrl_t::type_none;
2385 decodedcontroller.controller_number = 0;
2386 break;
2387 case _lev_ctrl_velocity:
2388 decodedcontroller.type = leverage_ctrl_t::type_velocity;
2389 decodedcontroller.controller_number = 0;
2390 break;
2391 case _lev_ctrl_channelaftertouch:
2392 decodedcontroller.type = leverage_ctrl_t::type_channelaftertouch;
2393 decodedcontroller.controller_number = 0;
2394 break;
2395
2396 // ordinary MIDI control change controller
2397 case _lev_ctrl_modwheel:
2398 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2399 decodedcontroller.controller_number = 1;
2400 break;
2401 case _lev_ctrl_breath:
2402 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2403 decodedcontroller.controller_number = 2;
2404 break;
2405 case _lev_ctrl_foot:
2406 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2407 decodedcontroller.controller_number = 4;
2408 break;
2409 case _lev_ctrl_effect1:
2410 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2411 decodedcontroller.controller_number = 12;
2412 break;
2413 case _lev_ctrl_effect2:
2414 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2415 decodedcontroller.controller_number = 13;
2416 break;
2417 case _lev_ctrl_genpurpose1:
2418 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2419 decodedcontroller.controller_number = 16;
2420 break;
2421 case _lev_ctrl_genpurpose2:
2422 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2423 decodedcontroller.controller_number = 17;
2424 break;
2425 case _lev_ctrl_genpurpose3:
2426 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2427 decodedcontroller.controller_number = 18;
2428 break;
2429 case _lev_ctrl_genpurpose4:
2430 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2431 decodedcontroller.controller_number = 19;
2432 break;
2433 case _lev_ctrl_portamentotime:
2434 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2435 decodedcontroller.controller_number = 5;
2436 break;
2437 case _lev_ctrl_sustainpedal:
2438 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2439 decodedcontroller.controller_number = 64;
2440 break;
2441 case _lev_ctrl_portamento:
2442 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2443 decodedcontroller.controller_number = 65;
2444 break;
2445 case _lev_ctrl_sostenutopedal:
2446 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2447 decodedcontroller.controller_number = 66;
2448 break;
2449 case _lev_ctrl_softpedal:
2450 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2451 decodedcontroller.controller_number = 67;
2452 break;
2453 case _lev_ctrl_genpurpose5:
2454 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2455 decodedcontroller.controller_number = 80;
2456 break;
2457 case _lev_ctrl_genpurpose6:
2458 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2459 decodedcontroller.controller_number = 81;
2460 break;
2461 case _lev_ctrl_genpurpose7:
2462 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2463 decodedcontroller.controller_number = 82;
2464 break;
2465 case _lev_ctrl_genpurpose8:
2466 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2467 decodedcontroller.controller_number = 83;
2468 break;
2469 case _lev_ctrl_effect1depth:
2470 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2471 decodedcontroller.controller_number = 91;
2472 break;
2473 case _lev_ctrl_effect2depth:
2474 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2475 decodedcontroller.controller_number = 92;
2476 break;
2477 case _lev_ctrl_effect3depth:
2478 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2479 decodedcontroller.controller_number = 93;
2480 break;
2481 case _lev_ctrl_effect4depth:
2482 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2483 decodedcontroller.controller_number = 94;
2484 break;
2485 case _lev_ctrl_effect5depth:
2486 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2487 decodedcontroller.controller_number = 95;
2488 break;
2489
2490 // format extension (these controllers are so far only supported by
2491 // LinuxSampler & gigedit) they will *NOT* work with
2492 // Gigasampler/GigaStudio !
2493 case _lev_ctrl_CC3_EXT:
2494 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2495 decodedcontroller.controller_number = 3;
2496 break;
2497 case _lev_ctrl_CC6_EXT:
2498 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2499 decodedcontroller.controller_number = 6;
2500 break;
2501 case _lev_ctrl_CC7_EXT:
2502 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2503 decodedcontroller.controller_number = 7;
2504 break;
2505 case _lev_ctrl_CC8_EXT:
2506 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2507 decodedcontroller.controller_number = 8;
2508 break;
2509 case _lev_ctrl_CC9_EXT:
2510 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2511 decodedcontroller.controller_number = 9;
2512 break;
2513 case _lev_ctrl_CC10_EXT:
2514 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2515 decodedcontroller.controller_number = 10;
2516 break;
2517 case _lev_ctrl_CC11_EXT:
2518 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2519 decodedcontroller.controller_number = 11;
2520 break;
2521 case _lev_ctrl_CC14_EXT:
2522 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2523 decodedcontroller.controller_number = 14;
2524 break;
2525 case _lev_ctrl_CC15_EXT:
2526 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2527 decodedcontroller.controller_number = 15;
2528 break;
2529 case _lev_ctrl_CC20_EXT:
2530 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2531 decodedcontroller.controller_number = 20;
2532 break;
2533 case _lev_ctrl_CC21_EXT:
2534 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2535 decodedcontroller.controller_number = 21;
2536 break;
2537 case _lev_ctrl_CC22_EXT:
2538 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2539 decodedcontroller.controller_number = 22;
2540 break;
2541 case _lev_ctrl_CC23_EXT:
2542 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2543 decodedcontroller.controller_number = 23;
2544 break;
2545 case _lev_ctrl_CC24_EXT:
2546 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2547 decodedcontroller.controller_number = 24;
2548 break;
2549 case _lev_ctrl_CC25_EXT:
2550 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2551 decodedcontroller.controller_number = 25;
2552 break;
2553 case _lev_ctrl_CC26_EXT:
2554 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2555 decodedcontroller.controller_number = 26;
2556 break;
2557 case _lev_ctrl_CC27_EXT:
2558 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2559 decodedcontroller.controller_number = 27;
2560 break;
2561 case _lev_ctrl_CC28_EXT:
2562 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2563 decodedcontroller.controller_number = 28;
2564 break;
2565 case _lev_ctrl_CC29_EXT:
2566 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2567 decodedcontroller.controller_number = 29;
2568 break;
2569 case _lev_ctrl_CC30_EXT:
2570 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2571 decodedcontroller.controller_number = 30;
2572 break;
2573 case _lev_ctrl_CC31_EXT:
2574 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2575 decodedcontroller.controller_number = 31;
2576 break;
2577 case _lev_ctrl_CC68_EXT:
2578 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2579 decodedcontroller.controller_number = 68;
2580 break;
2581 case _lev_ctrl_CC69_EXT:
2582 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2583 decodedcontroller.controller_number = 69;
2584 break;
2585 case _lev_ctrl_CC70_EXT:
2586 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2587 decodedcontroller.controller_number = 70;
2588 break;
2589 case _lev_ctrl_CC71_EXT:
2590 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2591 decodedcontroller.controller_number = 71;
2592 break;
2593 case _lev_ctrl_CC72_EXT:
2594 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2595 decodedcontroller.controller_number = 72;
2596 break;
2597 case _lev_ctrl_CC73_EXT:
2598 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2599 decodedcontroller.controller_number = 73;
2600 break;
2601 case _lev_ctrl_CC74_EXT:
2602 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2603 decodedcontroller.controller_number = 74;
2604 break;
2605 case _lev_ctrl_CC75_EXT:
2606 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2607 decodedcontroller.controller_number = 75;
2608 break;
2609 case _lev_ctrl_CC76_EXT:
2610 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2611 decodedcontroller.controller_number = 76;
2612 break;
2613 case _lev_ctrl_CC77_EXT:
2614 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2615 decodedcontroller.controller_number = 77;
2616 break;
2617 case _lev_ctrl_CC78_EXT:
2618 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2619 decodedcontroller.controller_number = 78;
2620 break;
2621 case _lev_ctrl_CC79_EXT:
2622 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2623 decodedcontroller.controller_number = 79;
2624 break;
2625 case _lev_ctrl_CC84_EXT:
2626 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2627 decodedcontroller.controller_number = 84;
2628 break;
2629 case _lev_ctrl_CC85_EXT:
2630 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2631 decodedcontroller.controller_number = 85;
2632 break;
2633 case _lev_ctrl_CC86_EXT:
2634 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2635 decodedcontroller.controller_number = 86;
2636 break;
2637 case _lev_ctrl_CC87_EXT:
2638 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2639 decodedcontroller.controller_number = 87;
2640 break;
2641 case _lev_ctrl_CC89_EXT:
2642 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2643 decodedcontroller.controller_number = 89;
2644 break;
2645 case _lev_ctrl_CC90_EXT:
2646 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2647 decodedcontroller.controller_number = 90;
2648 break;
2649 case _lev_ctrl_CC96_EXT:
2650 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2651 decodedcontroller.controller_number = 96;
2652 break;
2653 case _lev_ctrl_CC97_EXT:
2654 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2655 decodedcontroller.controller_number = 97;
2656 break;
2657 case _lev_ctrl_CC102_EXT:
2658 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2659 decodedcontroller.controller_number = 102;
2660 break;
2661 case _lev_ctrl_CC103_EXT:
2662 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2663 decodedcontroller.controller_number = 103;
2664 break;
2665 case _lev_ctrl_CC104_EXT:
2666 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2667 decodedcontroller.controller_number = 104;
2668 break;
2669 case _lev_ctrl_CC105_EXT:
2670 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2671 decodedcontroller.controller_number = 105;
2672 break;
2673 case _lev_ctrl_CC106_EXT:
2674 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2675 decodedcontroller.controller_number = 106;
2676 break;
2677 case _lev_ctrl_CC107_EXT:
2678 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2679 decodedcontroller.controller_number = 107;
2680 break;
2681 case _lev_ctrl_CC108_EXT:
2682 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2683 decodedcontroller.controller_number = 108;
2684 break;
2685 case _lev_ctrl_CC109_EXT:
2686 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2687 decodedcontroller.controller_number = 109;
2688 break;
2689 case _lev_ctrl_CC110_EXT:
2690 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2691 decodedcontroller.controller_number = 110;
2692 break;
2693 case _lev_ctrl_CC111_EXT:
2694 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2695 decodedcontroller.controller_number = 111;
2696 break;
2697 case _lev_ctrl_CC112_EXT:
2698 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2699 decodedcontroller.controller_number = 112;
2700 break;
2701 case _lev_ctrl_CC113_EXT:
2702 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2703 decodedcontroller.controller_number = 113;
2704 break;
2705 case _lev_ctrl_CC114_EXT:
2706 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2707 decodedcontroller.controller_number = 114;
2708 break;
2709 case _lev_ctrl_CC115_EXT:
2710 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2711 decodedcontroller.controller_number = 115;
2712 break;
2713 case _lev_ctrl_CC116_EXT:
2714 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2715 decodedcontroller.controller_number = 116;
2716 break;
2717 case _lev_ctrl_CC117_EXT:
2718 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2719 decodedcontroller.controller_number = 117;
2720 break;
2721 case _lev_ctrl_CC118_EXT:
2722 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2723 decodedcontroller.controller_number = 118;
2724 break;
2725 case _lev_ctrl_CC119_EXT:
2726 decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2727 decodedcontroller.controller_number = 119;
2728 break;
2729
2730 // unknown controller type
2731 default:
2732 decodedcontroller.type = leverage_ctrl_t::type_none;
2733 decodedcontroller.controller_number = 0;
2734 printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2735 break;
2736 }
2737 return decodedcontroller;
2738 }
2739
2740 // see above (diagnostic push not supported prior GCC 4.6)
2741 //#pragma GCC diagnostic pop
2742
2743 DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2744 _lev_ctrl_t encodedcontroller;
2745 switch (DecodedController.type) {
2746 // special controller
2747 case leverage_ctrl_t::type_none:
2748 encodedcontroller = _lev_ctrl_none;
2749 break;
2750 case leverage_ctrl_t::type_velocity:
2751 encodedcontroller = _lev_ctrl_velocity;
2752 break;
2753 case leverage_ctrl_t::type_channelaftertouch:
2754 encodedcontroller = _lev_ctrl_channelaftertouch;
2755 break;
2756
2757 // ordinary MIDI control change controller
2758 case leverage_ctrl_t::type_controlchange:
2759 switch (DecodedController.controller_number) {
2760 case 1:
2761 encodedcontroller = _lev_ctrl_modwheel;
2762 break;
2763 case 2:
2764 encodedcontroller = _lev_ctrl_breath;
2765 break;
2766 case 4:
2767 encodedcontroller = _lev_ctrl_foot;
2768 break;
2769 case 12:
2770 encodedcontroller = _lev_ctrl_effect1;
2771 break;
2772 case 13:
2773 encodedcontroller = _lev_ctrl_effect2;
2774 break;
2775 case 16:
2776 encodedcontroller = _lev_ctrl_genpurpose1;
2777 break;
2778 case 17:
2779 encodedcontroller = _lev_ctrl_genpurpose2;
2780 break;
2781 case 18:
2782 encodedcontroller = _lev_ctrl_genpurpose3;
2783 break;
2784 case 19:
2785 encodedcontroller = _lev_ctrl_genpurpose4;
2786 break;
2787 case 5:
2788 encodedcontroller = _lev_ctrl_portamentotime;
2789 break;
2790 case 64:
2791 encodedcontroller = _lev_ctrl_sustainpedal;
2792 break;
2793 case 65:
2794 encodedcontroller = _lev_ctrl_portamento;
2795 break;
2796 case 66:
2797 encodedcontroller = _lev_ctrl_sostenutopedal;
2798 break;
2799 case 67:
2800 encodedcontroller = _lev_ctrl_softpedal;
2801 break;
2802 case 80:
2803 encodedcontroller = _lev_ctrl_genpurpose5;
2804 break;
2805 case 81:
2806 encodedcontroller = _lev_ctrl_genpurpose6;
2807 break;
2808 case 82:
2809 encodedcontroller = _lev_ctrl_genpurpose7;
2810 break;
2811 case 83:
2812 encodedcontroller = _lev_ctrl_genpurpose8;
2813 break;
2814 case 91:
2815 encodedcontroller = _lev_ctrl_effect1depth;
2816 break;
2817 case 92:
2818 encodedcontroller = _lev_ctrl_effect2depth;
2819 break;
2820 case 93:
2821 encodedcontroller = _lev_ctrl_effect3depth;
2822 break;
2823 case 94:
2824 encodedcontroller = _lev_ctrl_effect4depth;
2825 break;
2826 case 95:
2827 encodedcontroller = _lev_ctrl_effect5depth;
2828 break;
2829
2830 // format extension (these controllers are so far only
2831 // supported by LinuxSampler & gigedit) they will *NOT*
2832 // work with Gigasampler/GigaStudio !
2833 case 3:
2834 encodedcontroller = _lev_ctrl_CC3_EXT;
2835 break;
2836 case 6:
2837 encodedcontroller = _lev_ctrl_CC6_EXT;
2838 break;
2839 case 7:
2840 encodedcontroller = _lev_ctrl_CC7_EXT;
2841 break;
2842 case 8:
2843 encodedcontroller = _lev_ctrl_CC8_EXT;
2844 break;
2845 case 9:
2846 encodedcontroller = _lev_ctrl_CC9_EXT;
2847 break;
2848 case 10:
2849 encodedcontroller = _lev_ctrl_CC10_EXT;
2850 break;
2851 case 11:
2852 encodedcontroller = _lev_ctrl_CC11_EXT;
2853 break;
2854 case 14:
2855 encodedcontroller = _lev_ctrl_CC14_EXT;
2856 break;
2857 case 15:
2858 encodedcontroller = _lev_ctrl_CC15_EXT;
2859 break;
2860 case 20:
2861 encodedcontroller = _lev_ctrl_CC20_EXT;
2862 break;
2863 case 21:
2864 encodedcontroller = _lev_ctrl_CC21_EXT;
2865 break;
2866 case 22:
2867 encodedcontroller = _lev_ctrl_CC22_EXT;
2868 break;
2869 case 23:
2870 encodedcontroller = _lev_ctrl_CC23_EXT;
2871 break;
2872 case 24:
2873 encodedcontroller = _lev_ctrl_CC24_EXT;
2874 break;
2875 case 25:
2876 encodedcontroller = _lev_ctrl_CC25_EXT;
2877 break;
2878 case 26:
2879 encodedcontroller = _lev_ctrl_CC26_EXT;
2880 break;
2881 case 27:
2882 encodedcontroller = _lev_ctrl_CC27_EXT;
2883 break;
2884 case 28:
2885 encodedcontroller = _lev_ctrl_CC28_EXT;
2886 break;
2887 case 29:
2888 encodedcontroller = _lev_ctrl_CC29_EXT;
2889 break;
2890 case 30:
2891 encodedcontroller = _lev_ctrl_CC30_EXT;
2892 break;
2893 case 31:
2894 encodedcontroller = _lev_ctrl_CC31_EXT;
2895 break;
2896 case 68:
2897 encodedcontroller = _lev_ctrl_CC68_EXT;
2898 break;
2899 case 69:
2900 encodedcontroller = _lev_ctrl_CC69_EXT;
2901 break;
2902 case 70:
2903 encodedcontroller = _lev_ctrl_CC70_EXT;
2904 break;
2905 case 71:
2906 encodedcontroller = _lev_ctrl_CC71_EXT;
2907 break;
2908 case 72:
2909 encodedcontroller = _lev_ctrl_CC72_EXT;
2910 break;
2911 case 73:
2912 encodedcontroller = _lev_ctrl_CC73_EXT;
2913 break;
2914 case 74:
2915 encodedcontroller = _lev_ctrl_CC74_EXT;
2916 break;
2917 case 75:
2918 encodedcontroller = _lev_ctrl_CC75_EXT;
2919 break;
2920 case 76:
2921 encodedcontroller = _lev_ctrl_CC76_EXT;
2922 break;
2923 case 77:
2924 encodedcontroller = _lev_ctrl_CC77_EXT;
2925 break;
2926 case 78:
2927 encodedcontroller = _lev_ctrl_CC78_EXT;
2928 break;
2929 case 79:
2930 encodedcontroller = _lev_ctrl_CC79_EXT;
2931 break;
2932 case 84:
2933 encodedcontroller = _lev_ctrl_CC84_EXT;
2934 break;
2935 case 85:
2936 encodedcontroller = _lev_ctrl_CC85_EXT;
2937 break;
2938 case 86:
2939 encodedcontroller = _lev_ctrl_CC86_EXT;
2940 break;
2941 case 87:
2942 encodedcontroller = _lev_ctrl_CC87_EXT;
2943 break;
2944 case 89:
2945 encodedcontroller = _lev_ctrl_CC89_EXT;
2946 break;
2947 case 90:
2948 encodedcontroller = _lev_ctrl_CC90_EXT;
2949 break;
2950 case 96:
2951 encodedcontroller = _lev_ctrl_CC96_EXT;
2952 break;
2953 case 97:
2954 encodedcontroller = _lev_ctrl_CC97_EXT;
2955 break;
2956 case 102:
2957 encodedcontroller = _lev_ctrl_CC102_EXT;
2958 break;
2959 case 103:
2960 encodedcontroller = _lev_ctrl_CC103_EXT;
2961 break;
2962 case 104:
2963 encodedcontroller = _lev_ctrl_CC104_EXT;
2964 break;
2965 case 105:
2966 encodedcontroller = _lev_ctrl_CC105_EXT;
2967 break;
2968 case 106:
2969 encodedcontroller = _lev_ctrl_CC106_EXT;
2970 break;
2971 case 107:
2972 encodedcontroller = _lev_ctrl_CC107_EXT;
2973 break;
2974 case 108:
2975 encodedcontroller = _lev_ctrl_CC108_EXT;
2976 break;
2977 case 109:
2978 encodedcontroller = _lev_ctrl_CC109_EXT;
2979 break;
2980 case 110:
2981 encodedcontroller = _lev_ctrl_CC110_EXT;
2982 break;
2983 case 111:
2984 encodedcontroller = _lev_ctrl_CC111_EXT;
2985 break;
2986 case 112:
2987 encodedcontroller = _lev_ctrl_CC112_EXT;
2988 break;
2989 case 113:
2990 encodedcontroller = _lev_ctrl_CC113_EXT;
2991 break;
2992 case 114:
2993 encodedcontroller = _lev_ctrl_CC114_EXT;
2994 break;
2995 case 115:
2996 encodedcontroller = _lev_ctrl_CC115_EXT;
2997 break;
2998 case 116:
2999 encodedcontroller = _lev_ctrl_CC116_EXT;
3000 break;
3001 case 117:
3002 encodedcontroller = _lev_ctrl_CC117_EXT;
3003 break;
3004 case 118:
3005 encodedcontroller = _lev_ctrl_CC118_EXT;
3006 break;
3007 case 119:
3008 encodedcontroller = _lev_ctrl_CC119_EXT;
3009 break;
3010
3011 default:
3012 throw gig::Exception("leverage controller number is not supported by the gig format");
3013 }
3014 break;
3015 default:
3016 throw gig::Exception("Unknown leverage controller type.");
3017 }
3018 return encodedcontroller;
3019 }
3020
3021 DimensionRegion::~DimensionRegion() {
3022 Instances--;
3023 if (!Instances) {
3024 // delete the velocity->volume tables
3025 VelocityTableMap::iterator iter;
3026 for (iter = pVelocityTables->begin(); iter != pVelocityTables->end(); iter++) {
3027 double* pTable = iter->second;
3028 if (pTable) delete[] pTable;
3029 }
3030 pVelocityTables->clear();
3031 delete pVelocityTables;
3032 pVelocityTables = NULL;
3033 }
3034 if (VelocityTable) delete[] VelocityTable;
3035 }
3036
3037 /**
3038 * Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
3039 * All involved parameters (VelocityResponseCurve, VelocityResponseDepth
3040 * and VelocityResponseCurveScaling) involved are taken into account to
3041 * calculate the amplitude factor. Use this method when a key was
3042 * triggered to get the volume with which the sample should be played
3043 * back.
3044 *
3045 * @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
3046 * @returns amplitude factor (between 0.0 and 1.0)
3047 */
3048 double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
3049 return pVelocityAttenuationTable[MIDIKeyVelocity];
3050 }
3051
3052 double DimensionRegion::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
3053 return pVelocityReleaseTable[MIDIKeyVelocity];
3054 }
3055
3056 double DimensionRegion::GetVelocityCutoff(uint8_t MIDIKeyVelocity) {
3057 return pVelocityCutoffTable[MIDIKeyVelocity];
3058 }
3059
3060 /**
3061 * Updates the respective member variable and the lookup table / cache
3062 * that depends on this value.
3063 */
3064 void DimensionRegion::SetVelocityResponseCurve(curve_type_t curve) {
3065 pVelocityAttenuationTable =
3066 GetVelocityTable(
3067 curve, VelocityResponseDepth, VelocityResponseCurveScaling
3068 );
3069 VelocityResponseCurve = curve;
3070 }
3071
3072 /**
3073 * Updates the respective member variable and the lookup table / cache
3074 * that depends on this value.
3075 */
3076 void DimensionRegion::SetVelocityResponseDepth(uint8_t depth) {
3077 pVelocityAttenuationTable =
3078 GetVelocityTable(
3079 VelocityResponseCurve, depth, VelocityResponseCurveScaling
3080 );
3081 VelocityResponseDepth = depth;
3082 }
3083
3084 /**
3085 * Updates the respective member variable and the lookup table / cache
3086 * that depends on this value.
3087 */
3088 void DimensionRegion::SetVelocityResponseCurveScaling(uint8_t scaling) {
3089 pVelocityAttenuationTable =
3090 GetVelocityTable(
3091 VelocityResponseCurve, VelocityResponseDepth, scaling
3092 );
3093 VelocityResponseCurveScaling = scaling;
3094 }
3095
3096 /**
3097 * Updates the respective member variable and the lookup table / cache
3098 * that depends on this value.
3099 */
3100 void DimensionRegion::SetReleaseVelocityResponseCurve(curve_type_t curve) {
3101 pVelocityReleaseTable = GetReleaseVelocityTable(curve, ReleaseVelocityResponseDepth);
3102 ReleaseVelocityResponseCurve = curve;
3103 }
3104
3105 /**
3106 * Updates the respective member variable and the lookup table / cache
3107 * that depends on this value.
3108 */
3109 void DimensionRegion::SetReleaseVelocityResponseDepth(uint8_t depth) {
3110 pVelocityReleaseTable = GetReleaseVelocityTable(ReleaseVelocityResponseCurve, depth);
3111 ReleaseVelocityResponseDepth = depth;
3112 }
3113
3114 /**
3115 * Updates the respective member variable and the lookup table / cache
3116 * that depends on this value.
3117 */
3118 void DimensionRegion::SetVCFCutoffController(vcf_cutoff_ctrl_t controller) {
3119 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, VCFVelocityScale, controller);
3120 VCFCutoffController = controller;
3121 }
3122
3123 /**
3124 * Updates the respective member variable and the lookup table / cache
3125 * that depends on this value.
3126 */
3127 void DimensionRegion::SetVCFVelocityCurve(curve_type_t curve) {
3128 pVelocityCutoffTable = GetCutoffVelocityTable(curve, VCFVelocityDynamicRange, VCFVelocityScale, VCFCutoffController);
3129 VCFVelocityCurve = curve;
3130 }
3131
3132 /**
3133 * Updates the respective member variable and the lookup table / cache
3134 * that depends on this value.
3135 */
3136 void DimensionRegion::SetVCFVelocityDynamicRange(uint8_t range) {
3137 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, range, VCFVelocityScale, VCFCutoffController);
3138 VCFVelocityDynamicRange = range;
3139 }
3140
3141 /**
3142 * Updates the respective member variable and the lookup table / cache
3143 * that depends on this value.
3144 */
3145 void DimensionRegion::SetVCFVelocityScale(uint8_t scaling) {
3146 pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, scaling, VCFCutoffController);
3147 VCFVelocityScale = scaling;
3148 }
3149
3150 double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
3151
3152 // line-segment approximations of the 15 velocity curves
3153
3154 // linear
3155 const int lin0[] = { 1, 1, 127, 127 };
3156 const int lin1[] = { 1, 21, 127, 127 };
3157 const int lin2[] = { 1, 45, 127, 127 };
3158 const int lin3[] = { 1, 74, 127, 127 };
3159 const int lin4[] = { 1, 127, 127, 127 };
3160
3161 // non-linear
3162 const int non0[] = { 1, 4, 24, 5, 57, 17, 92, 57, 122, 127, 127, 127 };
3163 const int non1[] = { 1, 4, 46, 9, 93, 56, 118, 106, 123, 127,
3164 127, 127 };
3165 const int non2[] = { 1, 4, 46, 9, 57, 20, 102, 107, 107, 127,
3166 127, 127 };
3167 const int non3[] = { 1, 15, 10, 19, 67, 73, 80, 80, 90, 98, 98, 127,
3168 127, 127 };
3169 const int non4[] = { 1, 25, 33, 57, 82, 81, 92, 127, 127, 127 };
3170
3171 // special
3172 const int spe0[] = { 1, 2, 76, 10, 90, 15, 95, 20, 99, 28, 103, 44,
3173 113, 127, 127, 127 };
3174 const int spe1[] = { 1, 2, 27, 5, 67, 18, 89, 29, 95, 35, 107, 67,
3175 118, 127, 127, 127 };
3176 const int spe2[] = { 1, 1, 33, 1, 53, 5, 61, 13, 69, 32, 79, 74,
3177 85, 90, 91, 127, 127, 127 };
3178 const int spe3[] = { 1, 32, 28, 35, 66, 48, 89, 59, 95, 65, 99, 73,
3179 117, 127, 127, 127 };
3180 const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
3181 127, 127 };
3182
3183 // this is only used by the VCF velocity curve
3184 const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
3185 91, 127, 127, 127 };
3186
3187 const int* const curves[] = { non0, non1, non2, non3, non4,
3188 lin0, lin1, lin2, lin3, lin4,
3189 spe0, spe1, spe2, spe3, spe4, spe5 };
3190
3191 double* const table = new double[128];
3192
3193 const int* curve = curves[curveType * 5 + depth];
3194 const int s = scaling == 0 ? 20 : scaling; // 0 or 20 means no scaling
3195
3196 table[0] = 0;
3197 for (int x = 1 ; x < 128 ; x++) {
3198
3199 if (x > curve[2]) curve += 2;
3200 double y = curve[1] + (x - curve[0]) *
3201 (double(curve[3] - curve[1]) / (curve[2] - curve[0]));
3202 y = y / 127;
3203
3204 // Scale up for s > 20, down for s < 20. When