libgig  4.1.0.svn8
gig.cpp
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2018 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 
36 #define GIG_FILE_EXT_VERSION 2
37 
43 #define INITIAL_SAMPLE_BUFFER_SIZE 512000 // 512 kB
44 
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 
259  inline static void __resetCRC(uint32_t& crc) {
260  crc = 0xffffffff;
261  }
262 
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 
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 
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 
504  void Sample::CopyAssignMeta(const Sample* orig) {
505  // handle base classes
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 
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 
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 
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 
700  buffer_t Sample::LoadSampleData() {
701  return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, 0); // 0 amount of NullSamples
702  }
703 
726  buffer_t Sample::LoadSampleData(file_offset_t SampleCount) {
727  return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
728  }
729 
749  buffer_t Sample::LoadSampleDataWithNullSamplesExtension(uint NullSamplesCount) {
750  return LoadSampleDataWithNullSamplesExtension(this->SamplesTotal, NullSamplesCount);
751  }
752 
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 
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 
824  if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
825  RAMCache.pStart = NULL;
826  RAMCache.Size = 0;
827  RAMCache.NullExtensionSize = 0;
828  }
829 
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 
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 
920  file_offset_t Sample::GetPos() const {
921  if (Compressed) return SamplePos;
922  else return pCkData->GetPos() / FrameSize;
923  }
924 
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 
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 
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 
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 
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 
1401  Group* Sample::GetGroup() const {
1402  return pGroup;
1403  }
1404 
1417  uint32_t Sample::GetWaveDataCRC32Checksum() {
1418  return crc;
1419  }
1420 
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 
1809  void DimensionRegion::CopyAssign(const DimensionRegion* orig) {
1810  CopyAssign(orig, NULL);
1811  }
1812 
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 
1960  void DimensionRegion::SetGain(int32_t gain) {
1961  DLS::Sampler::SetGain(gain);
1962  SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1963  }
1964 
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 
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 
3064  void DimensionRegion::SetVelocityResponseCurve(curve_type_t curve) {
3065  pVelocityAttenuationTable =
3066  GetVelocityTable(
3067  curve, VelocityResponseDepth, VelocityResponseCurveScaling
3068  );
3069  VelocityResponseCurve = curve;
3070  }
3071 
3076  void DimensionRegion::SetVelocityResponseDepth(uint8_t depth) {
3077  pVelocityAttenuationTable =
3078  GetVelocityTable(
3079  VelocityResponseCurve, depth, VelocityResponseCurveScaling
3080  );
3081  VelocityResponseDepth = depth;
3082  }
3083 
3088  void DimensionRegion::SetVelocityResponseCurveScaling(uint8_t scaling) {
3089  pVelocityAttenuationTable =
3090  GetVelocityTable(
3091  VelocityResponseCurve, VelocityResponseDepth, scaling
3092  );
3093  VelocityResponseCurveScaling = scaling;
3094  }
3095 
3100  void DimensionRegion::SetReleaseVelocityResponseCurve(curve_type_t curve) {
3101  pVelocityReleaseTable = GetReleaseVelocityTable(curve, ReleaseVelocityResponseDepth);
3102  ReleaseVelocityResponseCurve = curve;
3103  }
3104 
3109  void DimensionRegion::SetReleaseVelocityResponseDepth(uint8_t depth) {
3110  pVelocityReleaseTable = GetReleaseVelocityTable(ReleaseVelocityResponseCurve, depth);
3111  ReleaseVelocityResponseDepth = depth;
3112  }
3113 
3118  void DimensionRegion::SetVCFCutoffController(vcf_cutoff_ctrl_t controller) {
3119  pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, VCFVelocityDynamicRange, VCFVelocityScale, controller);
3120  VCFCutoffController = controller;
3121  }
3122 
3127  void DimensionRegion::SetVCFVelocityCurve(curve_type_t curve) {
3128  pVelocityCutoffTable = GetCutoffVelocityTable(curve, VCFVelocityDynamicRange, VCFVelocityScale, VCFCutoffController);
3129  VCFVelocityCurve = curve;
3130  }
3131 
3136  void DimensionRegion::SetVCFVelocityDynamicRange(uint8_t range) {
3137  pVelocityCutoffTable = GetCutoffVelocityTable(VCFVelocityCurve, range, VCFVelocityScale, VCFCutoffController);
3138  VCFVelocityDynamicRange = range;
3139  }
3140 
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
3205  // down-scaling, the curve still ends at 1.0.
3206  if (s < 20 && y >= 0.5)
3207  y = y / ((2 - 40.0 / s) * y + 40.0 / s - 1);
3208  else
3209  y = y * (s / 20.0);
3210  if (y > 1) y = 1;
3211 
3212  table[x] = y;
3213  }
3214  return table;
3215  }
3216 
3217 
3218 // *************** Region ***************
3219 // *
3220 
3221  Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {
3222  // Initialization
3223  Dimensions = 0;
3224  for (int i = 0; i < 256; i++) {
3225  pDimensionRegions[i] = NULL;
3226  }
3227  Layers = 1;
3228  File* file = (File*) GetParent()->GetParent();
3229  int dimensionBits = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3230 
3231  // Actual Loading
3232 
3233  if (!file->GetAutoLoad()) return;
3234 
3235  LoadDimensionRegions(rgnList);
3236 
3237  RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
3238  if (_3lnk) {
3239  DimensionRegions = _3lnk->ReadUint32();
3240  for (int i = 0; i < dimensionBits; i++) {
3241  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
3242  uint8_t bits = _3lnk->ReadUint8();
3243  _3lnk->ReadUint8(); // bit position of the dimension (bits[0] + bits[1] + ... + bits[i-1])
3244  _3lnk->ReadUint8(); // (1 << bit position of next dimension) - (1 << bit position of this dimension)
3245  uint8_t zones = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)
3246  if (dimension == dimension_none) { // inactive dimension
3247  pDimensionDefinitions[i].dimension = dimension_none;
3248  pDimensionDefinitions[i].bits = 0;
3249  pDimensionDefinitions[i].zones = 0;
3250  pDimensionDefinitions[i].split_type = split_type_bit;
3251  pDimensionDefinitions[i].zone_size = 0;
3252  }
3253  else { // active dimension
3254  pDimensionDefinitions[i].dimension = dimension;
3255  pDimensionDefinitions[i].bits = bits;
3256  pDimensionDefinitions[i].zones = zones ? zones : 0x01 << bits; // = pow(2,bits)
3257  pDimensionDefinitions[i].split_type = __resolveSplitType(dimension);
3258  pDimensionDefinitions[i].zone_size = __resolveZoneSize(pDimensionDefinitions[i]);
3259  Dimensions++;
3260 
3261  // if this is a layer dimension, remember the amount of layers
3262  if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
3263  }
3264  _3lnk->SetPos(3, RIFF::stream_curpos); // jump forward to next dimension definition
3265  }
3266  for (int i = dimensionBits ; i < 8 ; i++) pDimensionDefinitions[i].bits = 0;
3267 
3268  // if there's a velocity dimension and custom velocity zone splits are used,
3269  // update the VelocityTables in the dimension regions
3270  UpdateVelocityTable();
3271 
3272  // jump to start of the wave pool indices (if not already there)
3273  if (file->pVersion && file->pVersion->major > 2)
3274  _3lnk->SetPos(68); // version 3 has a different 3lnk structure
3275  else
3276  _3lnk->SetPos(44);
3277 
3278  // load sample references (if auto loading is enabled)
3279  if (file->GetAutoLoad()) {
3280  for (uint i = 0; i < DimensionRegions; i++) {
3281  uint32_t wavepoolindex = _3lnk->ReadUint32();
3282  if (file->pWavePoolTable && pDimensionRegions[i])
3283  pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3284  }
3285  GetSample(); // load global region sample reference
3286  }
3287  } else {
3288  DimensionRegions = 0;
3289  for (int i = 0 ; i < 8 ; i++) {
3290  pDimensionDefinitions[i].dimension = dimension_none;
3291  pDimensionDefinitions[i].bits = 0;
3292  pDimensionDefinitions[i].zones = 0;
3293  }
3294  }
3295 
3296  // make sure there is at least one dimension region
3297  if (!DimensionRegions) {
3298  RIFF::List* _3prg = rgnList->GetSubList(LIST_TYPE_3PRG);
3299  if (!_3prg) _3prg = rgnList->AddSubList(LIST_TYPE_3PRG);
3300  RIFF::List* _3ewl = _3prg->AddSubList(LIST_TYPE_3EWL);
3301  pDimensionRegions[0] = new DimensionRegion(this, _3ewl);
3302  DimensionRegions = 1;
3303  }
3304  }
3305 
3316  void Region::UpdateChunks(progress_t* pProgress) {
3317  // in the gig format we don't care about the Region's sample reference
3318  // but we still have to provide some existing one to not corrupt the
3319  // file, so to avoid the latter we simply always assign the sample of
3320  // the first dimension region of this region
3321  pSample = pDimensionRegions[0]->pSample;
3322 
3323  // first update base class's chunks
3324  DLS::Region::UpdateChunks(pProgress);
3325 
3326  // update dimension region's chunks
3327  for (int i = 0; i < DimensionRegions; i++) {
3328  pDimensionRegions[i]->UpdateChunks(pProgress);
3329  }
3330 
3331  File* pFile = (File*) GetParent()->GetParent();
3332  bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3333  const int iMaxDimensions = versiongt2 ? 8 : 5;
3334  const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3335 
3336  // make sure '3lnk' chunk exists
3337  RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
3338  if (!_3lnk) {
3339  const int _3lnkChunkSize = versiongt2 ? 1092 : 172;
3340  _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
3341  memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
3342 
3343  // move 3prg to last position
3344  pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), (RIFF::Chunk*)NULL);
3345  }
3346 
3347  // update dimension definitions in '3lnk' chunk
3348  uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
3349  store32(&pData[0], DimensionRegions);
3350  int shift = 0;
3351  for (int i = 0; i < iMaxDimensions; i++) {
3352  pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
3353  pData[5 + i * 8] = pDimensionDefinitions[i].bits;
3354  pData[6 + i * 8] = pDimensionDefinitions[i].dimension == dimension_none ? 0 : shift;
3355  pData[7 + i * 8] = (1 << (shift + pDimensionDefinitions[i].bits)) - (1 << shift);
3356  pData[8 + i * 8] = pDimensionDefinitions[i].zones;
3357  // next 3 bytes unknown, always zero?
3358 
3359  shift += pDimensionDefinitions[i].bits;
3360  }
3361 
3362  // update wave pool table in '3lnk' chunk
3363  const int iWavePoolOffset = versiongt2 ? 68 : 44;
3364  for (uint i = 0; i < iMaxDimensionRegions; i++) {
3365  int iWaveIndex = -1;
3366  if (i < DimensionRegions) {
3367  if (!pFile->pSamples || !pFile->pSamples->size()) throw gig::Exception("Could not update gig::Region, there are no samples");
3368  File::SampleList::iterator iter = pFile->pSamples->begin();
3369  File::SampleList::iterator end = pFile->pSamples->end();
3370  for (int index = 0; iter != end; ++iter, ++index) {
3371  if (*iter == pDimensionRegions[i]->pSample) {
3372  iWaveIndex = index;
3373  break;
3374  }
3375  }
3376  }
3377  store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3378  }
3379  }
3380 
3381  void Region::LoadDimensionRegions(RIFF::List* rgn) {
3382  RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);
3383  if (_3prg) {
3384  int dimensionRegionNr = 0;
3385  RIFF::List* _3ewl = _3prg->GetFirstSubList();
3386  while (_3ewl) {
3387  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
3388  pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);
3389  dimensionRegionNr++;
3390  }
3391  _3ewl = _3prg->GetNextSubList();
3392  }
3393  if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");
3394  }
3395  }
3396 
3397  void Region::SetKeyRange(uint16_t Low, uint16_t High) {
3398  // update KeyRange struct and make sure regions are in correct order
3399  DLS::Region::SetKeyRange(Low, High);
3400  // update Region key table for fast lookup
3401  ((gig::Instrument*)GetParent())->UpdateRegionKeyTable();
3402  }
3403 
3404  void Region::UpdateVelocityTable() {
3405  // get velocity dimension's index
3406  int veldim = -1;
3407  for (int i = 0 ; i < Dimensions ; i++) {
3408  if (pDimensionDefinitions[i].dimension == gig::dimension_velocity) {
3409  veldim = i;
3410  break;
3411  }
3412  }
3413  if (veldim == -1) return;
3414 
3415  int step = 1;
3416  for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
3417  int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
3418 
3419  // loop through all dimension regions for all dimensions except the velocity dimension
3420  int dim[8] = { 0 };
3421  for (int i = 0 ; i < DimensionRegions ; i++) {
3422  const int end = i + step * pDimensionDefinitions[veldim].zones;
3423 
3424  // create a velocity table for all cases where the velocity zone is zero
3425  if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
3426  pDimensionRegions[i]->VelocityUpperLimit) {
3427  // create the velocity table
3428  uint8_t* table = pDimensionRegions[i]->VelocityTable;
3429  if (!table) {
3430  table = new uint8_t[128];
3431  pDimensionRegions[i]->VelocityTable = table;
3432  }
3433  int tableidx = 0;
3434  int velocityZone = 0;
3435  if (pDimensionRegions[i]->DimensionUpperLimits[veldim]) { // gig3
3436  for (int k = i ; k < end ; k += step) {
3437  DimensionRegion *d = pDimensionRegions[k];
3438  for (; tableidx <= d->DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
3439  velocityZone++;
3440  }
3441  } else { // gig2
3442  for (int k = i ; k < end ; k += step) {
3443  DimensionRegion *d = pDimensionRegions[k];
3444  for (; tableidx <= d->VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
3445  velocityZone++;
3446  }
3447  }
3448  } else {
3449  if (pDimensionRegions[i]->VelocityTable) {
3450  delete[] pDimensionRegions[i]->VelocityTable;
3451  pDimensionRegions[i]->VelocityTable = 0;
3452  }
3453  }
3454 
3455  // jump to the next case where the velocity zone is zero
3456  int j;
3457  int shift = 0;
3458  for (j = 0 ; j < Dimensions ; j++) {
3459  if (j == veldim) i += skipveldim; // skip velocity dimension
3460  else {
3461  dim[j]++;
3462  if (dim[j] < pDimensionDefinitions[j].zones) break;
3463  else {
3464  // skip unused dimension regions
3465  dim[j] = 0;
3466  i += ((1 << pDimensionDefinitions[j].bits) -
3467  pDimensionDefinitions[j].zones) << shift;
3468  }
3469  }
3470  shift += pDimensionDefinitions[j].bits;
3471  }
3472  if (j == Dimensions) break;
3473  }
3474  }
3475 
3491  void Region::AddDimension(dimension_def_t* pDimDef) {
3492  // some initial sanity checks of the given dimension definition
3493  if (pDimDef->zones < 2)
3494  throw gig::Exception("Could not add new dimension, amount of requested zones must always be at least two");
3495  if (pDimDef->bits < 1)
3496  throw gig::Exception("Could not add new dimension, amount of requested requested zone bits must always be at least one");
3497  if (pDimDef->dimension == dimension_samplechannel) {
3498  if (pDimDef->zones != 2)
3499  throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3500  if (pDimDef->bits != 1)
3501  throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3502  }
3503 
3504  // check if max. amount of dimensions reached
3505  File* file = (File*) GetParent()->GetParent();
3506  const int iMaxDimensions = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3507  if (Dimensions >= iMaxDimensions)
3508  throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");
3509  // check if max. amount of dimension bits reached
3510  int iCurrentBits = 0;
3511  for (int i = 0; i < Dimensions; i++)
3512  iCurrentBits += pDimensionDefinitions[i].bits;
3513  if (iCurrentBits >= iMaxDimensions)
3514  throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimension bits already reached");
3515  const int iNewBits = iCurrentBits + pDimDef->bits;
3516  if (iNewBits > iMaxDimensions)
3517  throw gig::Exception("Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) + " dimension bits");
3518  // check if there's already a dimensions of the same type
3519  for (int i = 0; i < Dimensions; i++)
3520  if (pDimensionDefinitions[i].dimension == pDimDef->dimension)
3521  throw gig::Exception("Could not add new dimension, there is already a dimension of the same type");
3522 
3523  // pos is where the new dimension should be placed, normally
3524  // last in list, except for the samplechannel dimension which
3525  // has to be first in list
3526  int pos = pDimDef->dimension == dimension_samplechannel ? 0 : Dimensions;
3527  int bitpos = 0;
3528  for (int i = 0 ; i < pos ; i++)
3529  bitpos += pDimensionDefinitions[i].bits;
3530 
3531  // make room for the new dimension
3532  for (int i = Dimensions ; i > pos ; i--) pDimensionDefinitions[i] = pDimensionDefinitions[i - 1];
3533  for (int i = 0 ; i < (1 << iCurrentBits) ; i++) {
3534  for (int j = Dimensions ; j > pos ; j--) {
3535  pDimensionRegions[i]->DimensionUpperLimits[j] =
3536  pDimensionRegions[i]->DimensionUpperLimits[j - 1];
3537  }
3538  }
3539 
3540  // assign definition of new dimension
3541  pDimensionDefinitions[pos] = *pDimDef;
3542 
3543  // auto correct certain dimension definition fields (where possible)
3544  pDimensionDefinitions[pos].split_type =
3545  __resolveSplitType(pDimensionDefinitions[pos].dimension);
3546  pDimensionDefinitions[pos].zone_size =
3547  __resolveZoneSize(pDimensionDefinitions[pos]);
3548 
3549  // create new dimension region(s) for this new dimension, and make
3550  // sure that the dimension regions are placed correctly in both the
3551  // RIFF list and the pDimensionRegions array
3552  RIFF::Chunk* moveTo = NULL;
3553  RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
3554  for (int i = (1 << iCurrentBits) - (1 << bitpos) ; i >= 0 ; i -= (1 << bitpos)) {
3555  for (int k = 0 ; k < (1 << bitpos) ; k++) {
3556  pDimensionRegions[(i << pDimDef->bits) + k] = pDimensionRegions[i + k];
3557  }
3558  for (int j = 1 ; j < (1 << pDimDef->bits) ; j++) {
3559  for (int k = 0 ; k < (1 << bitpos) ; k++) {
3560  RIFF::List* pNewDimRgnListChunk = _3prg->AddSubList(LIST_TYPE_3EWL);
3561  if (moveTo) _3prg->MoveSubChunk(pNewDimRgnListChunk, moveTo);
3562  // create a new dimension region and copy all parameter values from
3563  // an existing dimension region
3564  pDimensionRegions[(i << pDimDef->bits) + (j << bitpos) + k] =
3565  new DimensionRegion(pNewDimRgnListChunk, *pDimensionRegions[i + k]);
3566 
3567  DimensionRegions++;
3568  }
3569  }
3570  moveTo = pDimensionRegions[i]->pParentList;
3571  }
3572 
3573  // initialize the upper limits for this dimension
3574  int mask = (1 << bitpos) - 1;
3575  for (int z = 0 ; z < pDimDef->zones ; z++) {
3576  uint8_t upperLimit = uint8_t((z + 1) * 128.0 / pDimDef->zones - 1);
3577  for (int i = 0 ; i < 1 << iCurrentBits ; i++) {
3578  pDimensionRegions[((i & ~mask) << pDimDef->bits) |
3579  (z << bitpos) |
3580  (i & mask)]->DimensionUpperLimits[pos] = upperLimit;
3581  }
3582  }
3583 
3584  Dimensions++;
3585 
3586  // if this is a layer dimension, update 'Layers' attribute
3587  if (pDimDef->dimension == dimension_layer) Layers = pDimDef->zones;
3588 
3589  UpdateVelocityTable();
3590  }
3591 
3603  void Region::DeleteDimension(dimension_def_t* pDimDef) {
3604  // get dimension's index
3605  int iDimensionNr = -1;
3606  for (int i = 0; i < Dimensions; i++) {
3607  if (&pDimensionDefinitions[i] == pDimDef) {
3608  iDimensionNr = i;
3609  break;
3610  }
3611  }
3612  if (iDimensionNr < 0) throw gig::Exception("Invalid dimension_def_t pointer");
3613 
3614  // get amount of bits below the dimension to delete
3615  int iLowerBits = 0;
3616  for (int i = 0; i < iDimensionNr; i++)
3617  iLowerBits += pDimensionDefinitions[i].bits;
3618 
3619  // get amount ot bits above the dimension to delete
3620  int iUpperBits = 0;
3621  for (int i = iDimensionNr + 1; i < Dimensions; i++)
3622  iUpperBits += pDimensionDefinitions[i].bits;
3623 
3624  RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
3625 
3626  // delete dimension regions which belong to the given dimension
3627  // (that is where the dimension's bit > 0)
3628  for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
3629  for (int iObsoleteBit = 1; iObsoleteBit < 1 << pDimensionDefinitions[iDimensionNr].bits; iObsoleteBit++) {
3630  for (int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
3631  int iToDelete = iUpperBit << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
3632  iObsoleteBit << iLowerBits |
3633  iLowerBit;
3634 
3635  _3prg->DeleteSubChunk(pDimensionRegions[iToDelete]->pParentList);
3636  delete pDimensionRegions[iToDelete];
3637  pDimensionRegions[iToDelete] = NULL;
3638  DimensionRegions--;
3639  }
3640  }
3641  }
3642 
3643  // defrag pDimensionRegions array
3644  // (that is remove the NULL spaces within the pDimensionRegions array)
3645  for (int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
3646  if (!pDimensionRegions[iTo]) {
3647  if (iFrom <= iTo) iFrom = iTo + 1;
3648  while (!pDimensionRegions[iFrom] && iFrom < 256) iFrom++;
3649  if (iFrom < 256 && pDimensionRegions[iFrom]) {
3650  pDimensionRegions[iTo] = pDimensionRegions[iFrom];
3651  pDimensionRegions[iFrom] = NULL;
3652  }
3653  }
3654  }
3655 
3656  // remove the this dimension from the upper limits arrays
3657  for (int j = 0 ; j < 256 && pDimensionRegions[j] ; j++) {
3658  DimensionRegion* d = pDimensionRegions[j];
3659  for (int i = iDimensionNr + 1; i < Dimensions; i++) {
3660  d->DimensionUpperLimits[i - 1] = d->DimensionUpperLimits[i];
3661  }
3662  d->DimensionUpperLimits[Dimensions - 1] = 127;
3663  }
3664 
3665  // 'remove' dimension definition
3666  for (int i = iDimensionNr + 1; i < Dimensions; i++) {
3667  pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
3668  }
3669  pDimensionDefinitions[Dimensions - 1].dimension = dimension_none;
3670  pDimensionDefinitions[Dimensions - 1].bits = 0;
3671  pDimensionDefinitions[Dimensions - 1].zones = 0;
3672 
3673  Dimensions--;
3674 
3675  // if this was a layer dimension, update 'Layers' attribute
3676  if (pDimDef->dimension == dimension_layer) Layers = 1;
3677  }
3678 
3693  void Region::DeleteDimensionZone(dimension_t type, int zone) {
3694  dimension_def_t* oldDef = GetDimensionDefinition(type);
3695  if (!oldDef)
3696  throw gig::Exception("Could not delete dimension zone, no such dimension of given type");
3697  if (oldDef->zones <= 2)
3698  throw gig::Exception("Could not delete dimension zone, because it would end up with only one zone.");
3699  if (zone < 0 || zone >= oldDef->zones)
3700  throw gig::Exception("Could not delete dimension zone, requested zone index out of bounds.");
3701 
3702  const int newZoneSize = oldDef->zones - 1;
3703 
3704  // create a temporary Region which just acts as a temporary copy
3705  // container and will be deleted at the end of this function and will
3706  // also not be visible through the API during this process
3707  gig::Region* tempRgn = NULL;
3708  {
3709  // adding these temporary chunks is probably not even necessary
3710  Instrument* instr = static_cast<Instrument*>(GetParent());
3711  RIFF::List* pCkInstrument = instr->pCkInstrument;
3712  RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
3713  if (!lrgn) lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
3714  RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
3715  tempRgn = new Region(instr, rgn);
3716  }
3717 
3718  // copy this region's dimensions (with already the dimension split size
3719  // requested by the arguments of this method call) to the temporary
3720  // region, and don't use Region::CopyAssign() here for this task, since
3721  // it would also alter fast lookup helper variables here and there
3722  dimension_def_t newDef;
3723  for (int i = 0; i < Dimensions; ++i) {
3724  dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
3725  // is this the dimension requested by the method arguments? ...
3726  if (def.dimension == type) { // ... if yes, decrement zone amount by one
3727  def.zones = newZoneSize;
3728  if ((1 << (def.bits - 1)) == def.zones) def.bits--;
3729  newDef = def;
3730  }
3731  tempRgn->AddDimension(&def);
3732  }
3733 
3734  // find the dimension index in the tempRegion which is the dimension
3735  // type passed to this method (paranoidly expecting different order)
3736  int tempReducedDimensionIndex = -1;
3737  for (int d = 0; d < tempRgn->Dimensions; ++d) {
3738  if (tempRgn->pDimensionDefinitions[d].dimension == type) {
3739  tempReducedDimensionIndex = d;
3740  break;
3741  }
3742  }
3743 
3744  // copy dimension regions from this region to the temporary region
3745  for (int iDst = 0; iDst < 256; ++iDst) {
3746  DimensionRegion* dstDimRgn = tempRgn->pDimensionRegions[iDst];
3747  if (!dstDimRgn) continue;
3748  std::map<dimension_t,int> dimCase;
3749  bool isValidZone = true;
3750  for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3751  const int dstBits = tempRgn->pDimensionDefinitions[d].bits;
3752  dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3753  (iDst >> baseBits) & ((1 << dstBits) - 1);
3754  baseBits += dstBits;
3755  // there are also DimensionRegion objects of unused zones, skip them
3756  if (dimCase[tempRgn->pDimensionDefinitions[d].dimension] >= tempRgn->pDimensionDefinitions[d].zones) {
3757  isValidZone = false;
3758  break;
3759  }
3760  }
3761  if (!isValidZone) continue;
3762  // a bit paranoid: cope with the chance that the dimensions would
3763  // have different order in source and destination regions
3764  const bool isLastZone = (dimCase[type] == newZoneSize - 1);
3765  if (dimCase[type] >= zone) dimCase[type]++;
3766  DimensionRegion* srcDimRgn = GetDimensionRegionByBit(dimCase);
3767  dstDimRgn->CopyAssign(srcDimRgn);
3768  // if this is the upper most zone of the dimension passed to this
3769  // method, then correct (raise) its upper limit to 127
3770  if (newDef.split_type == split_type_normal && isLastZone)
3771  dstDimRgn->DimensionUpperLimits[tempReducedDimensionIndex] = 127;
3772  }
3773 
3774  // now tempRegion's dimensions and DimensionRegions basically reflect
3775  // what we wanted to get for this actual Region here, so we now just
3776  // delete and recreate the dimension in question with the new amount
3777  // zones and then copy back from tempRegion
3778  DeleteDimension(oldDef);
3779  AddDimension(&newDef);
3780  for (int iSrc = 0; iSrc < 256; ++iSrc) {
3781  DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
3782  if (!srcDimRgn) continue;
3783  std::map<dimension_t,int> dimCase;
3784  for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3785  const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
3786  dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3787  (iSrc >> baseBits) & ((1 << srcBits) - 1);
3788  baseBits += srcBits;
3789  }
3790  // a bit paranoid: cope with the chance that the dimensions would
3791  // have different order in source and destination regions
3792  DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
3793  if (!dstDimRgn) continue;
3794  dstDimRgn->CopyAssign(srcDimRgn);
3795  }
3796 
3797  // delete temporary region
3798  delete tempRgn;
3799 
3800  UpdateVelocityTable();
3801  }
3802 
3817  void Region::SplitDimensionZone(dimension_t type, int zone) {
3818  dimension_def_t* oldDef = GetDimensionDefinition(type);
3819  if (!oldDef)
3820  throw gig::Exception("Could not split dimension zone, no such dimension of given type");
3821  if (zone < 0 || zone >= oldDef->zones)
3822  throw gig::Exception("Could not split dimension zone, requested zone index out of bounds.");
3823 
3824  const int newZoneSize = oldDef->zones + 1;
3825 
3826  // create a temporary Region which just acts as a temporary copy
3827  // container and will be deleted at the end of this function and will
3828  // also not be visible through the API during this process
3829  gig::Region* tempRgn = NULL;
3830  {
3831  // adding these temporary chunks is probably not even necessary
3832  Instrument* instr = static_cast<Instrument*>(GetParent());
3833  RIFF::List* pCkInstrument = instr->pCkInstrument;
3834  RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
3835  if (!lrgn) lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
3836  RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
3837  tempRgn = new Region(instr, rgn);
3838  }
3839 
3840  // copy this region's dimensions (with already the dimension split size
3841  // requested by the arguments of this method call) to the temporary
3842  // region, and don't use Region::CopyAssign() here for this task, since
3843  // it would also alter fast lookup helper variables here and there
3844  dimension_def_t newDef;
3845  for (int i = 0; i < Dimensions; ++i) {
3846  dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
3847  // is this the dimension requested by the method arguments? ...
3848  if (def.dimension == type) { // ... if yes, increment zone amount by one
3849  def.zones = newZoneSize;
3850  if ((1 << oldDef->bits) < newZoneSize) def.bits++;
3851  newDef = def;
3852  }
3853  tempRgn->AddDimension(&def);
3854  }
3855 
3856  // find the dimension index in the tempRegion which is the dimension
3857  // type passed to this method (paranoidly expecting different order)
3858  int tempIncreasedDimensionIndex = -1;
3859  for (int d = 0; d < tempRgn->Dimensions; ++d) {
3860  if (tempRgn->pDimensionDefinitions[d].dimension == type) {
3861  tempIncreasedDimensionIndex = d;
3862  break;
3863  }
3864  }
3865 
3866  // copy dimension regions from this region to the temporary region
3867  for (int iSrc = 0; iSrc < 256; ++iSrc) {
3868  DimensionRegion* srcDimRgn = pDimensionRegions[iSrc];
3869  if (!srcDimRgn) continue;
3870  std::map<dimension_t,int> dimCase;
3871  bool isValidZone = true;
3872  for (int d = 0, baseBits = 0; d < Dimensions; ++d) {
3873  const int srcBits = pDimensionDefinitions[d].bits;
3874  dimCase[pDimensionDefinitions[d].dimension] =
3875  (iSrc >> baseBits) & ((1 << srcBits) - 1);
3876  // there are also DimensionRegion objects for unused zones, skip them
3877  if (dimCase[pDimensionDefinitions[d].dimension] >= pDimensionDefinitions[d].zones) {
3878  isValidZone = false;
3879  break;
3880  }
3881  baseBits += srcBits;
3882  }
3883  if (!isValidZone) continue;
3884  // a bit paranoid: cope with the chance that the dimensions would
3885  // have different order in source and destination regions
3886  if (dimCase[type] > zone) dimCase[type]++;
3887  DimensionRegion* dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
3888  dstDimRgn->CopyAssign(srcDimRgn);
3889  // if this is the requested zone to be splitted, then also copy
3890  // the source DimensionRegion to the newly created target zone
3891  // and set the old zones upper limit lower
3892  if (dimCase[type] == zone) {
3893  // lower old zones upper limit
3894  if (newDef.split_type == split_type_normal) {
3895  const int high =
3896  dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex];
3897  int low = 0;
3898  if (zone > 0) {
3899  std::map<dimension_t,int> lowerCase = dimCase;
3900  lowerCase[type]--;
3901  DimensionRegion* dstDimRgnLow = tempRgn->GetDimensionRegionByBit(lowerCase);
3902  low = dstDimRgnLow->DimensionUpperLimits[tempIncreasedDimensionIndex];
3903  }
3904  dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex] = low + (high - low) / 2;
3905  }
3906  // fill the newly created zone of the divided zone as well
3907  dimCase[type]++;
3908  dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
3909  dstDimRgn->CopyAssign(srcDimRgn);
3910  }
3911  }
3912 
3913  // now tempRegion's dimensions and DimensionRegions basically reflect
3914  // what we wanted to get for this actual Region here, so we now just
3915  // delete and recreate the dimension in question with the new amount
3916  // zones and then copy back from tempRegion
3917  DeleteDimension(oldDef);
3918  AddDimension(&newDef);
3919  for (int iSrc = 0; iSrc < 256; ++iSrc) {
3920  DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
3921  if (!srcDimRgn) continue;
3922  std::map<dimension_t,int> dimCase;
3923  for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
3924  const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
3925  dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
3926  (iSrc >> baseBits) & ((1 << srcBits) - 1);
3927  baseBits += srcBits;
3928  }
3929  // a bit paranoid: cope with the chance that the dimensions would
3930  // have different order in source and destination regions
3931  DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
3932  if (!dstDimRgn) continue;
3933  dstDimRgn->CopyAssign(srcDimRgn);
3934  }
3935 
3936  // delete temporary region
3937  delete tempRgn;
3938 
3939  UpdateVelocityTable();
3940  }
3941 
3956  void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
3957  if (oldType == newType) return;
3958  dimension_def_t* def = GetDimensionDefinition(oldType);
3959  if (!def)
3960  throw gig::Exception("No dimension with provided old dimension type exists on this region");
3961  if (newType == dimension_samplechannel && def->zones != 2)
3962  throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3963  if (GetDimensionDefinition(newType))
3964  throw gig::Exception("There is already a dimension with requested new dimension type on this region");
3965  def->dimension = newType;
3966  def->split_type = __resolveSplitType(newType);
3967  }
3968 
3969  DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {
3970  uint8_t bits[8] = {};
3971  for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
3972  it != DimCase.end(); ++it)
3973  {
3974  for (int d = 0; d < Dimensions; ++d) {
3975  if (pDimensionDefinitions[d].dimension == it->first) {
3976  bits[d] = it->second;
3977  goto nextDimCaseSlice;
3978  }
3979  }
3980  assert(false); // do crash ... too harsh maybe ? ignore it instead ?
3981  nextDimCaseSlice:
3982  ; // noop
3983  }
3984  return GetDimensionRegionByBit(bits);
3985  }
3986 
3996  dimension_def_t* Region::GetDimensionDefinition(dimension_t type) {
3997  for (int i = 0; i < Dimensions; ++i)
3998  if (pDimensionDefinitions[i].dimension == type)
3999  return &pDimensionDefinitions[i];
4000  return NULL;
4001  }
4002 
4003  Region::~Region() {
4004  for (int i = 0; i < 256; i++) {
4005  if (pDimensionRegions[i]) delete pDimensionRegions[i];
4006  }
4007  }
4008 
4027  DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
4028  uint8_t bits;
4029  int veldim = -1;
4030  int velbitpos = 0;
4031  int bitpos = 0;
4032  int dimregidx = 0;
4033  for (uint i = 0; i < Dimensions; i++) {
4034  if (pDimensionDefinitions[i].dimension == dimension_velocity) {
4035  // the velocity dimension must be handled after the other dimensions
4036  veldim = i;
4037  velbitpos = bitpos;
4038  } else {
4039  switch (pDimensionDefinitions[i].split_type) {
4040  case split_type_normal:
4041  if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
4042  // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
4043  for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
4044  if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
4045  }
4046  } else {
4047  // gig2: evenly sized zones
4048  bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
4049  }
4050  break;
4051  case split_type_bit: // the value is already the sought dimension bit number
4052  const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
4053  bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
4054  break;
4055  }
4056  dimregidx |= bits << bitpos;
4057  }
4058  bitpos += pDimensionDefinitions[i].bits;
4059  }
4060  DimensionRegion* dimreg = pDimensionRegions[dimregidx & 255];
4061  if (!dimreg) return NULL;
4062  if (veldim != -1) {
4063  // (dimreg is now the dimension region for the lowest velocity)
4064  if (dimreg->VelocityTable) // custom defined zone ranges
4065  bits = dimreg->VelocityTable[DimValues[veldim] & 127];
4066  else // normal split type
4067  bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
4068 
4069  const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
4070  dimregidx |= (bits & limiter_mask) << velbitpos;
4071  dimreg = pDimensionRegions[dimregidx & 255];
4072  }
4073  return dimreg;
4074  }
4075 
4076  int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
4077  uint8_t bits;
4078  int veldim = -1;
4079  int velbitpos = 0;
4080  int bitpos = 0;
4081  int dimregidx = 0;
4082  for (uint i = 0; i < Dimensions; i++) {
4083  if (pDimensionDefinitions[i].dimension == dimension_velocity) {
4084  // the velocity dimension must be handled after the other dimensions
4085  veldim = i;
4086  velbitpos = bitpos;
4087  } else {
4088  switch (pDimensionDefinitions[i].split_type) {
4089  case split_type_normal:
4090  if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
4091  // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
4092  for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
4093  if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
4094  }
4095  } else {
4096  // gig2: evenly sized zones
4097  bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
4098  }
4099  break;
4100  case split_type_bit: // the value is already the sought dimension bit number
4101  const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
4102  bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
4103  break;
4104  }
4105  dimregidx |= bits << bitpos;
4106  }
4107  bitpos += pDimensionDefinitions[i].bits;
4108  }
4109  dimregidx &= 255;
4110  DimensionRegion* dimreg = pDimensionRegions[dimregidx];
4111  if (!dimreg) return -1;
4112  if (veldim != -1) {
4113  // (dimreg is now the dimension region for the lowest velocity)
4114  if (dimreg->VelocityTable) // custom defined zone ranges
4115  bits = dimreg->VelocityTable[DimValues[veldim] & 127];
4116  else // normal split type
4117  bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
4118 
4119  const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
4120  dimregidx |= (bits & limiter_mask) << velbitpos;
4121  dimregidx &= 255;
4122  }
4123  return dimregidx;
4124  }
4125 
4136  DimensionRegion* Region::GetDimensionRegionByBit(const uint8_t DimBits[8]) {
4137  return pDimensionRegions[((((((DimBits[7] << pDimensionDefinitions[6].bits | DimBits[6])
4138  << pDimensionDefinitions[5].bits | DimBits[5])
4139  << pDimensionDefinitions[4].bits | DimBits[4])
4140  << pDimensionDefinitions[3].bits | DimBits[3])
4141  << pDimensionDefinitions[2].bits | DimBits[2])
4142  << pDimensionDefinitions[1].bits | DimBits[1])
4143  << pDimensionDefinitions[0].bits | DimBits[0]];
4144  }
4145 
4155  Sample* Region::GetSample() {
4156  if (pSample) return static_cast<gig::Sample*>(pSample);
4157  else return static_cast<gig::Sample*>(pSample = GetSampleFromWavePool(WavePoolTableIndex));
4158  }
4159 
4160  Sample* Region::GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress) {
4161  if ((int32_t)WavePoolTableIndex == -1) return NULL;
4162  File* file = (File*) GetParent()->GetParent();
4163  if (!file->pWavePoolTable) return NULL;
4164  if (WavePoolTableIndex + 1 > file->WavePoolCount) return NULL;
4165  // for new files or files >= 2 GB use 64 bit wave pool offsets
4166  if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
4167  // use 64 bit wave pool offsets (treating this as large file)
4168  uint64_t soughtoffset =
4169  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
4170  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
4171  Sample* sample = file->GetFirstSample(pProgress);
4172  while (sample) {
4173  if (sample->ullWavePoolOffset == soughtoffset)
4174  return static_cast<gig::Sample*>(sample);
4175  sample = file->GetNextSample();
4176  }
4177  } else {
4178  // use extension files and 32 bit wave pool offsets
4179  file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
4180  file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
4181  Sample* sample = file->GetFirstSample(pProgress);
4182  while (sample) {
4183  if (sample->ullWavePoolOffset == soughtoffset &&
4184  sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);
4185  sample = file->GetNextSample();
4186  }
4187  }
4188  return NULL;
4189  }
4190 
4200  void Region::CopyAssign(const Region* orig) {
4201  CopyAssign(orig, NULL);
4202  }
4203 
4211  void Region::CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples) {
4212  // handle base classes
4214 
4215  if (mSamples && mSamples->count((gig::Sample*)orig->pSample)) {
4216  pSample = mSamples->find((gig::Sample*)orig->pSample)->second;
4217  }
4218 
4219  // handle own member variables
4220  for (int i = Dimensions - 1; i >= 0; --i) {
4221  DeleteDimension(&pDimensionDefinitions[i]);
4222  }
4223  Layers = 0; // just to be sure
4224  for (int i = 0; i < orig->Dimensions; i++) {
4225  // we need to copy the dim definition here, to avoid the compiler
4226  // complaining about const-ness issue
4227  dimension_def_t def = orig->pDimensionDefinitions[i];
4228  AddDimension(&def);
4229  }
4230  for (int i = 0; i < 256; i++) {
4231  if (pDimensionRegions[i] && orig->pDimensionRegions[i]) {
4232  pDimensionRegions[i]->CopyAssign(
4233  orig->pDimensionRegions[i],
4234  mSamples
4235  );
4236  }
4237  }
4238  Layers = orig->Layers;
4239  }
4240 
4241 
4242 // *************** MidiRule ***************
4243 // *
4244 
4245  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {
4246  _3ewg->SetPos(36);
4247  Triggers = _3ewg->ReadUint8();
4248  _3ewg->SetPos(40);
4249  ControllerNumber = _3ewg->ReadUint8();
4250  _3ewg->SetPos(46);
4251  for (int i = 0 ; i < Triggers ; i++) {
4252  pTriggers[i].TriggerPoint = _3ewg->ReadUint8();
4253  pTriggers[i].Descending = _3ewg->ReadUint8();
4254  pTriggers[i].VelSensitivity = _3ewg->ReadUint8();
4255  pTriggers[i].Key = _3ewg->ReadUint8();
4256  pTriggers[i].NoteOff = _3ewg->ReadUint8();
4257  pTriggers[i].Velocity = _3ewg->ReadUint8();
4258  pTriggers[i].OverridePedal = _3ewg->ReadUint8();
4259  _3ewg->ReadUint8();
4260  }
4261  }
4262 
4263  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger() :
4264  ControllerNumber(0),
4265  Triggers(0) {
4266  }
4267 
4268  void MidiRuleCtrlTrigger::UpdateChunks(uint8_t* pData) const {
4269  pData[32] = 4;
4270  pData[33] = 16;
4271  pData[36] = Triggers;
4272  pData[40] = ControllerNumber;
4273  for (int i = 0 ; i < Triggers ; i++) {
4274  pData[46 + i * 8] = pTriggers[i].TriggerPoint;
4275  pData[47 + i * 8] = pTriggers[i].Descending;
4276  pData[48 + i * 8] = pTriggers[i].VelSensitivity;
4277  pData[49 + i * 8] = pTriggers[i].Key;
4278  pData[50 + i * 8] = pTriggers[i].NoteOff;
4279  pData[51 + i * 8] = pTriggers[i].Velocity;
4280  pData[52 + i * 8] = pTriggers[i].OverridePedal;
4281  }
4282  }
4283 
4284  MidiRuleLegato::MidiRuleLegato(RIFF::Chunk* _3ewg) {
4285  _3ewg->SetPos(36);
4286  LegatoSamples = _3ewg->ReadUint8(); // always 12
4287  _3ewg->SetPos(40);
4288  BypassUseController = _3ewg->ReadUint8();
4289  BypassKey = _3ewg->ReadUint8();
4290  BypassController = _3ewg->ReadUint8();
4291  ThresholdTime = _3ewg->ReadUint16();
4292  _3ewg->ReadInt16();
4293  ReleaseTime = _3ewg->ReadUint16();
4294  _3ewg->ReadInt16();
4295  KeyRange.low = _3ewg->ReadUint8();
4296  KeyRange.high = _3ewg->ReadUint8();
4297  _3ewg->SetPos(64);
4298  ReleaseTriggerKey = _3ewg->ReadUint8();
4299  AltSustain1Key = _3ewg->ReadUint8();
4300  AltSustain2Key = _3ewg->ReadUint8();
4301  }
4302 
4303  MidiRuleLegato::MidiRuleLegato() :
4304  LegatoSamples(12),
4305  BypassUseController(false),
4306  BypassKey(0),
4307  BypassController(1),
4308  ThresholdTime(20),
4309  ReleaseTime(20),
4310  ReleaseTriggerKey(0),
4311  AltSustain1Key(0),
4312  AltSustain2Key(0)
4313  {
4314  KeyRange.low = KeyRange.high = 0;
4315  }
4316 
4317  void MidiRuleLegato::UpdateChunks(uint8_t* pData) const {
4318  pData[32] = 0;
4319  pData[33] = 16;
4320  pData[36] = LegatoSamples;
4321  pData[40] = BypassUseController;
4322  pData[41] = BypassKey;
4323  pData[42] = BypassController;
4324  store16(&pData[43], ThresholdTime);
4325  store16(&pData[47], ReleaseTime);
4326  pData[51] = KeyRange.low;
4327  pData[52] = KeyRange.high;
4328  pData[64] = ReleaseTriggerKey;
4329  pData[65] = AltSustain1Key;
4330  pData[66] = AltSustain2Key;
4331  }
4332 
4333  MidiRuleAlternator::MidiRuleAlternator(RIFF::Chunk* _3ewg) {
4334  _3ewg->SetPos(36);
4335  Articulations = _3ewg->ReadUint8();
4336  int flags = _3ewg->ReadUint8();
4337  Polyphonic = flags & 8;
4338  Chained = flags & 4;
4339  Selector = (flags & 2) ? selector_controller :
4340  (flags & 1) ? selector_key_switch : selector_none;
4341  Patterns = _3ewg->ReadUint8();
4342  _3ewg->ReadUint8(); // chosen row
4343  _3ewg->ReadUint8(); // unknown
4344  _3ewg->ReadUint8(); // unknown
4345  _3ewg->ReadUint8(); // unknown
4346  KeySwitchRange.low = _3ewg->ReadUint8();
4347  KeySwitchRange.high = _3ewg->ReadUint8();
4348  Controller = _3ewg->ReadUint8();
4349  PlayRange.low = _3ewg->ReadUint8();
4350  PlayRange.high = _3ewg->ReadUint8();
4351 
4352  int n = std::min(int(Articulations), 32);
4353  for (int i = 0 ; i < n ; i++) {
4354  _3ewg->ReadString(pArticulations[i], 32);
4355  }
4356  _3ewg->SetPos(1072);
4357  n = std::min(int(Patterns), 32);
4358  for (int i = 0 ; i < n ; i++) {
4359  _3ewg->ReadString(pPatterns[i].Name, 16);
4360  pPatterns[i].Size = _3ewg->ReadUint8();
4361  _3ewg->Read(&pPatterns[i][0], 1, 32);
4362  }
4363  }
4364 
4365  MidiRuleAlternator::MidiRuleAlternator() :
4366  Articulations(0),
4367  Patterns(0),
4368  Selector(selector_none),
4369  Controller(0),
4370  Polyphonic(false),
4371  Chained(false)
4372  {
4373  PlayRange.low = PlayRange.high = 0;
4374  KeySwitchRange.low = KeySwitchRange.high = 0;
4375  }
4376 
4377  void MidiRuleAlternator::UpdateChunks(uint8_t* pData) const {
4378  pData[32] = 3;
4379  pData[33] = 16;
4380  pData[36] = Articulations;
4381  pData[37] = (Polyphonic ? 8 : 0) | (Chained ? 4 : 0) |
4382  (Selector == selector_controller ? 2 :
4383  (Selector == selector_key_switch ? 1 : 0));
4384  pData[38] = Patterns;
4385 
4386  pData[43] = KeySwitchRange.low;
4387  pData[44] = KeySwitchRange.high;
4388  pData[45] = Controller;
4389  pData[46] = PlayRange.low;
4390  pData[47] = PlayRange.high;
4391 
4392  char* str = reinterpret_cast<char*>(pData);
4393  int pos = 48;
4394  int n = std::min(int(Articulations), 32);
4395  for (int i = 0 ; i < n ; i++, pos += 32) {
4396  strncpy(&str[pos], pArticulations[i].c_str(), 32);
4397  }
4398 
4399  pos = 1072;
4400  n = std::min(int(Patterns), 32);
4401  for (int i = 0 ; i < n ; i++, pos += 49) {
4402  strncpy(&str[pos], pPatterns[i].Name.c_str(), 16);
4403  pData[pos + 16] = pPatterns[i].Size;
4404  memcpy(&pData[pos + 16], &(pPatterns[i][0]), 32);
4405  }
4406  }
4407 
4408 // *************** Script ***************
4409 // *
4410 
4411  Script::Script(ScriptGroup* group, RIFF::Chunk* ckScri) {
4412  pGroup = group;
4413  pChunk = ckScri;
4414  if (ckScri) { // object is loaded from file ...
4415  // read header
4416  uint32_t headerSize = ckScri->ReadUint32();
4417  Compression = (Compression_t) ckScri->ReadUint32();
4418  Encoding = (Encoding_t) ckScri->ReadUint32();
4419  Language = (Language_t) ckScri->ReadUint32();
4420  Bypass = (Language_t) ckScri->ReadUint32() & 1;
4421  crc = ckScri->ReadUint32();
4422  uint32_t nameSize = ckScri->ReadUint32();
4423  Name.resize(nameSize, ' ');
4424  for (int i = 0; i < nameSize; ++i)
4425  Name[i] = ckScri->ReadUint8();
4426  // to handle potential future extensions of the header
4427  ckScri->SetPos(sizeof(int32_t) + headerSize);
4428  // read actual script data
4429  uint32_t scriptSize = uint32_t(ckScri->GetSize() - ckScri->GetPos());
4430  data.resize(scriptSize);
4431  for (int i = 0; i < scriptSize; ++i)
4432  data[i] = ckScri->ReadUint8();
4433  } else { // this is a new script object, so just initialize it as such ...
4434  Compression = COMPRESSION_NONE;
4435  Encoding = ENCODING_ASCII;
4436  Language = LANGUAGE_NKSP;
4437  Bypass = false;
4438  crc = 0;
4439  Name = "Unnamed Script";
4440  }
4441  }
4442 
4443  Script::~Script() {
4444  }
4445 
4449  String Script::GetScriptAsText() {
4450  String s;
4451  s.resize(data.size(), ' ');
4452  memcpy(&s[0], &data[0], data.size());
4453  return s;
4454  }
4455 
4462  void Script::SetScriptAsText(const String& text) {
4463  data.resize(text.size());
4464  memcpy(&data[0], &text[0], text.size());
4465  }
4466 
4476  void Script::UpdateChunks(progress_t* pProgress) {
4477  // recalculate CRC32 check sum
4478  __resetCRC(crc);
4479  __calculateCRC(&data[0], data.size(), crc);
4480  __finalizeCRC(crc);
4481  // make sure chunk exists and has the required size
4482  const file_offset_t chunkSize = (file_offset_t) 7*sizeof(int32_t) + Name.size() + data.size();
4483  if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4484  else pChunk->Resize(chunkSize);
4485  // fill the chunk data to be written to disk
4486  uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4487  int pos = 0;
4488  store32(&pData[pos], uint32_t(6*sizeof(int32_t) + Name.size())); // total header size
4489  pos += sizeof(int32_t);
4490  store32(&pData[pos], Compression);
4491  pos += sizeof(int32_t);
4492  store32(&pData[pos], Encoding);
4493  pos += sizeof(int32_t);
4494  store32(&pData[pos], Language);
4495  pos += sizeof(int32_t);
4496  store32(&pData[pos], Bypass ? 1 : 0);
4497  pos += sizeof(int32_t);
4498  store32(&pData[pos], crc);
4499  pos += sizeof(int32_t);
4500  store32(&pData[pos], (uint32_t) Name.size());
4501  pos += sizeof(int32_t);
4502  for (int i = 0; i < Name.size(); ++i, ++pos)
4503  pData[pos] = Name[i];
4504  for (int i = 0; i < data.size(); ++i, ++pos)
4505  pData[pos] = data[i];
4506  }
4507 
4514  void Script::SetGroup(ScriptGroup* pGroup) {
4515  if (this->pGroup == pGroup) return;
4516  if (pChunk)
4517  pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4518  this->pGroup = pGroup;
4519  }
4520 
4527  ScriptGroup* Script::GetGroup() const {
4528  return pGroup;
4529  }
4530 
4538  void Script::CopyAssign(const Script* orig) {
4539  Name = orig->Name;
4540  Compression = orig->Compression;
4541  Encoding = orig->Encoding;
4542  Language = orig->Language;
4543  Bypass = orig->Bypass;
4544  data = orig->data;
4545  }
4546 
4547  void Script::RemoveAllScriptReferences() {
4548  File* pFile = pGroup->pFile;
4549  for (int i = 0; pFile->GetInstrument(i); ++i) {
4550  Instrument* instr = pFile->GetInstrument(i);
4551  instr->RemoveScript(this);
4552  }
4553  }
4554 
4555 // *************** ScriptGroup ***************
4556 // *
4557 
4558  ScriptGroup::ScriptGroup(File* file, RIFF::List* lstRTIS) {
4559  pFile = file;
4560  pList = lstRTIS;
4561  pScripts = NULL;
4562  if (lstRTIS) {
4563  RIFF::Chunk* ckName = lstRTIS->GetSubChunk(CHUNK_ID_LSNM);
4564  ::LoadString(ckName, Name);
4565  } else {
4566  Name = "Default Group";
4567  }
4568  }
4569 
4570  ScriptGroup::~ScriptGroup() {
4571  if (pScripts) {
4572  std::list<Script*>::iterator iter = pScripts->begin();
4573  std::list<Script*>::iterator end = pScripts->end();
4574  while (iter != end) {
4575  delete *iter;
4576  ++iter;
4577  }
4578  delete pScripts;
4579  }
4580  }
4581 
4591  void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4592  if (pScripts) {
4593  if (!pList)
4594  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
4595 
4596  // now store the name of this group as <LSNM> chunk as subchunk of the <RTIS> list chunk
4597  ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64);
4598 
4599  for (std::list<Script*>::iterator it = pScripts->begin();
4600  it != pScripts->end(); ++it)
4601  {
4602  (*it)->UpdateChunks(pProgress);
4603  }
4604  }
4605  }
4606 
4614  Script* ScriptGroup::GetScript(uint index) {
4615  if (!pScripts) LoadScripts();
4616  std::list<Script*>::iterator it = pScripts->begin();
4617  for (uint i = 0; it != pScripts->end(); ++i, ++it)
4618  if (i == index) return *it;
4619  return NULL;
4620  }
4621 
4633  Script* ScriptGroup::AddScript() {
4634  if (!pScripts) LoadScripts();
4635  Script* pScript = new Script(this, NULL);
4636  pScripts->push_back(pScript);
4637  return pScript;
4638  }
4639 
4650  void ScriptGroup::DeleteScript(Script* pScript) {
4651  if (!pScripts) LoadScripts();
4652  std::list<Script*>::iterator iter =
4653  find(pScripts->begin(), pScripts->end(), pScript);
4654  if (iter == pScripts->end())
4655  throw gig::Exception("Could not delete script, could not find given script");
4656  pScripts->erase(iter);
4657  pScript->RemoveAllScriptReferences();
4658  if (pScript->pChunk)
4659  pScript->pChunk->GetParent()->DeleteSubChunk(pScript->pChunk);
4660  delete pScript;
4661  }
4662 
4663  void ScriptGroup::LoadScripts() {
4664  if (pScripts) return;
4665  pScripts = new std::list<Script*>;
4666  if (!pList) return;
4667 
4668  for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;
4669  ck = pList->GetNextSubChunk())
4670  {
4671  if (ck->GetChunkID() == CHUNK_ID_SCRI) {
4672  pScripts->push_back(new Script(this, ck));
4673  }
4674  }
4675  }
4676 
4677 // *************** Instrument ***************
4678 // *
4679 
4680  Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {
4681  static const DLS::Info::string_length_t fixedStringLengths[] = {
4682  { CHUNK_ID_INAM, 64 },
4683  { CHUNK_ID_ISFT, 12 },
4684  { 0, 0 }
4685  };
4686  pInfo->SetFixedStringLengths(fixedStringLengths);
4687 
4688  // Initialization
4689  for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
4690  EffectSend = 0;
4691  Attenuation = 0;
4692  FineTune = 0;
4693  PitchbendRange = 2;
4694  PianoReleaseMode = false;
4695  DimensionKeyRange.low = 0;
4696  DimensionKeyRange.high = 0;
4697  pMidiRules = new MidiRule*[3];
4698  pMidiRules[0] = NULL;
4699  pScriptRefs = NULL;
4700 
4701  // Loading
4702  RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
4703  if (lart) {
4704  RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
4705  if (_3ewg) {
4706  EffectSend = _3ewg->ReadUint16();
4707  Attenuation = _3ewg->ReadInt32();
4708  FineTune = _3ewg->ReadInt16();
4709  PitchbendRange = _3ewg->ReadInt16();
4710  uint8_t dimkeystart = _3ewg->ReadUint8();
4711  PianoReleaseMode = dimkeystart & 0x01;
4712  DimensionKeyRange.low = dimkeystart >> 1;
4713  DimensionKeyRange.high = _3ewg->ReadUint8();
4714 
4715  if (_3ewg->GetSize() > 32) {
4716  // read MIDI rules
4717  int i = 0;
4718  _3ewg->SetPos(32);
4719  uint8_t id1 = _3ewg->ReadUint8();
4720  uint8_t id2 = _3ewg->ReadUint8();
4721 
4722  if (id2 == 16) {
4723  if (id1 == 4) {
4724  pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
4725  } else if (id1 == 0) {
4726  pMidiRules[i++] = new MidiRuleLegato(_3ewg);
4727  } else if (id1 == 3) {
4728  pMidiRules[i++] = new MidiRuleAlternator(_3ewg);
4729  } else {
4730  pMidiRules[i++] = new MidiRuleUnknown;
4731  }
4732  }
4733  else if (id1 != 0 || id2 != 0) {
4734  pMidiRules[i++] = new MidiRuleUnknown;
4735  }
4736  //TODO: all the other types of rules
4737 
4738  pMidiRules[i] = NULL;
4739  }
4740  }
4741  }
4742 
4743  if (pFile->GetAutoLoad()) {
4744  if (!pRegions) pRegions = new RegionList;
4745  RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
4746  if (lrgn) {
4747  RIFF::List* rgn = lrgn->GetFirstSubList();
4748  while (rgn) {
4749  if (rgn->GetListType() == LIST_TYPE_RGN) {
4750  __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4751  pRegions->push_back(new Region(this, rgn));
4752  }
4753  rgn = lrgn->GetNextSubList();
4754  }
4755  // Creating Region Key Table for fast lookup
4756  UpdateRegionKeyTable();
4757  }
4758  }
4759 
4760  // own gig format extensions
4761  RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS);
4762  if (lst3LS) {
4763  RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4764  if (ckSCSL) {
4765  int headerSize = ckSCSL->ReadUint32();
4766  int slotCount = ckSCSL->ReadUint32();
4767  if (slotCount) {
4768  int slotSize = ckSCSL->ReadUint32();
4769  ckSCSL->SetPos(headerSize); // in case of future header extensions
4770  int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions
4771  for (int i = 0; i < slotCount; ++i) {
4772  _ScriptPooolEntry e;
4773  e.fileOffset = ckSCSL->ReadUint32();
4774  e.bypass = ckSCSL->ReadUint32() & 1;
4775  if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions
4776  scriptPoolFileOffsets.push_back(e);
4777  }
4778  }
4779  }
4780  }
4781 
4782  __notify_progress(pProgress, 1.0f); // notify done
4783  }
4784 
4785  void Instrument::UpdateRegionKeyTable() {
4786  for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
4787  RegionList::iterator iter = pRegions->begin();
4788  RegionList::iterator end = pRegions->end();
4789  for (; iter != end; ++iter) {
4790  gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4791  const int low = std::max(int(pRegion->KeyRange.low), 0);
4792  const int high = std::min(int(pRegion->KeyRange.high), 127);
4793  for (int iKey = low; iKey <= high; iKey++) {
4794  RegionKeyTable[iKey] = pRegion;
4795  }
4796  }
4797  }
4798 
4800  for (int i = 0 ; pMidiRules[i] ; i++) {
4801  delete pMidiRules[i];
4802  }
4803  delete[] pMidiRules;
4804  if (pScriptRefs) delete pScriptRefs;
4805  }
4806 
4817  void Instrument::UpdateChunks(progress_t* pProgress) {
4818  // first update base classes' chunks
4819  DLS::Instrument::UpdateChunks(pProgress);
4820 
4821  // update Regions' chunks
4822  {
4823  RegionList::iterator iter = pRegions->begin();
4824  RegionList::iterator end = pRegions->end();
4825  for (; iter != end; ++iter)
4826  (*iter)->UpdateChunks(pProgress);
4827  }
4828 
4829  // make sure 'lart' RIFF list chunk exists
4830  RIFF::List* lart = pCkInstrument->GetSubList(LIST_TYPE_LART);
4831  if (!lart) lart = pCkInstrument->AddSubList(LIST_TYPE_LART);
4832  // make sure '3ewg' RIFF chunk exists
4833  RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
4834  if (!_3ewg) {
4835  File* pFile = (File*) GetParent();
4836 
4837  // 3ewg is bigger in gig3, as it includes the iMIDI rules
4838  int size = (pFile->pVersion && pFile->pVersion->major > 2) ? 16416 : 12;
4839  _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);
4840  memset(_3ewg->LoadChunkData(), 0, size);
4841  }
4842  // update '3ewg' RIFF chunk
4843  uint8_t* pData = (uint8_t*) _3ewg->LoadChunkData();
4844  store16(&pData[0], EffectSend);
4845  store32(&pData[2], Attenuation);
4846  store16(&pData[6], FineTune);
4847  store16(&pData[8], PitchbendRange);
4848  const uint8_t dimkeystart = (PianoReleaseMode ? 0x01 : 0x00) |
4849  DimensionKeyRange.low << 1;
4850  pData[10] = dimkeystart;
4851  pData[11] = DimensionKeyRange.high;
4852 
4853  if (pMidiRules[0] == 0 && _3ewg->GetSize() >= 34) {
4854  pData[32] = 0;
4855  pData[33] = 0;
4856  } else {
4857  for (int i = 0 ; pMidiRules[i] ; i++) {
4858  pMidiRules[i]->UpdateChunks(pData);
4859  }
4860  }
4861 
4862  // own gig format extensions
4863  if (ScriptSlotCount()) {
4864  // make sure we have converted the original loaded script file
4865  // offsets into valid Script object pointers
4866  LoadScripts();
4867 
4868  RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4869  if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4870  const int slotCount = (int) pScriptRefs->size();
4871  const int headerSize = 3 * sizeof(uint32_t);
4872  const int slotSize = 2 * sizeof(uint32_t);
4873  const int totalChunkSize = headerSize + slotCount * slotSize;
4874  RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4875  if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
4876  else ckSCSL->Resize(totalChunkSize);
4877  uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();
4878  int pos = 0;
4879  store32(&pData[pos], headerSize);
4880  pos += sizeof(uint32_t);
4881  store32(&pData[pos], slotCount);
4882  pos += sizeof(uint32_t);
4883  store32(&pData[pos], slotSize);
4884  pos += sizeof(uint32_t);
4885  for (int i = 0; i < slotCount; ++i) {
4886  // arbitrary value, the actual file offset will be updated in
4887  // UpdateScriptFileOffsets() after the file has been resized
4888  int bogusFileOffset = 0;
4889  store32(&pData[pos], bogusFileOffset);
4890  pos += sizeof(uint32_t);
4891  store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4892  pos += sizeof(uint32_t);
4893  }
4894  } else {
4895  // no script slots, so get rid of any LS custom RIFF chunks (if any)
4896  RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4897  if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS);
4898  }
4899  }
4900 
4901  void Instrument::UpdateScriptFileOffsets() {
4902  // own gig format extensions
4903  if (pScriptRefs && pScriptRefs->size() > 0) {
4904  RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4905  RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4906  const int slotCount = (int) pScriptRefs->size();
4907  const int headerSize = 3 * sizeof(uint32_t);
4908  ckSCSL->SetPos(headerSize);
4909  for (int i = 0; i < slotCount; ++i) {
4910  uint32_t fileOffset = uint32_t(
4911  (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4912  (*pScriptRefs)[i].script->pChunk->GetPos() -
4913  CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
4914  );
4915  ckSCSL->WriteUint32(&fileOffset);
4916  // jump over flags entry (containing the bypass flag)
4917  ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
4918  }
4919  }
4920  }
4921 
4929  Region* Instrument::GetRegion(unsigned int Key) {
4930  if (!pRegions || pRegions->empty() || Key > 127) return NULL;
4931  return RegionKeyTable[Key];
4932 
4933  /*for (int i = 0; i < Regions; i++) {
4934  if (Key <= pRegions[i]->KeyRange.high &&
4935  Key >= pRegions[i]->KeyRange.low) return pRegions[i];
4936  }
4937  return NULL;*/
4938  }
4939 
4947  Region* Instrument::GetFirstRegion() {
4948  if (!pRegions) return NULL;
4949  RegionsIterator = pRegions->begin();
4950  return static_cast<gig::Region*>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
4951  }
4952 
4961  Region* Instrument::GetNextRegion() {
4962  if (!pRegions) return NULL;
4963  RegionsIterator++;
4964  return static_cast<gig::Region*>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
4965  }
4966 
4967  Region* Instrument::AddRegion() {
4968  // create new Region object (and its RIFF chunks)
4969  RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
4970  if (!lrgn) lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
4971  RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
4972  Region* pNewRegion = new Region(this, rgn);
4973  pRegions->push_back(pNewRegion);
4974  Regions = (uint32_t) pRegions->size();
4975  // update Region key table for fast lookup
4976  UpdateRegionKeyTable();
4977  // done
4978  return pNewRegion;
4979  }
4980 
4981  void Instrument::DeleteRegion(Region* pRegion) {
4982  if (!pRegions) return;
4983  DLS::Instrument::DeleteRegion((DLS::Region*) pRegion);
4984  // update Region key table for fast lookup
4985  UpdateRegionKeyTable();
4986  }
4987 
5015  void Instrument::MoveTo(Instrument* dst) {
5016  if (dst && GetParent() != dst->GetParent())
5017  throw Exception(
5018  "gig::Instrument::MoveTo() can only be used for moving within "
5019  "the same gig file."
5020  );
5021 
5022  File* pFile = (File*) GetParent();
5023 
5024  // move this instrument within the instrument list
5025  {
5026  File::InstrumentList& list = *pFile->pInstruments;
5027 
5028  File::InstrumentList::iterator itFrom =
5029  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
5030 
5031  File::InstrumentList::iterator itTo =
5032  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
5033 
5034  list.splice(itTo, list, itFrom);
5035  }
5036 
5037  // move the instrument's actual list RIFF chunk appropriately
5038  RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS);
5039  lstCkInstruments->MoveSubChunk(
5040  this->pCkInstrument,
5041  (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
5042  );
5043  }
5044 
5055  MidiRule* Instrument::GetMidiRule(int i) {
5056  return pMidiRules[i];
5057  }
5058 
5064  MidiRuleCtrlTrigger* Instrument::AddMidiRuleCtrlTrigger() {
5065  delete pMidiRules[0];
5066  MidiRuleCtrlTrigger* r = new MidiRuleCtrlTrigger;
5067  pMidiRules[0] = r;
5068  pMidiRules[1] = 0;
5069  return r;
5070  }
5071 
5077  MidiRuleLegato* Instrument::AddMidiRuleLegato() {
5078  delete pMidiRules[0];
5079  MidiRuleLegato* r = new MidiRuleLegato;
5080  pMidiRules[0] = r;
5081  pMidiRules[1] = 0;
5082  return r;
5083  }
5084 
5090  MidiRuleAlternator* Instrument::AddMidiRuleAlternator() {
5091  delete pMidiRules[0];
5092  MidiRuleAlternator* r = new MidiRuleAlternator;
5093  pMidiRules[0] = r;
5094  pMidiRules[1] = 0;
5095  return r;
5096  }
5097 
5103  void Instrument::DeleteMidiRule(int i) {
5104  delete pMidiRules[i];
5105  pMidiRules[i] = 0;
5106  }
5107 
5108  void Instrument::LoadScripts() {
5109  if (pScriptRefs) return;
5110  pScriptRefs = new std::vector<_ScriptPooolRef>;
5111  if (scriptPoolFileOffsets.empty()) return;
5112  File* pFile = (File*) GetParent();
5113  for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
5114  uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
5115  for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
5116  ScriptGroup* group = pFile->GetScriptGroup(i);
5117  for (uint s = 0; group->GetScript(s); ++s) {
5118  Script* script = group->GetScript(s);
5119  if (script->pChunk) {
5120  uint32_t offset = uint32_t(
5121  script->pChunk->GetFilePos() -
5122  script->pChunk->GetPos() -
5123  CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
5124  );
5125  if (offset == soughtOffset)
5126  {
5127  _ScriptPooolRef ref;
5128  ref.script = script;
5129  ref.bypass = scriptPoolFileOffsets[k].bypass;
5130  pScriptRefs->push_back(ref);
5131  break;
5132  }
5133  }
5134  }
5135  }
5136  }
5137  // we don't need that anymore
5138  scriptPoolFileOffsets.clear();
5139  }
5140 
5153  Script* Instrument::GetScriptOfSlot(uint index) {
5154  LoadScripts();
5155  if (index >= pScriptRefs->size()) return NULL;
5156  return pScriptRefs->at(index).script;
5157  }
5158 
5194  void Instrument::AddScriptSlot(Script* pScript, bool bypass) {
5195  LoadScripts();
5196  _ScriptPooolRef ref = { pScript, bypass };
5197  pScriptRefs->push_back(ref);
5198  }
5199 
5214  void Instrument::SwapScriptSlots(uint index1, uint index2) {
5215  LoadScripts();
5216  if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
5217  return;
5218  _ScriptPooolRef tmp = (*pScriptRefs)[index1];
5219  (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
5220  (*pScriptRefs)[index2] = tmp;
5221  }
5222 
5229  void Instrument::RemoveScriptSlot(uint index) {
5230  LoadScripts();
5231  if (index >= pScriptRefs->size()) return;
5232  pScriptRefs->erase( pScriptRefs->begin() + index );
5233  }
5234 
5247  void Instrument::RemoveScript(Script* pScript) {
5248  LoadScripts();
5249  for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5250  if ((*pScriptRefs)[i].script == pScript) {
5251  pScriptRefs->erase( pScriptRefs->begin() + i );
5252  }
5253  }
5254  }
5255 
5270  uint Instrument::ScriptSlotCount() const {
5271  return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5272  }
5273 
5290  bool Instrument::IsScriptSlotBypassed(uint index) {
5291  if (index >= ScriptSlotCount()) return false;
5292  return pScriptRefs ? pScriptRefs->at(index).bypass
5293  : scriptPoolFileOffsets.at(index).bypass;
5294 
5295  }
5296 
5310  void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {
5311  if (index >= ScriptSlotCount()) return;
5312  if (pScriptRefs)
5313  pScriptRefs->at(index).bypass = bBypass;
5314  else
5315  scriptPoolFileOffsets.at(index).bypass = bBypass;
5316  }
5317 
5327  void Instrument::CopyAssign(const Instrument* orig) {
5328  CopyAssign(orig, NULL);
5329  }
5330 
5339  void Instrument::CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples) {
5340  // handle base class
5341  // (without copying DLS region stuff)
5342  DLS::Instrument::CopyAssignCore(orig);
5343 
5344  // handle own member variables
5345  Attenuation = orig->Attenuation;
5346  EffectSend = orig->EffectSend;
5347  FineTune = orig->FineTune;
5348  PitchbendRange = orig->PitchbendRange;
5349  PianoReleaseMode = orig->PianoReleaseMode;
5350  DimensionKeyRange = orig->DimensionKeyRange;
5351  scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
5352  pScriptRefs = orig->pScriptRefs;
5353 
5354  // free old midi rules
5355  for (int i = 0 ; pMidiRules[i] ; i++) {
5356  delete pMidiRules[i];
5357  }
5358  //TODO: MIDI rule copying
5359  pMidiRules[0] = NULL;
5360 
5361  // delete all old regions
5362  while (Regions) DeleteRegion(GetFirstRegion());
5363  // create new regions and copy them from original
5364  {
5365  RegionList::const_iterator it = orig->pRegions->begin();
5366  for (int i = 0; i < orig->Regions; ++i, ++it) {
5367  Region* dstRgn = AddRegion();
5368  //NOTE: Region does semi-deep copy !
5369  dstRgn->CopyAssign(
5370  static_cast<gig::Region*>(*it),
5371  mSamples
5372  );
5373  }
5374  }
5375 
5376  UpdateRegionKeyTable();
5377  }
5378 
5379 
5380 // *************** Group ***************
5381 // *
5382 
5389  Group::Group(File* file, RIFF::Chunk* ck3gnm) {
5390  pFile = file;
5391  pNameChunk = ck3gnm;
5392  ::LoadString(pNameChunk, Name);
5393  }
5394 
5395  Group::~Group() {
5396  // remove the chunk associated with this group (if any)
5397  if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5398  }
5399 
5410  void Group::UpdateChunks(progress_t* pProgress) {
5411  // make sure <3gri> and <3gnl> list chunks exist
5412  RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5413  if (!_3gri) {
5414  _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);
5415  pFile->pRIFF->MoveSubChunk(_3gri, pFile->pRIFF->GetSubChunk(CHUNK_ID_PTBL));
5416  }
5417  RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
5418  if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
5419 
5420  if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
5421  // v3 has a fixed list of 128 strings, find a free one
5422  for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {
5423  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
5424  pNameChunk = ck;
5425  break;
5426  }
5427  }
5428  }
5429 
5430  // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
5431  ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
5432  }
5433 
5445  Sample* Group::GetFirstSample() {
5446  // FIXME: lazy und unsafe implementation, should be an autonomous iterator
5447  for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
5448  if (pSample->GetGroup() == this) return pSample;
5449  }
5450  return NULL;
5451  }
5452 
5463  Sample* Group::GetNextSample() {
5464  // FIXME: lazy und unsafe implementation, should be an autonomous iterator
5465  for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
5466  if (pSample->GetGroup() == this) return pSample;
5467  }
5468  return NULL;
5469  }
5470 
5474  void Group::AddSample(Sample* pSample) {
5475  pSample->pGroup = this;
5476  }
5477 
5484  void Group::MoveAll() {
5485  // get "that" other group first
5486  Group* pOtherGroup = NULL;
5487  for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
5488  if (pOtherGroup != this) break;
5489  }
5490  if (!pOtherGroup) throw Exception(
5491  "Could not move samples to another group, since there is no "
5492  "other Group. This is a bug, report it!"
5493  );
5494  // now move all samples of this group to the other group
5495  for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
5496  pOtherGroup->AddSample(pSample);
5497  }
5498  }
5499 
5500 
5501 
5502 // *************** File ***************
5503 // *
5504 
5506  const DLS::version_t File::VERSION_2 = {
5507  0, 2, 19980628 & 0xffff, 19980628 >> 16
5508  };
5509 
5511  const DLS::version_t File::VERSION_3 = {
5512  0, 3, 20030331 & 0xffff, 20030331 >> 16
5513  };
5514 
5516  const DLS::version_t File::VERSION_4 = {
5517  0, 4, 20071012 & 0xffff, 20071012 >> 16
5518  };
5519 
5520  static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
5521  { CHUNK_ID_IARL, 256 },
5522  { CHUNK_ID_IART, 128 },
5523  { CHUNK_ID_ICMS, 128 },
5524  { CHUNK_ID_ICMT, 1024 },
5525  { CHUNK_ID_ICOP, 128 },
5526  { CHUNK_ID_ICRD, 128 },
5527  { CHUNK_ID_IENG, 128 },
5528  { CHUNK_ID_IGNR, 128 },
5529  { CHUNK_ID_IKEY, 128 },
5530  { CHUNK_ID_IMED, 128 },
5531  { CHUNK_ID_INAM, 128 },
5532  { CHUNK_ID_IPRD, 128 },
5533  { CHUNK_ID_ISBJ, 128 },
5534  { CHUNK_ID_ISFT, 128 },
5535  { CHUNK_ID_ISRC, 128 },
5536  { CHUNK_ID_ISRF, 128 },
5537  { CHUNK_ID_ITCH, 128 },
5538  { 0, 0 }
5539  };
5540 
5541  File::File() : DLS::File() {
5542  bAutoLoad = true;
5543  *pVersion = VERSION_3;
5544  pGroups = NULL;
5545  pScriptGroups = NULL;
5546  pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5547  pInfo->ArchivalLocation = String(256, ' ');
5548 
5549  // add some mandatory chunks to get the file chunks in right
5550  // order (INFO chunk will be moved to first position later)
5551  pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);
5552  pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);
5553  pRIFF->AddSubChunk(CHUNK_ID_DLID, 16);
5554 
5555  GenerateDLSID();
5556  }
5557 
5558  File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
5559  bAutoLoad = true;
5560  pGroups = NULL;
5561  pScriptGroups = NULL;
5562  pInfo->SetFixedStringLengths(_FileFixedStringLengths);
5563  }
5564 
5565  File::~File() {
5566  if (pGroups) {
5567  std::list<Group*>::iterator iter = pGroups->begin();
5568  std::list<Group*>::iterator end = pGroups->end();
5569  while (iter != end) {
5570  delete *iter;
5571  ++iter;
5572  }
5573  delete pGroups;
5574  }
5575  if (pScriptGroups) {
5576  std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
5577  std::list<ScriptGroup*>::iterator end = pScriptGroups->end();
5578  while (iter != end) {
5579  delete *iter;
5580  ++iter;
5581  }
5582  delete pScriptGroups;
5583  }
5584  }
5585 
5586  Sample* File::GetFirstSample(progress_t* pProgress) {
5587  if (!pSamples) LoadSamples(pProgress);
5588  if (!pSamples) return NULL;
5589  SamplesIterator = pSamples->begin();
5590  return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
5591  }
5592 
5593  Sample* File::GetNextSample() {
5594  if (!pSamples) return NULL;
5595  SamplesIterator++;
5596  return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
5597  }
5598 
5604  Sample* File::GetSample(uint index) {
5605  if (!pSamples) LoadSamples();
5606  if (!pSamples) return NULL;
5607  DLS::File::SampleList::iterator it = pSamples->begin();
5608  for (int i = 0; i < index; ++i) {
5609  ++it;
5610  if (it == pSamples->end()) return NULL;
5611  }
5612  if (it == pSamples->end()) return NULL;
5613  return static_cast<gig::Sample*>( *it );
5614  }
5615 
5624  size_t File::CountSamples() {
5625  if (!pSamples) LoadSamples();
5626  if (!pSamples) return 0;
5627  return pSamples->size();
5628  }
5629 
5637  Sample* File::AddSample() {
5638  if (!pSamples) LoadSamples();
5640  RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
5641  // create new Sample object and its respective 'wave' list chunk
5642  RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);
5643  Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);
5644 
5645  // add mandatory chunks to get the chunks in right order
5646  wave->AddSubChunk(CHUNK_ID_FMT, 16);
5647  wave->AddSubList(LIST_TYPE_INFO);
5648 
5649  pSamples->push_back(pSample);
5650  return pSample;
5651  }
5652 
5662  void File::DeleteSample(Sample* pSample) {
5663  if (!pSamples || !pSamples->size()) throw gig::Exception("Could not delete sample as there are no samples");
5664  SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (DLS::Sample*) pSample);
5665  if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");
5666  if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
5667  pSamples->erase(iter);
5668  delete pSample;
5669 
5670  SampleList::iterator tmp = SamplesIterator;
5671  // remove all references to the sample
5672  for (Instrument* instrument = GetFirstInstrument() ; instrument ;
5673  instrument = GetNextInstrument()) {
5674  for (Region* region = instrument->GetFirstRegion() ; region ;
5675  region = instrument->GetNextRegion()) {
5676 
5677  if (region->GetSample() == pSample) region->SetSample(NULL);
5678 
5679  for (int i = 0 ; i < region->DimensionRegions ; i++) {
5680  gig::DimensionRegion *d = region->pDimensionRegions[i];
5681  if (d->pSample == pSample) d->pSample = NULL;
5682  }
5683  }
5684  }
5685  SamplesIterator = tmp; // restore iterator
5686  }
5687 
5688  void File::LoadSamples() {
5689  LoadSamples(NULL);
5690  }
5691 
5692  void File::LoadSamples(progress_t* pProgress) {
5693  // Groups must be loaded before samples, because samples will try
5694  // to resolve the group they belong to
5695  if (!pGroups) LoadGroups();
5696 
5697  if (!pSamples) pSamples = new SampleList;
5698 
5699  RIFF::File* file = pRIFF;
5700 
5701  // just for progress calculation
5702  int iSampleIndex = 0;
5703  int iTotalSamples = WavePoolCount;
5704 
5705  // check if samples should be loaded from extension files
5706  // (only for old gig files < 2 GB)
5707  int lastFileNo = 0;
5708  if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {
5709  for (int i = 0 ; i < WavePoolCount ; i++) {
5710  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
5711  }
5712  }
5713  String name(pRIFF->GetFileName());
5714  int nameLen = (int) name.length();
5715  char suffix[6];
5716  if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
5717 
5718  for (int fileNo = 0 ; ; ) {
5719  RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5720  if (wvpl) {
5721  file_offset_t wvplFileOffset = wvpl->GetFilePos();
5722  RIFF::List* wave = wvpl->GetFirstSubList();
5723  while (wave) {
5724  if (wave->GetListType() == LIST_TYPE_WAVE) {
5725  // notify current progress
5726  const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5727  __notify_progress(pProgress, subprogress);
5728 
5729  file_offset_t waveFileOffset = wave->GetFilePos();
5730  pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5731 
5732  iSampleIndex++;
5733  }
5734  wave = wvpl->GetNextSubList();
5735  }
5736 
5737  if (fileNo == lastFileNo) break;
5738 
5739  // open extension file (*.gx01, *.gx02, ...)
5740  fileNo++;
5741  sprintf(suffix, ".gx%02d", fileNo);
5742  name.replace(nameLen, 5, suffix);
5743  file = new RIFF::File(name);
5744  ExtensionFiles.push_back(file);
5745  } else break;
5746  }
5747 
5748  __notify_progress(pProgress, 1.0); // notify done
5749  }
5750 
5751  Instrument* File::GetFirstInstrument() {
5752  if (!pInstruments) LoadInstruments();
5753  if (!pInstruments) return NULL;
5754  InstrumentsIterator = pInstruments->begin();
5755  return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
5756  }
5757 
5758  Instrument* File::GetNextInstrument() {
5759  if (!pInstruments) return NULL;
5760  InstrumentsIterator++;
5761  return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
5762  }
5763 
5772  size_t File::CountInstruments() {
5773  if (!pInstruments) LoadInstruments();
5774  if (!pInstruments) return 0;
5775  return pInstruments->size();
5776  }
5777 
5785  Instrument* File::GetInstrument(uint index, progress_t* pProgress) {
5786  if (!pInstruments) {
5787  // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)
5788 
5789  // sample loading subtask
5790  progress_t subprogress;
5791  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
5792  __notify_progress(&subprogress, 0.0f);
5793  if (GetAutoLoad())
5794  GetFirstSample(&subprogress); // now force all samples to be loaded
5795  __notify_progress(&subprogress, 1.0f);
5796 
5797  // instrument loading subtask
5798  if (pProgress && pProgress->callback) {
5799  subprogress.__range_min = subprogress.__range_max;
5800  subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
5801  }
5802  __notify_progress(&subprogress, 0.0f);
5803  LoadInstruments(&subprogress);
5804  __notify_progress(&subprogress, 1.0f);
5805  }
5806  if (!pInstruments) return NULL;
5807  InstrumentsIterator = pInstruments->begin();
5808  for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {
5809  if (i == index) return static_cast<gig::Instrument*>( *InstrumentsIterator );
5810  InstrumentsIterator++;
5811  }
5812  return NULL;
5813  }
5814 
5822  Instrument* File::AddInstrument() {
5823  if (!pInstruments) LoadInstruments();
5825  RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
5826  RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);
5827 
5828  // add mandatory chunks to get the chunks in right order
5829  lstInstr->AddSubList(LIST_TYPE_INFO);
5830  lstInstr->AddSubChunk(CHUNK_ID_DLID, 16);
5831 
5832  Instrument* pInstrument = new Instrument(this, lstInstr);
5833  pInstrument->GenerateDLSID();
5834 
5835  lstInstr->AddSubChunk(CHUNK_ID_INSH, 12);
5836 
5837  // this string is needed for the gig to be loadable in GSt:
5838  pInstrument->pInfo->Software = "Endless Wave";
5839 
5840  pInstruments->push_back(pInstrument);
5841  return pInstrument;
5842  }
5843 
5859  Instrument* File::AddDuplicateInstrument(const Instrument* orig) {
5860  Instrument* instr = AddInstrument();
5861  instr->CopyAssign(orig);
5862  return instr;
5863  }
5864 
5876  void File::AddContentOf(File* pFile) {
5877  static int iCallCount = -1;
5878  iCallCount++;
5879  std::map<Group*,Group*> mGroups;
5880  std::map<Sample*,Sample*> mSamples;
5881 
5882  // clone sample groups
5883  for (int i = 0; pFile->GetGroup(i); ++i) {
5884  Group* g = AddGroup();
5885  g->Name =
5886  "COPY" + ToString(iCallCount) + "_" + pFile->GetGroup(i)->Name;
5887  mGroups[pFile->GetGroup(i)] = g;
5888  }
5889 
5890  // clone samples (not waveform data here yet)
5891  for (int i = 0; pFile->GetSample(i); ++i) {
5892  Sample* s = AddSample();
5893  s->CopyAssignMeta(pFile->GetSample(i));
5894  mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5895  mSamples[pFile->GetSample(i)] = s;
5896  }
5897 
5898  // clone script groups and their scripts
5899  for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5900  ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5901  ScriptGroup* dg = AddScriptGroup();
5902  dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5903  for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5904  Script* ss = sg->GetScript(iScript);
5905  Script* ds = dg->AddScript();
5906  ds->CopyAssign(ss);
5907  }
5908  }
5909 
5910  //BUG: For some reason this method only works with this additional
5911  // Save() call in between here.
5912  //
5913  // Important: The correct one of the 2 Save() methods has to be called
5914  // here, depending on whether the file is completely new or has been
5915  // saved to disk already, otherwise it will result in data corruption.
5916  if (pRIFF->IsNew())
5917  Save(GetFileName());
5918  else
5919  Save();
5920 
5921  // clone instruments
5922  // (passing the crosslink table here for the cloned samples)
5923  for (int i = 0; pFile->GetInstrument(i); ++i) {
5924  Instrument* instr = AddInstrument();
5925  instr->CopyAssign(pFile->GetInstrument(i), &mSamples);
5926  }
5927 
5928  // Mandatory: file needs to be saved to disk at this point, so this
5929  // file has the correct size and data layout for writing the samples'
5930  // waveform data to disk.
5931  Save();
5932 
5933  // clone samples' waveform data
5934  // (using direct read & write disk streaming)
5935  for (int i = 0; pFile->GetSample(i); ++i) {
5936  mSamples[pFile->GetSample(i)]->CopyAssignWave(pFile->GetSample(i));
5937  }
5938  }
5939 
5948  void File::DeleteInstrument(Instrument* pInstrument) {
5949  if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");
5950  InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
5951  if (iter == pInstruments->end()) throw gig::Exception("Could not delete instrument, could not find given instrument");
5952  pInstruments->erase(iter);
5953  delete pInstrument;
5954  }
5955 
5956  void File::LoadInstruments() {
5957  LoadInstruments(NULL);
5958  }
5959 
5960  void File::LoadInstruments(progress_t* pProgress) {
5961  if (!pInstruments) pInstruments = new InstrumentList;
5962  RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
5963  if (lstInstruments) {
5964  int iInstrumentIndex = 0;
5965  RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
5966  while (lstInstr) {
5967  if (lstInstr->GetListType() == LIST_TYPE_INS) {
5968  // notify current progress
5969  const float localProgress = (float) iInstrumentIndex / (float) Instruments;
5970  __notify_progress(pProgress, localProgress);
5971 
5972  // divide local progress into subprogress for loading current Instrument
5973  progress_t subprogress;
5974  __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
5975 
5976  pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
5977 
5978  iInstrumentIndex++;
5979  }
5980  lstInstr = lstInstruments->GetNextSubList();
5981  }
5982  __notify_progress(pProgress, 1.0); // notify done
5983  }
5984  }
5985 
5989  void File::SetSampleChecksum(Sample* pSample, uint32_t crc) {
5990  RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5991  if (!_3crc) return;
5992 
5993  // get the index of the sample
5994  int iWaveIndex = GetWaveTableIndexOf(pSample);
5995  if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
5996 
5997  // write the CRC-32 checksum to disk
5998  _3crc->SetPos(iWaveIndex * 8);
5999  uint32_t one = 1;
6000  _3crc->WriteUint32(&one); // always 1
6001  _3crc->WriteUint32(&crc);
6002  }
6003 
6004  uint32_t File::GetSampleChecksum(Sample* pSample) {
6005  // get the index of the sample
6006  int iWaveIndex = GetWaveTableIndexOf(pSample);
6007  if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
6008 
6009  return GetSampleChecksumByIndex(iWaveIndex);
6010  }
6011 
6012  uint32_t File::GetSampleChecksumByIndex(int index) {
6013  if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
6014 
6015  RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6016  if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
6017  uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
6018  if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
6019 
6020  // read the CRC-32 checksum directly from disk
6021  size_t pos = index * 8;
6022  if (pos + 8 > _3crc->GetNewSize())
6023  throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
6024 
6025  uint32_t one = load32(&pData[pos]); // always 1
6026  if (one != 1)
6027  throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
6028 
6029  return load32(&pData[pos+4]);
6030  }
6031 
6032  int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6033  if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
6034  File::SampleList::iterator iter = pSamples->begin();
6035  File::SampleList::iterator end = pSamples->end();
6036  for (int index = 0; iter != end; ++iter, ++index)
6037  if (*iter == pSample)
6038  return index;
6039  return -1;
6040  }
6041 
6048  bool File::VerifySampleChecksumTable() {
6049  RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6050  if (!_3crc) return false;
6051  if (_3crc->GetNewSize() <= 0) return false;
6052  if (_3crc->GetNewSize() % 8) return false;
6053  if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
6054  if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6055 
6056  const file_offset_t n = _3crc->GetNewSize() / 8;
6057 
6058  uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6059  if (!pData) return false;
6060 
6061  for (file_offset_t i = 0; i < n; ++i) {
6062  uint32_t one = pData[i*2];
6063  if (one != 1) return false;
6064  }
6065 
6066  return true;
6067  }
6068 
6085  bool File::RebuildSampleChecksumTable() {
6086  // make sure sample chunks were scanned
6087  if (!pSamples) GetFirstSample();
6088 
6089  bool bRequiresSave = false;
6090 
6091  // make sure "3CRC" chunk exists with required size
6092  RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6093  if (!_3crc) {
6094  _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6095  // the order of einf and 3crc is not the same in v2 and v3
6096  RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6097  if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6098  bRequiresSave = true;
6099  } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
6100  _3crc->Resize(pSamples->size() * 8);
6101  bRequiresSave = true;
6102  }
6103 
6104  if (bRequiresSave) { // refill CRC table for all samples in RAM ...
6105  uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6106  {
6107  File::SampleList::iterator iter = pSamples->begin();
6108  File::SampleList::iterator end = pSamples->end();
6109  for (; iter != end; ++iter) {
6110  gig::Sample* pSample = (gig::Sample*) *iter;
6111  int index = GetWaveTableIndexOf(pSample);
6112  if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6113  pData[index*2] = 1; // always 1
6114  pData[index*2+1] = pSample->CalculateWaveDataChecksum();
6115  }
6116  }
6117  } else { // no file structure changes necessary, so directly write to disk and we are done ...
6118  // make sure file is in write mode
6119  pRIFF->SetMode(RIFF::stream_mode_read_write);
6120  {
6121  File::SampleList::iterator iter = pSamples->begin();
6122  File::SampleList::iterator end = pSamples->end();
6123  for (; iter != end; ++iter) {
6124  gig::Sample* pSample = (gig::Sample*) *iter;
6125  int index = GetWaveTableIndexOf(pSample);
6126  if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6127  pSample->crc = pSample->CalculateWaveDataChecksum();
6128  SetSampleChecksum(pSample, pSample->crc);
6129  }
6130  }
6131  }
6132 
6133  return bRequiresSave;
6134  }
6135 
6136  Group* File::GetFirstGroup() {
6137  if (!pGroups) LoadGroups();
6138  // there must always be at least one group
6139  GroupsIterator = pGroups->begin();
6140  return *GroupsIterator;
6141  }
6142 
6143  Group* File::GetNextGroup() {
6144  if (!pGroups) return NULL;
6145  ++GroupsIterator;
6146  return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
6147  }
6148 
6155  Group* File::GetGroup(uint index) {
6156  if (!pGroups) LoadGroups();
6157  GroupsIterator = pGroups->begin();
6158  for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
6159  if (i == index) return *GroupsIterator;
6160  ++GroupsIterator;
6161  }
6162  return NULL;
6163  }
6164 
6175  Group* File::GetGroup(String name) {
6176  if (!pGroups) LoadGroups();
6177  GroupsIterator = pGroups->begin();
6178  for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
6179  if ((*GroupsIterator)->Name == name) return *GroupsIterator;
6180  return NULL;
6181  }
6182 
6183  Group* File::AddGroup() {
6184  if (!pGroups) LoadGroups();
6185  // there must always be at least one group
6187  Group* pGroup = new Group(this, NULL);
6188  pGroups->push_back(pGroup);
6189  return pGroup;
6190  }
6191 
6201  void File::DeleteGroup(Group* pGroup) {
6202  if (!pGroups) LoadGroups();
6203  std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
6204  if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
6205  if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
6206  // delete all members of this group
6207  for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {
6208  DeleteSample(pSample);
6209  }
6210  // now delete this group object
6211  pGroups->erase(iter);
6212  delete pGroup;
6213  }
6214 
6225  void File::DeleteGroupOnly(Group* pGroup) {
6226  if (!pGroups) LoadGroups();
6227  std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
6228  if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
6229  if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
6230  // move all members of this group to another group
6231  pGroup->MoveAll();
6232  pGroups->erase(iter);
6233  delete pGroup;
6234  }
6235 
6236  void File::LoadGroups() {
6237  if (!pGroups) pGroups = new std::list<Group*>;
6238  // try to read defined groups from file
6239  RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
6240  if (lst3gri) {
6241  RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
6242  if (lst3gnl) {
6243  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
6244  while (ck) {
6245  if (ck->GetChunkID() == CHUNK_ID_3GNM) {
6246  if (pVersion && pVersion->major > 2 &&
6247  strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
6248 
6249  pGroups->push_back(new Group(this, ck));
6250  }
6251  ck = lst3gnl->GetNextSubChunk();
6252  }
6253  }
6254  }
6255  // if there were no group(s), create at least the mandatory default group
6256  if (!pGroups->size()) {
6257  Group* pGroup = new Group(this, NULL);
6258  pGroup->Name = "Default Group";
6259  pGroups->push_back(pGroup);
6260  }
6261  }
6262 
6270  ScriptGroup* File::GetScriptGroup(uint index) {
6271  if (!pScriptGroups) LoadScriptGroups();
6272  std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6273  for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
6274  if (i == index) return *it;
6275  return NULL;
6276  }
6277 
6286  ScriptGroup* File::GetScriptGroup(const String& name) {
6287  if (!pScriptGroups) LoadScriptGroups();
6288  std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6289  for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
6290  if ((*it)->Name == name) return *it;
6291  return NULL;
6292  }
6293 
6302  ScriptGroup* File::AddScriptGroup() {
6303  if (!pScriptGroups) LoadScriptGroups();
6304  ScriptGroup* pScriptGroup = new ScriptGroup(this, NULL);
6305  pScriptGroups->push_back(pScriptGroup);
6306  return pScriptGroup;
6307  }
6308 
6321  void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
6322  if (!pScriptGroups) LoadScriptGroups();
6323  std::list<ScriptGroup*>::iterator iter =
6324  find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
6325  if (iter == pScriptGroups->end())
6326  throw gig::Exception("Could not delete script group, could not find given script group");
6327  pScriptGroups->erase(iter);
6328  for (int i = 0; pScriptGroup->GetScript(i); ++i)
6329  pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
6330  if (pScriptGroup->pList)
6331  pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
6332  delete pScriptGroup;
6333  }
6334 
6335  void File::LoadScriptGroups() {
6336  if (pScriptGroups) return;
6337  pScriptGroups = new std::list<ScriptGroup*>;
6338  RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
6339  if (lstLS) {
6340  for (RIFF::List* lst = lstLS->GetFirstSubList(); lst;
6341  lst = lstLS->GetNextSubList())
6342  {
6343  if (lst->GetListType() == LIST_TYPE_RTIS) {
6344  pScriptGroups->push_back(new ScriptGroup(this, lst));
6345  }
6346  }
6347  }
6348  }
6349 
6361  void File::UpdateChunks(progress_t* pProgress) {
6362  bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
6363 
6364  // update own gig format extension chunks
6365  // (not part of the GigaStudio 4 format)
6366  RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
6367  if (!lst3LS) {
6368  lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
6369  }
6370  // Make sure <3LS > chunk is placed before <ptbl> chunk. The precise
6371  // location of <3LS > is irrelevant, however it should be located
6372  // before the actual wave data
6373  RIFF::Chunk* ckPTBL = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
6374  pRIFF->MoveSubChunk(lst3LS, ckPTBL);
6375 
6376  // This must be performed before writing the chunks for instruments,
6377  // because the instruments' script slots will write the file offsets
6378  // of the respective instrument script chunk as reference.
6379  if (pScriptGroups) {
6380  // Update instrument script (group) chunks.
6381  for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6382  it != pScriptGroups->end(); ++it)
6383  {
6384  (*it)->UpdateChunks(pProgress);
6385  }
6386  }
6387 
6388  // in case no libgig custom format data was added, then remove the
6389  // custom "3LS " chunk again
6390  if (!lst3LS->CountSubChunks()) {
6391  pRIFF->DeleteSubChunk(lst3LS);
6392  lst3LS = NULL;
6393  }
6394 
6395  // first update base class's chunks
6396  DLS::File::UpdateChunks(pProgress);
6397 
6398  if (newFile) {
6399  // INFO was added by Resource::UpdateChunks - make sure it
6400  // is placed first in file
6401  RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);
6402  RIFF::Chunk* first = pRIFF->GetFirstSubChunk();
6403  if (first != info) {
6404  pRIFF->MoveSubChunk(info, first);
6405  }
6406  }
6407 
6408  // update group's chunks
6409  if (pGroups) {
6410  // make sure '3gri' and '3gnl' list chunks exist
6411  // (before updating the Group chunks)
6412  RIFF::List* _3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
6413  if (!_3gri) {
6414  _3gri = pRIFF->AddSubList(LIST_TYPE_3GRI);
6415  pRIFF->MoveSubChunk(_3gri, pRIFF->GetSubChunk(CHUNK_ID_PTBL));
6416  }
6417  RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
6418  if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
6419 
6420  // v3: make sure the file has 128 3gnm chunks
6421  // (before updating the Group chunks)
6422  if (pVersion && pVersion->major > 2) {
6423  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
6424  for (int i = 0 ; i < 128 ; i++) {
6425  if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
6426  if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();
6427  }
6428  }
6429 
6430  std::list<Group*>::iterator iter = pGroups->begin();
6431  std::list<Group*>::iterator end = pGroups->end();
6432  for (; iter != end; ++iter) {
6433  (*iter)->UpdateChunks(pProgress);
6434  }
6435  }
6436 
6437  // update einf chunk
6438 
6439  // The einf chunk contains statistics about the gig file, such
6440  // as the number of regions and samples used by each
6441  // instrument. It is divided in equally sized parts, where the
6442  // first part contains information about the whole gig file,
6443  // and the rest of the parts map to each instrument in the
6444  // file.
6445  //
6446  // At the end of each part there is a bit map of each sample
6447  // in the file, where a set bit means that the sample is used
6448  // by the file/instrument.
6449  //
6450  // Note that there are several fields with unknown use. These
6451  // are set to zero.
6452 
6453  int sublen = int(pSamples->size() / 8 + 49);
6454  int einfSize = (Instruments + 1) * sublen;
6455 
6456  RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6457  if (einf) {
6458  if (einf->GetSize() != einfSize) {
6459  einf->Resize(einfSize);
6460  memset(einf->LoadChunkData(), 0, einfSize);
6461  }
6462  } else if (newFile) {
6463  einf = pRIFF->AddSubChunk(CHUNK_ID_EINF, einfSize);
6464  }
6465  if (einf) {
6466  uint8_t* pData = (uint8_t*) einf->LoadChunkData();
6467 
6468  std::map<gig::Sample*,int> sampleMap;
6469  int sampleIdx = 0;
6470  for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
6471  sampleMap[pSample] = sampleIdx++;
6472  }
6473 
6474  int totnbusedsamples = 0;
6475  int totnbusedchannels = 0;
6476  int totnbregions = 0;
6477  int totnbdimregions = 0;
6478  int totnbloops = 0;
6479  int instrumentIdx = 0;
6480 
6481  memset(&pData[48], 0, sublen - 48);
6482 
6483  for (Instrument* instrument = GetFirstInstrument() ; instrument ;
6484  instrument = GetNextInstrument()) {
6485  int nbusedsamples = 0;
6486  int nbusedchannels = 0;
6487  int nbdimregions = 0;
6488  int nbloops = 0;
6489 
6490  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
6491 
6492  for (Region* region = instrument->GetFirstRegion() ; region ;
6493  region = instrument->GetNextRegion()) {
6494  for (int i = 0 ; i < region->DimensionRegions ; i++) {
6495  gig::DimensionRegion *d = region->pDimensionRegions[i];
6496  if (d->pSample) {
6497  int sampleIdx = sampleMap[d->pSample];
6498  int byte = 48 + sampleIdx / 8;
6499  int bit = 1 << (sampleIdx & 7);
6500  if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
6501  pData[(instrumentIdx + 1) * sublen + byte] |= bit;
6502  nbusedsamples++;
6503  nbusedchannels += d->pSample->Channels;
6504 
6505  if ((pData[byte] & bit) == 0) {
6506  pData[byte] |= bit;
6507  totnbusedsamples++;
6508  totnbusedchannels += d->pSample->Channels;
6509  }
6510  }
6511  }
6512  if (d->SampleLoops) nbloops++;
6513  }
6514  nbdimregions += region->DimensionRegions;
6515  }
6516  // first 4 bytes unknown - sometimes 0, sometimes length of einf part
6517  // store32(&pData[(instrumentIdx + 1) * sublen], sublen);
6518  store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
6519  store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
6520  store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
6521  store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
6522  store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
6523  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6524  // next 8 bytes unknown
6525  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6526  store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6527  // next 4 bytes unknown
6528 
6529  totnbregions += instrument->Regions;
6530  totnbdimregions += nbdimregions;
6531  totnbloops += nbloops;
6532  instrumentIdx++;
6533  }
6534  // first 4 bytes unknown - sometimes 0, sometimes length of einf part
6535  // store32(&pData[0], sublen);
6536  store32(&pData[4], totnbusedchannels);
6537  store32(&pData[8], totnbusedsamples);
6538  store32(&pData[12], Instruments);
6539  store32(&pData[16], totnbregions);
6540  store32(&pData[20], totnbdimregions);
6541  store32(&pData[24], totnbloops);
6542  // next 8 bytes unknown
6543  // next 4 bytes unknown, not always 0
6544  store32(&pData[40], (uint32_t) pSamples->size());
6545  // next 4 bytes unknown
6546  }
6547 
6548  // update 3crc chunk
6549 
6550  // The 3crc chunk contains CRC-32 checksums for the
6551  // samples. When saving a gig file to disk, we first update the 3CRC
6552  // chunk here (in RAM) with the old crc values which we read from the
6553  // 3CRC chunk when we opened the file (available with gig::Sample::crc
6554  // member variable). This step is required, because samples might have
6555  // been deleted by the user since the file was opened, which in turn
6556  // changes the order of the (i.e. old) checksums within the 3crc chunk.
6557  // If a sample was conciously modified by the user (that is if
6558  // Sample::Write() was called later on) then Sample::Write() will just
6559  // update the respective individual checksum(s) directly on disk and
6560  // leaves all other sample checksums untouched.
6561 
6562  RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6563  if (_3crc) {
6564  _3crc->Resize(pSamples->size() * 8);
6565  } else /*if (newFile)*/ {
6566  _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6567  // the order of einf and 3crc is not the same in v2 and v3
6568  if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6569  }
6570  { // must be performed in RAM here ...
6571  uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6572  if (pData) {
6573  File::SampleList::iterator iter = pSamples->begin();
6574  File::SampleList::iterator end = pSamples->end();
6575  for (int index = 0; iter != end; ++iter, ++index) {
6576  gig::Sample* pSample = (gig::Sample*) *iter;
6577  pData[index*2] = 1; // always 1
6578  pData[index*2+1] = pSample->crc;
6579  }
6580  }
6581  }
6582  }
6583 
6584  void File::UpdateFileOffsets() {
6586 
6587  for (Instrument* instrument = GetFirstInstrument(); instrument;
6588  instrument = GetNextInstrument())
6589  {
6590  instrument->UpdateScriptFileOffsets();
6591  }
6592  }
6593 
6609  void File::SetAutoLoad(bool b) {
6610  bAutoLoad = b;
6611  }
6612 
6617  bool File::GetAutoLoad() {
6618  return bAutoLoad;
6619  }
6620 
6621 
6622 
6623 // *************** Exception ***************
6624 // *
6625 
6626  Exception::Exception() : DLS::Exception() {
6627  }
6628 
6629  Exception::Exception(String format, ...) : DLS::Exception() {
6630  va_list arg;
6631  va_start(arg, format);
6632  Message = assemble(format, arg);
6633  va_end(arg);
6634  }
6635 
6636  Exception::Exception(String format, va_list arg) : DLS::Exception() {
6637  Message = assemble(format, arg);
6638  }
6639 
6640  void Exception::PrintMessage() {
6641  std::cout << "gig::Exception: " << Message << std::endl;
6642  }
6643 
6644 
6645 // *************** functions ***************
6646 // *
6647 
6653  String libraryName() {
6654  return PACKAGE;
6655  }
6656 
6661  String libraryVersion() {
6662  return VERSION;
6663  }
6664 
6665 } // namespace gig
file_offset_t WriteUint32(uint32_t *pData, file_offset_t WordCount=1)
Writes WordCount number of 32 Bit unsigned integer words from the buffer pointed by pData to the chun...
Definition: RIFF.cpp:684
bool IsNew() const
Returns true if this file has been created new from scratch and has not been stored to disk yet.
Definition: RIFF.cpp:2094
Destination container for serialization, and source container for deserialization.
uint32_t Regions
Reflects the number of Region defintions this Instrument has.
Definition: DLS.h:468
file_offset_t ReadUint16(uint16_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 16 Bit unsigned integer words and copies it into the buffer pointed by pDat...
Definition: RIFF.cpp:572
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:165
Chunk * GetFirstSubChunk()
Returns the first subchunk within the list (which may be an ordinary chunk as well as a list chunk).
Definition: RIFF.cpp:1116
uint32_t LoopType
Defines how the waveform samples will be looped (appropriate loop types for the gig format are define...
Definition: DLS.h:233
void __ensureMandatoryChunksExist()
Checks if all (for DLS) mandatory chunks exist, if not they will be created.
Definition: DLS.cpp:1871
virtual void CopyAssign(const Region *orig)
Make a (semi) deep copy of the Region object given by orig and assign it to this object.
Definition: DLS.cpp:1175
file_offset_t GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
Definition: RIFF.h:225
file_offset_t SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence=RIFF::stream_start)
Sets the position within the sample (in sample points, not in bytes).
Definition: DLS.cpp:918
file_offset_t ReadInt32(int32_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 32 Bit signed integer words and copies it into the buffer pointed by pData.
Definition: RIFF.cpp:609
Instrument * GetFirstInstrument()
Returns a pointer to the first Instrument object of the file, NULL otherwise.
Definition: DLS.cpp:1590
virtual void UpdateChunks(progress_t *pProgress)
Apply sample and its settings to the respective RIFF chunks.
Definition: DLS.cpp:970
void ReadString(String &s, int size)
Reads a null-padded string of size characters and copies it into the string s.
Definition: RIFF.cpp:663
file_offset_t GetSize() const
Returns sample size.
Definition: DLS.cpp:858
uint16_t Channels
Number of channels represented in the waveform data, e.g. 1 for mono, 2 for stereo (defaults to 1=mon...
Definition: DLS.h:399
File()
Constructor.
Definition: DLS.cpp:1408
file_offset_t SamplesTotal
Reflects total number of sample points (only if known sample data format is used, 0 otherwise),...
Definition: DLS.h:404
List * GetSubList(uint32_t ListType)
Returns sublist chunk with list type ListType within this chunk list.
Definition: RIFF.cpp:1090
void DeleteSubChunk(Chunk *pSubChunk)
Removes a sub chunk.
Definition: RIFF.cpp:1342
Defines Sample Loop Points.
Definition: DLS.h:231
List * GetFirstSubList()
Returns the first sublist within the list (that is a subchunk with chunk ID "LIST").
Definition: RIFF.cpp:1151
virtual ~Region()
Destructor.
Definition: DLS.cpp:1044
Sample * GetFirstSample()
Returns a pointer to the first Sample object of the file, NULL otherwise.
Definition: DLS.cpp:1514
uint FrameSize
Reflects the size (in bytes) of one single sample point (only if known sample data format is used,...
Definition: DLS.h:405
List * GetParent() const
Returns pointer to the chunk's parent list chunk.
Definition: RIFF.h:224
virtual ~Instrument()
Destructor.
Definition: DLS.cpp:1346
file_offset_t Write(void *pBuffer, file_offset_t SampleCount)
Write sample wave data.
Definition: DLS.cpp:956
RIFF List Chunk.
Definition: RIFF.h:294
file_offset_t Read(void *pData, file_offset_t WordCount, file_offset_t WordSize)
Reads WordCount number of data words with given WordSize and copies it into a buffer pointed by pData...
Definition: RIFF.cpp:318
void ReleaseSampleData()
Free sample data from RAM.
Definition: DLS.cpp:844
String libraryName()
Returns the name of this C++ library.
Definition: DLS.cpp:1998
file_offset_t SetPos(file_offset_t Where, stream_whence_t Whence=stream_start)
Sets the position within the chunk body, thus within the data portion of the chunk (in bytes).
Definition: RIFF.cpp:224
void Resize(file_offset_t NewSize)
Resize sample.
Definition: DLS.cpp:891
Sample * GetNextSample()
Returns a pointer to the next Sample object of the file, NULL otherwise.
Definition: DLS.cpp:1521
Region * GetNextRegion()
Returns the next Region of the instrument.
Definition: DLS.cpp:1252
virtual void Save(const String &Path, progress_t *pProgress=NULL)
Save changes to another file.
Definition: DLS.cpp:1803
Sample * AddSample()
Add a new sample.
Definition: DLS.cpp:1564
virtual void UpdateChunks(progress_t *pProgress)
Apply Instrument with all its Regions to the respective RIFF chunks.
Definition: DLS.cpp:1309
void DeleteSample(Sample *pSample)
Delete a sample.
Definition: DLS.cpp:1582
uint64_t file_offset_t
Type used by libgig for handling file positioning during file I/O tasks.
Definition: RIFF.h:148
file_offset_t ReadUint32(uint32_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 32 Bit unsigned integer words and copies it into the buffer pointed by pDat...
Definition: RIFF.cpp:646
virtual void UpdateChunks(progress_t *pProgress)
Apply all the DLS file's current instruments, samples and settings to the respective RIFF chunks.
Definition: DLS.cpp:1698
Chunk * GetSubChunk(uint32_t ChunkID)
Returns subchunk with chunk ID ChunkID within this chunk list.
Definition: RIFF.cpp:1071
Chunk * GetNextSubChunk()
Returns the next subchunk within the list (which may be an ordinary chunk as well as a list chunk).
Definition: RIFF.cpp:1133
virtual void SetKeyRange(uint16_t Low, uint16_t High)
Modifies the key range of this Region and makes sure the respective chunks are in correct order.
Definition: DLS.cpp:1078
uint16_t BitDepth
Size of each sample per channel (only if known sample data format is used, 0 otherwise).
Definition: DLS.h:403
Ordinary RIFF Chunk.
Definition: RIFF.h:218
virtual ~Sample()
Destructor.
Definition: DLS.cpp:753
Sample(File *pFile, RIFF::List *waveList, file_offset_t WavePoolOffset)
Constructor.
Definition: DLS.cpp:714
int GetFileOffsetSize() const
Returns the current size (in bytes) of file offsets stored in the headers of all chunks of this file.
Definition: RIFF.cpp:2209
uint32_t LoopLength
Length of the looping area (in sample points).
Definition: DLS.h:235
uint32_t GetChunkID() const
Chunk ID in unsigned integer representation.
Definition: RIFF.h:222
file_offset_t RemainingBytes() const
Returns the number of bytes left to read in the chunk body.
Definition: RIFF.cpp:256
file_offset_t Write(void *pData, file_offset_t WordCount, file_offset_t WordSize)
Writes WordCount number of data words with given WordSize from the buffer pointed by pData.
Definition: RIFF.cpp:388
uint32_t GetListType() const
Returns unsigned integer representation of the list's ID.
Definition: RIFF.h:298
file_offset_t ReadInt8(int8_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 8 Bit signed integer words and copies it into the buffer pointed by pData.
Definition: RIFF.cpp:461
void DeleteInstrument(Instrument *pInstrument)
Delete an instrument.
Definition: DLS.cpp:1641
version_t * pVersion
Points to a version_t structure if the file provided a version number else is set to NULL.
Definition: DLS.h:500
uint32_t LoopStart
The start value specifies the offset (in sample points) in the waveform data of the first sample poin...
Definition: DLS.h:234
Instrument(File *pFile, RIFF::List *insList)
Constructor.
Definition: DLS.cpp:1222
void * LoadChunkData()
Load chunk body into RAM.
Definition: RIFF.cpp:809
virtual void UpdateChunks(progress_t *pProgress)
Apply Region settings to the respective RIFF chunks.
Definition: DLS.cpp:1113
virtual void UpdateFileOffsets()
Updates all file offsets stored all over the file.
Definition: DLS.cpp:1862
void Resize(file_offset_t NewSize)
Resize chunk.
Definition: RIFF.cpp:880
RIFF File.
Definition: RIFF.h:344
List * AddSubList(uint32_t uiListType)
Creates a new list sub chunk.
Definition: RIFF.cpp:1323
virtual void CopyAssign(const Instrument *orig)
Make a (semi) deep copy of the Instrument object given by orig and assign it to this object.
Definition: DLS.cpp:1383
virtual void UpdateChunks(progress_t *pProgress)
Apply all sample player options to the respective RIFF chunk.
Definition: DLS.cpp:596
file_offset_t GetNewSize() const
New chunk size if it was modified with Resize(), otherwise value returned will be equal to GetSize().
Definition: RIFF.h:226
Encapsulates sample waves used for playback.
Definition: DLS.h:396
void MoveSubChunk(Chunk *pSrc, Chunk *pDst)
Moves a sub chunk witin this list.
Definition: RIFF.cpp:1275
uint32_t SamplesPerSecond
Sampling rate at which each channel should be played (defaults to 44100 if Sample was created with In...
Definition: DLS.h:400
File * GetFile() const
Returns pointer to the chunk's File object.
Definition: RIFF.h:223
size_t CountSubChunks()
Returns number of subchunks within the list (including list chunks).
Definition: RIFF.cpp:1191
String GetFileName()
File name of this DLS file.
Definition: DLS.cpp:1678
bool SetMode(stream_mode_t NewMode)
Change file access mode.
Definition: RIFF.cpp:1737
Instrument * AddInstrument()
Add a new instrument definition.
Definition: DLS.cpp:1624
file_offset_t Read(void *pBuffer, file_offset_t SampleCount)
Reads SampleCount number of sample points from the current position into the buffer pointed by pBuffe...
Definition: DLS.cpp:936
void CopyAssignCore(const Sample *orig)
Make a deep copy of the Sample object given by orig (without the actual sample waveform data however)...
Definition: DLS.cpp:769
file_offset_t GetFilePos() const
Current, actual offset of chunk data body start in file.
Definition: RIFF.h:228
file_offset_t GetCurrentFileSize() const
Returns the current size of this file (in bytes) as it is currently yet stored on disk.
Definition: RIFF.cpp:2116
uint32_t Instruments
Reflects the number of available Instrument objects.
Definition: DLS.h:501
Provides all neccessary information for the synthesis of a DLS Instrument.
Definition: DLS.h:461
Quadtuple version number ("major.minor.release.build").
Definition: DLS.h:111
Instrument * GetNextInstrument()
Returns a pointer to the next Instrument object of the file, NULL otherwise.
Definition: DLS.cpp:1597
file_offset_t GetPos() const
Position within the chunk data body (starting with 0).
Definition: RIFF.h:227
DLS specific classes and definitions.
Definition: DLS.h:104
String libraryVersion()
Returns version of this C++ library.
Definition: DLS.cpp:2006
file_offset_t ReadInt16(int16_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 16 Bit signed integer words and copies it into the buffer pointed by pData.
Definition: RIFF.cpp:535
file_offset_t ReadUint8(uint8_t *pData, file_offset_t WordCount=1)
Reads WordCount number of 8 Bit unsigned integer words and copies it into the buffer pointed by pData...
Definition: RIFF.cpp:498
Region * GetFirstRegion()
Returns the first Region of the instrument.
Definition: DLS.cpp:1245
List * GetNextSubList()
Returns the next sublist (that is a subchunk with chunk ID "LIST") within the list.
Definition: RIFF.cpp:1173
Defines Region information of an Instrument.
Definition: DLS.h:431
Chunk * AddSubChunk(uint32_t uiChunkID, file_offset_t ullBodySize)
Creates a new sub chunk.
Definition: RIFF.cpp:1253
void * LoadSampleData()
Load sample data into RAM.
Definition: DLS.cpp:835