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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 384 by schoenebeck, Thu Feb 17 02:22:26 2005 UTC revision 1106 by schoenebeck, Sun Mar 18 19:38:47 2007 UTC
# Line 1  Line 1 
1  /***************************************************************************  /***************************************************************************
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file loader library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2005 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2007 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 23  Line 23 
23    
24  #include "gig.h"  #include "gig.h"
25    
26    #include "helper.h"
27    
28    #include <math.h>
29  #include <iostream>  #include <iostream>
30    
31  namespace gig { namespace {  /// Initial size of the sample buffer which is used for decompression of
32    /// compressed sample wave streams - this value should always be bigger than
33    /// the biggest sample piece expected to be read by the sampler engine,
34    /// otherwise the buffer size will be raised at runtime and thus the buffer
35    /// reallocated which is time consuming and unefficient.
36    #define INITIAL_SAMPLE_BUFFER_SIZE              512000 // 512 kB
37    
38    /** (so far) every exponential paramater in the gig format has a basis of 1.000000008813822 */
39    #define GIG_EXP_DECODE(x)                       (pow(1.000000008813822, x))
40    #define GIG_EXP_ENCODE(x)                       (log(x) / log(1.000000008813822))
41    #define GIG_PITCH_TRACK_EXTRACT(x)              (!(x & 0x01))
42    #define GIG_PITCH_TRACK_ENCODE(x)               ((x) ? 0x00 : 0x01)
43    #define GIG_VCF_RESONANCE_CTRL_EXTRACT(x)       ((x >> 4) & 0x03)
44    #define GIG_VCF_RESONANCE_CTRL_ENCODE(x)        ((x & 0x03) << 4)
45    #define GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(x)  ((x >> 1) & 0x03)
46    #define GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(x)   ((x >> 3) & 0x03)
47    #define GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(x) ((x >> 5) & 0x03)
48    #define GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(x)   ((x & 0x03) << 1)
49    #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)
50    #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)
51    
52    namespace gig {
53    
54    // *************** progress_t ***************
55    // *
56    
57        progress_t::progress_t() {
58            callback    = NULL;
59            custom      = NULL;
60            __range_min = 0.0f;
61            __range_max = 1.0f;
62        }
63    
64        // private helper function to convert progress of a subprocess into the global progress
65        static void __notify_progress(progress_t* pProgress, float subprogress) {
66            if (pProgress && pProgress->callback) {
67                const float totalrange    = pProgress->__range_max - pProgress->__range_min;
68                const float totalprogress = pProgress->__range_min + subprogress * totalrange;
69                pProgress->factor         = totalprogress;
70                pProgress->callback(pProgress); // now actually notify about the progress
71            }
72        }
73    
74        // private helper function to divide a progress into subprogresses
75        static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress, float totalTasks, float currentTask) {
76            if (pParentProgress && pParentProgress->callback) {
77                const float totalrange    = pParentProgress->__range_max - pParentProgress->__range_min;
78                pSubProgress->callback    = pParentProgress->callback;
79                pSubProgress->custom      = pParentProgress->custom;
80                pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;
81                pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;
82            }
83        }
84    
85    
86  // *************** Internal functions for sample decopmression ***************  // *************** Internal functions for sample decompression ***************
87  // *  // *
88    
89    namespace {
90    
91      inline int get12lo(const unsigned char* pSrc)      inline int get12lo(const unsigned char* pSrc)
92      {      {
93          const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;          const int x = pSrc[0] | (pSrc[1] & 0x0f) << 8;
# Line 53  namespace gig { namespace { Line 111  namespace gig { namespace {
111          return x & 0x800000 ? x - 0x1000000 : x;          return x & 0x800000 ? x - 0x1000000 : x;
112      }      }
113    
114        inline void store24(unsigned char* pDst, int x)
115        {
116            pDst[0] = x;
117            pDst[1] = x >> 8;
118            pDst[2] = x >> 16;
119        }
120    
121      void Decompress16(int compressionmode, const unsigned char* params,      void Decompress16(int compressionmode, const unsigned char* params,
122                        int srcStep, int dstStep,                        int srcStep, int dstStep,
123                        const unsigned char* pSrc, int16_t* pDst,                        const unsigned char* pSrc, int16_t* pDst,
# Line 92  namespace gig { namespace { Line 157  namespace gig { namespace {
157      }      }
158    
159      void Decompress24(int compressionmode, const unsigned char* params,      void Decompress24(int compressionmode, const unsigned char* params,
160                        int dstStep, const unsigned char* pSrc, int16_t* pDst,                        int dstStep, const unsigned char* pSrc, uint8_t* pDst,
161                        unsigned long currentframeoffset,                        unsigned long currentframeoffset,
162                        unsigned long copysamples)                        unsigned long copysamples, int truncatedBits)
163      {      {
164          // Note: The 24 bits are truncated to 16 bits for now.          int y, dy, ddy, dddy;
165    
166          // Note: The calculation of the initial value of y is strange  #define GET_PARAMS(params)                      \
167          // and not 100% correct. What should the first two parameters          y    = get24(params);                   \
168          // really be used for? Why are they two? The correct value for          dy   = y - get24((params) + 3);         \
169          // y seems to lie somewhere between the values of the first          ddy  = get24((params) + 6);             \
170          // two parameters.          dddy = get24((params) + 9)
         //  
         // Strange thing #2: The formula in SKIP_ONE gives values for  
         // y that are twice as high as they should be. That's why  
         // COPY_ONE shifts 9 steps instead of 8, and also why y is  
         // initialized with a sum instead of a mean value.  
   
         int y, dy, ddy;  
   
 #define GET_PARAMS(params)                              \  
         y = (get24(params) + get24((params) + 3));      \  
         dy  = get24((params) + 6);                      \  
         ddy = get24((params) + 9)  
171    
172  #define SKIP_ONE(x)                             \  #define SKIP_ONE(x)                             \
173          ddy -= (x);                             \          dddy -= (x);                            \
174          dy -= ddy;                              \          ddy  -= dddy;                           \
175          y -= dy          dy   =  -dy - ddy;                      \
176            y    += dy
177    
178  #define COPY_ONE(x)                             \  #define COPY_ONE(x)                             \
179          SKIP_ONE(x);                            \          SKIP_ONE(x);                            \
180          *pDst = y >> 9;                         \          store24(pDst, y << truncatedBits);      \
181          pDst += dstStep          pDst += dstStep
182    
183          switch (compressionmode) {          switch (compressionmode) {
184              case 2: // 24 bit uncompressed              case 2: // 24 bit uncompressed
185                  pSrc += currentframeoffset * 3;                  pSrc += currentframeoffset * 3;
186                  while (copysamples) {                  while (copysamples) {
187                      *pDst = get24(pSrc) >> 8;                      store24(pDst, get24(pSrc) << truncatedBits);
188                      pDst += dstStep;                      pDst += dstStep;
189                      pSrc += 3;                      pSrc += 3;
190                      copysamples--;                      copysamples--;
# Line 206  namespace gig { namespace { Line 260  namespace gig { namespace {
260      unsigned int Sample::Instances = 0;      unsigned int Sample::Instances = 0;
261      buffer_t     Sample::InternalDecompressionBuffer;      buffer_t     Sample::InternalDecompressionBuffer;
262    
263      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {      /** @brief Constructor.
264         *
265         * Load an existing sample or create a new one. A 'wave' list chunk must
266         * be given to this constructor. In case the given 'wave' list chunk
267         * contains a 'fmt', 'data' (and optionally a '3gix', 'smpl') chunk, the
268         * format and sample data will be loaded from there, otherwise default
269         * values will be used and those chunks will be created when
270         * File::Save() will be called later on.
271         *
272         * @param pFile          - pointer to gig::File where this sample is
273         *                         located (or will be located)
274         * @param waveList       - pointer to 'wave' list chunk which is (or
275         *                         will be) associated with this sample
276         * @param WavePoolOffset - offset of this sample data from wave pool
277         *                         ('wvpl') list chunk
278         * @param fileNo         - number of an extension file where this sample
279         *                         is located, 0 otherwise
280         */
281        Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
282            pInfo->UseFixedLengthStrings = true;
283          Instances++;          Instances++;
284            FileNo = fileNo;
285    
286          RIFF::Chunk* _3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
287          if (!_3gix) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");          if (pCk3gix) {
288          SampleGroup = _3gix->ReadInt16();              uint16_t iSampleGroup = pCk3gix->ReadInt16();
289                pGroup = pFile->GetGroup(iSampleGroup);
290          RIFF::Chunk* smpl = waveList->GetSubChunk(CHUNK_ID_SMPL);          } else { // '3gix' chunk missing
291          if (!smpl) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");              // by default assigned to that mandatory "Default Group"
292          Manufacturer      = smpl->ReadInt32();              pGroup = pFile->GetGroup(0);
293          Product           = smpl->ReadInt32();          }
294          SamplePeriod      = smpl->ReadInt32();  
295          MIDIUnityNote     = smpl->ReadInt32();          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
296          FineTune          = smpl->ReadInt32();          if (pCkSmpl) {
297          smpl->Read(&SMPTEFormat, 1, 4);              Manufacturer  = pCkSmpl->ReadInt32();
298          SMPTEOffset       = smpl->ReadInt32();              Product       = pCkSmpl->ReadInt32();
299          Loops             = smpl->ReadInt32();              SamplePeriod  = pCkSmpl->ReadInt32();
300          smpl->ReadInt32(); // manufByt              MIDIUnityNote = pCkSmpl->ReadInt32();
301          LoopID            = smpl->ReadInt32();              FineTune      = pCkSmpl->ReadInt32();
302          smpl->Read(&LoopType, 1, 4);              pCkSmpl->Read(&SMPTEFormat, 1, 4);
303          LoopStart         = smpl->ReadInt32();              SMPTEOffset   = pCkSmpl->ReadInt32();
304          LoopEnd           = smpl->ReadInt32();              Loops         = pCkSmpl->ReadInt32();
305          LoopFraction      = smpl->ReadInt32();              pCkSmpl->ReadInt32(); // manufByt
306          LoopPlayCount     = smpl->ReadInt32();              LoopID        = pCkSmpl->ReadInt32();
307                pCkSmpl->Read(&LoopType, 1, 4);
308                LoopStart     = pCkSmpl->ReadInt32();
309                LoopEnd       = pCkSmpl->ReadInt32();
310                LoopFraction  = pCkSmpl->ReadInt32();
311                LoopPlayCount = pCkSmpl->ReadInt32();
312            } else { // 'smpl' chunk missing
313                // use default values
314                Manufacturer  = 0;
315                Product       = 0;
316                SamplePeriod  = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
317                MIDIUnityNote = 64;
318                FineTune      = 0;
319                SMPTEOffset   = 0;
320                Loops         = 0;
321                LoopID        = 0;
322                LoopStart     = 0;
323                LoopEnd       = 0;
324                LoopFraction  = 0;
325                LoopPlayCount = 0;
326            }
327    
328          FrameTable                 = NULL;          FrameTable                 = NULL;
329          SamplePos                  = 0;          SamplePos                  = 0;
# Line 239  namespace gig { namespace { Line 333  namespace gig { namespace {
333    
334          if (BitDepth > 24) throw gig::Exception("Only samples up to 24 bit supported");          if (BitDepth > 24) throw gig::Exception("Only samples up to 24 bit supported");
335    
336          Compressed = (waveList->GetSubChunk(CHUNK_ID_EWAV));          RIFF::Chunk* ewav = waveList->GetSubChunk(CHUNK_ID_EWAV);
337            Compressed        = ewav;
338            Dithered          = false;
339            TruncatedBits     = 0;
340          if (Compressed) {          if (Compressed) {
341                uint32_t version = ewav->ReadInt32();
342                if (version == 3 && BitDepth == 24) {
343                    Dithered = ewav->ReadInt32();
344                    ewav->SetPos(Channels == 2 ? 84 : 64);
345                    TruncatedBits = ewav->ReadInt32();
346                }
347              ScanCompressedSample();              ScanCompressedSample();
348          }          }
349    
# Line 249  namespace gig { namespace { Line 352  namespace gig { namespace {
352              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
353              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;
354          }          }
355          FrameOffset = 0; // just for streaming compressed samples          FrameOffset = 0; // just for streaming compressed samples
356    
357          LoopSize = LoopEnd - LoopStart;          LoopSize = LoopEnd - LoopStart + 1;
358        }
359    
360        /**
361         * Apply sample and its settings to the respective RIFF chunks. You have
362         * to call File::Save() to make changes persistent.
363         *
364         * Usually there is absolutely no need to call this method explicitly.
365         * It will be called automatically when File::Save() was called.
366         *
367         * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
368         *                        was provided yet
369         * @throws gig::Exception if there is any invalid sample setting
370         */
371        void Sample::UpdateChunks() {
372            // first update base class's chunks
373            DLS::Sample::UpdateChunks();
374    
375            // make sure 'smpl' chunk exists
376            pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
377            if (!pCkSmpl) pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);
378            // update 'smpl' chunk
379            uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();
380            SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
381            memcpy(&pData[0], &Manufacturer, 4);
382            memcpy(&pData[4], &Product, 4);
383            memcpy(&pData[8], &SamplePeriod, 4);
384            memcpy(&pData[12], &MIDIUnityNote, 4);
385            memcpy(&pData[16], &FineTune, 4);
386            memcpy(&pData[20], &SMPTEFormat, 4);
387            memcpy(&pData[24], &SMPTEOffset, 4);
388            memcpy(&pData[28], &Loops, 4);
389    
390            // we skip 'manufByt' for now (4 bytes)
391    
392            memcpy(&pData[36], &LoopID, 4);
393            memcpy(&pData[40], &LoopType, 4);
394            memcpy(&pData[44], &LoopStart, 4);
395            memcpy(&pData[48], &LoopEnd, 4);
396            memcpy(&pData[52], &LoopFraction, 4);
397            memcpy(&pData[56], &LoopPlayCount, 4);
398    
399            // make sure '3gix' chunk exists
400            pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
401            if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
402            // determine appropriate sample group index (to be stored in chunk)
403            uint16_t iSampleGroup = 0; // 0 refers to default sample group
404            File* pFile = static_cast<File*>(pParent);
405            if (pFile->pGroups) {
406                std::list<Group*>::iterator iter = pFile->pGroups->begin();
407                std::list<Group*>::iterator end  = pFile->pGroups->end();
408                for (int i = 0; iter != end; i++, iter++) {
409                    if (*iter == pGroup) {
410                        iSampleGroup = i;
411                        break; // found
412                    }
413                }
414            }
415            // update '3gix' chunk
416            pData = (uint8_t*) pCk3gix->LoadChunkData();
417            memcpy(&pData[0], &iSampleGroup, 2);
418      }      }
419    
420      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
# Line 454  namespace gig { namespace { Line 617  namespace gig { namespace {
617          RAMCache.Size   = 0;          RAMCache.Size   = 0;
618      }      }
619    
620        /** @brief Resize sample.
621         *
622         * Resizes the sample's wave form data, that is the actual size of
623         * sample wave data possible to be written for this sample. This call
624         * will return immediately and just schedule the resize operation. You
625         * should call File::Save() to actually perform the resize operation(s)
626         * "physically" to the file. As this can take a while on large files, it
627         * is recommended to call Resize() first on all samples which have to be
628         * resized and finally to call File::Save() to perform all those resize
629         * operations in one rush.
630         *
631         * The actual size (in bytes) is dependant to the current FrameSize
632         * value. You may want to set FrameSize before calling Resize().
633         *
634         * <b>Caution:</b> You cannot directly write (i.e. with Write()) to
635         * enlarged samples before calling File::Save() as this might exceed the
636         * current sample's boundary!
637         *
638         * Also note: only DLS_WAVE_FORMAT_PCM is currently supported, that is
639         * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
640         * other formats will fail!
641         *
642         * @param iNewSize - new sample wave data size in sample points (must be
643         *                   greater than zero)
644         * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
645         *                         or if \a iNewSize is less than 1
646         * @throws gig::Exception if existing sample is compressed
647         * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
648         *      DLS::Sample::FormatTag, File::Save()
649         */
650        void Sample::Resize(int iNewSize) {
651            if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
652            DLS::Sample::Resize(iNewSize);
653        }
654    
655      /**      /**
656       * Sets the position within the sample (in sample points, not in       * Sets the position within the sample (in sample points, not in
657       * bytes). Use this method and <i>Read()</i> if you don't want to load       * bytes). Use this method and <i>Read()</i> if you don't want to load
# Line 543  namespace gig { namespace { Line 741  namespace gig { namespace {
741       * @param SampleCount      number of sample points to read       * @param SampleCount      number of sample points to read
742       * @param pPlaybackState   will be used to store and reload the playback       * @param pPlaybackState   will be used to store and reload the playback
743       *                         state for the next ReadAndLoop() call       *                         state for the next ReadAndLoop() call
744         * @param pDimRgn          dimension region with looping information
745       * @param pExternalDecompressionBuffer  (optional) external buffer to use for decompression       * @param pExternalDecompressionBuffer  (optional) external buffer to use for decompression
746       * @returns                number of successfully read sample points       * @returns                number of successfully read sample points
747       * @see                    CreateDecompressionBuffer()       * @see                    CreateDecompressionBuffer()
748       */       */
749      unsigned long Sample::ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState, buffer_t* pExternalDecompressionBuffer) {      unsigned long Sample::ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState,
750                                          DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
751          unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;          unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
752          uint8_t* pDst = (uint8_t*) pBuffer;          uint8_t* pDst = (uint8_t*) pBuffer;
753    
754          SetPos(pPlaybackState->position); // recover position from the last time          SetPos(pPlaybackState->position); // recover position from the last time
755    
756          if (this->Loops && GetPos() <= this->LoopEnd) { // honor looping if there are loop points defined          if (pDimRgn->SampleLoops) { // honor looping if there are loop points defined
757    
758              switch (this->LoopType) {              const DLS::sample_loop_t& loop = pDimRgn->pSampleLoops[0];
759                const uint32_t loopEnd = loop.LoopStart + loop.LoopLength;
760    
761                  case loop_type_bidirectional: { //TODO: not tested yet!              if (GetPos() <= loopEnd) {
762                      do {                  switch (loop.LoopType) {
                         // if not endless loop check if max. number of loop cycles have been passed  
                         if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;  
   
                         if (!pPlaybackState->reverse) { // forward playback  
                             do {  
                                 samplestoloopend  = this->LoopEnd - GetPos();  
                                 readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);  
                                 samplestoread    -= readsamples;  
                                 totalreadsamples += readsamples;  
                                 if (readsamples == samplestoloopend) {  
                                     pPlaybackState->reverse = true;  
                                     break;  
                                 }  
                             } while (samplestoread && readsamples);  
                         }  
                         else { // backward playback  
763    
764                              // as we can only read forward from disk, we have to                      case loop_type_bidirectional: { //TODO: not tested yet!
765                              // determine the end position within the loop first,                          do {
766                              // read forward from that 'end' and finally after                              // if not endless loop check if max. number of loop cycles have been passed
767                              // reading, swap all sample frames so it reflects                              if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
768                              // backward playback  
769                                if (!pPlaybackState->reverse) { // forward playback
770                              unsigned long swapareastart       = totalreadsamples;                                  do {
771                              unsigned long loopoffset          = GetPos() - this->LoopStart;                                      samplestoloopend  = loopEnd - GetPos();
772                              unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);                                      readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
773                              unsigned long reverseplaybackend  = GetPos() - samplestoreadinloop;                                      samplestoread    -= readsamples;
774                                        totalreadsamples += readsamples;
775                              SetPos(reverseplaybackend);                                      if (readsamples == samplestoloopend) {
776                                            pPlaybackState->reverse = true;
777                              // read samples for backward playback                                          break;
778                              do {                                      }
779                                  readsamples          = Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);                                  } while (samplestoread && readsamples);
780                                  samplestoreadinloop -= readsamples;                              }
781                                  samplestoread       -= readsamples;                              else { // backward playback
                                 totalreadsamples    += readsamples;  
                             } while (samplestoreadinloop && readsamples);  
782    
783                              SetPos(reverseplaybackend); // pretend we really read backwards                                  // as we can only read forward from disk, we have to
784                                    // determine the end position within the loop first,
785                                    // read forward from that 'end' and finally after
786                                    // reading, swap all sample frames so it reflects
787                                    // backward playback
788    
789                                    unsigned long swapareastart       = totalreadsamples;
790                                    unsigned long loopoffset          = GetPos() - loop.LoopStart;
791                                    unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);
792                                    unsigned long reverseplaybackend  = GetPos() - samplestoreadinloop;
793    
794                                    SetPos(reverseplaybackend);
795    
796                                    // read samples for backward playback
797                                    do {
798                                        readsamples          = Read(&pDst[totalreadsamples * this->FrameSize], samplestoreadinloop, pExternalDecompressionBuffer);
799                                        samplestoreadinloop -= readsamples;
800                                        samplestoread       -= readsamples;
801                                        totalreadsamples    += readsamples;
802                                    } while (samplestoreadinloop && readsamples);
803    
804                                    SetPos(reverseplaybackend); // pretend we really read backwards
805    
806                                    if (reverseplaybackend == loop.LoopStart) {
807                                        pPlaybackState->loop_cycles_left--;
808                                        pPlaybackState->reverse = false;
809                                    }
810    
811                              if (reverseplaybackend == this->LoopStart) {                                  // reverse the sample frames for backward playback
812                                  pPlaybackState->loop_cycles_left--;                                  SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
                                 pPlaybackState->reverse = false;  
813                              }                              }
814                            } while (samplestoread && readsamples);
815                            break;
816                        }
817    
818                              // reverse the sample frames for backward playback                      case loop_type_backward: { // TODO: not tested yet!
819                              SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);                          // forward playback (not entered the loop yet)
820                          }                          if (!pPlaybackState->reverse) do {
821                      } while (samplestoread && readsamples);                              samplestoloopend  = loopEnd - GetPos();
822                      break;                              readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
823                  }                              samplestoread    -= readsamples;
824                                totalreadsamples += readsamples;
825                  case loop_type_backward: { // TODO: not tested yet!                              if (readsamples == samplestoloopend) {
826                      // forward playback (not entered the loop yet)                                  pPlaybackState->reverse = true;
827                      if (!pPlaybackState->reverse) do {                                  break;
828                          samplestoloopend  = this->LoopEnd - GetPos();                              }
829                          readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);                          } while (samplestoread && readsamples);
                         samplestoread    -= readsamples;  
                         totalreadsamples += readsamples;  
                         if (readsamples == samplestoloopend) {  
                             pPlaybackState->reverse = true;  
                             break;  
                         }  
                     } while (samplestoread && readsamples);  
830    
831                      if (!samplestoread) break;                          if (!samplestoread) break;
832    
833                      // as we can only read forward from disk, we have to                          // as we can only read forward from disk, we have to
834                      // determine the end position within the loop first,                          // determine the end position within the loop first,
835                      // read forward from that 'end' and finally after                          // read forward from that 'end' and finally after
836                      // reading, swap all sample frames so it reflects                          // reading, swap all sample frames so it reflects
837                      // backward playback                          // backward playback
838    
839                      unsigned long swapareastart       = totalreadsamples;                          unsigned long swapareastart       = totalreadsamples;
840                      unsigned long loopoffset          = GetPos() - this->LoopStart;                          unsigned long loopoffset          = GetPos() - loop.LoopStart;
841                      unsigned long samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * LoopSize - loopoffset)                          unsigned long samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.LoopLength - loopoffset)
842                                                                                : samplestoread;                                                                                    : samplestoread;
843                      unsigned long reverseplaybackend  = this->LoopStart + Abs((loopoffset - samplestoreadinloop) % this->LoopSize);                          unsigned long reverseplaybackend  = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);
844    
845                      SetPos(reverseplaybackend);                          SetPos(reverseplaybackend);
846    
847                      // read samples for backward playback                          // read samples for backward playback
848                      do {                          do {
849                          // if not endless loop check if max. number of loop cycles have been passed                              // if not endless loop check if max. number of loop cycles have been passed
850                          if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;                              if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
851                          samplestoloopend     = this->LoopEnd - GetPos();                              samplestoloopend     = loopEnd - GetPos();
852                          readsamples          = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);                              readsamples          = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoreadinloop, samplestoloopend), pExternalDecompressionBuffer);
853                          samplestoreadinloop -= readsamples;                              samplestoreadinloop -= readsamples;
854                          samplestoread       -= readsamples;                              samplestoread       -= readsamples;
855                          totalreadsamples    += readsamples;                              totalreadsamples    += readsamples;
856                          if (readsamples == samplestoloopend) {                              if (readsamples == samplestoloopend) {
857                              pPlaybackState->loop_cycles_left--;                                  pPlaybackState->loop_cycles_left--;
858                              SetPos(this->LoopStart);                                  SetPos(loop.LoopStart);
859                          }                              }
860                      } while (samplestoreadinloop && readsamples);                          } while (samplestoreadinloop && readsamples);
861    
862                      SetPos(reverseplaybackend); // pretend we really read backwards                          SetPos(reverseplaybackend); // pretend we really read backwards
863    
864                      // reverse the sample frames for backward playback                          // reverse the sample frames for backward playback
865                      SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);                          SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
866                      break;                          break;
867                  }                      }
868    
869                  default: case loop_type_normal: {                      default: case loop_type_normal: {
870                      do {                          do {
871                          // if not endless loop check if max. number of loop cycles have been passed                              // if not endless loop check if max. number of loop cycles have been passed
872                          if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;                              if (this->LoopPlayCount && !pPlaybackState->loop_cycles_left) break;
873                          samplestoloopend  = this->LoopEnd - GetPos();                              samplestoloopend  = loopEnd - GetPos();
874                          readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);                              readsamples       = Read(&pDst[totalreadsamples * this->FrameSize], Min(samplestoread, samplestoloopend), pExternalDecompressionBuffer);
875                          samplestoread    -= readsamples;                              samplestoread    -= readsamples;
876                          totalreadsamples += readsamples;                              totalreadsamples += readsamples;
877                          if (readsamples == samplestoloopend) {                              if (readsamples == samplestoloopend) {
878                              pPlaybackState->loop_cycles_left--;                                  pPlaybackState->loop_cycles_left--;
879                              SetPos(this->LoopStart);                                  SetPos(loop.LoopStart);
880                          }                              }
881                      } while (samplestoread && readsamples);                          } while (samplestoread && readsamples);
882                      break;                          break;
883                        }
884                  }                  }
885              }              }
886          }          }
# Line 705  namespace gig { namespace { Line 910  namespace gig { namespace {
910       * have to use an external decompression buffer for <b>EACH</b>       * have to use an external decompression buffer for <b>EACH</b>
911       * streaming thread to avoid race conditions and crashes!       * streaming thread to avoid race conditions and crashes!
912       *       *
913         * For 16 bit samples, the data in the buffer will be int16_t
914         * (using native endianness). For 24 bit, the buffer will
915         * contain three bytes per sample, little-endian.
916         *
917       * @param pBuffer      destination buffer       * @param pBuffer      destination buffer
918       * @param SampleCount  number of sample points to read       * @param SampleCount  number of sample points to read
919       * @param pExternalDecompressionBuffer  (optional) external buffer to use for decompression       * @param pExternalDecompressionBuffer  (optional) external buffer to use for decompression
# Line 715  namespace gig { namespace { Line 924  namespace gig { namespace {
924          if (SampleCount == 0) return 0;          if (SampleCount == 0) return 0;
925          if (!Compressed) {          if (!Compressed) {
926              if (BitDepth == 24) {              if (BitDepth == 24) {
927                  // 24 bit sample. For now just truncate to 16 bit.                  return pCkData->Read(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
                 unsigned char* pSrc = (unsigned char*) ((pExternalDecompressionBuffer) ? pExternalDecompressionBuffer->pStart : this->InternalDecompressionBuffer.pStart);  
                 int16_t* pDst = static_cast<int16_t*>(pBuffer);  
                 if (Channels == 2) { // Stereo  
                     unsigned long readBytes = pCkData->Read(pSrc, SampleCount * 6, 1);  
                     pSrc++;  
                     for (unsigned long i = readBytes ; i > 0 ; i -= 3) {  
                         *pDst++ = get16(pSrc);  
                         pSrc += 3;  
                     }  
                     return (pDst - static_cast<int16_t*>(pBuffer)) >> 1;  
                 }  
                 else { // Mono  
                     unsigned long readBytes = pCkData->Read(pSrc, SampleCount * 3, 1);  
                     pSrc++;  
                     for (unsigned long i = readBytes ; i > 0 ; i -= 3) {  
                         *pDst++ = get16(pSrc);  
                         pSrc += 3;  
                     }  
                     return pDst - static_cast<int16_t*>(pBuffer);  
                 }  
928              }              }
929              else { // 16 bit              else { // 16 bit
930                  // (pCkData->Read does endian correction)                  // (pCkData->Read does endian correction)
# Line 765  namespace gig { namespace { Line 954  namespace gig { namespace {
954    
955              unsigned char* pSrc = (unsigned char*) pDecompressionBuffer->pStart;              unsigned char* pSrc = (unsigned char*) pDecompressionBuffer->pStart;
956              int16_t* pDst = static_cast<int16_t*>(pBuffer);              int16_t* pDst = static_cast<int16_t*>(pBuffer);
957                uint8_t* pDst24 = static_cast<uint8_t*>(pBuffer);
958              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
959    
960              while (remainingsamples && remainingbytes) {              while (remainingsamples && remainingbytes) {
# Line 846  namespace gig { namespace { Line 1036  namespace gig { namespace {
1036                              const unsigned char* const param_r = pSrc;                              const unsigned char* const param_r = pSrc;
1037                              if (mode_r != 2) pSrc += 12;                              if (mode_r != 2) pSrc += 12;
1038    
1039                              Decompress24(mode_l, param_l, 2, pSrc, pDst, skipsamples, copysamples);                              Decompress24(mode_l, param_l, 6, pSrc, pDst24,
1040                              Decompress24(mode_r, param_r, 2, pSrc + rightChannelOffset, pDst + 1,                                           skipsamples, copysamples, TruncatedBits);
1041                                           skipsamples, copysamples);                              Decompress24(mode_r, param_r, 6, pSrc + rightChannelOffset, pDst24 + 3,
1042                              pDst += copysamples << 1;                                           skipsamples, copysamples, TruncatedBits);
1043                                pDst24 += copysamples * 6;
1044                          }                          }
1045                          else { // Mono                          else { // Mono
1046                              Decompress24(mode_l, param_l, 1, pSrc, pDst, skipsamples, copysamples);                              Decompress24(mode_l, param_l, 3, pSrc, pDst24,
1047                              pDst += copysamples;                                           skipsamples, copysamples, TruncatedBits);
1048                                pDst24 += copysamples * 3;
1049                          }                          }
1050                      }                      }
1051                      else { // 16 bit                      else { // 16 bit
# Line 895  namespace gig { namespace { Line 1087  namespace gig { namespace {
1087          }          }
1088      }      }
1089    
1090        /** @brief Write sample wave data.
1091         *
1092         * Writes \a SampleCount number of sample points from the buffer pointed
1093         * by \a pBuffer and increments the position within the sample. Use this
1094         * method to directly write the sample data to disk, i.e. if you don't
1095         * want or cannot load the whole sample data into RAM.
1096         *
1097         * You have to Resize() the sample to the desired size and call
1098         * File::Save() <b>before</b> using Write().
1099         *
1100         * Note: there is currently no support for writing compressed samples.
1101         *
1102         * @param pBuffer     - source buffer
1103         * @param SampleCount - number of sample points to write
1104         * @throws DLS::Exception if current sample size is too small
1105         * @throws gig::Exception if sample is compressed
1106         * @see DLS::LoadSampleData()
1107         */
1108        unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {
1109            if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1110            return DLS::Sample::Write(pBuffer, SampleCount);
1111        }
1112    
1113      /**      /**
1114       * Allocates a decompression buffer for streaming (compressed) samples       * Allocates a decompression buffer for streaming (compressed) samples
1115       * with Sample::Read(). If you are using more than one streaming thread       * with Sample::Read(). If you are using more than one streaming thread
# Line 937  namespace gig { namespace { Line 1152  namespace gig { namespace {
1152          }          }
1153      }      }
1154    
1155        /**
1156         * Returns pointer to the Group this Sample belongs to. In the .gig
1157         * format a sample always belongs to one group. If it wasn't explicitly
1158         * assigned to a certain group, it will be automatically assigned to a
1159         * default group.
1160         *
1161         * @returns Sample's Group (never NULL)
1162         */
1163        Group* Sample::GetGroup() const {
1164            return pGroup;
1165        }
1166    
1167      Sample::~Sample() {      Sample::~Sample() {
1168          Instances--;          Instances--;
1169          if (!Instances && InternalDecompressionBuffer.Size) {          if (!Instances && InternalDecompressionBuffer.Size) {
# Line 959  namespace gig { namespace { Line 1186  namespace gig { namespace {
1186      DimensionRegion::DimensionRegion(RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {      DimensionRegion::DimensionRegion(RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
1187          Instances++;          Instances++;
1188    
1189            pSample = NULL;
1190    
1191          memcpy(&Crossfade, &SamplerOptions, 4);          memcpy(&Crossfade, &SamplerOptions, 4);
1192          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1193    
1194          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
1195          _3ewa->ReadInt32(); // unknown, always 0x0000008C ?          if (_3ewa) { // if '3ewa' chunk exists
1196          LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              _3ewa->ReadInt32(); // unknown, always == chunk size ?
1197          EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1198          _3ewa->ReadInt16(); // unknown              EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1199          LFO1InternalDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1200          _3ewa->ReadInt16(); // unknown              LFO1InternalDepth = _3ewa->ReadUint16();
1201          LFO3InternalDepth = _3ewa->ReadInt16();              _3ewa->ReadInt16(); // unknown
1202          _3ewa->ReadInt16(); // unknown              LFO3InternalDepth = _3ewa->ReadInt16();
1203          LFO1ControlDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1204          _3ewa->ReadInt16(); // unknown              LFO1ControlDepth = _3ewa->ReadUint16();
1205          LFO3ControlDepth = _3ewa->ReadInt16();              _3ewa->ReadInt16(); // unknown
1206          EG1Attack           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO3ControlDepth = _3ewa->ReadInt16();
1207          EG1Decay1           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG1Attack           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1208          _3ewa->ReadInt16(); // unknown              EG1Decay1           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1209          EG1Sustain          = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1210          EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG1Sustain          = _3ewa->ReadUint16();
1211          EG1Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));              EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1212          uint8_t eg1ctrloptions        = _3ewa->ReadUint8();              EG1Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1213          EG1ControllerInvert           = eg1ctrloptions & 0x01;              uint8_t eg1ctrloptions        = _3ewa->ReadUint8();
1214          EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerInvert           = eg1ctrloptions & 0x01;
1215          EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1216          EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1217          EG2Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));              EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1218          uint8_t eg2ctrloptions        = _3ewa->ReadUint8();              EG2Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1219          EG2ControllerInvert           = eg2ctrloptions & 0x01;              uint8_t eg2ctrloptions        = _3ewa->ReadUint8();
1220          EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerInvert           = eg2ctrloptions & 0x01;
1221          EG2ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1222          EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1223          LFO1Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1224          EG2Attack        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO1Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1225          EG2Decay1        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2Attack        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1226          _3ewa->ReadInt16(); // unknown              EG2Decay1        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1227          EG2Sustain       = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1228          EG2Release       = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2Sustain       = _3ewa->ReadUint16();
1229          _3ewa->ReadInt16(); // unknown              EG2Release       = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1230          LFO2ControlDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1231          LFO2Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO2ControlDepth = _3ewa->ReadUint16();
1232          _3ewa->ReadInt16(); // unknown              LFO2Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1233          LFO2InternalDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1234          int32_t eg1decay2 = _3ewa->ReadInt32();              LFO2InternalDepth = _3ewa->ReadUint16();
1235          EG1Decay2          = (double) GIG_EXP_DECODE(eg1decay2);              int32_t eg1decay2 = _3ewa->ReadInt32();
1236          EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);              EG1Decay2          = (double) GIG_EXP_DECODE(eg1decay2);
1237          _3ewa->ReadInt16(); // unknown              EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1238          EG1PreAttack      = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1239          int32_t eg2decay2 = _3ewa->ReadInt32();              EG1PreAttack      = _3ewa->ReadUint16();
1240          EG2Decay2         = (double) GIG_EXP_DECODE(eg2decay2);              int32_t eg2decay2 = _3ewa->ReadInt32();
1241          EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);              EG2Decay2         = (double) GIG_EXP_DECODE(eg2decay2);
1242          _3ewa->ReadInt16(); // unknown              EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1243          EG2PreAttack      = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1244          uint8_t velocityresponse = _3ewa->ReadUint8();              EG2PreAttack      = _3ewa->ReadUint16();
1245          if (velocityresponse < 5) {              uint8_t velocityresponse = _3ewa->ReadUint8();
1246              VelocityResponseCurve = curve_type_nonlinear;              if (velocityresponse < 5) {
1247              VelocityResponseDepth = velocityresponse;                  VelocityResponseCurve = curve_type_nonlinear;
1248          }                  VelocityResponseDepth = velocityresponse;
1249          else if (velocityresponse < 10) {              } else if (velocityresponse < 10) {
1250              VelocityResponseCurve = curve_type_linear;                  VelocityResponseCurve = curve_type_linear;
1251              VelocityResponseDepth = velocityresponse - 5;                  VelocityResponseDepth = velocityresponse - 5;
1252          }              } else if (velocityresponse < 15) {
1253          else if (velocityresponse < 15) {                  VelocityResponseCurve = curve_type_special;
1254              VelocityResponseCurve = curve_type_special;                  VelocityResponseDepth = velocityresponse - 10;
1255              VelocityResponseDepth = velocityresponse - 10;              } else {
1256                    VelocityResponseCurve = curve_type_unknown;
1257                    VelocityResponseDepth = 0;
1258                }
1259                uint8_t releasevelocityresponse = _3ewa->ReadUint8();
1260                if (releasevelocityresponse < 5) {
1261                    ReleaseVelocityResponseCurve = curve_type_nonlinear;
1262                    ReleaseVelocityResponseDepth = releasevelocityresponse;
1263                } else if (releasevelocityresponse < 10) {
1264                    ReleaseVelocityResponseCurve = curve_type_linear;
1265                    ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1266                } else if (releasevelocityresponse < 15) {
1267                    ReleaseVelocityResponseCurve = curve_type_special;
1268                    ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1269                } else {
1270                    ReleaseVelocityResponseCurve = curve_type_unknown;
1271                    ReleaseVelocityResponseDepth = 0;
1272                }
1273                VelocityResponseCurveScaling = _3ewa->ReadUint8();
1274                AttenuationControllerThreshold = _3ewa->ReadInt8();
1275                _3ewa->ReadInt32(); // unknown
1276                SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
1277                _3ewa->ReadInt16(); // unknown
1278                uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();
1279                PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1280                if      (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1281                else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1282                else                                       DimensionBypass = dim_bypass_ctrl_none;
1283                uint8_t pan = _3ewa->ReadUint8();
1284                Pan         = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
1285                SelfMask = _3ewa->ReadInt8() & 0x01;
1286                _3ewa->ReadInt8(); // unknown
1287                uint8_t lfo3ctrl = _3ewa->ReadUint8();
1288                LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
1289                LFO3Sync                 = lfo3ctrl & 0x20; // bit 5
1290                InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
1291                AttenuationController  = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1292                uint8_t lfo2ctrl       = _3ewa->ReadUint8();
1293                LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
1294                LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7
1295                LFO2Sync               = lfo2ctrl & 0x20; // bit 5
1296                bool extResonanceCtrl  = lfo2ctrl & 0x40; // bit 6
1297                uint8_t lfo1ctrl       = _3ewa->ReadUint8();
1298                LFO1Controller         = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
1299                LFO1FlipPhase          = lfo1ctrl & 0x80; // bit 7
1300                LFO1Sync               = lfo1ctrl & 0x40; // bit 6
1301                VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1302                                                            : vcf_res_ctrl_none;
1303                uint16_t eg3depth = _3ewa->ReadUint16();
1304                EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1305                                            : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */
1306                _3ewa->ReadInt16(); // unknown
1307                ChannelOffset = _3ewa->ReadUint8() / 4;
1308                uint8_t regoptions = _3ewa->ReadUint8();
1309                MSDecode           = regoptions & 0x01; // bit 0
1310                SustainDefeat      = regoptions & 0x02; // bit 1
1311                _3ewa->ReadInt16(); // unknown
1312                VelocityUpperLimit = _3ewa->ReadInt8();
1313                _3ewa->ReadInt8(); // unknown
1314                _3ewa->ReadInt16(); // unknown
1315                ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
1316                _3ewa->ReadInt8(); // unknown
1317                _3ewa->ReadInt8(); // unknown
1318                EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
1319                uint8_t vcfcutoff = _3ewa->ReadUint8();
1320                VCFEnabled = vcfcutoff & 0x80; // bit 7
1321                VCFCutoff  = vcfcutoff & 0x7f; // lower 7 bits
1322                VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
1323                uint8_t vcfvelscale = _3ewa->ReadUint8();
1324                VCFCutoffControllerInvert = vcfvelscale & 0x80; // bit 7
1325                VCFVelocityScale = vcfvelscale & 0x7f; // lower 7 bits
1326                _3ewa->ReadInt8(); // unknown
1327                uint8_t vcfresonance = _3ewa->ReadUint8();
1328                VCFResonance = vcfresonance & 0x7f; // lower 7 bits
1329                VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
1330                uint8_t vcfbreakpoint         = _3ewa->ReadUint8();
1331                VCFKeyboardTracking           = vcfbreakpoint & 0x80; // bit 7
1332                VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
1333                uint8_t vcfvelocity = _3ewa->ReadUint8();
1334                VCFVelocityDynamicRange = vcfvelocity % 5;
1335                VCFVelocityCurve        = static_cast<curve_type_t>(vcfvelocity / 5);
1336                VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
1337                if (VCFType == vcf_type_lowpass) {
1338                    if (lfo3ctrl & 0x40) // bit 6
1339                        VCFType = vcf_type_lowpassturbo;
1340                }
1341                if (_3ewa->RemainingBytes() >= 8) {
1342                    _3ewa->Read(DimensionUpperLimits, 1, 8);
1343                } else {
1344                    memset(DimensionUpperLimits, 0, 8);
1345                }
1346            } else { // '3ewa' chunk does not exist yet
1347                // use default values
1348                LFO3Frequency                   = 1.0;
1349                EG3Attack                       = 0.0;
1350                LFO1InternalDepth               = 0;
1351                LFO3InternalDepth               = 0;
1352                LFO1ControlDepth                = 0;
1353                LFO3ControlDepth                = 0;
1354                EG1Attack                       = 0.0;
1355                EG1Decay1                       = 0.0;
1356                EG1Sustain                      = 0;
1357                EG1Release                      = 0.0;
1358                EG1Controller.type              = eg1_ctrl_t::type_none;
1359                EG1Controller.controller_number = 0;
1360                EG1ControllerInvert             = false;
1361                EG1ControllerAttackInfluence    = 0;
1362                EG1ControllerDecayInfluence     = 0;
1363                EG1ControllerReleaseInfluence   = 0;
1364                EG2Controller.type              = eg2_ctrl_t::type_none;
1365                EG2Controller.controller_number = 0;
1366                EG2ControllerInvert             = false;
1367                EG2ControllerAttackInfluence    = 0;
1368                EG2ControllerDecayInfluence     = 0;
1369                EG2ControllerReleaseInfluence   = 0;
1370                LFO1Frequency                   = 1.0;
1371                EG2Attack                       = 0.0;
1372                EG2Decay1                       = 0.0;
1373                EG2Sustain                      = 0;
1374                EG2Release                      = 0.0;
1375                LFO2ControlDepth                = 0;
1376                LFO2Frequency                   = 1.0;
1377                LFO2InternalDepth               = 0;
1378                EG1Decay2                       = 0.0;
1379                EG1InfiniteSustain              = false;
1380                EG1PreAttack                    = 1000;
1381                EG2Decay2                       = 0.0;
1382                EG2InfiniteSustain              = false;
1383                EG2PreAttack                    = 1000;
1384                VelocityResponseCurve           = curve_type_nonlinear;
1385                VelocityResponseDepth           = 3;
1386                ReleaseVelocityResponseCurve    = curve_type_nonlinear;
1387                ReleaseVelocityResponseDepth    = 3;
1388                VelocityResponseCurveScaling    = 32;
1389                AttenuationControllerThreshold  = 0;
1390                SampleStartOffset               = 0;
1391                PitchTrack                      = true;
1392                DimensionBypass                 = dim_bypass_ctrl_none;
1393                Pan                             = 0;
1394                SelfMask                        = true;
1395                LFO3Controller                  = lfo3_ctrl_modwheel;
1396                LFO3Sync                        = false;
1397                InvertAttenuationController     = false;
1398                AttenuationController.type      = attenuation_ctrl_t::type_none;
1399                AttenuationController.controller_number = 0;
1400                LFO2Controller                  = lfo2_ctrl_internal;
1401                LFO2FlipPhase                   = false;
1402                LFO2Sync                        = false;
1403                LFO1Controller                  = lfo1_ctrl_internal;
1404                LFO1FlipPhase                   = false;
1405                LFO1Sync                        = false;
1406                VCFResonanceController          = vcf_res_ctrl_none;
1407                EG3Depth                        = 0;
1408                ChannelOffset                   = 0;
1409                MSDecode                        = false;
1410                SustainDefeat                   = false;
1411                VelocityUpperLimit              = 0;
1412                ReleaseTriggerDecay             = 0;
1413                EG1Hold                         = false;
1414                VCFEnabled                      = false;
1415                VCFCutoff                       = 0;
1416                VCFCutoffController             = vcf_cutoff_ctrl_none;
1417                VCFCutoffControllerInvert       = false;
1418                VCFVelocityScale                = 0;
1419                VCFResonance                    = 0;
1420                VCFResonanceDynamic             = false;
1421                VCFKeyboardTracking             = false;
1422                VCFKeyboardTrackingBreakpoint   = 0;
1423                VCFVelocityDynamicRange         = 0x04;
1424                VCFVelocityCurve                = curve_type_linear;
1425                VCFType                         = vcf_type_lowpass;
1426                memset(DimensionUpperLimits, 0, 8);
1427            }
1428    
1429            pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1430                                                         VelocityResponseDepth,
1431                                                         VelocityResponseCurveScaling);
1432    
1433            curve_type_t curveType = ReleaseVelocityResponseCurve;
1434            uint8_t depth = ReleaseVelocityResponseDepth;
1435    
1436            // this models a strange behaviour or bug in GSt: two of the
1437            // velocity response curves for release time are not used even
1438            // if specified, instead another curve is chosen.
1439            if ((curveType == curve_type_nonlinear && depth == 0) ||
1440                (curveType == curve_type_special   && depth == 4)) {
1441                curveType = curve_type_nonlinear;
1442                depth = 3;
1443            }
1444            pVelocityReleaseTable = GetVelocityTable(curveType, depth, 0);
1445    
1446            curveType = VCFVelocityCurve;
1447            depth = VCFVelocityDynamicRange;
1448    
1449            // even stranger GSt: two of the velocity response curves for
1450            // filter cutoff are not used, instead another special curve
1451            // is chosen. This curve is not used anywhere else.
1452            if ((curveType == curve_type_nonlinear && depth == 0) ||
1453                (curveType == curve_type_special   && depth == 4)) {
1454                curveType = curve_type_special;
1455                depth = 5;
1456          }          }
1457          else {          pVelocityCutoffTable = GetVelocityTable(curveType, depth,
1458              VelocityResponseCurve = curve_type_unknown;                                                  VCFCutoffController <= vcf_cutoff_ctrl_none2 ? VCFVelocityScale : 0);
1459              VelocityResponseDepth = 0;  
1460            SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1461            VelocityTable = 0;
1462        }
1463    
1464        /**
1465         * Apply dimension region settings to the respective RIFF chunks. You
1466         * have to call File::Save() to make changes persistent.
1467         *
1468         * Usually there is absolutely no need to call this method explicitly.
1469         * It will be called automatically when File::Save() was called.
1470         */
1471        void DimensionRegion::UpdateChunks() {
1472            // first update base class's chunk
1473            DLS::Sampler::UpdateChunks();
1474    
1475            // make sure '3ewa' chunk exists
1476            RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1477            if (!_3ewa)  _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, 140);
1478            uint8_t* pData = (uint8_t*) _3ewa->LoadChunkData();
1479    
1480            // update '3ewa' chunk with DimensionRegion's current settings
1481    
1482            const uint32_t chunksize = _3ewa->GetSize();
1483            memcpy(&pData[0], &chunksize, 4); // unknown, always chunk size?
1484    
1485            const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
1486            memcpy(&pData[4], &lfo3freq, 4);
1487    
1488            const int32_t eg3attack = (int32_t) GIG_EXP_ENCODE(EG3Attack);
1489            memcpy(&pData[8], &eg3attack, 4);
1490    
1491            // next 2 bytes unknown
1492    
1493            memcpy(&pData[14], &LFO1InternalDepth, 2);
1494    
1495            // next 2 bytes unknown
1496    
1497            memcpy(&pData[18], &LFO3InternalDepth, 2);
1498    
1499            // next 2 bytes unknown
1500    
1501            memcpy(&pData[22], &LFO1ControlDepth, 2);
1502    
1503            // next 2 bytes unknown
1504    
1505            memcpy(&pData[26], &LFO3ControlDepth, 2);
1506    
1507            const int32_t eg1attack = (int32_t) GIG_EXP_ENCODE(EG1Attack);
1508            memcpy(&pData[28], &eg1attack, 4);
1509    
1510            const int32_t eg1decay1 = (int32_t) GIG_EXP_ENCODE(EG1Decay1);
1511            memcpy(&pData[32], &eg1decay1, 4);
1512    
1513            // next 2 bytes unknown
1514    
1515            memcpy(&pData[38], &EG1Sustain, 2);
1516    
1517            const int32_t eg1release = (int32_t) GIG_EXP_ENCODE(EG1Release);
1518            memcpy(&pData[40], &eg1release, 4);
1519    
1520            const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(EG1Controller);
1521            memcpy(&pData[44], &eg1ctl, 1);
1522    
1523            const uint8_t eg1ctrloptions =
1524                (EG1ControllerInvert) ? 0x01 : 0x00 |
1525                GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
1526                GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
1527                GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
1528            memcpy(&pData[45], &eg1ctrloptions, 1);
1529    
1530            const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(EG2Controller);
1531            memcpy(&pData[46], &eg2ctl, 1);
1532    
1533            const uint8_t eg2ctrloptions =
1534                (EG2ControllerInvert) ? 0x01 : 0x00 |
1535                GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
1536                GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
1537                GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
1538            memcpy(&pData[47], &eg2ctrloptions, 1);
1539    
1540            const int32_t lfo1freq = (int32_t) GIG_EXP_ENCODE(LFO1Frequency);
1541            memcpy(&pData[48], &lfo1freq, 4);
1542    
1543            const int32_t eg2attack = (int32_t) GIG_EXP_ENCODE(EG2Attack);
1544            memcpy(&pData[52], &eg2attack, 4);
1545    
1546            const int32_t eg2decay1 = (int32_t) GIG_EXP_ENCODE(EG2Decay1);
1547            memcpy(&pData[56], &eg2decay1, 4);
1548    
1549            // next 2 bytes unknown
1550    
1551            memcpy(&pData[62], &EG2Sustain, 2);
1552    
1553            const int32_t eg2release = (int32_t) GIG_EXP_ENCODE(EG2Release);
1554            memcpy(&pData[64], &eg2release, 4);
1555    
1556            // next 2 bytes unknown
1557    
1558            memcpy(&pData[70], &LFO2ControlDepth, 2);
1559    
1560            const int32_t lfo2freq = (int32_t) GIG_EXP_ENCODE(LFO2Frequency);
1561            memcpy(&pData[72], &lfo2freq, 4);
1562    
1563            // next 2 bytes unknown
1564    
1565            memcpy(&pData[78], &LFO2InternalDepth, 2);
1566    
1567            const int32_t eg1decay2 = (int32_t) (EG1InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG1Decay2);
1568            memcpy(&pData[80], &eg1decay2, 4);
1569    
1570            // next 2 bytes unknown
1571    
1572            memcpy(&pData[86], &EG1PreAttack, 2);
1573    
1574            const int32_t eg2decay2 = (int32_t) (EG2InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG2Decay2);
1575            memcpy(&pData[88], &eg2decay2, 4);
1576    
1577            // next 2 bytes unknown
1578    
1579            memcpy(&pData[94], &EG2PreAttack, 2);
1580    
1581            {
1582                if (VelocityResponseDepth > 4) throw Exception("VelocityResponseDepth must be between 0 and 4");
1583                uint8_t velocityresponse = VelocityResponseDepth;
1584                switch (VelocityResponseCurve) {
1585                    case curve_type_nonlinear:
1586                        break;
1587                    case curve_type_linear:
1588                        velocityresponse += 5;
1589                        break;
1590                    case curve_type_special:
1591                        velocityresponse += 10;
1592                        break;
1593                    case curve_type_unknown:
1594                    default:
1595                        throw Exception("Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
1596                }
1597                memcpy(&pData[96], &velocityresponse, 1);
1598          }          }
1599          uint8_t releasevelocityresponse = _3ewa->ReadUint8();  
1600          if (releasevelocityresponse < 5) {          {
1601              ReleaseVelocityResponseCurve = curve_type_nonlinear;              if (ReleaseVelocityResponseDepth > 4) throw Exception("ReleaseVelocityResponseDepth must be between 0 and 4");
1602              ReleaseVelocityResponseDepth = releasevelocityresponse;              uint8_t releasevelocityresponse = ReleaseVelocityResponseDepth;
1603          }              switch (ReleaseVelocityResponseCurve) {
1604          else if (releasevelocityresponse < 10) {                  case curve_type_nonlinear:
1605              ReleaseVelocityResponseCurve = curve_type_linear;                      break;
1606              ReleaseVelocityResponseDepth = releasevelocityresponse - 5;                  case curve_type_linear:
1607          }                      releasevelocityresponse += 5;
1608          else if (releasevelocityresponse < 15) {                      break;
1609              ReleaseVelocityResponseCurve = curve_type_special;                  case curve_type_special:
1610              ReleaseVelocityResponseDepth = releasevelocityresponse - 10;                      releasevelocityresponse += 10;
1611                        break;
1612                    case curve_type_unknown:
1613                    default:
1614                        throw Exception("Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
1615                }
1616                memcpy(&pData[97], &releasevelocityresponse, 1);
1617          }          }
1618          else {  
1619              ReleaseVelocityResponseCurve = curve_type_unknown;          memcpy(&pData[98], &VelocityResponseCurveScaling, 1);
1620              ReleaseVelocityResponseDepth = 0;  
1621            memcpy(&pData[99], &AttenuationControllerThreshold, 1);
1622    
1623            // next 4 bytes unknown
1624    
1625            memcpy(&pData[104], &SampleStartOffset, 2);
1626    
1627            // next 2 bytes unknown
1628    
1629            {
1630                uint8_t pitchTrackDimensionBypass = GIG_PITCH_TRACK_ENCODE(PitchTrack);
1631                switch (DimensionBypass) {
1632                    case dim_bypass_ctrl_94:
1633                        pitchTrackDimensionBypass |= 0x10;
1634                        break;
1635                    case dim_bypass_ctrl_95:
1636                        pitchTrackDimensionBypass |= 0x20;
1637                        break;
1638                    case dim_bypass_ctrl_none:
1639                        //FIXME: should we set anything here?
1640                        break;
1641                    default:
1642                        throw Exception("Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
1643                }
1644                memcpy(&pData[108], &pitchTrackDimensionBypass, 1);
1645            }
1646    
1647            const uint8_t pan = (Pan >= 0) ? Pan : ((-Pan) + 63); // signed 8 bit -> signed 7 bit
1648            memcpy(&pData[109], &pan, 1);
1649    
1650            const uint8_t selfmask = (SelfMask) ? 0x01 : 0x00;
1651            memcpy(&pData[110], &selfmask, 1);
1652    
1653            // next byte unknown
1654    
1655            {
1656                uint8_t lfo3ctrl = LFO3Controller & 0x07; // lower 3 bits
1657                if (LFO3Sync) lfo3ctrl |= 0x20; // bit 5
1658                if (InvertAttenuationController) lfo3ctrl |= 0x80; // bit 7
1659                if (VCFType == vcf_type_lowpassturbo) lfo3ctrl |= 0x40; // bit 6
1660                memcpy(&pData[112], &lfo3ctrl, 1);
1661            }
1662    
1663            const uint8_t attenctl = EncodeLeverageController(AttenuationController);
1664            memcpy(&pData[113], &attenctl, 1);
1665    
1666            {
1667                uint8_t lfo2ctrl = LFO2Controller & 0x07; // lower 3 bits
1668                if (LFO2FlipPhase) lfo2ctrl |= 0x80; // bit 7
1669                if (LFO2Sync)      lfo2ctrl |= 0x20; // bit 5
1670                if (VCFResonanceController != vcf_res_ctrl_none) lfo2ctrl |= 0x40; // bit 6
1671                memcpy(&pData[114], &lfo2ctrl, 1);
1672            }
1673    
1674            {
1675                uint8_t lfo1ctrl = LFO1Controller & 0x07; // lower 3 bits
1676                if (LFO1FlipPhase) lfo1ctrl |= 0x80; // bit 7
1677                if (LFO1Sync)      lfo1ctrl |= 0x40; // bit 6
1678                if (VCFResonanceController != vcf_res_ctrl_none)
1679                    lfo1ctrl |= GIG_VCF_RESONANCE_CTRL_ENCODE(VCFResonanceController);
1680                memcpy(&pData[115], &lfo1ctrl, 1);
1681          }          }
1682          VelocityResponseCurveScaling = _3ewa->ReadUint8();  
1683          AttenuationControllerThreshold = _3ewa->ReadInt8();          const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
1684          _3ewa->ReadInt32(); // unknown                                                    : uint16_t(((-EG3Depth) - 1) ^ 0xffff); /* binary complementary for negatives */
1685          SampleStartOffset = (uint16_t) _3ewa->ReadInt16();          memcpy(&pData[116], &eg3depth, 1);
1686          _3ewa->ReadInt16(); // unknown  
1687          uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();          // next 2 bytes unknown
1688          PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);  
1689          if      (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;          const uint8_t channeloffset = ChannelOffset * 4;
1690          else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;          memcpy(&pData[120], &channeloffset, 1);
1691          else                                       DimensionBypass = dim_bypass_ctrl_none;  
1692          uint8_t pan = _3ewa->ReadUint8();          {
1693          Pan         = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit              uint8_t regoptions = 0;
1694          SelfMask = _3ewa->ReadInt8() & 0x01;              if (MSDecode)      regoptions |= 0x01; // bit 0
1695          _3ewa->ReadInt8(); // unknown              if (SustainDefeat) regoptions |= 0x02; // bit 1
1696          uint8_t lfo3ctrl = _3ewa->ReadUint8();              memcpy(&pData[121], &regoptions, 1);
         LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits  
         LFO3Sync                 = lfo3ctrl & 0x20; // bit 5  
         InvertAttenuationController = lfo3ctrl & 0x80; // bit 7  
         AttenuationController  = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));  
         uint8_t lfo2ctrl       = _3ewa->ReadUint8();  
         LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits  
         LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7  
         LFO2Sync               = lfo2ctrl & 0x20; // bit 5  
         bool extResonanceCtrl  = lfo2ctrl & 0x40; // bit 6  
         uint8_t lfo1ctrl       = _3ewa->ReadUint8();  
         LFO1Controller         = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits  
         LFO1FlipPhase          = lfo1ctrl & 0x80; // bit 7  
         LFO1Sync               = lfo1ctrl & 0x40; // bit 6  
         VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))  
                                                     : vcf_res_ctrl_none;  
         uint16_t eg3depth = _3ewa->ReadUint16();  
         EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */  
                                       : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */  
         _3ewa->ReadInt16(); // unknown  
         ChannelOffset = _3ewa->ReadUint8() / 4;  
         uint8_t regoptions = _3ewa->ReadUint8();  
         MSDecode           = regoptions & 0x01; // bit 0  
         SustainDefeat      = regoptions & 0x02; // bit 1  
         _3ewa->ReadInt16(); // unknown  
         VelocityUpperLimit = _3ewa->ReadInt8();  
         _3ewa->ReadInt8(); // unknown  
         _3ewa->ReadInt16(); // unknown  
         ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay  
         _3ewa->ReadInt8(); // unknown  
         _3ewa->ReadInt8(); // unknown  
         EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7  
         uint8_t vcfcutoff = _3ewa->ReadUint8();  
         VCFEnabled = vcfcutoff & 0x80; // bit 7  
         VCFCutoff  = vcfcutoff & 0x7f; // lower 7 bits  
         VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());  
         VCFVelocityScale = _3ewa->ReadUint8();  
         _3ewa->ReadInt8(); // unknown  
         uint8_t vcfresonance = _3ewa->ReadUint8();  
         VCFResonance = vcfresonance & 0x7f; // lower 7 bits  
         VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7  
         uint8_t vcfbreakpoint         = _3ewa->ReadUint8();  
         VCFKeyboardTracking           = vcfbreakpoint & 0x80; // bit 7  
         VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits  
         uint8_t vcfvelocity = _3ewa->ReadUint8();  
         VCFVelocityDynamicRange = vcfvelocity % 5;  
         VCFVelocityCurve        = static_cast<curve_type_t>(vcfvelocity / 5);  
         VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());  
         if (VCFType == vcf_type_lowpass) {  
             if (lfo3ctrl & 0x40) // bit 6  
                 VCFType = vcf_type_lowpassturbo;  
1697          }          }
1698    
1699          // get the corresponding velocity->volume table from the table map or create & calculate that table if it doesn't exist yet          // next 2 bytes unknown
1700          uint32_t tableKey = (VelocityResponseCurve<<16) | (VelocityResponseDepth<<8) | VelocityResponseCurveScaling;  
1701            memcpy(&pData[124], &VelocityUpperLimit, 1);
1702    
1703            // next 3 bytes unknown
1704    
1705            memcpy(&pData[128], &ReleaseTriggerDecay, 1);
1706    
1707            // next 2 bytes unknown
1708    
1709            const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7
1710            memcpy(&pData[131], &eg1hold, 1);
1711    
1712            const uint8_t vcfcutoff = (VCFEnabled) ? 0x80 : 0x00 |  /* bit 7 */
1713                                      (VCFCutoff & 0x7f);   /* lower 7 bits */
1714            memcpy(&pData[132], &vcfcutoff, 1);
1715    
1716            memcpy(&pData[133], &VCFCutoffController, 1);
1717    
1718            const uint8_t vcfvelscale = (VCFCutoffControllerInvert) ? 0x80 : 0x00 | /* bit 7 */
1719                                        (VCFVelocityScale & 0x7f); /* lower 7 bits */
1720            memcpy(&pData[134], &vcfvelscale, 1);
1721    
1722            // next byte unknown
1723    
1724            const uint8_t vcfresonance = (VCFResonanceDynamic) ? 0x00 : 0x80 | /* bit 7 */
1725                                         (VCFResonance & 0x7f); /* lower 7 bits */
1726            memcpy(&pData[136], &vcfresonance, 1);
1727    
1728            const uint8_t vcfbreakpoint = (VCFKeyboardTracking) ? 0x80 : 0x00 | /* bit 7 */
1729                                          (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
1730            memcpy(&pData[137], &vcfbreakpoint, 1);
1731    
1732            const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 |
1733                                        VCFVelocityCurve * 5;
1734            memcpy(&pData[138], &vcfvelocity, 1);
1735    
1736            const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
1737            memcpy(&pData[139], &vcftype, 1);
1738    
1739            if (chunksize >= 148) {
1740                memcpy(&pData[140], DimensionUpperLimits, 8);
1741            }
1742        }
1743    
1744        // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
1745        double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
1746        {
1747            double* table;
1748            uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
1749          if (pVelocityTables->count(tableKey)) { // if key exists          if (pVelocityTables->count(tableKey)) { // if key exists
1750              pVelocityAttenuationTable = (*pVelocityTables)[tableKey];              table = (*pVelocityTables)[tableKey];
1751          }          }
1752          else {          else {
1753              pVelocityAttenuationTable =              table = CreateVelocityTable(curveType, depth, scaling);
1754                  CreateVelocityTable(VelocityResponseCurve,              (*pVelocityTables)[tableKey] = table; // put the new table into the tables map
                                     VelocityResponseDepth,  
                                     VelocityResponseCurveScaling);  
             (*pVelocityTables)[tableKey] = pVelocityAttenuationTable; // put the new table into the tables map  
1755          }          }
1756            return table;
1757      }      }
1758    
1759      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
# Line 1245  namespace gig { namespace { Line 1874  namespace gig { namespace {
1874          return decodedcontroller;          return decodedcontroller;
1875      }      }
1876    
1877        DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
1878            _lev_ctrl_t encodedcontroller;
1879            switch (DecodedController.type) {
1880                // special controller
1881                case leverage_ctrl_t::type_none:
1882                    encodedcontroller = _lev_ctrl_none;
1883                    break;
1884                case leverage_ctrl_t::type_velocity:
1885                    encodedcontroller = _lev_ctrl_velocity;
1886                    break;
1887                case leverage_ctrl_t::type_channelaftertouch:
1888                    encodedcontroller = _lev_ctrl_channelaftertouch;
1889                    break;
1890    
1891                // ordinary MIDI control change controller
1892                case leverage_ctrl_t::type_controlchange:
1893                    switch (DecodedController.controller_number) {
1894                        case 1:
1895                            encodedcontroller = _lev_ctrl_modwheel;
1896                            break;
1897                        case 2:
1898                            encodedcontroller = _lev_ctrl_breath;
1899                            break;
1900                        case 4:
1901                            encodedcontroller = _lev_ctrl_foot;
1902                            break;
1903                        case 12:
1904                            encodedcontroller = _lev_ctrl_effect1;
1905                            break;
1906                        case 13:
1907                            encodedcontroller = _lev_ctrl_effect2;
1908                            break;
1909                        case 16:
1910                            encodedcontroller = _lev_ctrl_genpurpose1;
1911                            break;
1912                        case 17:
1913                            encodedcontroller = _lev_ctrl_genpurpose2;
1914                            break;
1915                        case 18:
1916                            encodedcontroller = _lev_ctrl_genpurpose3;
1917                            break;
1918                        case 19:
1919                            encodedcontroller = _lev_ctrl_genpurpose4;
1920                            break;
1921                        case 5:
1922                            encodedcontroller = _lev_ctrl_portamentotime;
1923                            break;
1924                        case 64:
1925                            encodedcontroller = _lev_ctrl_sustainpedal;
1926                            break;
1927                        case 65:
1928                            encodedcontroller = _lev_ctrl_portamento;
1929                            break;
1930                        case 66:
1931                            encodedcontroller = _lev_ctrl_sostenutopedal;
1932                            break;
1933                        case 67:
1934                            encodedcontroller = _lev_ctrl_softpedal;
1935                            break;
1936                        case 80:
1937                            encodedcontroller = _lev_ctrl_genpurpose5;
1938                            break;
1939                        case 81:
1940                            encodedcontroller = _lev_ctrl_genpurpose6;
1941                            break;
1942                        case 82:
1943                            encodedcontroller = _lev_ctrl_genpurpose7;
1944                            break;
1945                        case 83:
1946                            encodedcontroller = _lev_ctrl_genpurpose8;
1947                            break;
1948                        case 91:
1949                            encodedcontroller = _lev_ctrl_effect1depth;
1950                            break;
1951                        case 92:
1952                            encodedcontroller = _lev_ctrl_effect2depth;
1953                            break;
1954                        case 93:
1955                            encodedcontroller = _lev_ctrl_effect3depth;
1956                            break;
1957                        case 94:
1958                            encodedcontroller = _lev_ctrl_effect4depth;
1959                            break;
1960                        case 95:
1961                            encodedcontroller = _lev_ctrl_effect5depth;
1962                            break;
1963                        default:
1964                            throw gig::Exception("leverage controller number is not supported by the gig format");
1965                    }
1966                default:
1967                    throw gig::Exception("Unknown leverage controller type.");
1968            }
1969            return encodedcontroller;
1970        }
1971    
1972      DimensionRegion::~DimensionRegion() {      DimensionRegion::~DimensionRegion() {
1973          Instances--;          Instances--;
1974          if (!Instances) {          if (!Instances) {
# Line 1258  namespace gig { namespace { Line 1982  namespace gig { namespace {
1982              delete pVelocityTables;              delete pVelocityTables;
1983              pVelocityTables = NULL;              pVelocityTables = NULL;
1984          }          }
1985            if (VelocityTable) delete[] VelocityTable;
1986      }      }
1987    
1988      /**      /**
# Line 1275  namespace gig { namespace { Line 2000  namespace gig { namespace {
2000          return pVelocityAttenuationTable[MIDIKeyVelocity];          return pVelocityAttenuationTable[MIDIKeyVelocity];
2001      }      }
2002    
2003        double DimensionRegion::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
2004            return pVelocityReleaseTable[MIDIKeyVelocity];
2005        }
2006    
2007        double DimensionRegion::GetVelocityCutoff(uint8_t MIDIKeyVelocity) {
2008            return pVelocityCutoffTable[MIDIKeyVelocity];
2009        }
2010    
2011      double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {      double* DimensionRegion::CreateVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling) {
2012    
2013          // line-segment approximations of the 15 velocity curves          // line-segment approximations of the 15 velocity curves
# Line 1308  namespace gig { namespace { Line 2041  namespace gig { namespace {
2041          const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,          const int spe4[] = { 1, 4, 23, 5, 49, 13, 57, 17, 92, 57, 122, 127,
2042                               127, 127 };                               127, 127 };
2043    
2044            // this is only used by the VCF velocity curve
2045            const int spe5[] = { 1, 2, 30, 5, 60, 19, 77, 70, 83, 85, 88, 106,
2046                                 91, 127, 127, 127 };
2047    
2048          const int* const curves[] = { non0, non1, non2, non3, non4,          const int* const curves[] = { non0, non1, non2, non3, non4,
2049                                        lin0, lin1, lin2, lin3, lin4,                                        lin0, lin1, lin2, lin3, lin4,
2050                                        spe0, spe1, spe2, spe3, spe4 };                                        spe0, spe1, spe2, spe3, spe4, spe5 };
2051    
2052          double* const table = new double[128];          double* const table = new double[128];
2053    
# Line 1343  namespace gig { namespace { Line 2080  namespace gig { namespace {
2080  // *  // *
2081    
2082      Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {      Region::Region(Instrument* pInstrument, RIFF::List* rgnList) : DLS::Region((DLS::Instrument*) pInstrument, rgnList) {
2083            pInfo->UseFixedLengthStrings = true;
2084    
2085          // Initialization          // Initialization
2086          Dimensions = 0;          Dimensions = 0;
2087          for (int i = 0; i < 256; i++) {          for (int i = 0; i < 256; i++) {
# Line 1362  namespace gig { namespace { Line 2101  namespace gig { namespace {
2101              for (int i = 0; i < dimensionBits; i++) {              for (int i = 0; i < dimensionBits; i++) {
2102                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
2103                  uint8_t     bits      = _3lnk->ReadUint8();                  uint8_t     bits      = _3lnk->ReadUint8();
2104                    _3lnk->ReadUint8(); // probably the position of the dimension
2105                    _3lnk->ReadUint8(); // unknown
2106                    uint8_t     zones     = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)
2107                  if (dimension == dimension_none) { // inactive dimension                  if (dimension == dimension_none) { // inactive dimension
2108                      pDimensionDefinitions[i].dimension  = dimension_none;                      pDimensionDefinitions[i].dimension  = dimension_none;
2109                      pDimensionDefinitions[i].bits       = 0;                      pDimensionDefinitions[i].bits       = 0;
2110                      pDimensionDefinitions[i].zones      = 0;                      pDimensionDefinitions[i].zones      = 0;
2111                      pDimensionDefinitions[i].split_type = split_type_bit;                      pDimensionDefinitions[i].split_type = split_type_bit;
                     pDimensionDefinitions[i].ranges     = NULL;  
2112                      pDimensionDefinitions[i].zone_size  = 0;                      pDimensionDefinitions[i].zone_size  = 0;
2113                  }                  }
2114                  else { // active dimension                  else { // active dimension
2115                      pDimensionDefinitions[i].dimension = dimension;                      pDimensionDefinitions[i].dimension = dimension;
2116                      pDimensionDefinitions[i].bits      = bits;                      pDimensionDefinitions[i].bits      = bits;
2117                      pDimensionDefinitions[i].zones     = 0x01 << bits; // = pow(2,bits)                      pDimensionDefinitions[i].zones     = zones ? zones : 0x01 << bits; // = pow(2,bits)
2118                      pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||                      pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||
2119                                                             dimension == dimension_samplechannel ||                                                             dimension == dimension_samplechannel ||
2120                                                             dimension == dimension_releasetrigger) ? split_type_bit                                                             dimension == dimension_releasetrigger ||
2121                                                                                                    : split_type_normal;                                                             dimension == dimension_keyboard ||
2122                      pDimensionDefinitions[i].ranges = NULL; // it's not possible to check velocity dimensions for custom defined ranges at this point                                                             dimension == dimension_roundrobin ||
2123                                                               dimension == dimension_random ||
2124                                                               dimension == dimension_smartmidi ||
2125                                                               dimension == dimension_roundrobinkeyboard) ? split_type_bit
2126                                                                                                          : split_type_normal;
2127                      pDimensionDefinitions[i].zone_size  =                      pDimensionDefinitions[i].zone_size  =
2128                          (pDimensionDefinitions[i].split_type == split_type_normal) ? 128 / pDimensionDefinitions[i].zones                          (pDimensionDefinitions[i].split_type == split_type_normal) ? 128.0 / pDimensionDefinitions[i].zones
2129                                                                                     : 0;                                                                                     : 0;
2130                      Dimensions++;                      Dimensions++;
2131    
2132                      // if this is a layer dimension, remember the amount of layers                      // if this is a layer dimension, remember the amount of layers
2133                      if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;                      if (dimension == dimension_layer) Layers = pDimensionDefinitions[i].zones;
2134                  }                  }
2135                  _3lnk->SetPos(6, RIFF::stream_curpos); // jump forward to next dimension definition                  _3lnk->SetPos(3, RIFF::stream_curpos); // jump forward to next dimension definition
2136              }              }
2137                for (int i = dimensionBits ; i < 8 ; i++) pDimensionDefinitions[i].bits = 0;
2138    
2139              // check velocity dimension (if there is one) for custom defined zone ranges              // if there's a velocity dimension and custom velocity zone splits are used,
2140              for (uint i = 0; i < Dimensions; i++) {              // update the VelocityTables in the dimension regions
2141                  dimension_def_t* pDimDef = pDimensionDefinitions + i;              UpdateVelocityTable();
                 if (pDimDef->dimension == dimension_velocity) {  
                     if (pDimensionRegions[0]->VelocityUpperLimit == 0) {  
                         // no custom defined ranges  
                         pDimDef->split_type = split_type_normal;  
                         pDimDef->ranges     = NULL;  
                     }  
                     else { // custom defined ranges  
                         pDimDef->split_type = split_type_customvelocity;  
                         pDimDef->ranges     = new range_t[pDimDef->zones];  
                         uint8_t bits[8] = { 0 };  
                         int previousUpperLimit = -1;  
                         for (int velocityZone = 0; velocityZone < pDimDef->zones; velocityZone++) {  
                             bits[i] = velocityZone;  
                             DimensionRegion* pDimRegion = GetDimensionRegionByBit(bits);  
   
                             pDimDef->ranges[velocityZone].low  = previousUpperLimit + 1;  
                             pDimDef->ranges[velocityZone].high = pDimRegion->VelocityUpperLimit;  
                             previousUpperLimit = pDimDef->ranges[velocityZone].high;  
                             // fill velocity table  
                             for (int i = pDimDef->ranges[velocityZone].low; i <= pDimDef->ranges[velocityZone].high; i++) {  
                                 VelocityTable[i] = velocityZone;  
                             }  
                         }  
                     }  
                 }  
             }  
2142    
2143              // jump to start of the wave pool indices (if not already there)              // jump to start of the wave pool indices (if not already there)
             File* file = (File*) GetParent()->GetParent();  
2144              if (file->pVersion && file->pVersion->major == 3)              if (file->pVersion && file->pVersion->major == 3)
2145                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure
2146              else              else
# Line 1430  namespace gig { namespace { Line 2149  namespace gig { namespace {
2149              // load sample references              // load sample references
2150              for (uint i = 0; i < DimensionRegions; i++) {              for (uint i = 0; i < DimensionRegions; i++) {
2151                  uint32_t wavepoolindex = _3lnk->ReadUint32();                  uint32_t wavepoolindex = _3lnk->ReadUint32();
2152                  pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                  if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
2153              }              }
2154                GetSample(); // load global region sample reference
2155            } else {
2156                DimensionRegions = 0;
2157            }
2158    
2159            // make sure there is at least one dimension region
2160            if (!DimensionRegions) {
2161                RIFF::List* _3prg = rgnList->GetSubList(LIST_TYPE_3PRG);
2162                if (!_3prg) _3prg = rgnList->AddSubList(LIST_TYPE_3PRG);
2163                RIFF::List* _3ewl = _3prg->AddSubList(LIST_TYPE_3EWL);
2164                pDimensionRegions[0] = new DimensionRegion(_3ewl);
2165                DimensionRegions = 1;
2166            }
2167        }
2168    
2169        /**
2170         * Apply Region settings and all its DimensionRegions to the respective
2171         * RIFF chunks. You have to call File::Save() to make changes persistent.
2172         *
2173         * Usually there is absolutely no need to call this method explicitly.
2174         * It will be called automatically when File::Save() was called.
2175         *
2176         * @throws gig::Exception if samples cannot be dereferenced
2177         */
2178        void Region::UpdateChunks() {
2179            // in the gig format we don't care about the Region's sample reference
2180            // but we still have to provide some existing one to not corrupt the
2181            // file, so to avoid the latter we simply always assign the sample of
2182            // the first dimension region of this region
2183            pSample = pDimensionRegions[0]->pSample;
2184    
2185            // first update base class's chunks
2186            DLS::Region::UpdateChunks();
2187    
2188            // update dimension region's chunks
2189            for (int i = 0; i < DimensionRegions; i++) {
2190                pDimensionRegions[i]->UpdateChunks();
2191            }
2192    
2193            File* pFile = (File*) GetParent()->GetParent();
2194            const int iMaxDimensions = (pFile->pVersion && pFile->pVersion->major == 3) ? 8 : 5;
2195            const int iMaxDimensionRegions = (pFile->pVersion && pFile->pVersion->major == 3) ? 256 : 32;
2196    
2197            // make sure '3lnk' chunk exists
2198            RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
2199            if (!_3lnk) {
2200                const int _3lnkChunkSize = (pFile->pVersion && pFile->pVersion->major == 3) ? 1092 : 172;
2201                _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
2202            }
2203    
2204            // update dimension definitions in '3lnk' chunk
2205            uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
2206            memcpy(&pData[0], &DimensionRegions, 4);
2207            for (int i = 0; i < iMaxDimensions; i++) {
2208                pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
2209                pData[5 + i * 8] = pDimensionDefinitions[i].bits;
2210                // next 2 bytes unknown
2211                pData[8 + i * 8] = pDimensionDefinitions[i].zones;
2212                // next 3 bytes unknown
2213            }
2214    
2215            // update wave pool table in '3lnk' chunk
2216            const int iWavePoolOffset = (pFile->pVersion && pFile->pVersion->major == 3) ? 68 : 44;
2217            for (uint i = 0; i < iMaxDimensionRegions; i++) {
2218                int iWaveIndex = -1;
2219                if (i < DimensionRegions) {
2220                    if (!pFile->pSamples || !pFile->pSamples->size()) throw gig::Exception("Could not update gig::Region, there are no samples");
2221                    File::SampleList::iterator iter = pFile->pSamples->begin();
2222                    File::SampleList::iterator end  = pFile->pSamples->end();
2223                    for (int index = 0; iter != end; ++iter, ++index) {
2224                        if (*iter == pDimensionRegions[i]->pSample) {
2225                            iWaveIndex = index;
2226                            break;
2227                        }
2228                    }
2229                    if (iWaveIndex < 0) throw gig::Exception("Could not update gig::Region, could not find DimensionRegion's sample");
2230                }
2231                memcpy(&pData[iWavePoolOffset + i * 4], &iWaveIndex, 4);
2232          }          }
         else throw gig::Exception("Mandatory <3lnk> chunk not found.");  
2233      }      }
2234    
2235      void Region::LoadDimensionRegions(RIFF::List* rgn) {      void Region::LoadDimensionRegions(RIFF::List* rgn) {
# Line 1452  namespace gig { namespace { Line 2248  namespace gig { namespace {
2248          }          }
2249      }      }
2250    
2251      Region::~Region() {      void Region::UpdateVelocityTable() {
2252          for (uint i = 0; i < Dimensions; i++) {          // get velocity dimension's index
2253              if (pDimensionDefinitions[i].ranges) delete[] pDimensionDefinitions[i].ranges;          int veldim = -1;
2254            for (int i = 0 ; i < Dimensions ; i++) {
2255                if (pDimensionDefinitions[i].dimension == gig::dimension_velocity) {
2256                    veldim = i;
2257                    break;
2258                }
2259            }
2260            if (veldim == -1) return;
2261    
2262            int step = 1;
2263            for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
2264            int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
2265            int end = step * pDimensionDefinitions[veldim].zones;
2266    
2267            // loop through all dimension regions for all dimensions except the velocity dimension
2268            int dim[8] = { 0 };
2269            for (int i = 0 ; i < DimensionRegions ; i++) {
2270    
2271                if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
2272                    pDimensionRegions[i]->VelocityUpperLimit) {
2273                    // create the velocity table
2274                    uint8_t* table = pDimensionRegions[i]->VelocityTable;
2275                    if (!table) {
2276                        table = new uint8_t[128];
2277                        pDimensionRegions[i]->VelocityTable = table;
2278                    }
2279                    int tableidx = 0;
2280                    int velocityZone = 0;
2281                    if (pDimensionRegions[i]->DimensionUpperLimits[veldim]) { // gig3
2282                        for (int k = i ; k < end ; k += step) {
2283                            DimensionRegion *d = pDimensionRegions[k];
2284                            for (; tableidx <= d->DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
2285                            velocityZone++;
2286                        }
2287                    } else { // gig2
2288                        for (int k = i ; k < end ; k += step) {
2289                            DimensionRegion *d = pDimensionRegions[k];
2290                            for (; tableidx <= d->VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
2291                            velocityZone++;
2292                        }
2293                    }
2294                } else {
2295                    if (pDimensionRegions[i]->VelocityTable) {
2296                        delete[] pDimensionRegions[i]->VelocityTable;
2297                        pDimensionRegions[i]->VelocityTable = 0;
2298                    }
2299                }
2300    
2301                int j;
2302                int shift = 0;
2303                for (j = 0 ; j < Dimensions ; j++) {
2304                    if (j == veldim) i += skipveldim; // skip velocity dimension
2305                    else {
2306                        dim[j]++;
2307                        if (dim[j] < pDimensionDefinitions[j].zones) break;
2308                        else {
2309                            // skip unused dimension regions
2310                            dim[j] = 0;
2311                            i += ((1 << pDimensionDefinitions[j].bits) -
2312                                  pDimensionDefinitions[j].zones) << shift;
2313                        }
2314                    }
2315                    shift += pDimensionDefinitions[j].bits;
2316                }
2317                if (j == Dimensions) break;
2318            }
2319        }
2320    
2321        /** @brief Einstein would have dreamed of it - create a new dimension.
2322         *
2323         * Creates a new dimension with the dimension definition given by
2324         * \a pDimDef. The appropriate amount of DimensionRegions will be created.
2325         * There is a hard limit of dimensions and total amount of "bits" all
2326         * dimensions can have. This limit is dependant to what gig file format
2327         * version this file refers to. The gig v2 (and lower) format has a
2328         * dimension limit and total amount of bits limit of 5, whereas the gig v3
2329         * format has a limit of 8.
2330         *
2331         * @param pDimDef - defintion of the new dimension
2332         * @throws gig::Exception if dimension of the same type exists already
2333         * @throws gig::Exception if amount of dimensions or total amount of
2334         *                        dimension bits limit is violated
2335         */
2336        void Region::AddDimension(dimension_def_t* pDimDef) {
2337            // check if max. amount of dimensions reached
2338            File* file = (File*) GetParent()->GetParent();
2339            const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
2340            if (Dimensions >= iMaxDimensions)
2341                throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");
2342            // check if max. amount of dimension bits reached
2343            int iCurrentBits = 0;
2344            for (int i = 0; i < Dimensions; i++)
2345                iCurrentBits += pDimensionDefinitions[i].bits;
2346            if (iCurrentBits >= iMaxDimensions)
2347                throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimension bits already reached");
2348            const int iNewBits = iCurrentBits + pDimDef->bits;
2349            if (iNewBits > iMaxDimensions)
2350                throw gig::Exception("Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) + " dimension bits");
2351            // check if there's already a dimensions of the same type
2352            for (int i = 0; i < Dimensions; i++)
2353                if (pDimensionDefinitions[i].dimension == pDimDef->dimension)
2354                    throw gig::Exception("Could not add new dimension, there is already a dimension of the same type");
2355    
2356            // assign definition of new dimension
2357            pDimensionDefinitions[Dimensions] = *pDimDef;
2358    
2359            // create new dimension region(s) for this new dimension
2360            for (int i = 1 << iCurrentBits; i < 1 << iNewBits; i++) {
2361                //TODO: maybe we should copy existing dimension regions if possible instead of simply creating new ones with default values
2362                RIFF::List* pNewDimRgnListChunk = pCkRegion->AddSubList(LIST_TYPE_3EWL);
2363                pDimensionRegions[i] = new DimensionRegion(pNewDimRgnListChunk);
2364                DimensionRegions++;
2365            }
2366    
2367            Dimensions++;
2368    
2369            // if this is a layer dimension, update 'Layers' attribute
2370            if (pDimDef->dimension == dimension_layer) Layers = pDimDef->zones;
2371    
2372            UpdateVelocityTable();
2373        }
2374    
2375        /** @brief Delete an existing dimension.
2376         *
2377         * Deletes the dimension given by \a pDimDef and deletes all respective
2378         * dimension regions, that is all dimension regions where the dimension's
2379         * bit(s) part is greater than 0. In case of a 'sustain pedal' dimension
2380         * for example this would delete all dimension regions for the case(s)
2381         * where the sustain pedal is pressed down.
2382         *
2383         * @param pDimDef - dimension to delete
2384         * @throws gig::Exception if given dimension cannot be found
2385         */
2386        void Region::DeleteDimension(dimension_def_t* pDimDef) {
2387            // get dimension's index
2388            int iDimensionNr = -1;
2389            for (int i = 0; i < Dimensions; i++) {
2390                if (&pDimensionDefinitions[i] == pDimDef) {
2391                    iDimensionNr = i;
2392                    break;
2393                }
2394            }
2395            if (iDimensionNr < 0) throw gig::Exception("Invalid dimension_def_t pointer");
2396    
2397            // get amount of bits below the dimension to delete
2398            int iLowerBits = 0;
2399            for (int i = 0; i < iDimensionNr; i++)
2400                iLowerBits += pDimensionDefinitions[i].bits;
2401    
2402            // get amount ot bits above the dimension to delete
2403            int iUpperBits = 0;
2404            for (int i = iDimensionNr + 1; i < Dimensions; i++)
2405                iUpperBits += pDimensionDefinitions[i].bits;
2406    
2407            // delete dimension regions which belong to the given dimension
2408            // (that is where the dimension's bit > 0)
2409            for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
2410                for (int iObsoleteBit = 1; iObsoleteBit < 1 << pDimensionDefinitions[iDimensionNr].bits; iObsoleteBit++) {
2411                    for (int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
2412                        int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
2413                                        iObsoleteBit << iLowerBits |
2414                                        iLowerBit;
2415                        delete pDimensionRegions[iToDelete];
2416                        pDimensionRegions[iToDelete] = NULL;
2417                        DimensionRegions--;
2418                    }
2419                }
2420            }
2421    
2422            // defrag pDimensionRegions array
2423            // (that is remove the NULL spaces within the pDimensionRegions array)
2424            for (int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
2425                if (!pDimensionRegions[iTo]) {
2426                    if (iFrom <= iTo) iFrom = iTo + 1;
2427                    while (!pDimensionRegions[iFrom] && iFrom < 256) iFrom++;
2428                    if (iFrom < 256 && pDimensionRegions[iFrom]) {
2429                        pDimensionRegions[iTo]   = pDimensionRegions[iFrom];
2430                        pDimensionRegions[iFrom] = NULL;
2431                    }
2432                }
2433            }
2434    
2435            // 'remove' dimension definition
2436            for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2437                pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
2438          }          }
2439            pDimensionDefinitions[Dimensions - 1].dimension = dimension_none;
2440            pDimensionDefinitions[Dimensions - 1].bits      = 0;
2441            pDimensionDefinitions[Dimensions - 1].zones     = 0;
2442    
2443            Dimensions--;
2444    
2445            // if this was a layer dimension, update 'Layers' attribute
2446            if (pDimDef->dimension == dimension_layer) Layers = 1;
2447        }
2448    
2449        Region::~Region() {
2450          for (int i = 0; i < 256; i++) {          for (int i = 0; i < 256; i++) {
2451              if (pDimensionRegions[i]) delete pDimensionRegions[i];              if (pDimensionRegions[i]) delete pDimensionRegions[i];
2452          }          }
# Line 1480  namespace gig { namespace { Line 2471  namespace gig { namespace {
2471       * @see             Dimensions       * @see             Dimensions
2472       */       */
2473      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
2474          uint8_t bits[8] = { 0 };          uint8_t bits;
2475            int veldim = -1;
2476            int velbitpos;
2477            int bitpos = 0;
2478            int dimregidx = 0;
2479          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
2480              bits[i] = DimValues[i];              if (pDimensionDefinitions[i].dimension == dimension_velocity) {
2481              switch (pDimensionDefinitions[i].split_type) {                  // the velocity dimension must be handled after the other dimensions
2482                  case split_type_normal:                  veldim = i;
2483                      bits[i] /= pDimensionDefinitions[i].zone_size;                  velbitpos = bitpos;
2484                      break;              } else {
2485                  case split_type_customvelocity:                  switch (pDimensionDefinitions[i].split_type) {
2486                      bits[i] = VelocityTable[bits[i]];                      case split_type_normal:
2487                      break;                          if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
2488                  case split_type_bit: // the value is already the sought dimension bit number                              // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
2489                      const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;                              for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
2490                      bits[i] = bits[i] & limiter_mask; // just make sure the value don't uses more bits than allowed                                  if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
2491                      break;                              }
2492              }                          } else {
2493                                // gig2: evenly sized zones
2494                                bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
2495                            }
2496                            break;
2497                        case split_type_bit: // the value is already the sought dimension bit number
2498                            const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
2499                            bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
2500                            break;
2501                    }
2502                    dimregidx |= bits << bitpos;
2503                }
2504                bitpos += pDimensionDefinitions[i].bits;
2505            }
2506            DimensionRegion* dimreg = pDimensionRegions[dimregidx];
2507            if (veldim != -1) {
2508                // (dimreg is now the dimension region for the lowest velocity)
2509                if (dimreg->VelocityTable) // custom defined zone ranges
2510                    bits = dimreg->VelocityTable[DimValues[veldim]];
2511                else // normal split type
2512                    bits = uint8_t(DimValues[veldim] / pDimensionDefinitions[veldim].zone_size);
2513    
2514                dimregidx |= bits << velbitpos;
2515                dimreg = pDimensionRegions[dimregidx];
2516          }          }
2517          return GetDimensionRegionByBit(bits);          return dimreg;
2518      }      }
2519    
2520      /**      /**
# Line 1533  namespace gig { namespace { Line 2551  namespace gig { namespace {
2551          else         return static_cast<gig::Sample*>(pSample = GetSampleFromWavePool(WavePoolTableIndex));          else         return static_cast<gig::Sample*>(pSample = GetSampleFromWavePool(WavePoolTableIndex));
2552      }      }
2553    
2554      Sample* Region::GetSampleFromWavePool(unsigned int WavePoolTableIndex) {      Sample* Region::GetSampleFromWavePool(unsigned int WavePoolTableIndex, progress_t* pProgress) {
2555          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
2556          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
2557            if (!file->pWavePoolTable) return NULL;
2558          unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];          unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
2559          Sample* sample = file->GetFirstSample();          unsigned long soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
2560            Sample* sample = file->GetFirstSample(pProgress);
2561          while (sample) {          while (sample) {
2562              if (sample->ulWavePoolOffset == soughtoffset) return static_cast<gig::Sample*>(pSample = sample);              if (sample->ulWavePoolOffset == soughtoffset &&
2563                    sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);
2564              sample = file->GetNextSample();              sample = file->GetNextSample();
2565          }          }
2566          return NULL;          return NULL;
# Line 1550  namespace gig { namespace { Line 2571  namespace gig { namespace {
2571  // *************** Instrument ***************  // *************** Instrument ***************
2572  // *  // *
2573    
2574      Instrument::Instrument(File* pFile, RIFF::List* insList) : DLS::Instrument((DLS::File*)pFile, insList) {      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {
2575            pInfo->UseFixedLengthStrings = true;
2576    
2577          // Initialization          // Initialization
2578          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
         RegionIndex = -1;  
2579    
2580          // Loading          // Loading
2581          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
# Line 1569  namespace gig { namespace { Line 2591  namespace gig { namespace {
2591                  DimensionKeyRange.low  = dimkeystart >> 1;                  DimensionKeyRange.low  = dimkeystart >> 1;
2592                  DimensionKeyRange.high = _3ewg->ReadUint8();                  DimensionKeyRange.high = _3ewg->ReadUint8();
2593              }              }
             else throw gig::Exception("Mandatory <3ewg> chunk not found.");  
2594          }          }
         else throw gig::Exception("Mandatory <lart> list chunk not found.");  
2595    
2596            if (!pRegions) pRegions = new RegionList;
2597          RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);          RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
2598          if (!lrgn) throw gig::Exception("Mandatory chunks in <ins > chunk not found.");          if (lrgn) {
2599          pRegions = new Region*[Regions];              RIFF::List* rgn = lrgn->GetFirstSubList();
2600          for (uint i = 0; i < Regions; i++) pRegions[i] = NULL;              while (rgn) {
2601          RIFF::List* rgn = lrgn->GetFirstSubList();                  if (rgn->GetListType() == LIST_TYPE_RGN) {
2602          unsigned int iRegion = 0;                      __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
2603          while (rgn) {                      pRegions->push_back(new Region(this, rgn));
2604              if (rgn->GetListType() == LIST_TYPE_RGN) {                  }
2605                  pRegions[iRegion] = new Region(this, rgn);                  rgn = lrgn->GetNextSubList();
                 iRegion++;  
             }  
             rgn = lrgn->GetNextSubList();  
         }  
   
         // Creating Region Key Table for fast lookup  
         for (uint iReg = 0; iReg < Regions; iReg++) {  
             for (int iKey = pRegions[iReg]->KeyRange.low; iKey <= pRegions[iReg]->KeyRange.high; iKey++) {  
                 RegionKeyTable[iKey] = pRegions[iReg];  
2606              }              }
2607                // Creating Region Key Table for fast lookup
2608                UpdateRegionKeyTable();
2609          }          }
2610    
2611            __notify_progress(pProgress, 1.0f); // notify done
2612      }      }
2613    
2614      Instrument::~Instrument() {      void Instrument::UpdateRegionKeyTable() {
2615          for (uint i = 0; i < Regions; i++) {          RegionList::iterator iter = pRegions->begin();
2616              if (pRegions) {          RegionList::iterator end  = pRegions->end();
2617                  if (pRegions[i]) delete (pRegions[i]);          for (; iter != end; ++iter) {
2618                gig::Region* pRegion = static_cast<gig::Region*>(*iter);
2619                for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {
2620                    RegionKeyTable[iKey] = pRegion;
2621              }              }
2622          }          }
2623          if (pRegions) delete[] pRegions;      }
2624    
2625        Instrument::~Instrument() {
2626        }
2627    
2628        /**
2629         * Apply Instrument with all its Regions to the respective RIFF chunks.
2630         * You have to call File::Save() to make changes persistent.
2631         *
2632         * Usually there is absolutely no need to call this method explicitly.
2633         * It will be called automatically when File::Save() was called.
2634         *
2635         * @throws gig::Exception if samples cannot be dereferenced
2636         */
2637        void Instrument::UpdateChunks() {
2638            // first update base classes' chunks
2639            DLS::Instrument::UpdateChunks();
2640    
2641            // update Regions' chunks
2642            {
2643                RegionList::iterator iter = pRegions->begin();
2644                RegionList::iterator end  = pRegions->end();
2645                for (; iter != end; ++iter)
2646                    (*iter)->UpdateChunks();
2647            }
2648    
2649            // make sure 'lart' RIFF list chunk exists
2650            RIFF::List* lart = pCkInstrument->GetSubList(LIST_TYPE_LART);
2651            if (!lart)  lart = pCkInstrument->AddSubList(LIST_TYPE_LART);
2652            // make sure '3ewg' RIFF chunk exists
2653            RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
2654            if (!_3ewg)  _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, 12);
2655            // update '3ewg' RIFF chunk
2656            uint8_t* pData = (uint8_t*) _3ewg->LoadChunkData();
2657            memcpy(&pData[0], &EffectSend, 2);
2658            memcpy(&pData[2], &Attenuation, 4);
2659            memcpy(&pData[6], &FineTune, 2);
2660            memcpy(&pData[8], &PitchbendRange, 2);
2661            const uint8_t dimkeystart = (PianoReleaseMode) ? 0x01 : 0x00 |
2662                                        DimensionKeyRange.low << 1;
2663            memcpy(&pData[10], &dimkeystart, 1);
2664            memcpy(&pData[11], &DimensionKeyRange.high, 1);
2665      }      }
2666    
2667      /**      /**
# Line 1612  namespace gig { namespace { Line 2672  namespace gig { namespace {
2672       *             there is no Region defined for the given \a Key       *             there is no Region defined for the given \a Key
2673       */       */
2674      Region* Instrument::GetRegion(unsigned int Key) {      Region* Instrument::GetRegion(unsigned int Key) {
2675          if (!pRegions || Key > 127) return NULL;          if (!pRegions || !pRegions->size() || Key > 127) return NULL;
2676          return RegionKeyTable[Key];          return RegionKeyTable[Key];
2677    
2678          /*for (int i = 0; i < Regions; i++) {          /*for (int i = 0; i < Regions; i++) {
2679              if (Key <= pRegions[i]->KeyRange.high &&              if (Key <= pRegions[i]->KeyRange.high &&
2680                  Key >= pRegions[i]->KeyRange.low) return pRegions[i];                  Key >= pRegions[i]->KeyRange.low) return pRegions[i];
# Line 1629  namespace gig { namespace { Line 2690  namespace gig { namespace {
2690       * @see      GetNextRegion()       * @see      GetNextRegion()
2691       */       */
2692      Region* Instrument::GetFirstRegion() {      Region* Instrument::GetFirstRegion() {
2693          if (!Regions) return NULL;          if (!pRegions) return NULL;
2694          RegionIndex = 1;          RegionsIterator = pRegions->begin();
2695          return pRegions[0];          return static_cast<gig::Region*>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
2696      }      }
2697    
2698      /**      /**
# Line 1643  namespace gig { namespace { Line 2704  namespace gig { namespace {
2704       * @see      GetFirstRegion()       * @see      GetFirstRegion()
2705       */       */
2706      Region* Instrument::GetNextRegion() {      Region* Instrument::GetNextRegion() {
2707          if (RegionIndex < 0 || uint32_t(RegionIndex) >= Regions) return NULL;          if (!pRegions) return NULL;
2708          return pRegions[RegionIndex++];          RegionsIterator++;
2709            return static_cast<gig::Region*>( (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL );
2710        }
2711    
2712        Region* Instrument::AddRegion() {
2713            // create new Region object (and its RIFF chunks)
2714            RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
2715            if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
2716            RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
2717            Region* pNewRegion = new Region(this, rgn);
2718            pRegions->push_back(pNewRegion);
2719            Regions = pRegions->size();
2720            // update Region key table for fast lookup
2721            UpdateRegionKeyTable();
2722            // done
2723            return pNewRegion;
2724        }
2725    
2726        void Instrument::DeleteRegion(Region* pRegion) {
2727            if (!pRegions) return;
2728            DLS::Instrument::DeleteRegion((DLS::Region*) pRegion);
2729            // update Region key table for fast lookup
2730            UpdateRegionKeyTable();
2731        }
2732    
2733    
2734    
2735    // *************** Group ***************
2736    // *
2737    
2738        /** @brief Constructor.
2739         *
2740         * @param file   - pointer to the gig::File object
2741         * @param ck3gnm - pointer to 3gnm chunk associated with this group or
2742         *                 NULL if this is a new Group
2743         */
2744        Group::Group(File* file, RIFF::Chunk* ck3gnm) {
2745            pFile      = file;
2746            pNameChunk = ck3gnm;
2747            ::LoadString(pNameChunk, Name);
2748        }
2749    
2750        Group::~Group() {
2751            // remove the chunk associated with this group (if any)
2752            if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
2753        }
2754    
2755        /** @brief Update chunks with current group settings.
2756         *
2757         * Apply current Group field values to the respective chunks. You have
2758         * to call File::Save() to make changes persistent.
2759         *
2760         * Usually there is absolutely no need to call this method explicitly.
2761         * It will be called automatically when File::Save() was called.
2762         */
2763        void Group::UpdateChunks() {
2764            // make sure <3gri> and <3gnl> list chunks exist
2765            RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
2766            if (!_3gri) _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);
2767            RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
2768            if (!_3gnl) _3gnl = pFile->pRIFF->AddSubList(LIST_TYPE_3GNL);
2769            // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
2770            ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
2771        }
2772    
2773        /**
2774         * Returns the first Sample of this Group. You have to call this method
2775         * once before you use GetNextSample().
2776         *
2777         * <b>Notice:</b> this method might block for a long time, in case the
2778         * samples of this .gig file were not scanned yet
2779         *
2780         * @returns  pointer address to first Sample or NULL if there is none
2781         *           applied to this Group
2782         * @see      GetNextSample()
2783         */
2784        Sample* Group::GetFirstSample() {
2785            // FIXME: lazy und unsafe implementation, should be an autonomous iterator
2786            for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
2787                if (pSample->GetGroup() == this) return pSample;
2788            }
2789            return NULL;
2790        }
2791    
2792        /**
2793         * Returns the next Sample of the Group. You have to call
2794         * GetFirstSample() once before you can use this method. By calling this
2795         * method multiple times it iterates through the Samples assigned to
2796         * this Group.
2797         *
2798         * @returns  pointer address to the next Sample of this Group or NULL if
2799         *           end reached
2800         * @see      GetFirstSample()
2801         */
2802        Sample* Group::GetNextSample() {
2803            // FIXME: lazy und unsafe implementation, should be an autonomous iterator
2804            for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
2805                if (pSample->GetGroup() == this) return pSample;
2806            }
2807            return NULL;
2808        }
2809    
2810        /**
2811         * Move Sample given by \a pSample from another Group to this Group.
2812         */
2813        void Group::AddSample(Sample* pSample) {
2814            pSample->pGroup = this;
2815        }
2816    
2817        /**
2818         * Move all members of this group to another group (preferably the 1st
2819         * one except this). This method is called explicitly by
2820         * File::DeleteGroup() thus when a Group was deleted. This code was
2821         * intentionally not placed in the destructor!
2822         */
2823        void Group::MoveAll() {
2824            // get "that" other group first
2825            Group* pOtherGroup = NULL;
2826            for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
2827                if (pOtherGroup != this) break;
2828            }
2829            if (!pOtherGroup) throw Exception(
2830                "Could not move samples to another group, since there is no "
2831                "other Group. This is a bug, report it!"
2832            );
2833            // now move all samples of this group to the other group
2834            for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
2835                pOtherGroup->AddSample(pSample);
2836            }
2837      }      }
2838    
2839    
# Line 1652  namespace gig { namespace { Line 2841  namespace gig { namespace {
2841  // *************** File ***************  // *************** File ***************
2842  // *  // *
2843    
2844        File::File() : DLS::File() {
2845            pGroups = NULL;
2846            pInfo->UseFixedLengthStrings = true;
2847        }
2848    
2849      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
2850          pSamples     = NULL;          pGroups = NULL;
2851          pInstruments = NULL;          pInfo->UseFixedLengthStrings = true;
2852      }      }
2853    
2854      File::~File() {      File::~File() {
2855          // free samples          if (pGroups) {
2856          if (pSamples) {              std::list<Group*>::iterator iter = pGroups->begin();
2857              SamplesIterator = pSamples->begin();              std::list<Group*>::iterator end  = pGroups->end();
2858              while (SamplesIterator != pSamples->end() ) {              while (iter != end) {
2859                  delete (*SamplesIterator);                  delete *iter;
2860                  SamplesIterator++;                  ++iter;
             }  
             pSamples->clear();  
             delete pSamples;  
   
         }  
         // free instruments  
         if (pInstruments) {  
             InstrumentsIterator = pInstruments->begin();  
             while (InstrumentsIterator != pInstruments->end() ) {  
                 delete (*InstrumentsIterator);  
                 InstrumentsIterator++;  
2861              }              }
2862              pInstruments->clear();              delete pGroups;
             delete pInstruments;  
2863          }          }
2864      }      }
2865    
2866      Sample* File::GetFirstSample() {      Sample* File::GetFirstSample(progress_t* pProgress) {
2867          if (!pSamples) LoadSamples();          if (!pSamples) LoadSamples(pProgress);
2868          if (!pSamples) return NULL;          if (!pSamples) return NULL;
2869          SamplesIterator = pSamples->begin();          SamplesIterator = pSamples->begin();
2870          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
# Line 1694  namespace gig { namespace { Line 2876  namespace gig { namespace {
2876          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
2877      }      }
2878    
2879        /** @brief Add a new sample.
2880         *
2881         * This will create a new Sample object for the gig file. You have to
2882         * call Save() to make this persistent to the file.
2883         *
2884         * @returns pointer to new Sample object
2885         */
2886        Sample* File::AddSample() {
2887           if (!pSamples) LoadSamples();
2888           __ensureMandatoryChunksExist();
2889           RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
2890           // create new Sample object and its respective 'wave' list chunk
2891           RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);
2892           Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);
2893           pSamples->push_back(pSample);
2894           return pSample;
2895        }
2896    
2897        /** @brief Delete a sample.
2898         *
2899         * This will delete the given Sample object from the gig file. You have
2900         * to call Save() to make this persistent to the file.
2901         *
2902         * @param pSample - sample to delete
2903         * @throws gig::Exception if given sample could not be found
2904         */
2905        void File::DeleteSample(Sample* pSample) {
2906            if (!pSamples || !pSamples->size()) throw gig::Exception("Could not delete sample as there are no samples");
2907            SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (DLS::Sample*) pSample);
2908            if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");
2909            if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
2910            pSamples->erase(iter);
2911            delete pSample;
2912        }
2913    
2914      void File::LoadSamples() {      void File::LoadSamples() {
2915          RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);          LoadSamples(NULL);
2916          if (wvpl) {      }
2917              unsigned long wvplFileOffset = wvpl->GetFilePos();  
2918              RIFF::List* wave = wvpl->GetFirstSubList();      void File::LoadSamples(progress_t* pProgress) {
2919              while (wave) {          // Groups must be loaded before samples, because samples will try
2920                  if (wave->GetListType() == LIST_TYPE_WAVE) {          // to resolve the group they belong to
2921                      if (!pSamples) pSamples = new SampleList;          LoadGroups();
2922                      unsigned long waveFileOffset = wave->GetFilePos();  
2923                      pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset));          if (!pSamples) pSamples = new SampleList;
2924    
2925            RIFF::File* file = pRIFF;
2926    
2927            // just for progress calculation
2928            int iSampleIndex  = 0;
2929            int iTotalSamples = WavePoolCount;
2930    
2931            // check if samples should be loaded from extension files
2932            int lastFileNo = 0;
2933            for (int i = 0 ; i < WavePoolCount ; i++) {
2934                if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
2935            }
2936            String name(pRIFF->GetFileName());
2937            int nameLen = name.length();
2938            char suffix[6];
2939            if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
2940    
2941            for (int fileNo = 0 ; ; ) {
2942                RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
2943                if (wvpl) {
2944                    unsigned long wvplFileOffset = wvpl->GetFilePos();
2945                    RIFF::List* wave = wvpl->GetFirstSubList();
2946                    while (wave) {
2947                        if (wave->GetListType() == LIST_TYPE_WAVE) {
2948                            // notify current progress
2949                            const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
2950                            __notify_progress(pProgress, subprogress);
2951    
2952                            unsigned long waveFileOffset = wave->GetFilePos();
2953                            pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));
2954    
2955                            iSampleIndex++;
2956                        }
2957                        wave = wvpl->GetNextSubList();
2958                  }                  }
2959                  wave = wvpl->GetNextSubList();  
2960              }                  if (fileNo == lastFileNo) break;
2961    
2962                    // open extension file (*.gx01, *.gx02, ...)
2963                    fileNo++;
2964                    sprintf(suffix, ".gx%02d", fileNo);
2965                    name.replace(nameLen, 5, suffix);
2966                    file = new RIFF::File(name);
2967                    ExtensionFiles.push_back(file);
2968                } else break;
2969          }          }
2970          else throw gig::Exception("Mandatory <wvpl> chunk not found.");  
2971            __notify_progress(pProgress, 1.0); // notify done
2972      }      }
2973    
2974      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
2975          if (!pInstruments) LoadInstruments();          if (!pInstruments) LoadInstruments();
2976          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
2977          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
2978          return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
2979      }      }
2980    
2981      Instrument* File::GetNextInstrument() {      Instrument* File::GetNextInstrument() {
2982          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
2983          InstrumentsIterator++;          InstrumentsIterator++;
2984          return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
2985      }      }
2986    
2987      /**      /**
2988       * Returns the instrument with the given index.       * Returns the instrument with the given index.
2989       *       *
2990         * @param index     - number of the sought instrument (0..n)
2991         * @param pProgress - optional: callback function for progress notification
2992       * @returns  sought instrument or NULL if there's no such instrument       * @returns  sought instrument or NULL if there's no such instrument
2993       */       */
2994      Instrument* File::GetInstrument(uint index) {      Instrument* File::GetInstrument(uint index, progress_t* pProgress) {
2995          if (!pInstruments) LoadInstruments();          if (!pInstruments) {
2996                // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)
2997    
2998                // sample loading subtask
2999                progress_t subprogress;
3000                __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
3001                __notify_progress(&subprogress, 0.0f);
3002                GetFirstSample(&subprogress); // now force all samples to be loaded
3003                __notify_progress(&subprogress, 1.0f);
3004    
3005                // instrument loading subtask
3006                if (pProgress && pProgress->callback) {
3007                    subprogress.__range_min = subprogress.__range_max;
3008                    subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
3009                }
3010                __notify_progress(&subprogress, 0.0f);
3011                LoadInstruments(&subprogress);
3012                __notify_progress(&subprogress, 1.0f);
3013            }
3014          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
3015          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
3016          for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {          for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {
3017              if (i == index) return *InstrumentsIterator;              if (i == index) return static_cast<gig::Instrument*>( *InstrumentsIterator );
3018              InstrumentsIterator++;              InstrumentsIterator++;
3019          }          }
3020          return NULL;          return NULL;
3021      }      }
3022    
3023        /** @brief Add a new instrument definition.
3024         *
3025         * This will create a new Instrument object for the gig file. You have
3026         * to call Save() to make this persistent to the file.
3027         *
3028         * @returns pointer to new Instrument object
3029         */
3030        Instrument* File::AddInstrument() {
3031           if (!pInstruments) LoadInstruments();
3032           __ensureMandatoryChunksExist();
3033           RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
3034           RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);
3035           Instrument* pInstrument = new Instrument(this, lstInstr);
3036           pInstruments->push_back(pInstrument);
3037           return pInstrument;
3038        }
3039    
3040        /** @brief Delete an instrument.
3041         *
3042         * This will delete the given Instrument object from the gig file. You
3043         * have to call Save() to make this persistent to the file.
3044         *
3045         * @param pInstrument - instrument to delete
3046         * @throws gig::Exception if given instrument could not be found
3047         */
3048        void File::DeleteInstrument(Instrument* pInstrument) {
3049            if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");
3050            InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
3051            if (iter == pInstruments->end()) throw gig::Exception("Could not delete instrument, could not find given instrument");
3052            pInstruments->erase(iter);
3053            delete pInstrument;
3054        }
3055    
3056      void File::LoadInstruments() {      void File::LoadInstruments() {
3057            LoadInstruments(NULL);
3058        }
3059    
3060        void File::LoadInstruments(progress_t* pProgress) {
3061            if (!pInstruments) pInstruments = new InstrumentList;
3062          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
3063          if (lstInstruments) {          if (lstInstruments) {
3064                int iInstrumentIndex = 0;
3065              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
3066              while (lstInstr) {              while (lstInstr) {
3067                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
3068                      if (!pInstruments) pInstruments = new InstrumentList;                      // notify current progress
3069                      pInstruments->push_back(new Instrument(this, lstInstr));                      const float localProgress = (float) iInstrumentIndex / (float) Instruments;
3070                        __notify_progress(pProgress, localProgress);
3071    
3072                        // divide local progress into subprogress for loading current Instrument
3073                        progress_t subprogress;
3074                        __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
3075    
3076                        pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
3077    
3078                        iInstrumentIndex++;
3079                  }                  }
3080                  lstInstr = lstInstruments->GetNextSubList();                  lstInstr = lstInstruments->GetNextSubList();
3081              }              }
3082                __notify_progress(pProgress, 1.0); // notify done
3083            }
3084        }
3085    
3086        Group* File::GetFirstGroup() {
3087            if (!pGroups) LoadGroups();
3088            // there must always be at least one group
3089            GroupsIterator = pGroups->begin();
3090            return *GroupsIterator;
3091        }
3092    
3093        Group* File::GetNextGroup() {
3094            if (!pGroups) return NULL;
3095            ++GroupsIterator;
3096            return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
3097        }
3098    
3099        /**
3100         * Returns the group with the given index.
3101         *
3102         * @param index - number of the sought group (0..n)
3103         * @returns sought group or NULL if there's no such group
3104         */
3105        Group* File::GetGroup(uint index) {
3106            if (!pGroups) LoadGroups();
3107            GroupsIterator = pGroups->begin();
3108            for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
3109                if (i == index) return *GroupsIterator;
3110                ++GroupsIterator;
3111            }
3112            return NULL;
3113        }
3114    
3115        Group* File::AddGroup() {
3116            if (!pGroups) LoadGroups();
3117            // there must always be at least one group
3118            __ensureMandatoryChunksExist();
3119            Group* pGroup = new Group(this, NULL);
3120            pGroups->push_back(pGroup);
3121            return pGroup;
3122        }
3123    
3124        /** @brief Delete a group and its samples.
3125         *
3126         * This will delete the given Group object and all the samples that
3127         * belong to this group from the gig file. You have to call Save() to
3128         * make this persistent to the file.
3129         *
3130         * @param pGroup - group to delete
3131         * @throws gig::Exception if given group could not be found
3132         */
3133        void File::DeleteGroup(Group* pGroup) {
3134            if (!pGroups) LoadGroups();
3135            std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
3136            if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
3137            if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
3138            // delete all members of this group
3139            for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {
3140                DeleteSample(pSample);
3141            }
3142            // now delete this group object
3143            pGroups->erase(iter);
3144            delete pGroup;
3145        }
3146    
3147        /** @brief Delete a group.
3148         *
3149         * This will delete the given Group object from the gig file. All the
3150         * samples that belong to this group will not be deleted, but instead
3151         * be moved to another group. You have to call Save() to make this
3152         * persistent to the file.
3153         *
3154         * @param pGroup - group to delete
3155         * @throws gig::Exception if given group could not be found
3156         */
3157        void File::DeleteGroupOnly(Group* pGroup) {
3158            if (!pGroups) LoadGroups();
3159            std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
3160            if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
3161            if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
3162            // move all members of this group to another group
3163            pGroup->MoveAll();
3164            pGroups->erase(iter);
3165            delete pGroup;
3166        }
3167    
3168        void File::LoadGroups() {
3169            if (!pGroups) pGroups = new std::list<Group*>;
3170            // try to read defined groups from file
3171            RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
3172            if (lst3gri) {
3173                RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
3174                if (lst3gnl) {
3175                    RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
3176                    while (ck) {
3177                        if (ck->GetChunkID() == CHUNK_ID_3GNM) {
3178                            pGroups->push_back(new Group(this, ck));
3179                        }
3180                        ck = lst3gnl->GetNextSubChunk();
3181                    }
3182                }
3183            }
3184            // if there were no group(s), create at least the mandatory default group
3185            if (!pGroups->size()) {
3186                Group* pGroup = new Group(this, NULL);
3187                pGroup->Name = "Default Group";
3188                pGroups->push_back(pGroup);
3189            }
3190        }
3191    
3192        /**
3193         * Apply all the gig file's current instruments, samples, groups and settings
3194         * to the respective RIFF chunks. You have to call Save() to make changes
3195         * persistent.
3196         *
3197         * Usually there is absolutely no need to call this method explicitly.
3198         * It will be called automatically when File::Save() was called.
3199         *
3200         * @throws Exception - on errors
3201         */
3202        void File::UpdateChunks() {
3203            // first update base class's chunks
3204            DLS::File::UpdateChunks();
3205    
3206            // update group's chunks
3207            if (pGroups) {
3208                std::list<Group*>::iterator iter = pGroups->begin();
3209                std::list<Group*>::iterator end  = pGroups->end();
3210                for (; iter != end; ++iter) {
3211                    (*iter)->UpdateChunks();
3212                }
3213          }          }
         else throw gig::Exception("Mandatory <lins> list chunk not found.");  
3214      }      }
3215    
3216    
# Line 1767  namespace gig { namespace { Line 3225  namespace gig { namespace {
3225          std::cout << "gig::Exception: " << Message << std::endl;          std::cout << "gig::Exception: " << Message << std::endl;
3226      }      }
3227    
3228    
3229    // *************** functions ***************
3230    // *
3231    
3232        /**
3233         * Returns the name of this C++ library. This is usually "libgig" of
3234         * course. This call is equivalent to RIFF::libraryName() and
3235         * DLS::libraryName().
3236         */
3237        String libraryName() {
3238            return PACKAGE;
3239        }
3240    
3241        /**
3242         * Returns version of this C++ library. This call is equivalent to
3243         * RIFF::libraryVersion() and DLS::libraryVersion().
3244         */
3245        String libraryVersion() {
3246            return VERSION;
3247        }
3248    
3249  } // namespace gig  } // namespace gig

Legend:
Removed from v.384  
changed lines
  Added in v.1106

  ViewVC Help
Powered by ViewVC