/[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 3198 by schoenebeck, Sun May 21 12:46:05 2017 UTC revision 3723 by schoenebeck, Wed Jan 22 15:48:32 2020 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2017 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2020 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 341  namespace { Line 341  namespace {
341    
342    
343    
344    // *************** eg_opt_t ***************
345    // *
346    
347        eg_opt_t::eg_opt_t() {
348            AttackCancel     = true;
349            AttackHoldCancel = true;
350            Decay1Cancel     = true;
351            Decay2Cancel     = true;
352            ReleaseCancel    = true;
353        }
354    
355        void eg_opt_t::serialize(Serialization::Archive* archive) {
356            SRLZ(AttackCancel);
357            SRLZ(AttackHoldCancel);
358            SRLZ(Decay1Cancel);
359            SRLZ(Decay2Cancel);
360            SRLZ(ReleaseCancel);
361        }
362    
363    
364    
365  // *************** Sample ***************  // *************** Sample ***************
366  // *  // *
367    
# Line 391  namespace { Line 412  namespace {
412    
413          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
414          if (pCk3gix) {          if (pCk3gix) {
415                pCk3gix->SetPos(0);
416    
417              uint16_t iSampleGroup = pCk3gix->ReadInt16();              uint16_t iSampleGroup = pCk3gix->ReadInt16();
418              pGroup = pFile->GetGroup(iSampleGroup);              pGroup = pFile->GetGroup(iSampleGroup);
419          } else { // '3gix' chunk missing          } else { // '3gix' chunk missing
# Line 400  namespace { Line 423  namespace {
423    
424          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
425          if (pCkSmpl) {          if (pCkSmpl) {
426                pCkSmpl->SetPos(0);
427    
428              Manufacturer  = pCkSmpl->ReadInt32();              Manufacturer  = pCkSmpl->ReadInt32();
429              Product       = pCkSmpl->ReadInt32();              Product       = pCkSmpl->ReadInt32();
430              SamplePeriod  = pCkSmpl->ReadInt32();              SamplePeriod  = pCkSmpl->ReadInt32();
# Line 446  namespace { Line 471  namespace {
471          Dithered          = false;          Dithered          = false;
472          TruncatedBits     = 0;          TruncatedBits     = 0;
473          if (Compressed) {          if (Compressed) {
474                ewav->SetPos(0);
475    
476              uint32_t version = ewav->ReadInt32();              uint32_t version = ewav->ReadInt32();
477              if (version == 3 && BitDepth == 24) {              if (version > 2 && BitDepth == 24) {
478                  Dithered = ewav->ReadInt32();                  Dithered = ewav->ReadInt32();
479                  ewav->SetPos(Channels == 2 ? 84 : 64);                  ewav->SetPos(Channels == 2 ? 84 : 64);
480                  TruncatedBits = ewav->ReadInt32();                  TruncatedBits = ewav->ReadInt32();
# Line 1479  namespace { Line 1506  namespace {
1506    
1507          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
1508          if (_3ewa) { // if '3ewa' chunk exists          if (_3ewa) { // if '3ewa' chunk exists
1509                _3ewa->SetPos(0);
1510    
1511              _3ewa->ReadInt32(); // unknown, always == chunk size ?              _3ewa->ReadInt32(); // unknown, always == chunk size ?
1512              LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
1513              EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());              EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
# Line 1712  namespace { Line 1741  namespace {
1741              memset(DimensionUpperLimits, 127, 8);              memset(DimensionUpperLimits, 127, 8);
1742          }          }
1743    
1744            // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1745            RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1746            if (lsde) { // format extension for EG behavior options
1747                lsde->SetPos(0);
1748    
1749                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1750                for (int i = 0; i < 2; ++i) { // NOTE: we reserved a 3rd byte for a potential future EG3 option
1751                    unsigned char byte = lsde->ReadUint8();
1752                    pEGOpts[i]->AttackCancel     = byte & 1;
1753                    pEGOpts[i]->AttackHoldCancel = byte & (1 << 1);
1754                    pEGOpts[i]->Decay1Cancel     = byte & (1 << 2);
1755                    pEGOpts[i]->Decay2Cancel     = byte & (1 << 3);
1756                    pEGOpts[i]->ReleaseCancel    = byte & (1 << 4);
1757                }
1758            }
1759            // format extension for sustain pedal up effect on release trigger samples
1760            if (lsde && lsde->GetSize() > 3) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
1761                lsde->SetPos(3);
1762                uint8_t byte = lsde->ReadUint8();
1763                SustainReleaseTrigger   = static_cast<sust_rel_trg_t>(byte & 0x03);
1764                NoNoteOffReleaseTrigger = byte >> 7;
1765            } else {
1766                SustainReleaseTrigger   = sust_rel_trg_none;
1767                NoNoteOffReleaseTrigger = false;
1768            }
1769            // format extension for LFOs' wave form, phase displacement and for
1770            // LFO3's flip phase
1771            if (lsde && lsde->GetSize() > 4) {
1772                lsde->SetPos(4);
1773                LFO1WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1774                LFO2WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1775                LFO3WaveForm = static_cast<lfo_wave_t>( lsde->ReadUint16() );
1776                lsde->ReadUint16(); // unused 16 bits, reserved for potential future use
1777                LFO1Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1778                LFO2Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1779                LFO3Phase = (double) GIG_EXP_DECODE( lsde->ReadInt32() );
1780                const uint32_t flags = lsde->ReadInt32();
1781                LFO3FlipPhase = flags & 1;
1782            } else {
1783                LFO1WaveForm = lfo_wave_sine;
1784                LFO2WaveForm = lfo_wave_sine;
1785                LFO3WaveForm = lfo_wave_sine;
1786                LFO1Phase = 0.0;
1787                LFO2Phase = 0.0;
1788                LFO3Phase = 0.0;
1789                LFO3FlipPhase = false;
1790            }
1791    
1792          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1793                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
1794                                                       VelocityResponseCurveScaling);                                                       VelocityResponseCurveScaling);
# Line 1836  namespace { Line 1913  namespace {
1913          SRLZ(EG1ControllerAttackInfluence);          SRLZ(EG1ControllerAttackInfluence);
1914          SRLZ(EG1ControllerDecayInfluence);          SRLZ(EG1ControllerDecayInfluence);
1915          SRLZ(EG1ControllerReleaseInfluence);          SRLZ(EG1ControllerReleaseInfluence);
1916            SRLZ(LFO1WaveForm);
1917          SRLZ(LFO1Frequency);          SRLZ(LFO1Frequency);
1918            SRLZ(LFO1Phase);
1919          SRLZ(LFO1InternalDepth);          SRLZ(LFO1InternalDepth);
1920          SRLZ(LFO1ControlDepth);          SRLZ(LFO1ControlDepth);
1921          SRLZ(LFO1Controller);          SRLZ(LFO1Controller);
# Line 1854  namespace { Line 1933  namespace {
1933          SRLZ(EG2ControllerAttackInfluence);          SRLZ(EG2ControllerAttackInfluence);
1934          SRLZ(EG2ControllerDecayInfluence);          SRLZ(EG2ControllerDecayInfluence);
1935          SRLZ(EG2ControllerReleaseInfluence);          SRLZ(EG2ControllerReleaseInfluence);
1936            SRLZ(LFO2WaveForm);
1937          SRLZ(LFO2Frequency);          SRLZ(LFO2Frequency);
1938            SRLZ(LFO2Phase);
1939          SRLZ(LFO2InternalDepth);          SRLZ(LFO2InternalDepth);
1940          SRLZ(LFO2ControlDepth);          SRLZ(LFO2ControlDepth);
1941          SRLZ(LFO2Controller);          SRLZ(LFO2Controller);
# Line 1862  namespace { Line 1943  namespace {
1943          SRLZ(LFO2Sync);          SRLZ(LFO2Sync);
1944          SRLZ(EG3Attack);          SRLZ(EG3Attack);
1945          SRLZ(EG3Depth);          SRLZ(EG3Depth);
1946            SRLZ(LFO3WaveForm);
1947          SRLZ(LFO3Frequency);          SRLZ(LFO3Frequency);
1948            SRLZ(LFO3Phase);
1949          SRLZ(LFO3InternalDepth);          SRLZ(LFO3InternalDepth);
1950          SRLZ(LFO3ControlDepth);          SRLZ(LFO3ControlDepth);
1951          SRLZ(LFO3Controller);          SRLZ(LFO3Controller);
1952            SRLZ(LFO3FlipPhase);
1953          SRLZ(LFO3Sync);          SRLZ(LFO3Sync);
1954          SRLZ(VCFEnabled);          SRLZ(VCFEnabled);
1955          SRLZ(VCFType);          SRLZ(VCFType);
# Line 1899  namespace { Line 1983  namespace {
1983          SRLZ(MSDecode);          SRLZ(MSDecode);
1984          //SRLZ(SampleStartOffset);          //SRLZ(SampleStartOffset);
1985          SRLZ(SampleAttenuation);          SRLZ(SampleAttenuation);
1986            SRLZ(EG1Options);
1987            SRLZ(EG2Options);
1988            SRLZ(SustainReleaseTrigger);
1989            SRLZ(NoNoteOffReleaseTrigger);
1990    
1991          // derived attributes from DLS::Sampler          // derived attributes from DLS::Sampler
1992          SRLZ(FineTune);          SRLZ(FineTune);
# Line 1938  namespace { Line 2026  namespace {
2026          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
2027          if (!_3ewa) {          if (!_3ewa) {
2028              File* pFile = (File*) GetParent()->GetParent()->GetParent();              File* pFile = (File*) GetParent()->GetParent()->GetParent();
2029              bool version3 = pFile->pVersion && pFile->pVersion->major == 3;              bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
2030              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, versiongt2 ? 148 : 140);
2031          }          }
2032          pData = (uint8_t*) _3ewa->LoadChunkData();          pData = (uint8_t*) _3ewa->LoadChunkData();
2033    
# Line 2205  namespace { Line 2293  namespace {
2293          if (chunksize >= 148) {          if (chunksize >= 148) {
2294              memcpy(&pData[140], DimensionUpperLimits, 8);              memcpy(&pData[140], DimensionUpperLimits, 8);
2295          }          }
2296    
2297            // chunk for own format extensions, these will *NOT* work with
2298            // Gigasampler/GigaStudio !
2299            RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2300            const int lsdeSize =
2301                3 /* EG cancel options */ +
2302                1 /* sustain pedal up on release trigger option */ +
2303                8 /* LFOs' wave forms */ + 12 /* LFOs' phase */ + 4 /* flags (LFO3FlipPhase) */;
2304            if (!lsde && UsesAnyGigFormatExtension()) {
2305                // only add this "LSDE" chunk if there is some (format extension)
2306                // setting effective that would require our "LSDE" format extension
2307                // chunk to be stored
2308                lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2309                // move LSDE chunk to the end of parent list
2310                pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
2311            }
2312            if (lsde) {
2313                if (lsde->GetNewSize() < lsdeSize)
2314                    lsde->Resize(lsdeSize);
2315                // format extension for EG behavior options
2316                unsigned char* pData = (unsigned char*) lsde->LoadChunkData();
2317                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
2318                for (int i = 0; i < 2; ++i) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
2319                    pData[i] =
2320                        (pEGOpts[i]->AttackCancel     ? 1 : 0) |
2321                        (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) |
2322                        (pEGOpts[i]->Decay1Cancel     ? (1<<2) : 0) |
2323                        (pEGOpts[i]->Decay2Cancel     ? (1<<3) : 0) |
2324                        (pEGOpts[i]->ReleaseCancel    ? (1<<4) : 0);
2325                }
2326                // format extension for release trigger options
2327                pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2328                // format extension for LFOs' wave form, phase displacement and for
2329                // LFO3's flip phase
2330                store16(&pData[4], LFO1WaveForm);
2331                store16(&pData[6], LFO2WaveForm);
2332                store16(&pData[8], LFO3WaveForm);
2333                //NOTE: 16 bits reserved here for potential future use !
2334                const int32_t lfo1Phase = (int32_t) GIG_EXP_ENCODE(LFO1Phase);
2335                const int32_t lfo2Phase = (int32_t) GIG_EXP_ENCODE(LFO2Phase);
2336                const int32_t lfo3Phase = (int32_t) GIG_EXP_ENCODE(LFO3Phase);
2337                store32(&pData[12], lfo1Phase);
2338                store32(&pData[16], lfo2Phase);
2339                store32(&pData[20], lfo3Phase);
2340                const int32_t flags = LFO3FlipPhase ? 1 : 0;
2341                store32(&pData[24], flags);
2342    
2343                // compile time sanity check: is our last store access here
2344                // consistent with the initial lsdeSize value assignment?
2345                static_assert(lsdeSize == 28, "Inconsistency in assumed 'LSDE' RIFF chunk size");
2346            }
2347        }
2348    
2349        /**
2350         * Returns @c true in case this DimensionRegion object uses any gig format
2351         * extension, that is whether this DimensionRegion object currently has any
2352         * setting effective that would require our "LSDE" RIFF chunk to be stored
2353         * to the gig file.
2354         *
2355         * Right now this is a private method. It is considerable though this method
2356         * to become (in slightly modified form) a public API method in future, i.e.
2357         * to allow instrument editors to visualize and/or warn the user of any
2358         * format extension being used. Right now this method really just serves to
2359         * answer the question whether an LSDE chunk is required, for the public API
2360         * purpose this method would also need to check whether any other setting
2361         * stored to the regular value '3ewa' chunk, is actually a format extension
2362         * as well.
2363         */
2364        bool DimensionRegion::UsesAnyGigFormatExtension() const {
2365            eg_opt_t defaultOpt;
2366            return memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2367                   memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||
2368                   SustainReleaseTrigger || NoNoteOffReleaseTrigger ||
2369                   LFO1WaveForm || LFO2WaveForm || LFO3WaveForm ||
2370                   LFO1Phase || LFO2Phase || LFO3Phase ||
2371                   LFO3FlipPhase;
2372      }      }
2373    
2374      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
# Line 2244  namespace { Line 2408  namespace {
2408      // 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
2409      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)
2410      {      {
2411            // sanity check input parameters
2412            // (fallback to some default parameters on ill input)
2413            switch (curveType) {
2414                case curve_type_nonlinear:
2415                case curve_type_linear:
2416                    if (depth > 4) {
2417                        printf("Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2418                        depth   = 0;
2419                        scaling = 0;
2420                    }
2421                    break;
2422                case curve_type_special:
2423                    if (depth > 5) {
2424                        printf("Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2425                        depth   = 0;
2426                        scaling = 0;
2427                    }
2428                    break;
2429                case curve_type_unknown:
2430                default:
2431                    printf("Warning: Unknown velocity curve type (0x%x).\n", curveType);
2432                    curveType = curve_type_linear;
2433                    depth     = 0;
2434                    scaling   = 0;
2435                    break;
2436            }
2437    
2438          double* table;          double* table;
2439          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2440          if (pVelocityTables->count(tableKey)) { // if key exists          if (pVelocityTables->count(tableKey)) { // if key exists
# Line 2619  namespace { Line 2810  namespace {
2810    
2811              // unknown controller type              // unknown controller type
2812              default:              default:
2813                  throw gig::Exception("Unknown leverage controller type (0x%x).", EncodedController);                  decodedcontroller.type = leverage_ctrl_t::type_none;
2814                    decodedcontroller.controller_number = 0;
2815                    printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2816                    break;
2817          }          }
2818          return decodedcontroller;          return decodedcontroller;
2819      }      }
# Line 3113  namespace { Line 3307  namespace {
3307          }          }
3308          Layers = 1;          Layers = 1;
3309          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3310          int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          int dimensionBits = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3311    
3312          // Actual Loading          // Actual Loading
3313    
# Line 3123  namespace { Line 3317  namespace {
3317    
3318          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
3319          if (_3lnk) {          if (_3lnk) {
3320                _3lnk->SetPos(0);
3321    
3322              DimensionRegions = _3lnk->ReadUint32();              DimensionRegions = _3lnk->ReadUint32();
3323              for (int i = 0; i < dimensionBits; i++) {              for (int i = 0; i < dimensionBits; i++) {
3324                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
# Line 3157  namespace { Line 3353  namespace {
3353              UpdateVelocityTable();              UpdateVelocityTable();
3354    
3355              // jump to start of the wave pool indices (if not already there)              // jump to start of the wave pool indices (if not already there)
3356              if (file->pVersion && file->pVersion->major == 3)              if (file->pVersion && file->pVersion->major > 2)
3357                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure
3358              else              else
3359                  _3lnk->SetPos(44);                  _3lnk->SetPos(44);
# Line 3166  namespace { Line 3362  namespace {
3362              if (file->GetAutoLoad()) {              if (file->GetAutoLoad()) {
3363                  for (uint i = 0; i < DimensionRegions; i++) {                  for (uint i = 0; i < DimensionRegions; i++) {
3364                      uint32_t wavepoolindex = _3lnk->ReadUint32();                      uint32_t wavepoolindex = _3lnk->ReadUint32();
3365                      if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      if (file->pWavePoolTable && pDimensionRegions[i])
3366                            pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3367                  }                  }
3368                  GetSample(); // load global region sample reference                  GetSample(); // load global region sample reference
3369              }              }
# Line 3215  namespace { Line 3412  namespace {
3412          }          }
3413    
3414          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
3415          bool version3 = pFile->pVersion && pFile->pVersion->major == 3;          const bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3416          const int iMaxDimensions =  version3 ? 8 : 5;          const int iMaxDimensions =  versiongt2 ? 8 : 5;
3417          const int iMaxDimensionRegions = version3 ? 256 : 32;          const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3418    
3419          // make sure '3lnk' chunk exists          // make sure '3lnk' chunk exists
3420          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
3421          if (!_3lnk) {          if (!_3lnk) {
3422              const int _3lnkChunkSize = version3 ? 1092 : 172;              const int _3lnkChunkSize = versiongt2 ? 1092 : 172;
3423              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
3424              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
3425    
# Line 3246  namespace { Line 3443  namespace {
3443          }          }
3444    
3445          // update wave pool table in '3lnk' chunk          // update wave pool table in '3lnk' chunk
3446          const int iWavePoolOffset = version3 ? 68 : 44;          const int iWavePoolOffset = versiongt2 ? 68 : 44;
3447          for (uint i = 0; i < iMaxDimensionRegions; i++) {          for (uint i = 0; i < iMaxDimensionRegions; i++) {
3448              int iWaveIndex = -1;              int iWaveIndex = -1;
3449              if (i < DimensionRegions) {              if (i < DimensionRegions) {
# Line 3262  namespace { Line 3459  namespace {
3459              }              }
3460              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);              store32(&pData[iWavePoolOffset + i * 4], iWaveIndex);
3461          }          }
3462    
3463            // The following chunks are just added for compatibility with the
3464            // GigaStudio software, which would show a warning if these were
3465            // missing. However currently these chunks don't cover any useful
3466            // data. So if this gig file uses any of our own gig format
3467            // extensions which would cause this gig file to be unloadable
3468            // with GSt software anyway, then just skip these GSt compatibility
3469            // chunks here as well.
3470            if (versiongt2 && !UsesAnyGigFormatExtension()) {
3471                // add 3dnm list which always seems to be empty
3472                RIFF::List* _3dnm = pCkRegion->GetSubList(LIST_TYPE_3DNM);
3473                if (!_3dnm) _3dnm = pCkRegion->AddSubList(LIST_TYPE_3DNM);
3474    
3475                // add 3ddp chunk which always seems to have 16 bytes of 0xFF
3476                RIFF::Chunk* _3ddp = pCkRegion->GetSubChunk(CHUNK_ID_3DDP);
3477                if (!_3ddp) _3ddp =  pCkRegion->AddSubChunk(CHUNK_ID_3DDP, 16);
3478                uint8_t* pData = (uint8_t*) _3ddp->LoadChunkData();
3479                for (int i = 0; i < 16; i += 4) {
3480                    store32(&pData[i], 0xFFFFFFFF);
3481                }
3482    
3483                // move 3dnm and 3ddp to the end of the region list
3484                pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3DNM), (RIFF::Chunk*)NULL);
3485                pCkRegion->MoveSubChunk(pCkRegion->GetSubChunk(CHUNK_ID_3DDP), (RIFF::Chunk*)NULL);
3486            } else {
3487                // this is intended for the user switching from GSt >= 3 version
3488                // back to an older format version, delete GSt3 chunks ...
3489                RIFF::List* _3dnm = pCkRegion->GetSubList(LIST_TYPE_3DNM);
3490                if (_3dnm) pCkRegion->DeleteSubChunk(_3dnm);
3491    
3492                RIFF::Chunk* _3ddp = pCkRegion->GetSubChunk(CHUNK_ID_3DDP);
3493                if (_3ddp) pCkRegion->DeleteSubChunk(_3ddp);
3494            }
3495      }      }
3496    
3497      void Region::LoadDimensionRegions(RIFF::List* rgn) {      void Region::LoadDimensionRegions(RIFF::List* rgn) {
# Line 3389  namespace { Line 3619  namespace {
3619    
3620          // check if max. amount of dimensions reached          // check if max. amount of dimensions reached
3621          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3622          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensions = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3623          if (Dimensions >= iMaxDimensions)          if (Dimensions >= iMaxDimensions)
3624              throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");              throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");
3625          // check if max. amount of dimension bits reached          // check if max. amount of dimension bits reached
# Line 3660  namespace { Line 3890  namespace {
3890          // now tempRegion's dimensions and DimensionRegions basically reflect          // now tempRegion's dimensions and DimensionRegions basically reflect
3891          // what we wanted to get for this actual Region here, so we now just          // what we wanted to get for this actual Region here, so we now just
3892          // delete and recreate the dimension in question with the new amount          // delete and recreate the dimension in question with the new amount
3893          // zones and then copy back from tempRegion                // zones and then copy back from tempRegion. we're actually deleting and
3894          DeleteDimension(oldDef);          // recreating all dimensions here, to avoid altering the precise order
3895          AddDimension(&newDef);          // of the dimensions (which would not be an error per se, but it would
3896            // cause usability issues with instrument editors)
3897            {
3898                std::vector<dimension_def_t> oldDefs;
3899                for (int i = 0; i < Dimensions; ++i)
3900                    oldDefs.push_back(pDimensionDefinitions[i]); // copy, don't reference
3901                for (int i = Dimensions - 1; i >= 0; --i)
3902                    DeleteDimension(&pDimensionDefinitions[i]);
3903                for (int i = 0; i < oldDefs.size(); ++i) {
3904                    dimension_def_t& def = oldDefs[i];
3905                    AddDimension(
3906                        (def.dimension == newDef.dimension) ? &newDef : &def
3907                    );
3908                }
3909            }
3910          for (int iSrc = 0; iSrc < 256; ++iSrc) {          for (int iSrc = 0; iSrc < 256; ++iSrc) {
3911              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
3912              if (!srcDimRgn) continue;              if (!srcDimRgn) continue;
# Line 3681  namespace { Line 3925  namespace {
3925          }          }
3926    
3927          // delete temporary region          // delete temporary region
3928            tempRgn->DeleteChunks();
3929          delete tempRgn;          delete tempRgn;
3930    
3931          UpdateVelocityTable();          UpdateVelocityTable();
# Line 3799  namespace { Line 4044  namespace {
4044          // now tempRegion's dimensions and DimensionRegions basically reflect          // now tempRegion's dimensions and DimensionRegions basically reflect
4045          // what we wanted to get for this actual Region here, so we now just          // what we wanted to get for this actual Region here, so we now just
4046          // delete and recreate the dimension in question with the new amount          // delete and recreate the dimension in question with the new amount
4047          // zones and then copy back from tempRegion                // zones and then copy back from tempRegion. we're actually deleting and
4048          DeleteDimension(oldDef);          // recreating all dimensions here, to avoid altering the precise order
4049          AddDimension(&newDef);          // of the dimensions (which would not be an error per se, but it would
4050            // cause usability issues with instrument editors)
4051            {
4052                std::vector<dimension_def_t> oldDefs;
4053                for (int i = 0; i < Dimensions; ++i)
4054                    oldDefs.push_back(pDimensionDefinitions[i]); // copy, don't reference
4055                for (int i = Dimensions - 1; i >= 0; --i)
4056                    DeleteDimension(&pDimensionDefinitions[i]);
4057                for (int i = 0; i < oldDefs.size(); ++i) {
4058                    dimension_def_t& def = oldDefs[i];
4059                    AddDimension(
4060                        (def.dimension == newDef.dimension) ? &newDef : &def
4061                    );
4062                }
4063            }
4064          for (int iSrc = 0; iSrc < 256; ++iSrc) {          for (int iSrc = 0; iSrc < 256; ++iSrc) {
4065              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];              DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
4066              if (!srcDimRgn) continue;              if (!srcDimRgn) continue;
# Line 3820  namespace { Line 4079  namespace {
4079          }          }
4080    
4081          // delete temporary region          // delete temporary region
4082            tempRgn->DeleteChunks();
4083          delete tempRgn;          delete tempRgn;
4084    
4085          UpdateVelocityTable();          UpdateVelocityTable();
# Line 4047  namespace { Line 4307  namespace {
4307          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
4308          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
4309          if (!file->pWavePoolTable) return NULL;          if (!file->pWavePoolTable) return NULL;
4310            if (WavePoolTableIndex + 1 > file->WavePoolCount) return NULL;
4311          // for new files or files >= 2 GB use 64 bit wave pool offsets          // for new files or files >= 2 GB use 64 bit wave pool offsets
4312          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
4313              // use 64 bit wave pool offsets (treating this as large file)              // use 64 bit wave pool offsets (treating this as large file)
# Line 4123  namespace { Line 4384  namespace {
4384          Layers = orig->Layers;          Layers = orig->Layers;
4385      }      }
4386    
4387        /**
4388         * Returns @c true in case this Region object uses any gig format
4389         * extension, that is e.g. whether any DimensionRegion object currently
4390         * has any setting effective that would require our "LSDE" RIFF chunk to
4391         * be stored to the gig file.
4392         *
4393         * Right now this is a private method. It is considerable though this method
4394         * to become (in slightly modified form) a public API method in future, i.e.
4395         * to allow instrument editors to visualize and/or warn the user of any gig
4396         * format extension being used. See also comments on
4397         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
4398         * potential public API change in future.
4399         */
4400        bool Region::UsesAnyGigFormatExtension() const {
4401            for (int i = 0; i < 256; i++) {
4402                if (pDimensionRegions[i]) {
4403                    if (pDimensionRegions[i]->UsesAnyGigFormatExtension())
4404                        return true;
4405                }
4406            }
4407            return false;
4408        }
4409    
4410    
4411  // *************** MidiRule ***************  // *************** MidiRule ***************
4412  // *  // *
# Line 4297  namespace { Line 4581  namespace {
4581          pGroup = group;          pGroup = group;
4582          pChunk = ckScri;          pChunk = ckScri;
4583          if (ckScri) { // object is loaded from file ...          if (ckScri) { // object is loaded from file ...
4584                ckScri->SetPos(0);
4585    
4586              // read header              // read header
4587              uint32_t headerSize = ckScri->ReadUint32();              uint32_t headerSize = ckScri->ReadUint32();
4588              Compression = (Compression_t) ckScri->ReadUint32();              Compression = (Compression_t) ckScri->ReadUint32();
4589              Encoding    = (Encoding_t) ckScri->ReadUint32();              Encoding    = (Encoding_t) ckScri->ReadUint32();
4590              Language    = (Language_t) ckScri->ReadUint32();              Language    = (Language_t) ckScri->ReadUint32();
4591              Bypass      = (Language_t) ckScri->ReadUint32() & 1;              Bypass      = ckScri->ReadUint32() & 1;
4592              crc         = ckScri->ReadUint32();              crc         = ckScri->ReadUint32();
4593              uint32_t nameSize = ckScri->ReadUint32();              uint32_t nameSize = ckScri->ReadUint32();
4594              Name.resize(nameSize, ' ');              Name.resize(nameSize, ' ');
4595              for (int i = 0; i < nameSize; ++i)              for (int i = 0; i < nameSize; ++i)
4596                  Name[i] = ckScri->ReadUint8();                  Name[i] = ckScri->ReadUint8();
4597                // check if an uuid was already stored along with this script
4598                if (headerSize >= 6*sizeof(int32_t) + nameSize + 16) { // yes ...
4599                    for (uint i = 0; i < 16; ++i) {
4600                        Uuid[i] = ckScri->ReadUint8();
4601                    }
4602                } else { // no uuid yet, generate one now ...
4603                    GenerateUuid();
4604                }
4605              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4606              ckScri->SetPos(sizeof(int32_t) + headerSize);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4607              // read actual script data              // read actual script data
# Line 4322  namespace { Line 4616  namespace {
4616              Bypass   = false;              Bypass   = false;
4617              crc      = 0;              crc      = 0;
4618              Name     = "Unnamed Script";              Name     = "Unnamed Script";
4619                GenerateUuid();
4620          }          }
4621      }      }
4622    
# Line 4349  namespace { Line 4644  namespace {
4644          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4645      }      }
4646    
4647        /** @brief Remove all RIFF chunks associated with this Script object.
4648         *
4649         * At the moment Script::DeleteChunks() does nothing. It is
4650         * recommended to call this method explicitly though from deriving classes's
4651         * own overridden implementation of this method to avoid potential future
4652         * compatiblity issues.
4653         *
4654         * See DLS::Storage::DeleteChunks() for details.
4655         */
4656        void Script::DeleteChunks() {
4657        }
4658    
4659      /**      /**
4660       * Apply this script to the respective RIFF chunks. You have to call       * Apply this script to the respective RIFF chunks. You have to call
4661       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4364  namespace { Line 4671  namespace {
4671          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
4672          __finalizeCRC(crc);          __finalizeCRC(crc);
4673          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4674          const file_offset_t chunkSize = (file_offset_t) 7*sizeof(int32_t) + Name.size() + data.size();          const file_offset_t chunkSize =
4675                (file_offset_t) 7*sizeof(int32_t) + Name.size() + 16 + data.size();
4676          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4677          else pChunk->Resize(chunkSize);          else pChunk->Resize(chunkSize);
4678          // fill the chunk data to be written to disk          // fill the chunk data to be written to disk
4679          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4680          int pos = 0;          int pos = 0;
4681          store32(&pData[pos], uint32_t(6*sizeof(int32_t) + Name.size())); // total header size          store32(&pData[pos], uint32_t(6*sizeof(int32_t) + Name.size() + 16)); // total header size
4682          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4683          store32(&pData[pos], Compression);          store32(&pData[pos], Compression);
4684          pos += sizeof(int32_t);          pos += sizeof(int32_t);
# Line 4386  namespace { Line 4694  namespace {
4694          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4695          for (int i = 0; i < Name.size(); ++i, ++pos)          for (int i = 0; i < Name.size(); ++i, ++pos)
4696              pData[pos] = Name[i];              pData[pos] = Name[i];
4697            for (int i = 0; i < 16; ++i, ++pos)
4698                pData[pos] = Uuid[i];
4699          for (int i = 0; i < data.size(); ++i, ++pos)          for (int i = 0; i < data.size(); ++i, ++pos)
4700              pData[pos] = data[i];              pData[pos] = data[i];
4701      }      }
4702    
4703      /**      /**
4704         * Generate a new Universally Unique Identifier (UUID) for this script.
4705         */
4706        void Script::GenerateUuid() {
4707            DLS::dlsid_t dlsid;
4708            DLS::Resource::GenerateDLSID(&dlsid);
4709            Uuid[0]  = dlsid.ulData1       & 0xff;
4710            Uuid[1]  = dlsid.ulData1 >>  8 & 0xff;
4711            Uuid[2]  = dlsid.ulData1 >> 16 & 0xff;
4712            Uuid[3]  = dlsid.ulData1 >> 24 & 0xff;
4713            Uuid[4]  = dlsid.usData2       & 0xff;
4714            Uuid[5]  = dlsid.usData2 >>  8 & 0xff;
4715            Uuid[6]  = dlsid.usData3       & 0xff;
4716            Uuid[7]  = dlsid.usData3 >>  8 & 0xff;
4717            Uuid[8]  = dlsid.abData[0];
4718            Uuid[9]  = dlsid.abData[1];
4719            Uuid[10] = dlsid.abData[2];
4720            Uuid[11] = dlsid.abData[3];
4721            Uuid[12] = dlsid.abData[4];
4722            Uuid[13] = dlsid.abData[5];
4723            Uuid[14] = dlsid.abData[6];
4724            Uuid[15] = dlsid.abData[7];
4725        }
4726    
4727        /**
4728       * Move this script from its current ScriptGroup to another ScriptGroup       * Move this script from its current ScriptGroup to another ScriptGroup
4729       * given by @a pGroup.       * given by @a pGroup.
4730       *       *
# Line 4464  namespace { Line 4798  namespace {
4798          }          }
4799      }      }
4800    
4801        /** @brief Remove all RIFF chunks associated with this ScriptGroup object.
4802         *
4803         * At the moment ScriptGroup::DeleteChunks() does nothing. It is
4804         * recommended to call this method explicitly though from deriving classes's
4805         * own overridden implementation of this method to avoid potential future
4806         * compatiblity issues.
4807         *
4808         * See DLS::Storage::DeleteChunks() for details.
4809         */
4810        void ScriptGroup::DeleteChunks() {
4811        }
4812    
4813      /**      /**
4814       * Apply this script group to the respective RIFF chunks. You have to call       * Apply this script group to the respective RIFF chunks. You have to call
4815       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4588  namespace { Line 4934  namespace {
4934          if (lart) {          if (lart) {
4935              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
4936              if (_3ewg) {              if (_3ewg) {
4937                    _3ewg->SetPos(0);
4938    
4939                  EffectSend             = _3ewg->ReadUint16();                  EffectSend             = _3ewg->ReadUint16();
4940                  Attenuation            = _3ewg->ReadInt32();                  Attenuation            = _3ewg->ReadInt32();
4941                  FineTune               = _3ewg->ReadInt16();                  FineTune               = _3ewg->ReadInt16();
# Line 4632  namespace { Line 4980  namespace {
4980                  RIFF::List* rgn = lrgn->GetFirstSubList();                  RIFF::List* rgn = lrgn->GetFirstSubList();
4981                  while (rgn) {                  while (rgn) {
4982                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4983                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                          if (pProgress)
4984                                __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4985                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
4986                      }                      }
4987                      rgn = lrgn->GetNextSubList();                      rgn = lrgn->GetNextSubList();
# Line 4647  namespace { Line 4996  namespace {
4996          if (lst3LS) {          if (lst3LS) {
4997              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4998              if (ckSCSL) {              if (ckSCSL) {
4999                    ckSCSL->SetPos(0);
5000    
5001                  int headerSize = ckSCSL->ReadUint32();                  int headerSize = ckSCSL->ReadUint32();
5002                  int slotCount  = ckSCSL->ReadUint32();                  int slotCount  = ckSCSL->ReadUint32();
5003                  if (slotCount) {                  if (slotCount) {
# Line 4664  namespace { Line 5015  namespace {
5015              }              }
5016          }          }
5017    
5018          __notify_progress(pProgress, 1.0f); // notify done          if (pProgress)
5019                __notify_progress(pProgress, 1.0f); // notify done
5020      }      }
5021    
5022      void Instrument::UpdateRegionKeyTable() {      void Instrument::UpdateRegionKeyTable() {
# Line 4673  namespace { Line 5025  namespace {
5025          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
5026          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
5027              gig::Region* pRegion = static_cast<gig::Region*>(*iter);              gig::Region* pRegion = static_cast<gig::Region*>(*iter);
5028              for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {              const int low  = std::max(int(pRegion->KeyRange.low), 0);
5029                const int high = std::min(int(pRegion->KeyRange.high), 127);
5030                for (int iKey = low; iKey <= high; iKey++) {
5031                  RegionKeyTable[iKey] = pRegion;                  RegionKeyTable[iKey] = pRegion;
5032              }              }
5033          }          }
# Line 4718  namespace { Line 5072  namespace {
5072              File* pFile = (File*) GetParent();              File* pFile = (File*) GetParent();
5073    
5074              // 3ewg is bigger in gig3, as it includes the iMIDI rules              // 3ewg is bigger in gig3, as it includes the iMIDI rules
5075              int size = (pFile->pVersion && pFile->pVersion->major == 3) ? 16416 : 12;              int size = (pFile->pVersion && pFile->pVersion->major > 2) ? 16416 : 12;
5076              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);
5077              memset(_3ewg->LoadChunkData(), 0, size);              memset(_3ewg->LoadChunkData(), 0, size);
5078          }          }
# Line 5259  namespace { Line 5613  namespace {
5613          UpdateRegionKeyTable();          UpdateRegionKeyTable();
5614      }      }
5615    
5616        /**
5617         * Returns @c true in case this Instrument object uses any gig format
5618         * extension, that is e.g. whether any DimensionRegion object currently
5619         * has any setting effective that would require our "LSDE" RIFF chunk to
5620         * be stored to the gig file.
5621         *
5622         * Right now this is a private method. It is considerable though this method
5623         * to become (in slightly modified form) a public API method in future, i.e.
5624         * to allow instrument editors to visualize and/or warn the user of any gig
5625         * format extension being used. See also comments on
5626         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
5627         * potential public API change in future.
5628         */
5629        bool Instrument::UsesAnyGigFormatExtension() const {
5630            if (!pRegions) return false;
5631            RegionList::const_iterator iter = pRegions->begin();
5632            RegionList::const_iterator end  = pRegions->end();
5633            for (; iter != end; ++iter) {
5634                gig::Region* rgn = static_cast<gig::Region*>(*iter);
5635                if (rgn->UsesAnyGigFormatExtension())
5636                    return true;
5637            }
5638            return false;
5639        }
5640    
5641    
5642  // *************** Group ***************  // *************** Group ***************
5643  // *  // *
# Line 5275  namespace { Line 5654  namespace {
5654          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
5655      }      }
5656    
5657        /** @brief Destructor.
5658         *
5659         * Currently this destructor implementation does nothing.
5660         */
5661      Group::~Group() {      Group::~Group() {
5662          // remove the chunk associated with this group (if any)      }
5663          if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);  
5664        /** @brief Remove all RIFF chunks associated with this Group object.
5665         *
5666         * See DLS::Storage::DeleteChunks() for details.
5667         */
5668        void Group::DeleteChunks() {
5669            // handle own RIFF chunks
5670            if (pNameChunk) {
5671                pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5672                pNameChunk = NULL;
5673            }
5674      }      }
5675    
5676      /** @brief Update chunks with current group settings.      /** @brief Update chunks with current group settings.
# Line 5300  namespace { Line 5693  namespace {
5693          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
5694          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
5695    
5696          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major == 3) {          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
5697              // v3 has a fixed list of 128 strings, find a free one              // v3 has a fixed list of 128 strings, find a free one
5698              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {
5699                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
# Line 5395  namespace { Line 5788  namespace {
5788          0, 3, 20030331 & 0xffff, 20030331 >> 16          0, 3, 20030331 & 0xffff, 20030331 >> 16
5789      };      };
5790    
5791        /// Reflects Gigasampler file format version 4.0 (2007-10-12).
5792        const DLS::version_t File::VERSION_4 = {
5793            0, 4, 20071012 & 0xffff, 20071012 >> 16
5794        };
5795    
5796      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
5797          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
5798          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
# Line 5491  namespace { Line 5889  namespace {
5889          return static_cast<gig::Sample*>( *it );          return static_cast<gig::Sample*>( *it );
5890      }      }
5891    
5892        /**
5893         * Returns the total amount of samples of this gig file.
5894         *
5895         * Note that this method might block for a long time in case it is required
5896         * to load the sample info for the first time.
5897         *
5898         * @returns total amount of samples
5899         */
5900        size_t File::CountSamples() {
5901            if (!pSamples) LoadSamples();
5902            if (!pSamples) return 0;
5903            return pSamples->size();
5904        }
5905    
5906      /** @brief Add a new sample.      /** @brief Add a new sample.
5907       *       *
5908       * This will create a new Sample object for the gig file. You have to       * This will create a new Sample object for the gig file. You have to
# Line 5529  namespace { Line 5941  namespace {
5941          if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");          if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");
5942          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
5943          pSamples->erase(iter);          pSamples->erase(iter);
5944            pSample->DeleteChunks();
5945          delete pSample;          delete pSample;
5946    
5947          SampleList::iterator tmp = SamplesIterator;          SampleList::iterator tmp = SamplesIterator;
# Line 5566  namespace { Line 5979  namespace {
5979          int iSampleIndex  = 0;          int iSampleIndex  = 0;
5980          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5981    
5982          // check if samples should be loaded from extension files          // just for assembling path of optional extension files to be read
5983          // (only for old gig files < 2 GB)          const std::string folder = parentPath(pRIFF->GetFileName());
5984          int lastFileNo = 0;          const std::string baseName = pathWithoutExtension(pRIFF->GetFileName());
5985          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {  
5986              for (int i = 0 ; i < WavePoolCount ; i++) {          // the main gig file and the extension files (.gx01, ... , .gx98) may
5987                  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];          // contain wave data (wave pool)
5988              }          std::vector<RIFF::File*> poolFiles;
5989          }          poolFiles.push_back(pRIFF);
5990          String name(pRIFF->GetFileName());  
5991          int nameLen = (int) name.length();          // get info about all extension files
5992          char suffix[6];          RIFF::Chunk* ckXfil = pRIFF->GetSubChunk(CHUNK_ID_XFIL);
5993          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (ckXfil) { // there are extension files (.gx01, ... , .gx98) ...
5994                const uint32_t n = ckXfil->ReadInt32();
5995          for (int fileNo = 0 ; ; ) {              for (int i = 0; i < n; i++) {
5996                    // read the filename and load the extension file
5997                    std::string name;
5998                    ckXfil->ReadString(name, 128);
5999                    std::string path = concatPath(folder, name);
6000                    RIFF::File* pExtFile = new RIFF::File(path);
6001                    // check that the dlsids match
6002                    RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
6003                    if (ckDLSID) {
6004                        ::DLS::dlsid_t idExpected;
6005                        idExpected.ulData1 = ckXfil->ReadInt32();
6006                        idExpected.usData2 = ckXfil->ReadInt16();
6007                        idExpected.usData3 = ckXfil->ReadInt16();
6008                        ckXfil->Read(idExpected.abData, 8, 1);
6009                        ::DLS::dlsid_t idFound;
6010                        ckDLSID->Read(&idFound.ulData1, 1, 4);
6011                        ckDLSID->Read(&idFound.usData2, 1, 2);
6012                        ckDLSID->Read(&idFound.usData3, 1, 2);
6013                        ckDLSID->Read(idFound.abData, 8, 1);
6014                        if (memcmp(&idExpected, &idFound, 16) != 0)
6015                            throw gig::Exception("dlsid mismatch for extension file: %s", path.c_str());
6016                    }
6017                    poolFiles.push_back(pExtFile);
6018                    ExtensionFiles.push_back(pExtFile);
6019                }
6020            }
6021    
6022            // check if a .gx99 (GigaPulse) file exists
6023            RIFF::Chunk* ckDoxf = pRIFF->GetSubChunk(CHUNK_ID_DOXF);
6024            if (ckDoxf) { // there is a .gx99 (GigaPulse) file ...
6025                std::string path = baseName + ".gx99";
6026                RIFF::File* pExtFile = new RIFF::File(path);
6027    
6028                // skip unused int and filename
6029                ckDoxf->SetPos(132, RIFF::stream_curpos);
6030    
6031                // check that the dlsids match
6032                RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
6033                if (ckDLSID) {
6034                    ::DLS::dlsid_t idExpected;
6035                    idExpected.ulData1 = ckDoxf->ReadInt32();
6036                    idExpected.usData2 = ckDoxf->ReadInt16();
6037                    idExpected.usData3 = ckDoxf->ReadInt16();
6038                    ckDoxf->Read(idExpected.abData, 8, 1);
6039                    ::DLS::dlsid_t idFound;
6040                    ckDLSID->Read(&idFound.ulData1, 1, 4);
6041                    ckDLSID->Read(&idFound.usData2, 1, 2);
6042                    ckDLSID->Read(&idFound.usData3, 1, 2);
6043                    ckDLSID->Read(idFound.abData, 8, 1);
6044                    if (memcmp(&idExpected, &idFound, 16) != 0)
6045                        throw gig::Exception("dlsid mismatch for GigaPulse file: %s", path.c_str());
6046                }
6047                poolFiles.push_back(pExtFile);
6048                ExtensionFiles.push_back(pExtFile);
6049            }
6050    
6051            // load samples from extension files (if required)
6052            for (int i = 0; i < poolFiles.size(); i++) {
6053                RIFF::File* file = poolFiles[i];
6054              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
6055              if (wvpl) {              if (wvpl) {
6056                  file_offset_t wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
6057                                                   wvpl->GetPos(); // should be zero, but just to be sure
6058                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
6059                  while (wave) {                  while (wave) {
6060                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
6061                          // notify current progress                          // notify current progress
6062                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          if (pProgress) {
6063                          __notify_progress(pProgress, subprogress);                              const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
6064                                __notify_progress(pProgress, subprogress);
6065                            }
6066    
6067                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
6068                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));
6069    
6070                          iSampleIndex++;                          iSampleIndex++;
6071                      }                      }
6072                      wave = wvpl->GetNextSubList();                      wave = wvpl->GetNextSubList();
6073                  }                  }
6074                }
                 if (fileNo == lastFileNo) break;  
   
                 // open extension file (*.gx01, *.gx02, ...)  
                 fileNo++;  
                 sprintf(suffix, ".gx%02d", fileNo);  
                 name.replace(nameLen, 5, suffix);  
                 file = new RIFF::File(name);  
                 ExtensionFiles.push_back(file);  
             } else break;  
6075          }          }
6076    
6077          __notify_progress(pProgress, 1.0); // notify done          if (pProgress)
6078                __notify_progress(pProgress, 1.0); // notify done
6079      }      }
6080    
6081      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
# Line 5626  namespace { Line 6092  namespace {
6092      }      }
6093    
6094      /**      /**
6095         * Returns the total amount of instruments of this gig file.
6096         *
6097         * Note that this method might block for a long time in case it is required
6098         * to load the instruments info for the first time.
6099         *
6100         * @returns total amount of instruments
6101         */
6102        size_t File::CountInstruments() {
6103            if (!pInstruments) LoadInstruments();
6104            if (!pInstruments) return 0;
6105            return pInstruments->size();
6106        }
6107    
6108        /**
6109       * Returns the instrument with the given index.       * Returns the instrument with the given index.
6110       *       *
6111       * @param index     - number of the sought instrument (0..n)       * @param index     - number of the sought instrument (0..n)
# Line 5636  namespace { Line 6116  namespace {
6116          if (!pInstruments) {          if (!pInstruments) {
6117              // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)              // TODO: hack - we simply load ALL samples here, it would have been done in the Region constructor anyway (ATM)
6118    
6119              // sample loading subtask              if (pProgress) {
6120              progress_t subprogress;                  // sample loading subtask
6121              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask                  progress_t subprogress;
6122              __notify_progress(&subprogress, 0.0f);                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
6123              if (GetAutoLoad())                  __notify_progress(&subprogress, 0.0f);
6124                  GetFirstSample(&subprogress); // now force all samples to be loaded                  if (GetAutoLoad())
6125              __notify_progress(&subprogress, 1.0f);                      GetFirstSample(&subprogress); // now force all samples to be loaded
6126                    __notify_progress(&subprogress, 1.0f);
6127              // instrument loading subtask  
6128              if (pProgress && pProgress->callback) {                  // instrument loading subtask
6129                  subprogress.__range_min = subprogress.__range_max;                  if (pProgress->callback) {
6130                  subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask                      subprogress.__range_min = subprogress.__range_max;
6131              }                      subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
6132              __notify_progress(&subprogress, 0.0f);                  }
6133              LoadInstruments(&subprogress);                  __notify_progress(&subprogress, 0.0f);
6134              __notify_progress(&subprogress, 1.0f);                  LoadInstruments(&subprogress);
6135                    __notify_progress(&subprogress, 1.0f);
6136                } else {
6137                    // sample loading subtask
6138                    if (GetAutoLoad())
6139                        GetFirstSample(); // now force all samples to be loaded
6140    
6141                    // instrument loading subtask
6142                    LoadInstruments();
6143                }
6144          }          }
6145          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6146          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
# Line 5800  namespace { Line 6289  namespace {
6289          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
6290          if (iter == pInstruments->end()) throw gig::Exception("Could not delete instrument, could not find given instrument");          if (iter == pInstruments->end()) throw gig::Exception("Could not delete instrument, could not find given instrument");
6291          pInstruments->erase(iter);          pInstruments->erase(iter);
6292            pInstrument->DeleteChunks();
6293          delete pInstrument;          delete pInstrument;
6294      }      }
6295    
# Line 5815  namespace { Line 6305  namespace {
6305              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
6306              while (lstInstr) {              while (lstInstr) {
6307                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6308                      // notify current progress                      if (pProgress) {
6309                      const float localProgress = (float) iInstrumentIndex / (float) Instruments;                          // notify current progress
6310                      __notify_progress(pProgress, localProgress);                          const float localProgress = (float) iInstrumentIndex / (float) Instruments;
6311                            __notify_progress(pProgress, localProgress);
                     // divide local progress into subprogress for loading current Instrument  
                     progress_t subprogress;  
                     __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);  
6312    
6313                      pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));                          // divide local progress into subprogress for loading current Instrument
6314                            progress_t subprogress;
6315                            __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
6316    
6317                            pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
6318                        } else {
6319                            pInstruments->push_back(new Instrument(this, lstInstr));
6320                        }
6321    
6322                      iInstrumentIndex++;                      iInstrumentIndex++;
6323                  }                  }
6324                  lstInstr = lstInstruments->GetNextSubList();                  lstInstr = lstInstruments->GetNextSubList();
6325              }              }
6326              __notify_progress(pProgress, 1.0); // notify done              if (pProgress)
6327                    __notify_progress(pProgress, 1.0); // notify done
6328          }          }
6329      }      }
6330    
# Line 5944  namespace { Line 6439  namespace {
6439              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6440              // the order of einf and 3crc is not the same in v2 and v3              // the order of einf and 3crc is not the same in v2 and v3
6441              RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);              RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6442              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6443              bRequiresSave = true;              bRequiresSave = true;
6444          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
6445              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
# Line 6059  namespace { Line 6554  namespace {
6554          }          }
6555          // now delete this group object          // now delete this group object
6556          pGroups->erase(iter);          pGroups->erase(iter);
6557            pGroup->DeleteChunks();
6558          delete pGroup;          delete pGroup;
6559      }      }
6560    
# Line 6080  namespace { Line 6576  namespace {
6576          // move all members of this group to another group          // move all members of this group to another group
6577          pGroup->MoveAll();          pGroup->MoveAll();
6578          pGroups->erase(iter);          pGroups->erase(iter);
6579            pGroup->DeleteChunks();
6580          delete pGroup;          delete pGroup;
6581      }      }
6582    
# Line 6093  namespace { Line 6590  namespace {
6590                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
6591                  while (ck) {                  while (ck) {
6592                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
6593                          if (pVersion && pVersion->major == 3 &&                          if (pVersion && pVersion->major > 2 &&
6594                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
6595    
6596                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
# Line 6179  namespace { Line 6676  namespace {
6676              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
6677          if (pScriptGroup->pList)          if (pScriptGroup->pList)
6678              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
6679            pScriptGroup->DeleteChunks();
6680          delete pScriptGroup;          delete pScriptGroup;
6681      }      }
6682    
# Line 6269  namespace { Line 6767  namespace {
6767    
6768              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
6769              // (before updating the Group chunks)              // (before updating the Group chunks)
6770              if (pVersion && pVersion->major == 3) {              if (pVersion && pVersion->major > 2) {
6771                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
6772                  for (int i = 0 ; i < 128 ; i++) {                  for (int i = 0 ; i < 128 ; i++) {
6773                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      // create 128 empty placeholder strings which will either
6774                        // be filled by Group::UpdateChunks below or left empty.
6775                        ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
6776                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();
6777                  }                  }
6778              }              }
# Line 6415  namespace { Line 6915  namespace {
6915          } else /*if (newFile)*/ {          } else /*if (newFile)*/ {
6916              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6917              // the order of einf and 3crc is not the same in v2 and v3              // the order of einf and 3crc is not the same in v2 and v3
6918              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6919          }          }
6920          { // must be performed in RAM here ...          { // must be performed in RAM here ...
6921              uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();              uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
# Line 6442  namespace { Line 6942  namespace {
6942      }      }
6943    
6944      /**      /**
6945       * Enable / disable automatic loading. By default this properyt is       * Enable / disable automatic loading. By default this property is
6946       * enabled and all informations are loaded automatically. However       * enabled and every information is loaded automatically. However
6947       * loading all Regions, DimensionRegions and especially samples might       * loading all Regions, DimensionRegions and especially samples might
6948       * take a long time for large .gig files, and sometimes one might only       * take a long time for large .gig files, and sometimes one might only
6949       * be interested in retrieving very superficial informations like the       * be interested in retrieving very superficial informations like the
# Line 6451  namespace { Line 6951  namespace {
6951       * automatic loading to avoid very slow response times.       * automatic loading to avoid very slow response times.
6952       *       *
6953       * @e CAUTION: by disabling this property many pointers (i.e. sample       * @e CAUTION: by disabling this property many pointers (i.e. sample
6954       * references) and informations will have invalid or even undefined       * references) and attributes will have invalid or even undefined
6955       * data! This feature is currently only intended for retrieving very       * data! This feature is currently only intended for retrieving very
6956       * superficial informations in a very fast way. Don't use it to retrieve       * superficial information in a very fast way. Don't use it to retrieve
6957       * details like synthesis informations or even to modify .gig files!       * details like synthesis information or even to modify .gig files!
6958       */       */
6959      void File::SetAutoLoad(bool b) {      void File::SetAutoLoad(bool b) {
6960          bAutoLoad = b;          bAutoLoad = b;
# Line 6468  namespace { Line 6968  namespace {
6968          return bAutoLoad;          return bAutoLoad;
6969      }      }
6970    
6971        /**
6972         * Returns @c true in case this gig File object uses any gig format
6973         * extension, that is e.g. whether any DimensionRegion object currently
6974         * has any setting effective that would require our "LSDE" RIFF chunk to
6975         * be stored to the gig file.
6976         *
6977         * Right now this is a private method. It is considerable though this method
6978         * to become (in slightly modified form) a public API method in future, i.e.
6979         * to allow instrument editors to visualize and/or warn the user of any gig
6980         * format extension being used. See also comments on
6981         * DimensionRegion::UsesAnyGigFormatExtension() for details about such a
6982         * potential public API change in future.
6983         */
6984        bool File::UsesAnyGigFormatExtension() const {
6985            if (!pInstruments) return false;
6986            InstrumentList::iterator iter = pInstruments->begin();
6987            InstrumentList::iterator end  = pInstruments->end();
6988            for (; iter != end; ++iter) {
6989                Instrument* pInstrument = static_cast<gig::Instrument*>(*iter);
6990                if (pInstrument->UsesAnyGigFormatExtension())
6991                    return true;
6992            }
6993            return false;
6994        }
6995    
6996    
6997  // *************** Exception ***************  // *************** Exception ***************
Legend:
Removed from v.3198  
changed lines
  Added in v.3723
  ViewVC Help
Powered by ViewVC