/[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 780 by schoenebeck, Sun Sep 25 13:40:37 2005 UTC revision 809 by schoenebeck, Tue Nov 22 11:26:55 2005 UTC
# 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    /// 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 {  namespace gig {
53    
54    // *************** dimension_def_t ***************
55    // *
56    
57        dimension_def_t& dimension_def_t::operator=(const dimension_def_t& arg) {
58            dimension  = arg.dimension;
59            bits       = arg.bits;
60            zones      = arg.zones;
61            split_type = arg.split_type;
62            ranges     = arg.ranges;
63            zone_size  = arg.zone_size;
64            if (ranges) {
65                ranges = new range_t[zones];
66                for (int i = 0; i < zones; i++)
67                    ranges[i] = arg.ranges[i];
68            }
69            return *this;
70        }
71    
72    
73    
74  // *************** progress_t ***************  // *************** progress_t ***************
75  // *  // *
76    
# Line 59  namespace gig { Line 103  namespace gig {
103      }      }
104    
105    
106  // *************** Internal functions for sample decopmression ***************  // *************** Internal functions for sample decompression ***************
107  // *  // *
108    
109  namespace {  namespace {
# Line 232  namespace { Line 276  namespace {
276      unsigned int Sample::Instances = 0;      unsigned int Sample::Instances = 0;
277      buffer_t     Sample::InternalDecompressionBuffer;      buffer_t     Sample::InternalDecompressionBuffer;
278    
279        /** @brief Constructor.
280         *
281         * Load an existing sample or create a new one. A 'wave' list chunk must
282         * be given to this constructor. In case the given 'wave' list chunk
283         * contains a 'fmt', 'data' (and optionally a '3gix', 'smpl') chunk, the
284         * format and sample data will be loaded from there, otherwise default
285         * values will be used and those chunks will be created when
286         * File::Save() will be called later on.
287         *
288         * @param pFile          - pointer to gig::File where this sample is
289         *                         located (or will be located)
290         * @param waveList       - pointer to 'wave' list chunk which is (or
291         *                         will be) associated with this sample
292         * @param WavePoolOffset - offset of this sample data from wave pool
293         *                         ('wvpl') list chunk
294         * @param fileNo         - number of an extension file where this sample
295         *                         is located, 0 otherwise
296         */
297      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
298          Instances++;          Instances++;
299          FileNo = fileNo;          FileNo = fileNo;
300    
301          RIFF::Chunk* _3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
302          if (!_3gix) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");          if (pCk3gix) {
303          SampleGroup = _3gix->ReadInt16();              SampleGroup = pCk3gix->ReadInt16();
304            } else { // '3gix' chunk missing
305          RIFF::Chunk* smpl = waveList->GetSubChunk(CHUNK_ID_SMPL);              // use default value(s)
306          if (!smpl) throw gig::Exception("Mandatory chunks in <wave> list chunk not found.");              SampleGroup = 0;
307          Manufacturer      = smpl->ReadInt32();          }
308          Product           = smpl->ReadInt32();  
309          SamplePeriod      = smpl->ReadInt32();          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
310          MIDIUnityNote     = smpl->ReadInt32();          if (pCkSmpl) {
311          FineTune          = smpl->ReadInt32();              Manufacturer  = pCkSmpl->ReadInt32();
312          smpl->Read(&SMPTEFormat, 1, 4);              Product       = pCkSmpl->ReadInt32();
313          SMPTEOffset       = smpl->ReadInt32();              SamplePeriod  = pCkSmpl->ReadInt32();
314          Loops             = smpl->ReadInt32();              MIDIUnityNote = pCkSmpl->ReadInt32();
315          smpl->ReadInt32(); // manufByt              FineTune      = pCkSmpl->ReadInt32();
316          LoopID            = smpl->ReadInt32();              pCkSmpl->Read(&SMPTEFormat, 1, 4);
317          smpl->Read(&LoopType, 1, 4);              SMPTEOffset   = pCkSmpl->ReadInt32();
318          LoopStart         = smpl->ReadInt32();              Loops         = pCkSmpl->ReadInt32();
319          LoopEnd           = smpl->ReadInt32();              pCkSmpl->ReadInt32(); // manufByt
320          LoopFraction      = smpl->ReadInt32();              LoopID        = pCkSmpl->ReadInt32();
321          LoopPlayCount     = smpl->ReadInt32();              pCkSmpl->Read(&LoopType, 1, 4);
322                LoopStart     = pCkSmpl->ReadInt32();
323                LoopEnd       = pCkSmpl->ReadInt32();
324                LoopFraction  = pCkSmpl->ReadInt32();
325                LoopPlayCount = pCkSmpl->ReadInt32();
326            } else { // 'smpl' chunk missing
327                // use default values
328                Manufacturer  = 0;
329                Product       = 0;
330                SamplePeriod  = 1 / SamplesPerSecond;
331                MIDIUnityNote = 64;
332                FineTune      = 0;
333                SMPTEOffset   = 0;
334                Loops         = 0;
335                LoopID        = 0;
336                LoopStart     = 0;
337                LoopEnd       = 0;
338                LoopFraction  = 0;
339                LoopPlayCount = 0;
340            }
341    
342          FrameTable                 = NULL;          FrameTable                 = NULL;
343          SamplePos                  = 0;          SamplePos                  = 0;
# Line 290  namespace { Line 371  namespace {
371          LoopSize = LoopEnd - LoopStart;          LoopSize = LoopEnd - LoopStart;
372      }      }
373    
374        /**
375         * Apply sample and its settings to the respective RIFF chunks. You have
376         * to call File::Save() to make changes persistent.
377         *
378         * Usually there is absolutely no need to call this method explicitly.
379         * It will be called automatically when File::Save() was called.
380         *
381         * @throws DLS::Exception if FormatTag != WAVE_FORMAT_PCM or no sample data
382         *                        was provided yet
383         * @throws gig::Exception if there is any invalid sample setting
384         */
385        void Sample::UpdateChunks() {
386            // first update base class's chunks
387            DLS::Sample::UpdateChunks();
388    
389            // make sure 'smpl' chunk exists
390            pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
391            if (!pCkSmpl) pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);
392            // update 'smpl' chunk
393            uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();
394            SamplePeriod = 1 / SamplesPerSecond;
395            memcpy(&pData[0], &Manufacturer, 4);
396            memcpy(&pData[4], &Product, 4);
397            memcpy(&pData[8], &SamplePeriod, 4);
398            memcpy(&pData[12], &MIDIUnityNote, 4);
399            memcpy(&pData[16], &FineTune, 4);
400            memcpy(&pData[20], &SMPTEFormat, 4);
401            memcpy(&pData[24], &SMPTEOffset, 4);
402            memcpy(&pData[28], &Loops, 4);
403    
404            // we skip 'manufByt' for now (4 bytes)
405    
406            memcpy(&pData[36], &LoopID, 4);
407            memcpy(&pData[40], &LoopType, 4);
408            memcpy(&pData[44], &LoopStart, 4);
409            memcpy(&pData[48], &LoopEnd, 4);
410            memcpy(&pData[52], &LoopFraction, 4);
411            memcpy(&pData[56], &LoopPlayCount, 4);
412    
413            // make sure '3gix' chunk exists
414            pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
415            if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
416            // update '3gix' chunk
417            pData = (uint8_t*) pCk3gix->LoadChunkData();
418            memcpy(&pData[0], &SampleGroup, 2);
419        }
420    
421      /// 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).
422      void Sample::ScanCompressedSample() {      void Sample::ScanCompressedSample() {
423          //TODO: we have to add some more scans here (e.g. determine compression rate)          //TODO: we have to add some more scans here (e.g. determine compression rate)
# Line 490  namespace { Line 618  namespace {
618          RAMCache.Size   = 0;          RAMCache.Size   = 0;
619      }      }
620    
621        /** @brief Resize sample.
622         *
623         * Resizes the sample's wave form data, that is the actual size of
624         * sample wave data possible to be written for this sample. This call
625         * will return immediately and just schedule the resize operation. You
626         * should call File::Save() to actually perform the resize operation(s)
627         * "physically" to the file. As this can take a while on large files, it
628         * is recommended to call Resize() first on all samples which have to be
629         * resized and finally to call File::Save() to perform all those resize
630         * operations in one rush.
631         *
632         * The actual size (in bytes) is dependant to the current FrameSize
633         * value. You may want to set FrameSize before calling Resize().
634         *
635         * <b>Caution:</b> You cannot directly write (i.e. with Write()) to
636         * enlarged samples before calling File::Save() as this might exceed the
637         * current sample's boundary!
638         *
639         * Also note: only WAVE_FORMAT_PCM is currently supported, that is
640         * FormatTag must be WAVE_FORMAT_PCM. Trying to resize samples with
641         * other formats will fail!
642         *
643         * @param iNewSize - new sample wave data size in sample points (must be
644         *                   greater than zero)
645         * @throws DLS::Excecption if FormatTag != WAVE_FORMAT_PCM
646         *                         or if \a iNewSize is less than 1
647         * @throws gig::Exception if existing sample is compressed
648         * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
649         *      DLS::Sample::FormatTag, File::Save()
650         */
651        void Sample::Resize(int iNewSize) {
652            if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
653            DLS::Sample::Resize(iNewSize);
654        }
655    
656      /**      /**
657       * Sets the position within the sample (in sample points, not in       * Sets the position within the sample (in sample points, not in
658       * 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 933  namespace { Line 1096  namespace {
1096          }          }
1097      }      }
1098    
1099        /** @brief Write sample wave data.
1100         *
1101         * Writes \a SampleCount number of sample points from the buffer pointed
1102         * by \a pBuffer and increments the position within the sample. Use this
1103         * method to directly write the sample data to disk, i.e. if you don't
1104         * want or cannot load the whole sample data into RAM.
1105         *
1106         * You have to Resize() the sample to the desired size and call
1107         * File::Save() <b>before</b> using Write().
1108         *
1109         * Note: there is currently no support for writing compressed samples.
1110         *
1111         * @param pBuffer     - source buffer
1112         * @param SampleCount - number of sample points to write
1113         * @throws DLS::Exception if current sample size is too small
1114         * @throws gig::Exception if sample is compressed
1115         * @see DLS::LoadSampleData()
1116         */
1117        unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {
1118            if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1119            return DLS::Sample::Write(pBuffer, SampleCount);
1120        }
1121    
1122      /**      /**
1123       * Allocates a decompression buffer for streaming (compressed) samples       * Allocates a decompression buffer for streaming (compressed) samples
1124       * 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 1001  namespace { Line 1187  namespace {
1187          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1188    
1189          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
1190          _3ewa->ReadInt32(); // unknown, always 0x0000008C ?          if (_3ewa) { // if '3ewa' chunk exists
1191          LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              _3ewa->ReadInt32(); // unknown, always 0x0000008C ?
1192          EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1193          _3ewa->ReadInt16(); // unknown              EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1194          LFO1InternalDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1195          _3ewa->ReadInt16(); // unknown              LFO1InternalDepth = _3ewa->ReadUint16();
1196          LFO3InternalDepth = _3ewa->ReadInt16();              _3ewa->ReadInt16(); // unknown
1197          _3ewa->ReadInt16(); // unknown              LFO3InternalDepth = _3ewa->ReadInt16();
1198          LFO1ControlDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1199          _3ewa->ReadInt16(); // unknown              LFO1ControlDepth = _3ewa->ReadUint16();
1200          LFO3ControlDepth = _3ewa->ReadInt16();              _3ewa->ReadInt16(); // unknown
1201          EG1Attack           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO3ControlDepth = _3ewa->ReadInt16();
1202          EG1Decay1           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG1Attack           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1203          _3ewa->ReadInt16(); // unknown              EG1Decay1           = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1204          EG1Sustain          = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1205          EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG1Sustain          = _3ewa->ReadUint16();
1206          EG1Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));              EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1207          uint8_t eg1ctrloptions        = _3ewa->ReadUint8();              EG1Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1208          EG1ControllerInvert           = eg1ctrloptions & 0x01;              uint8_t eg1ctrloptions        = _3ewa->ReadUint8();
1209          EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerInvert           = eg1ctrloptions & 0x01;
1210          EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
1211          EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);              EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
1212          EG2Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));              EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
1213          uint8_t eg2ctrloptions        = _3ewa->ReadUint8();              EG2Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1214          EG2ControllerInvert           = eg2ctrloptions & 0x01;              uint8_t eg2ctrloptions        = _3ewa->ReadUint8();
1215          EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerInvert           = eg2ctrloptions & 0x01;
1216          EG2ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
1217          EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);              EG2ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg2ctrloptions);
1218          LFO1Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg2ctrloptions);
1219          EG2Attack        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO1Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1220          EG2Decay1        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2Attack        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1221          _3ewa->ReadInt16(); // unknown              EG2Decay1        = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1222          EG2Sustain       = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1223          EG2Release       = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG2Sustain       = _3ewa->ReadUint16();
1224          _3ewa->ReadInt16(); // unknown              EG2Release       = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1225          LFO2ControlDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1226          LFO2Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO2ControlDepth = _3ewa->ReadUint16();
1227          _3ewa->ReadInt16(); // unknown              LFO2Frequency    = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1228          LFO2InternalDepth = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1229          int32_t eg1decay2 = _3ewa->ReadInt32();              LFO2InternalDepth = _3ewa->ReadUint16();
1230          EG1Decay2          = (double) GIG_EXP_DECODE(eg1decay2);              int32_t eg1decay2 = _3ewa->ReadInt32();
1231          EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);              EG1Decay2          = (double) GIG_EXP_DECODE(eg1decay2);
1232          _3ewa->ReadInt16(); // unknown              EG1InfiniteSustain = (eg1decay2 == 0x7fffffff);
1233          EG1PreAttack      = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1234          int32_t eg2decay2 = _3ewa->ReadInt32();              EG1PreAttack      = _3ewa->ReadUint16();
1235          EG2Decay2         = (double) GIG_EXP_DECODE(eg2decay2);              int32_t eg2decay2 = _3ewa->ReadInt32();
1236          EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);              EG2Decay2         = (double) GIG_EXP_DECODE(eg2decay2);
1237          _3ewa->ReadInt16(); // unknown              EG2InfiniteSustain = (eg2decay2 == 0x7fffffff);
1238          EG2PreAttack      = _3ewa->ReadUint16();              _3ewa->ReadInt16(); // unknown
1239          uint8_t velocityresponse = _3ewa->ReadUint8();              EG2PreAttack      = _3ewa->ReadUint16();
1240          if (velocityresponse < 5) {              uint8_t velocityresponse = _3ewa->ReadUint8();
1241              VelocityResponseCurve = curve_type_nonlinear;              if (velocityresponse < 5) {
1242              VelocityResponseDepth = velocityresponse;                  VelocityResponseCurve = curve_type_nonlinear;
1243          }                  VelocityResponseDepth = velocityresponse;
1244          else if (velocityresponse < 10) {              } else if (velocityresponse < 10) {
1245              VelocityResponseCurve = curve_type_linear;                  VelocityResponseCurve = curve_type_linear;
1246              VelocityResponseDepth = velocityresponse - 5;                  VelocityResponseDepth = velocityresponse - 5;
1247          }              } else if (velocityresponse < 15) {
1248          else if (velocityresponse < 15) {                  VelocityResponseCurve = curve_type_special;
1249              VelocityResponseCurve = curve_type_special;                  VelocityResponseDepth = velocityresponse - 10;
1250              VelocityResponseDepth = velocityresponse - 10;              } else {
1251          }                  VelocityResponseCurve = curve_type_unknown;
1252          else {                  VelocityResponseDepth = 0;
1253              VelocityResponseCurve = curve_type_unknown;              }
1254              VelocityResponseDepth = 0;              uint8_t releasevelocityresponse = _3ewa->ReadUint8();
1255          }              if (releasevelocityresponse < 5) {
1256          uint8_t releasevelocityresponse = _3ewa->ReadUint8();                  ReleaseVelocityResponseCurve = curve_type_nonlinear;
1257          if (releasevelocityresponse < 5) {                  ReleaseVelocityResponseDepth = releasevelocityresponse;
1258              ReleaseVelocityResponseCurve = curve_type_nonlinear;              } else if (releasevelocityresponse < 10) {
1259              ReleaseVelocityResponseDepth = releasevelocityresponse;                  ReleaseVelocityResponseCurve = curve_type_linear;
1260          }                  ReleaseVelocityResponseDepth = releasevelocityresponse - 5;
1261          else if (releasevelocityresponse < 10) {              } else if (releasevelocityresponse < 15) {
1262              ReleaseVelocityResponseCurve = curve_type_linear;                  ReleaseVelocityResponseCurve = curve_type_special;
1263              ReleaseVelocityResponseDepth = releasevelocityresponse - 5;                  ReleaseVelocityResponseDepth = releasevelocityresponse - 10;
1264          }              } else {
1265          else if (releasevelocityresponse < 15) {                  ReleaseVelocityResponseCurve = curve_type_unknown;
1266              ReleaseVelocityResponseCurve = curve_type_special;                  ReleaseVelocityResponseDepth = 0;
1267              ReleaseVelocityResponseDepth = releasevelocityresponse - 10;              }
1268          }              VelocityResponseCurveScaling = _3ewa->ReadUint8();
1269          else {              AttenuationControllerThreshold = _3ewa->ReadInt8();
1270              ReleaseVelocityResponseCurve = curve_type_unknown;              _3ewa->ReadInt32(); // unknown
1271              ReleaseVelocityResponseDepth = 0;              SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
1272          }              _3ewa->ReadInt16(); // unknown
1273          VelocityResponseCurveScaling = _3ewa->ReadUint8();              uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();
1274          AttenuationControllerThreshold = _3ewa->ReadInt8();              PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);
1275          _3ewa->ReadInt32(); // unknown              if      (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;
1276          SampleStartOffset = (uint16_t) _3ewa->ReadInt16();              else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
1277          _3ewa->ReadInt16(); // unknown              else                                       DimensionBypass = dim_bypass_ctrl_none;
1278          uint8_t pitchTrackDimensionBypass = _3ewa->ReadInt8();              uint8_t pan = _3ewa->ReadUint8();
1279          PitchTrack = GIG_PITCH_TRACK_EXTRACT(pitchTrackDimensionBypass);              Pan         = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
1280          if      (pitchTrackDimensionBypass & 0x10) DimensionBypass = dim_bypass_ctrl_94;              SelfMask = _3ewa->ReadInt8() & 0x01;
1281          else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;              _3ewa->ReadInt8(); // unknown
1282          else                                       DimensionBypass = dim_bypass_ctrl_none;              uint8_t lfo3ctrl = _3ewa->ReadUint8();
1283          uint8_t pan = _3ewa->ReadUint8();              LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
1284          Pan         = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit              LFO3Sync                 = lfo3ctrl & 0x20; // bit 5
1285          SelfMask = _3ewa->ReadInt8() & 0x01;              InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
1286          _3ewa->ReadInt8(); // unknown              AttenuationController  = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
1287          uint8_t lfo3ctrl = _3ewa->ReadUint8();              uint8_t lfo2ctrl       = _3ewa->ReadUint8();
1288          LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits              LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
1289          LFO3Sync                 = lfo3ctrl & 0x20; // bit 5              LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7
1290          InvertAttenuationController = lfo3ctrl & 0x80; // bit 7              LFO2Sync               = lfo2ctrl & 0x20; // bit 5
1291          AttenuationController  = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));              bool extResonanceCtrl  = lfo2ctrl & 0x40; // bit 6
1292          uint8_t lfo2ctrl       = _3ewa->ReadUint8();              uint8_t lfo1ctrl       = _3ewa->ReadUint8();
1293          LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits              LFO1Controller         = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits
1294          LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7              LFO1FlipPhase          = lfo1ctrl & 0x80; // bit 7
1295          LFO2Sync               = lfo2ctrl & 0x20; // bit 5              LFO1Sync               = lfo1ctrl & 0x40; // bit 6
1296          bool extResonanceCtrl  = lfo2ctrl & 0x40; // bit 6              VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))
1297          uint8_t lfo1ctrl       = _3ewa->ReadUint8();                                                          : vcf_res_ctrl_none;
1298          LFO1Controller         = static_cast<lfo1_ctrl_t>(lfo1ctrl & 0x07); // lower 3 bits              uint16_t eg3depth = _3ewa->ReadUint16();
1299          LFO1FlipPhase          = lfo1ctrl & 0x80; // bit 7              EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1300          LFO1Sync               = lfo1ctrl & 0x40; // bit 6                                          : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */
1301          VCFResonanceController = (extResonanceCtrl) ? static_cast<vcf_res_ctrl_t>(GIG_VCF_RESONANCE_CTRL_EXTRACT(lfo1ctrl))              _3ewa->ReadInt16(); // unknown
1302                                                      : vcf_res_ctrl_none;              ChannelOffset = _3ewa->ReadUint8() / 4;
1303          uint16_t eg3depth = _3ewa->ReadUint16();              uint8_t regoptions = _3ewa->ReadUint8();
1304          EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */              MSDecode           = regoptions & 0x01; // bit 0
1305                                        : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */              SustainDefeat      = regoptions & 0x02; // bit 1
1306          _3ewa->ReadInt16(); // unknown              _3ewa->ReadInt16(); // unknown
1307          ChannelOffset = _3ewa->ReadUint8() / 4;              VelocityUpperLimit = _3ewa->ReadInt8();
1308          uint8_t regoptions = _3ewa->ReadUint8();              _3ewa->ReadInt8(); // unknown
1309          MSDecode           = regoptions & 0x01; // bit 0              _3ewa->ReadInt16(); // unknown
1310          SustainDefeat      = regoptions & 0x02; // bit 1              ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay
1311          _3ewa->ReadInt16(); // unknown              _3ewa->ReadInt8(); // unknown
1312          VelocityUpperLimit = _3ewa->ReadInt8();              _3ewa->ReadInt8(); // unknown
1313          _3ewa->ReadInt8(); // unknown              EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7
1314          _3ewa->ReadInt16(); // unknown              uint8_t vcfcutoff = _3ewa->ReadUint8();
1315          ReleaseTriggerDecay = _3ewa->ReadUint8(); // release trigger decay              VCFEnabled = vcfcutoff & 0x80; // bit 7
1316          _3ewa->ReadInt8(); // unknown              VCFCutoff  = vcfcutoff & 0x7f; // lower 7 bits
1317          _3ewa->ReadInt8(); // unknown              VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());
1318          EG1Hold = _3ewa->ReadUint8() & 0x80; // bit 7              uint8_t vcfvelscale = _3ewa->ReadUint8();
1319          uint8_t vcfcutoff = _3ewa->ReadUint8();              VCFCutoffControllerInvert = vcfvelscale & 0x80; // bit 7
1320          VCFEnabled = vcfcutoff & 0x80; // bit 7              VCFVelocityScale = vcfvelscale & 0x7f; // lower 7 bits
1321          VCFCutoff  = vcfcutoff & 0x7f; // lower 7 bits              _3ewa->ReadInt8(); // unknown
1322          VCFCutoffController = static_cast<vcf_cutoff_ctrl_t>(_3ewa->ReadUint8());              uint8_t vcfresonance = _3ewa->ReadUint8();
1323          uint8_t vcfvelscale = _3ewa->ReadUint8();              VCFResonance = vcfresonance & 0x7f; // lower 7 bits
1324          VCFCutoffControllerInvert = vcfvelscale & 0x80; // bit 7              VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7
1325          VCFVelocityScale = vcfvelscale & 0x7f; // lower 7 bits              uint8_t vcfbreakpoint         = _3ewa->ReadUint8();
1326          _3ewa->ReadInt8(); // unknown              VCFKeyboardTracking           = vcfbreakpoint & 0x80; // bit 7
1327          uint8_t vcfresonance = _3ewa->ReadUint8();              VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits
1328          VCFResonance = vcfresonance & 0x7f; // lower 7 bits              uint8_t vcfvelocity = _3ewa->ReadUint8();
1329          VCFResonanceDynamic = !(vcfresonance & 0x80); // bit 7              VCFVelocityDynamicRange = vcfvelocity % 5;
1330          uint8_t vcfbreakpoint         = _3ewa->ReadUint8();              VCFVelocityCurve        = static_cast<curve_type_t>(vcfvelocity / 5);
1331          VCFKeyboardTracking           = vcfbreakpoint & 0x80; // bit 7              VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());
1332          VCFKeyboardTrackingBreakpoint = vcfbreakpoint & 0x7f; // lower 7 bits              if (VCFType == vcf_type_lowpass) {
1333          uint8_t vcfvelocity = _3ewa->ReadUint8();                  if (lfo3ctrl & 0x40) // bit 6
1334          VCFVelocityDynamicRange = vcfvelocity % 5;                      VCFType = vcf_type_lowpassturbo;
1335          VCFVelocityCurve        = static_cast<curve_type_t>(vcfvelocity / 5);              }
1336          VCFType = static_cast<vcf_type_t>(_3ewa->ReadUint8());          } else { // '3ewa' chunk does not exist yet
1337          if (VCFType == vcf_type_lowpass) {              // use default values
1338              if (lfo3ctrl & 0x40) // bit 6              LFO3Frequency                   = 1.0;
1339                  VCFType = vcf_type_lowpassturbo;              EG3Attack                       = 0.0;
1340                LFO1InternalDepth               = 0;
1341                LFO3InternalDepth               = 0;
1342                LFO1ControlDepth                = 0;
1343                LFO3ControlDepth                = 0;
1344                EG1Attack                       = 0.0;
1345                EG1Decay1                       = 0.0;
1346                EG1Sustain                      = 0;
1347                EG1Release                      = 0.0;
1348                EG1Controller.type              = eg1_ctrl_t::type_none;
1349                EG1Controller.controller_number = 0;
1350                EG1ControllerInvert             = false;
1351                EG1ControllerAttackInfluence    = 0;
1352                EG1ControllerDecayInfluence     = 0;
1353                EG1ControllerReleaseInfluence   = 0;
1354                EG2Controller.type              = eg2_ctrl_t::type_none;
1355                EG2Controller.controller_number = 0;
1356                EG2ControllerInvert             = false;
1357                EG2ControllerAttackInfluence    = 0;
1358                EG2ControllerDecayInfluence     = 0;
1359                EG2ControllerReleaseInfluence   = 0;
1360                LFO1Frequency                   = 1.0;
1361                EG2Attack                       = 0.0;
1362                EG2Decay1                       = 0.0;
1363                EG2Sustain                      = 0;
1364                EG2Release                      = 0.0;
1365                LFO2ControlDepth                = 0;
1366                LFO2Frequency                   = 1.0;
1367                LFO2InternalDepth               = 0;
1368                EG1Decay2                       = 0.0;
1369                EG1InfiniteSustain              = false;
1370                EG1PreAttack                    = 1000;
1371                EG2Decay2                       = 0.0;
1372                EG2InfiniteSustain              = false;
1373                EG2PreAttack                    = 1000;
1374                VelocityResponseCurve           = curve_type_nonlinear;
1375                VelocityResponseDepth           = 3;
1376                ReleaseVelocityResponseCurve    = curve_type_nonlinear;
1377                ReleaseVelocityResponseDepth    = 3;
1378                VelocityResponseCurveScaling    = 32;
1379                AttenuationControllerThreshold  = 0;
1380                SampleStartOffset               = 0;
1381                PitchTrack                      = true;
1382                DimensionBypass                 = dim_bypass_ctrl_none;
1383                Pan                             = 0;
1384                SelfMask                        = true;
1385                LFO3Controller                  = lfo3_ctrl_modwheel;
1386                LFO3Sync                        = false;
1387                InvertAttenuationController     = false;
1388                AttenuationController.type      = attenuation_ctrl_t::type_none;
1389                AttenuationController.controller_number = 0;
1390                LFO2Controller                  = lfo2_ctrl_internal;
1391                LFO2FlipPhase                   = false;
1392                LFO2Sync                        = false;
1393                LFO1Controller                  = lfo1_ctrl_internal;
1394                LFO1FlipPhase                   = false;
1395                LFO1Sync                        = false;
1396                VCFResonanceController          = vcf_res_ctrl_none;
1397                EG3Depth                        = 0;
1398                ChannelOffset                   = 0;
1399                MSDecode                        = false;
1400                SustainDefeat                   = false;
1401                VelocityUpperLimit              = 0;
1402                ReleaseTriggerDecay             = 0;
1403                EG1Hold                         = false;
1404                VCFEnabled                      = false;
1405                VCFCutoff                       = 0;
1406                VCFCutoffController             = vcf_cutoff_ctrl_none;
1407                VCFCutoffControllerInvert       = false;
1408                VCFVelocityScale                = 0;
1409                VCFResonance                    = 0;
1410                VCFResonanceDynamic             = false;
1411                VCFKeyboardTracking             = false;
1412                VCFKeyboardTrackingBreakpoint   = 0;
1413                VCFVelocityDynamicRange         = 0x04;
1414                VCFVelocityCurve                = curve_type_linear;
1415                VCFType                         = vcf_type_lowpass;
1416          }          }
1417    
1418          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
# Line 1187  namespace { Line 1449  namespace {
1449          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));          SampleAttenuation = pow(10.0, -Gain / (20.0 * 655360));
1450      }      }
1451    
1452        /**
1453         * Apply dimension region settings to the respective RIFF chunks. You
1454         * have to call File::Save() to make changes persistent.
1455         *
1456         * Usually there is absolutely no need to call this method explicitly.
1457         * It will be called automatically when File::Save() was called.
1458         */
1459        void DimensionRegion::UpdateChunks() {
1460            // first update base class's chunk
1461            DLS::Sampler::UpdateChunks();
1462    
1463            // make sure '3ewa' chunk exists
1464            RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1465            if (!_3ewa)  _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, 140);
1466            uint8_t* pData = (uint8_t*) _3ewa->LoadChunkData();
1467    
1468            // update '3ewa' chunk with DimensionRegion's current settings
1469    
1470            const uint32_t unknown = 0x0000008C; // unknown, always 0x0000008C ?
1471            memcpy(&pData[0], &unknown, 4);
1472    
1473            const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
1474            memcpy(&pData[4], &lfo3freq, 4);
1475    
1476            const int32_t eg3attack = (int32_t) GIG_EXP_ENCODE(EG3Attack);
1477            memcpy(&pData[4], &eg3attack, 4);
1478    
1479            // next 2 bytes unknown
1480    
1481            memcpy(&pData[10], &LFO1InternalDepth, 2);
1482    
1483            // next 2 bytes unknown
1484    
1485            memcpy(&pData[14], &LFO3InternalDepth, 2);
1486    
1487            // next 2 bytes unknown
1488    
1489            memcpy(&pData[18], &LFO1ControlDepth, 2);
1490    
1491            // next 2 bytes unknown
1492    
1493            memcpy(&pData[22], &LFO3ControlDepth, 2);
1494    
1495            const int32_t eg1attack = (int32_t) GIG_EXP_ENCODE(EG1Attack);
1496            memcpy(&pData[24], &eg1attack, 4);
1497    
1498            const int32_t eg1decay1 = (int32_t) GIG_EXP_ENCODE(EG1Decay1);
1499            memcpy(&pData[28], &eg1decay1, 4);
1500    
1501            // next 2 bytes unknown
1502    
1503            memcpy(&pData[34], &EG1Sustain, 2);
1504    
1505            const int32_t eg1release = (int32_t) GIG_EXP_ENCODE(EG1Release);
1506            memcpy(&pData[36], &eg1release, 4);
1507    
1508            const uint8_t eg1ctl = (uint8_t) EncodeLeverageController(EG1Controller);
1509            memcpy(&pData[40], &eg1ctl, 1);
1510    
1511            const uint8_t eg1ctrloptions =
1512                (EG1ControllerInvert) ? 0x01 : 0x00 |
1513                GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG1ControllerAttackInfluence) |
1514                GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG1ControllerDecayInfluence) |
1515                GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG1ControllerReleaseInfluence);
1516            memcpy(&pData[41], &eg1ctrloptions, 1);
1517    
1518            const uint8_t eg2ctl = (uint8_t) EncodeLeverageController(EG2Controller);
1519            memcpy(&pData[42], &eg2ctl, 1);
1520    
1521            const uint8_t eg2ctrloptions =
1522                (EG2ControllerInvert) ? 0x01 : 0x00 |
1523                GIG_EG_CTR_ATTACK_INFLUENCE_ENCODE(EG2ControllerAttackInfluence) |
1524                GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(EG2ControllerDecayInfluence) |
1525                GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(EG2ControllerReleaseInfluence);
1526            memcpy(&pData[43], &eg2ctrloptions, 1);
1527    
1528            const int32_t lfo1freq = (int32_t) GIG_EXP_ENCODE(LFO1Frequency);
1529            memcpy(&pData[44], &lfo1freq, 4);
1530    
1531            const int32_t eg2attack = (int32_t) GIG_EXP_ENCODE(EG2Attack);
1532            memcpy(&pData[48], &eg2attack, 4);
1533    
1534            const int32_t eg2decay1 = (int32_t) GIG_EXP_ENCODE(EG2Decay1);
1535            memcpy(&pData[52], &eg2decay1, 4);
1536    
1537            // next 2 bytes unknown
1538    
1539            memcpy(&pData[58], &EG2Sustain, 2);
1540    
1541            const int32_t eg2release = (int32_t) GIG_EXP_ENCODE(EG2Release);
1542            memcpy(&pData[60], &eg2release, 4);
1543    
1544            // next 2 bytes unknown
1545    
1546            memcpy(&pData[66], &LFO2ControlDepth, 2);
1547    
1548            const int32_t lfo2freq = (int32_t) GIG_EXP_ENCODE(LFO2Frequency);
1549            memcpy(&pData[68], &lfo2freq, 4);
1550    
1551            // next 2 bytes unknown
1552    
1553            memcpy(&pData[72], &LFO2InternalDepth, 2);
1554    
1555            const int32_t eg1decay2 = (int32_t) (EG1InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG1Decay2);
1556            memcpy(&pData[74], &eg1decay2, 4);
1557    
1558            // next 2 bytes unknown
1559    
1560            memcpy(&pData[80], &EG1PreAttack, 2);
1561    
1562            const int32_t eg2decay2 = (int32_t) (EG2InfiniteSustain) ? 0x7fffffff : (int32_t) GIG_EXP_ENCODE(EG2Decay2);
1563            memcpy(&pData[82], &eg2decay2, 4);
1564    
1565            // next 2 bytes unknown
1566    
1567            memcpy(&pData[88], &EG2PreAttack, 2);
1568    
1569            {
1570                if (VelocityResponseDepth > 4) throw Exception("VelocityResponseDepth must be between 0 and 4");
1571                uint8_t velocityresponse = VelocityResponseDepth;
1572                switch (VelocityResponseCurve) {
1573                    case curve_type_nonlinear:
1574                        break;
1575                    case curve_type_linear:
1576                        velocityresponse += 5;
1577                        break;
1578                    case curve_type_special:
1579                        velocityresponse += 10;
1580                        break;
1581                    case curve_type_unknown:
1582                    default:
1583                        throw Exception("Could not update DimensionRegion's chunk, unknown VelocityResponseCurve selected");
1584                }
1585                memcpy(&pData[90], &velocityresponse, 1);
1586            }
1587    
1588            {
1589                if (ReleaseVelocityResponseDepth > 4) throw Exception("ReleaseVelocityResponseDepth must be between 0 and 4");
1590                uint8_t releasevelocityresponse = ReleaseVelocityResponseDepth;
1591                switch (ReleaseVelocityResponseCurve) {
1592                    case curve_type_nonlinear:
1593                        break;
1594                    case curve_type_linear:
1595                        releasevelocityresponse += 5;
1596                        break;
1597                    case curve_type_special:
1598                        releasevelocityresponse += 10;
1599                        break;
1600                    case curve_type_unknown:
1601                    default:
1602                        throw Exception("Could not update DimensionRegion's chunk, unknown ReleaseVelocityResponseCurve selected");
1603                }
1604                memcpy(&pData[91], &releasevelocityresponse, 1);
1605            }
1606    
1607            memcpy(&pData[92], &VelocityResponseCurveScaling, 1);
1608    
1609            memcpy(&pData[93], &AttenuationControllerThreshold, 1);
1610    
1611            // next 4 bytes unknown
1612    
1613            memcpy(&pData[98], &SampleStartOffset, 2);
1614    
1615            // next 2 bytes unknown
1616    
1617            {
1618                uint8_t pitchTrackDimensionBypass = GIG_PITCH_TRACK_ENCODE(PitchTrack);
1619                switch (DimensionBypass) {
1620                    case dim_bypass_ctrl_94:
1621                        pitchTrackDimensionBypass |= 0x10;
1622                        break;
1623                    case dim_bypass_ctrl_95:
1624                        pitchTrackDimensionBypass |= 0x20;
1625                        break;
1626                    case dim_bypass_ctrl_none:
1627                        //FIXME: should we set anything here?
1628                        break;
1629                    default:
1630                        throw Exception("Could not update DimensionRegion's chunk, unknown DimensionBypass selected");
1631                }
1632                memcpy(&pData[102], &pitchTrackDimensionBypass, 1);
1633            }
1634    
1635            const uint8_t pan = (Pan >= 0) ? Pan : ((-Pan) + 63); // signed 8 bit -> signed 7 bit
1636            memcpy(&pData[103], &pan, 1);
1637    
1638            const uint8_t selfmask = (SelfMask) ? 0x01 : 0x00;
1639            memcpy(&pData[104], &selfmask, 1);
1640    
1641            // next byte unknown
1642    
1643            {
1644                uint8_t lfo3ctrl = LFO3Controller & 0x07; // lower 3 bits
1645                if (LFO3Sync) lfo3ctrl |= 0x20; // bit 5
1646                if (InvertAttenuationController) lfo3ctrl |= 0x80; // bit 7
1647                if (VCFType == vcf_type_lowpassturbo) lfo3ctrl |= 0x40; // bit 6
1648                memcpy(&pData[106], &lfo3ctrl, 1);
1649            }
1650    
1651            const uint8_t attenctl = EncodeLeverageController(AttenuationController);
1652            memcpy(&pData[107], &attenctl, 1);
1653    
1654            {
1655                uint8_t lfo2ctrl = LFO2Controller & 0x07; // lower 3 bits
1656                if (LFO2FlipPhase) lfo2ctrl |= 0x80; // bit 7
1657                if (LFO2Sync)      lfo2ctrl |= 0x20; // bit 5
1658                if (VCFResonanceController != vcf_res_ctrl_none) lfo2ctrl |= 0x40; // bit 6
1659                memcpy(&pData[108], &lfo2ctrl, 1);
1660            }
1661    
1662            {
1663                uint8_t lfo1ctrl = LFO1Controller & 0x07; // lower 3 bits
1664                if (LFO1FlipPhase) lfo1ctrl |= 0x80; // bit 7
1665                if (LFO1Sync)      lfo1ctrl |= 0x40; // bit 6
1666                if (VCFResonanceController != vcf_res_ctrl_none)
1667                    lfo1ctrl |= GIG_VCF_RESONANCE_CTRL_ENCODE(VCFResonanceController);
1668                memcpy(&pData[109], &lfo1ctrl, 1);
1669            }
1670    
1671            const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
1672                                                      : uint16_t(((-EG3Depth) - 1) ^ 0xffff); /* binary complementary for negatives */
1673            memcpy(&pData[110], &eg3depth, 1);
1674    
1675            // next 2 bytes unknown
1676    
1677            const uint8_t channeloffset = ChannelOffset * 4;
1678            memcpy(&pData[113], &channeloffset, 1);
1679    
1680            {
1681                uint8_t regoptions = 0;
1682                if (MSDecode)      regoptions |= 0x01; // bit 0
1683                if (SustainDefeat) regoptions |= 0x02; // bit 1
1684                memcpy(&pData[114], &regoptions, 1);
1685            }
1686    
1687            // next 2 bytes unknown
1688    
1689            memcpy(&pData[117], &VelocityUpperLimit, 1);
1690    
1691            // next 3 bytes unknown
1692    
1693            memcpy(&pData[121], &ReleaseTriggerDecay, 1);
1694    
1695            // next 2 bytes unknown
1696    
1697            const uint8_t eg1hold = (EG1Hold) ? 0x80 : 0x00; // bit 7
1698            memcpy(&pData[124], &eg1hold, 1);
1699    
1700            const uint8_t vcfcutoff = (VCFEnabled) ? 0x80 : 0x00 |  /* bit 7 */
1701                                      (VCFCutoff)  ? 0x7f : 0x00;   /* lower 7 bits */
1702            memcpy(&pData[125], &vcfcutoff, 1);
1703    
1704            memcpy(&pData[126], &VCFCutoffController, 1);
1705    
1706            const uint8_t vcfvelscale = (VCFCutoffControllerInvert) ? 0x80 : 0x00 | /* bit 7 */
1707                                        (VCFVelocityScale) ? 0x7f : 0x00; /* lower 7 bits */
1708            memcpy(&pData[127], &vcfvelscale, 1);
1709    
1710            // next byte unknown
1711    
1712            const uint8_t vcfresonance = (VCFResonanceDynamic) ? 0x00 : 0x80 | /* bit 7 */
1713                                         (VCFResonance) ? 0x7f : 0x00; /* lower 7 bits */
1714            memcpy(&pData[129], &vcfresonance, 1);
1715    
1716            const uint8_t vcfbreakpoint = (VCFKeyboardTracking) ? 0x80 : 0x00 | /* bit 7 */
1717                                          (VCFKeyboardTrackingBreakpoint) ? 0x7f : 0x00; /* lower 7 bits */
1718            memcpy(&pData[130], &vcfbreakpoint, 1);
1719    
1720            const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 |
1721                                        VCFVelocityCurve * 5;
1722            memcpy(&pData[131], &vcfvelocity, 1);
1723    
1724            const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
1725            memcpy(&pData[132], &vcftype, 1);
1726        }
1727    
1728      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
1729      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
1730      {      {
# Line 1320  namespace { Line 1858  namespace {
1858          return decodedcontroller;          return decodedcontroller;
1859      }      }
1860    
1861        DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
1862            _lev_ctrl_t encodedcontroller;
1863            switch (DecodedController.type) {
1864                // special controller
1865                case leverage_ctrl_t::type_none:
1866                    encodedcontroller = _lev_ctrl_none;
1867                    break;
1868                case leverage_ctrl_t::type_velocity:
1869                    encodedcontroller = _lev_ctrl_velocity;
1870                    break;
1871                case leverage_ctrl_t::type_channelaftertouch:
1872                    encodedcontroller = _lev_ctrl_channelaftertouch;
1873                    break;
1874    
1875                // ordinary MIDI control change controller
1876                case leverage_ctrl_t::type_controlchange:
1877                    switch (DecodedController.controller_number) {
1878                        case 1:
1879                            encodedcontroller = _lev_ctrl_modwheel;
1880                            break;
1881                        case 2:
1882                            encodedcontroller = _lev_ctrl_breath;
1883                            break;
1884                        case 4:
1885                            encodedcontroller = _lev_ctrl_foot;
1886                            break;
1887                        case 12:
1888                            encodedcontroller = _lev_ctrl_effect1;
1889                            break;
1890                        case 13:
1891                            encodedcontroller = _lev_ctrl_effect2;
1892                            break;
1893                        case 16:
1894                            encodedcontroller = _lev_ctrl_genpurpose1;
1895                            break;
1896                        case 17:
1897                            encodedcontroller = _lev_ctrl_genpurpose2;
1898                            break;
1899                        case 18:
1900                            encodedcontroller = _lev_ctrl_genpurpose3;
1901                            break;
1902                        case 19:
1903                            encodedcontroller = _lev_ctrl_genpurpose4;
1904                            break;
1905                        case 5:
1906                            encodedcontroller = _lev_ctrl_portamentotime;
1907                            break;
1908                        case 64:
1909                            encodedcontroller = _lev_ctrl_sustainpedal;
1910                            break;
1911                        case 65:
1912                            encodedcontroller = _lev_ctrl_portamento;
1913                            break;
1914                        case 66:
1915                            encodedcontroller = _lev_ctrl_sostenutopedal;
1916                            break;
1917                        case 67:
1918                            encodedcontroller = _lev_ctrl_softpedal;
1919                            break;
1920                        case 80:
1921                            encodedcontroller = _lev_ctrl_genpurpose5;
1922                            break;
1923                        case 81:
1924                            encodedcontroller = _lev_ctrl_genpurpose6;
1925                            break;
1926                        case 82:
1927                            encodedcontroller = _lev_ctrl_genpurpose7;
1928                            break;
1929                        case 83:
1930                            encodedcontroller = _lev_ctrl_genpurpose8;
1931                            break;
1932                        case 91:
1933                            encodedcontroller = _lev_ctrl_effect1depth;
1934                            break;
1935                        case 92:
1936                            encodedcontroller = _lev_ctrl_effect2depth;
1937                            break;
1938                        case 93:
1939                            encodedcontroller = _lev_ctrl_effect3depth;
1940                            break;
1941                        case 94:
1942                            encodedcontroller = _lev_ctrl_effect4depth;
1943                            break;
1944                        case 95:
1945                            encodedcontroller = _lev_ctrl_effect5depth;
1946                            break;
1947                        default:
1948                            throw gig::Exception("leverage controller number is not supported by the gig format");
1949                    }
1950                default:
1951                    throw gig::Exception("Unknown leverage controller type.");
1952            }
1953            return encodedcontroller;
1954        }
1955    
1956      DimensionRegion::~DimensionRegion() {      DimensionRegion::~DimensionRegion() {
1957          Instances--;          Instances--;
1958          if (!Instances) {          if (!Instances) {
# Line 1494  namespace { Line 2127  namespace {
2127                      else { // custom defined ranges                      else { // custom defined ranges
2128                          pDimDef->split_type = split_type_customvelocity;                          pDimDef->split_type = split_type_customvelocity;
2129                          pDimDef->ranges     = new range_t[pDimDef->zones];                          pDimDef->ranges     = new range_t[pDimDef->zones];
2130                          uint8_t bits[8] = { 0 };                          UpdateVelocityTable(pDimDef);
                         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;  
                             }  
                         }  
2131                      }                      }
2132                  }                  }
2133              }              }
# Line 1525  namespace { Line 2145  namespace {
2145                  pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                  pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
2146              }              }
2147          }          }
2148          else throw gig::Exception("Mandatory <3lnk> chunk not found.");      }
2149    
2150        /**
2151         * Apply Region settings and all its DimensionRegions to the respective
2152         * RIFF chunks. You have to call File::Save() to make changes persistent.
2153         *
2154         * Usually there is absolutely no need to call this method explicitly.
2155         * It will be called automatically when File::Save() was called.
2156         *
2157         * @throws gig::Exception if samples cannot be dereferenced
2158         */
2159        void Region::UpdateChunks() {
2160            // first update base class's chunks
2161            DLS::Region::UpdateChunks();
2162    
2163            // update dimension region's chunks
2164            for (int i = 0; i < Dimensions; i++)
2165                pDimensionRegions[i]->UpdateChunks();
2166    
2167            File* pFile = (File*) GetParent()->GetParent();
2168            const int iMaxDimensions = (pFile->pVersion && pFile->pVersion->major == 3) ? 8 : 5;
2169            const int iMaxDimensionRegions = (pFile->pVersion && pFile->pVersion->major == 3) ? 256 : 32;
2170    
2171            // make sure '3lnk' chunk exists
2172            RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
2173            if (!_3lnk) {
2174                const int _3lnkChunkSize = (pFile->pVersion && pFile->pVersion->major == 3) ? 1092 : 172;
2175                _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
2176            }
2177    
2178            // update dimension definitions in '3lnk' chunk
2179            uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
2180            for (int i = 0; i < iMaxDimensions; i++) {
2181                pData[i * 8]     = (uint8_t) pDimensionDefinitions[i].dimension;
2182                pData[i * 8 + 1] = pDimensionDefinitions[i].bits;
2183                // next 2 bytes unknown
2184                pData[i * 8 + 4] = pDimensionDefinitions[i].zones;
2185                // next 3 bytes unknown
2186            }
2187    
2188            // update wave pool table in '3lnk' chunk
2189            const int iWavePoolOffset = (pFile->pVersion && pFile->pVersion->major == 3) ? 68 : 44;
2190            for (uint i = 0; i < iMaxDimensionRegions; i++) {
2191                int iWaveIndex = -1;
2192                if (i < DimensionRegions) {
2193                    if (!pFile->pSamples) throw gig::Exception("Could not update gig::Region, there are no samples");
2194                    std::list<Sample*>::iterator iter = pFile->pSamples->begin();
2195                    std::list<Sample*>::iterator end  = pFile->pSamples->end();
2196                    for (int index = 0; iter != end; ++iter, ++index) {
2197                        if (*iter == pDimensionRegions[i]->pSample) iWaveIndex = index;
2198                        break;
2199                    }
2200                    if (iWaveIndex < 0) throw gig::Exception("Could not update gig::Region, could not find DimensionRegion's sample");
2201                }
2202                memcpy(&pData[iWavePoolOffset + i * 4], &iWaveIndex, 4);
2203            }
2204      }      }
2205    
2206      void Region::LoadDimensionRegions(RIFF::List* rgn) {      void Region::LoadDimensionRegions(RIFF::List* rgn) {
# Line 1544  namespace { Line 2219  namespace {
2219          }          }
2220      }      }
2221    
2222        void Region::UpdateVelocityTable(dimension_def_t* pDimDef) {
2223            // get dimension's index
2224            int iDimensionNr = -1;
2225            for (int i = 0; i < Dimensions; i++) {
2226                if (&pDimensionDefinitions[i] == pDimDef) {
2227                    iDimensionNr = i;
2228                    break;
2229                }
2230            }
2231            if (iDimensionNr < 0) throw gig::Exception("Invalid dimension_def_t pointer");
2232    
2233            uint8_t bits[8] = { 0 };
2234            int previousUpperLimit = -1;
2235            for (int velocityZone = 0; velocityZone < pDimDef->zones; velocityZone++) {
2236                bits[iDimensionNr] = velocityZone;
2237                DimensionRegion* pDimRegion = GetDimensionRegionByBit(bits);
2238    
2239                pDimDef->ranges[velocityZone].low  = previousUpperLimit + 1;
2240                pDimDef->ranges[velocityZone].high = pDimRegion->VelocityUpperLimit;
2241                previousUpperLimit = pDimDef->ranges[velocityZone].high;
2242                // fill velocity table
2243                for (int i = pDimDef->ranges[velocityZone].low; i <= pDimDef->ranges[velocityZone].high; i++) {
2244                    VelocityTable[i] = velocityZone;
2245                }
2246            }
2247        }
2248    
2249        /** @brief Einstein would have dreamed of it - create a new dimension.
2250         *
2251         * Creates a new dimension with the dimension definition given by
2252         * \a pDimDef. The appropriate amount of DimensionRegions will be created.
2253         * There is a hard limit of dimensions and total amount of "bits" all
2254         * dimensions can have. This limit is dependant to what gig file format
2255         * version this file refers to. The gig v2 (and lower) format has a
2256         * dimension limit and total amount of bits limit of 5, whereas the gig v3
2257         * format has a limit of 8.
2258         *
2259         * @param pDimDef - defintion of the new dimension
2260         * @throws gig::Exception if dimension of the same type exists already
2261         * @throws gig::Exception if amount of dimensions or total amount of
2262         *                        dimension bits limit is violated
2263         */
2264        void Region::AddDimension(dimension_def_t* pDimDef) {
2265            // check if max. amount of dimensions reached
2266            File* file = (File*) GetParent()->GetParent();
2267            const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
2268            if (Dimensions >= iMaxDimensions)
2269                throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");
2270            // check if max. amount of dimension bits reached
2271            int iCurrentBits = 0;
2272            for (int i = 0; i < Dimensions; i++)
2273                iCurrentBits += pDimensionDefinitions[i].bits;
2274            if (iCurrentBits >= iMaxDimensions)
2275                throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimension bits already reached");
2276            const int iNewBits = iCurrentBits + pDimDef->bits;
2277            if (iNewBits > iMaxDimensions)
2278                throw gig::Exception("Could not add new dimension, new dimension would exceed max. amount of " + ToString(iMaxDimensions) + " dimension bits");
2279            // check if there's already a dimensions of the same type
2280            for (int i = 0; i < Dimensions; i++)
2281                if (pDimensionDefinitions[i].dimension == pDimDef->dimension)
2282                    throw gig::Exception("Could not add new dimension, there is already a dimension of the same type");
2283    
2284            // assign definition of new dimension
2285            pDimensionDefinitions[Dimensions] = *pDimDef;
2286    
2287            // create new dimension region(s) for this new dimension
2288            for (int i = 1 << iCurrentBits; i < 1 << iNewBits; i++) {
2289                //TODO: maybe we should copy existing dimension regions if possible instead of simply creating new ones with default values
2290                RIFF::List* pNewDimRgnListChunk = pCkRegion->AddSubList(LIST_TYPE_3EWL);
2291                pDimensionRegions[i] = new DimensionRegion(pNewDimRgnListChunk);
2292                DimensionRegions++;
2293            }
2294    
2295            Dimensions++;
2296    
2297            // if this is a layer dimension, update 'Layers' attribute
2298            if (pDimDef->dimension == dimension_layer) Layers = pDimDef->zones;
2299    
2300            // if this is velocity dimension and got custom defined ranges, update velocity table
2301            if (pDimDef->dimension  == dimension_velocity &&
2302                pDimDef->split_type == split_type_customvelocity) {
2303                UpdateVelocityTable(pDimDef);
2304            }
2305        }
2306    
2307        /** @brief Delete an existing dimension.
2308         *
2309         * Deletes the dimension given by \a pDimDef and deletes all respective
2310         * dimension regions, that is all dimension regions where the dimension's
2311         * bit(s) part is greater than 0. In case of a 'sustain pedal' dimension
2312         * for example this would delete all dimension regions for the case(s)
2313         * where the sustain pedal is pressed down.
2314         *
2315         * @param pDimDef - dimension to delete
2316         * @throws gig::Exception if given dimension cannot be found
2317         */
2318        void Region::DeleteDimension(dimension_def_t* pDimDef) {
2319            // get dimension's index
2320            int iDimensionNr = -1;
2321            for (int i = 0; i < Dimensions; i++) {
2322                if (&pDimensionDefinitions[i] == pDimDef) {
2323                    iDimensionNr = i;
2324                    break;
2325                }
2326            }
2327            if (iDimensionNr < 0) throw gig::Exception("Invalid dimension_def_t pointer");
2328    
2329            // get amount of bits below the dimension to delete
2330            int iLowerBits = 0;
2331            for (int i = 0; i < iDimensionNr; i++)
2332                iLowerBits += pDimensionDefinitions[i].bits;
2333    
2334            // get amount ot bits above the dimension to delete
2335            int iUpperBits = 0;
2336            for (int i = iDimensionNr + 1; i < Dimensions; i++)
2337                iUpperBits += pDimensionDefinitions[i].bits;
2338    
2339            // delete dimension regions which belong to the given dimension
2340            // (that is where the dimension's bit > 0)
2341            for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
2342                for (int iObsoleteBit = 1; iObsoleteBit < 1 << pDimensionDefinitions[iDimensionNr].bits; iObsoleteBit++) {
2343                    for (int iLowerBit = 0; iLowerBit < 1 << iLowerBits; iLowerBit++) {
2344                        int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
2345                                        iObsoleteBit << iLowerBits |
2346                                        iLowerBit;
2347                        delete pDimensionRegions[iToDelete];
2348                        pDimensionRegions[iToDelete] = NULL;
2349                        DimensionRegions--;
2350                    }
2351                }
2352            }
2353    
2354            // defrag pDimensionRegions array
2355            // (that is remove the NULL spaces within the pDimensionRegions array)
2356            for (int iFrom = 2, iTo = 1; iFrom < 256 && iTo < 256 - 1; iTo++) {
2357                if (!pDimensionRegions[iTo]) {
2358                    if (iFrom <= iTo) iFrom = iTo + 1;
2359                    while (!pDimensionRegions[iFrom] && iFrom < 256) iFrom++;
2360                    if (iFrom < 256 && pDimensionRegions[iFrom]) {
2361                        pDimensionRegions[iTo]   = pDimensionRegions[iFrom];
2362                        pDimensionRegions[iFrom] = NULL;
2363                    }
2364                }
2365            }
2366    
2367            // 'remove' dimension definition
2368            for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2369                pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
2370            }
2371            pDimensionDefinitions[Dimensions - 1].dimension = dimension_none;
2372            pDimensionDefinitions[Dimensions - 1].bits      = 0;
2373            pDimensionDefinitions[Dimensions - 1].zones     = 0;
2374            if (pDimensionDefinitions[Dimensions - 1].ranges) {
2375                delete[] pDimensionDefinitions[Dimensions - 1].ranges;
2376                pDimensionDefinitions[Dimensions - 1].ranges = NULL;
2377            }
2378    
2379            Dimensions--;
2380    
2381            // if this was a layer dimension, update 'Layers' attribute
2382            if (pDimDef->dimension == dimension_layer) Layers = 1;
2383        }
2384    
2385      Region::~Region() {      Region::~Region() {
2386          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
2387              if (pDimensionDefinitions[i].ranges) delete[] pDimensionDefinitions[i].ranges;              if (pDimensionDefinitions[i].ranges) delete[] pDimensionDefinitions[i].ranges;
# Line 1663  namespace { Line 2501  namespace {
2501                  DimensionKeyRange.low  = dimkeystart >> 1;                  DimensionKeyRange.low  = dimkeystart >> 1;
2502                  DimensionKeyRange.high = _3ewg->ReadUint8();                  DimensionKeyRange.high = _3ewg->ReadUint8();
2503              }              }
             else throw gig::Exception("Mandatory <3ewg> chunk not found.");  
2504          }          }
         else throw gig::Exception("Mandatory <lart> list chunk not found.");  
2505    
         RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);  
         if (!lrgn) throw gig::Exception("Mandatory chunks in <ins > chunk not found.");  
2506          pRegions = new Region*[Regions];          pRegions = new Region*[Regions];
2507          for (uint i = 0; i < Regions; i++) pRegions[i] = NULL;          RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
2508          RIFF::List* rgn = lrgn->GetFirstSubList();          if (lrgn) {
2509          unsigned int iRegion = 0;              for (uint i = 0; i < Regions; i++) pRegions[i] = NULL;
2510          while (rgn) {              RIFF::List* rgn = lrgn->GetFirstSubList();
2511              if (rgn->GetListType() == LIST_TYPE_RGN) {              unsigned int iRegion = 0;
2512                  __notify_progress(pProgress, (float) iRegion / (float) Regions);              while (rgn) {
2513                  pRegions[iRegion] = new Region(this, rgn);                  if (rgn->GetListType() == LIST_TYPE_RGN) {
2514                  iRegion++;                      __notify_progress(pProgress, (float) iRegion / (float) Regions);
2515                        pRegions[iRegion] = new Region(this, rgn);
2516                        iRegion++;
2517                    }
2518                    rgn = lrgn->GetNextSubList();
2519              }              }
2520              rgn = lrgn->GetNextSubList();              // Creating Region Key Table for fast lookup
2521                UpdateRegionKeyTable();
2522          }          }
2523    
2524          // Creating Region Key Table for fast lookup          __notify_progress(pProgress, 1.0f); // notify done
2525        }
2526    
2527        void Instrument::UpdateRegionKeyTable() {
2528          for (uint iReg = 0; iReg < Regions; iReg++) {          for (uint iReg = 0; iReg < Regions; iReg++) {
2529              for (int iKey = pRegions[iReg]->KeyRange.low; iKey <= pRegions[iReg]->KeyRange.high; iKey++) {              for (int iKey = pRegions[iReg]->KeyRange.low; iKey <= pRegions[iReg]->KeyRange.high; iKey++) {
2530                  RegionKeyTable[iKey] = pRegions[iReg];                  RegionKeyTable[iKey] = pRegions[iReg];
2531              }              }
2532          }          }
   
         __notify_progress(pProgress, 1.0f); // notify done  
2533      }      }
2534    
2535      Instrument::~Instrument() {      Instrument::~Instrument() {
# Line 1702  namespace { Line 2542  namespace {
2542      }      }
2543    
2544      /**      /**
2545         * Apply Instrument with all its Regions to the respective RIFF chunks.
2546         * You have to call File::Save() to make changes persistent.
2547         *
2548         * Usually there is absolutely no need to call this method explicitly.
2549         * It will be called automatically when File::Save() was called.
2550         *
2551         * @throws gig::Exception if samples cannot be dereferenced
2552         */
2553        void Instrument::UpdateChunks() {
2554            // first update base classes' chunks
2555            DLS::Instrument::UpdateChunks();
2556    
2557            // update Regions' chunks
2558            for (int i = 0; i < Regions; i++)
2559                pRegions[i]->UpdateChunks();
2560    
2561            // make sure 'lart' RIFF list chunk exists
2562            RIFF::List* lart = pCkInstrument->GetSubList(LIST_TYPE_LART);
2563            if (!lart)  lart = pCkInstrument->AddSubList(LIST_TYPE_LART);
2564            // make sure '3ewg' RIFF chunk exists
2565            RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
2566            if (!_3ewg)  _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, 12);
2567            // update '3ewg' RIFF chunk
2568            uint8_t* pData = (uint8_t*) _3ewg->LoadChunkData();
2569            memcpy(&pData[0], &EffectSend, 2);
2570            memcpy(&pData[2], &Attenuation, 4);
2571            memcpy(&pData[6], &FineTune, 2);
2572            memcpy(&pData[8], &PitchbendRange, 2);
2573            const uint8_t dimkeystart = (PianoReleaseMode) ? 0x01 : 0x00 |
2574                                        DimensionKeyRange.low << 1;
2575            memcpy(&pData[10], &dimkeystart, 1);
2576            memcpy(&pData[11], &DimensionKeyRange.high, 1);
2577        }
2578    
2579        /**
2580       * Returns the appropriate Region for a triggered note.       * Returns the appropriate Region for a triggered note.
2581       *       *
2582       * @param Key  MIDI Key number of triggered note / key (0 - 127)       * @param Key  MIDI Key number of triggered note / key (0 - 127)
# Line 1744  namespace { Line 2619  namespace {
2619          return pRegions[RegionIndex++];          return pRegions[RegionIndex++];
2620      }      }
2621    
2622        Region* Instrument::AddRegion() {
2623            // create new Region object (and its RIFF chunks)
2624            RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
2625            if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
2626            RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
2627            Region* pNewRegion = new Region(this, rgn);
2628            // resize 'pRegions' array (increase by one)
2629            Region** pNewRegions = new Region*[Regions + 1];
2630            memcpy(pNewRegions, pRegions, Regions * sizeof(Region*));
2631            // add new Region object
2632            pNewRegions[Regions] = pNewRegion;
2633            // replace old 'pRegions' array by the new increased array
2634            if (pRegions) delete[] pRegions;
2635            pRegions = pNewRegions;
2636            Regions++;
2637            // update Region key table for fast lookup
2638            UpdateRegionKeyTable();
2639            // done
2640            return pNewRegion;
2641        }
2642    
2643        void Instrument::DeleteRegion(Region* pRegion) {
2644            if (!pRegions) return;
2645            int iOffset = 0;
2646            // resize 'pRegions' array (decrease by one)
2647            Region** pNewRegions = new Region*[Regions - 1];
2648            for (int i = 0; i < Regions; i++) {
2649                if (pRegions[i] == pRegion) { // found Region to delete
2650                    iOffset = 1;
2651                    delete pRegion;
2652                }
2653                if (i < Regions - 1) pNewRegions[i] = pRegions[i + iOffset];
2654            }
2655            if (!iOffset) throw gig::Exception("There is no such gig::Region to delete");
2656            // replace old 'pRegions' array by the new decreased array
2657            if (pRegions) delete[] pRegions;
2658            pRegions = pNewRegions;
2659            Regions--;
2660            // update Region key table for fast lookup
2661            UpdateRegionKeyTable();
2662        }
2663    
2664    
2665    
2666  // *************** File ***************  // *************** File ***************
2667  // *  // *
2668    
2669        File::File() : DLS::File() {
2670            pSamples     = NULL;
2671            pInstruments = NULL;
2672        }
2673    
2674      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
2675          pSamples     = NULL;          pSamples     = NULL;
2676          pInstruments = NULL;          pInstruments = NULL;
# Line 1794  namespace { Line 2716  namespace {
2716          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
2717      }      }
2718    
2719        /** @brief Add a new sample.
2720         *
2721         * This will create a new Sample object for the gig file. You have to
2722         * call Save() to make this persistent to the file.
2723         *
2724         * @returns pointer to new Sample object
2725         */
2726        Sample* File::AddSample() {
2727           if (!pSamples) LoadSamples();
2728           __ensureMandatoryChunksExist();
2729           RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
2730           // create new Sample object and its respective 'wave' list chunk
2731           if (!pSamples) pSamples = new SampleList;
2732           RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);
2733           Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);
2734           pSamples->push_back(pSample);
2735           return pSample;
2736        }
2737    
2738        /** @brief Delete a sample.
2739         *
2740         * This will delete the given Sample object from the gig file. You have
2741         * to call Save() to make this persistent to the file.
2742         *
2743         * @param pSample - sample to delete
2744         * @throws gig::Exception if given sample could not be found
2745         */
2746        void File::DeleteSample(Sample* pSample) {
2747            if (!pSamples) throw gig::Exception("Could not delete sample as there are no samples");
2748            SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), pSample);
2749            if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");
2750            pSamples->erase(iter);
2751            delete pSample;
2752        }
2753    
2754      void File::LoadSamples(progress_t* pProgress) {      void File::LoadSamples(progress_t* pProgress) {
2755          RIFF::File* file = pRIFF;          RIFF::File* file = pRIFF;
2756    
# Line 1895  namespace { Line 2852  namespace {
2852          return NULL;          return NULL;
2853      }      }
2854    
2855        /** @brief Add a new instrument definition.
2856         *
2857         * This will create a new Instrument object for the gig file. You have
2858         * to call Save() to make this persistent to the file.
2859         *
2860         * @returns pointer to new Instrument object
2861         */
2862        Instrument* File::AddInstrument() {
2863           if (!pInstruments) LoadInstruments();
2864           __ensureMandatoryChunksExist();
2865           if (!pInstruments) pInstruments = new InstrumentList;
2866           RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
2867           RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);
2868           Instrument* pInstrument = new Instrument(this, lstInstr);
2869           pInstruments->push_back(pInstrument);
2870           return pInstrument;
2871        }
2872    
2873        /** @brief Delete an instrument.
2874         *
2875         * This will delete the given Instrument object from the gig file. You
2876         * have to call Save() to make this persistent to the file.
2877         *
2878         * @param pInstrument - instrument to delete
2879         * @throws gig::Excption if given instrument could not be found
2880         */
2881        void File::DeleteInstrument(Instrument* pInstrument) {
2882            if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");
2883            InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), pInstrument);
2884            if (iter == pInstruments->end()) throw gig::Exception("Could not delete instrument, could not find given instrument");
2885            pInstruments->erase(iter);
2886            delete pInstrument;
2887        }
2888    
2889      void File::LoadInstruments(progress_t* pProgress) {      void File::LoadInstruments(progress_t* pProgress) {
2890          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
2891          if (lstInstruments) {          if (lstInstruments) {

Legend:
Removed from v.780  
changed lines
  Added in v.809

  ViewVC Help
Powered by ViewVC