/[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 3446 by schoenebeck, Sun Dec 23 21:47:26 2018 UTC revision 3623 by schoenebeck, Wed Oct 2 16:30:29 2019 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-2018 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2019 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 412  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 421  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 467  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 > 2 && BitDepth == 24) {              if (version > 2 && BitDepth == 24) {
478                  Dithered = ewav->ReadInt32();                  Dithered = ewav->ReadInt32();
# Line 1500  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 1732  namespace { Line 1740  namespace {
1740              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1741              memset(DimensionUpperLimits, 127, 8);              memset(DimensionUpperLimits, 127, 8);
1742          }          }
1743    
1744          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1745          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1746          if (lsde) { // format extension for EG behavior options          if (lsde) { // format extension for EG behavior options
1747                lsde->SetPos(0);
1748    
1749              eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };              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              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();                  unsigned char byte = lsde->ReadUint8();
# Line 1755  namespace { Line 1766  namespace {
1766              SustainReleaseTrigger   = sust_rel_trg_none;              SustainReleaseTrigger   = sust_rel_trg_none;
1767              NoNoteOffReleaseTrigger = false;              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,
# Line 1880  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 1898  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 1906  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 2257  namespace { Line 2297  namespace {
2297          // chunk for own format extensions, these will *NOT* work with          // chunk for own format extensions, these will *NOT* work with
2298          // Gigasampler/GigaStudio !          // Gigasampler/GigaStudio !
2299          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2300          const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option          const int lsdeSize =
2301          if (!lsde) {              3 /* EG cancel options */ +
2302              // only add this "LSDE" chunk if either EG options or release              1 /* sustain pedal up on release trigger option */ +
2303              // trigger options deviate from their default behaviour              8 /* LFOs' wave forms */ + 12 /* LFOs' phase */ + 4 /* flags (LFO3FlipPhase) */;
2304              eg_opt_t defaultOpt;          if (!lsde && UsesAnyGigFormatExtension()) {
2305              if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||              // only add this "LSDE" chunk if there is some (format extension)
2306                  memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||              // setting effective that would require our "LSDE" format extension
2307                  SustainReleaseTrigger || NoNoteOffReleaseTrigger)              // chunk to be stored
2308              {              lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2309                  lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);              // move LSDE chunk to the end of parent list
2310                  // move LSDE chunk to the end of parent list              pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
                 pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);  
             }  
2311          }          }
2312          if (lsde) {          if (lsde) {
2313              if (lsde->GetNewSize() < lsdeSize)              if (lsde->GetNewSize() < lsdeSize)
# Line 2287  namespace { Line 2325  namespace {
2325              }              }
2326              // format extension for release trigger options              // format extension for release trigger options
2327              pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);              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) {
2375          curve_type_t curveType = releaseVelocityResponseCurve;          curve_type_t curveType = releaseVelocityResponseCurve;
2376          uint8_t depth = releaseVelocityResponseDepth;          uint8_t depth = releaseVelocityResponseDepth;
# Line 3236  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 3795  namespace { Line 3878  namespace {
3878          }          }
3879    
3880          // delete temporary region          // delete temporary region
3881            tempRgn->DeleteChunks();
3882          delete tempRgn;          delete tempRgn;
3883    
3884          UpdateVelocityTable();          UpdateVelocityTable();
# Line 3934  namespace { Line 4018  namespace {
4018          }          }
4019    
4020          // delete temporary region          // delete temporary region
4021            tempRgn->DeleteChunks();
4022          delete tempRgn;          delete tempRgn;
4023    
4024          UpdateVelocityTable();          UpdateVelocityTable();
# Line 4412  namespace { Line 4497  namespace {
4497          pGroup = group;          pGroup = group;
4498          pChunk = ckScri;          pChunk = ckScri;
4499          if (ckScri) { // object is loaded from file ...          if (ckScri) { // object is loaded from file ...
4500                ckScri->SetPos(0);
4501    
4502              // read header              // read header
4503              uint32_t headerSize = ckScri->ReadUint32();              uint32_t headerSize = ckScri->ReadUint32();
4504              Compression = (Compression_t) ckScri->ReadUint32();              Compression = (Compression_t) ckScri->ReadUint32();
# Line 4464  namespace { Line 4551  namespace {
4551          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4552      }      }
4553    
4554        /** @brief Remove all RIFF chunks associated with this Script object.
4555         *
4556         * At the moment Script::DeleteChunks() does nothing. It is
4557         * recommended to call this method explicitly though from deriving classes's
4558         * own overridden implementation of this method to avoid potential future
4559         * compatiblity issues.
4560         *
4561         * See DLS::Storage::DeleteChunks() for details.
4562         */
4563        void Script::DeleteChunks() {
4564        }
4565    
4566      /**      /**
4567       * Apply this script to the respective RIFF chunks. You have to call       * Apply this script to the respective RIFF chunks. You have to call
4568       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4579  namespace { Line 4678  namespace {
4678          }          }
4679      }      }
4680    
4681        /** @brief Remove all RIFF chunks associated with this ScriptGroup object.
4682         *
4683         * At the moment ScriptGroup::DeleteChunks() does nothing. It is
4684         * recommended to call this method explicitly though from deriving classes's
4685         * own overridden implementation of this method to avoid potential future
4686         * compatiblity issues.
4687         *
4688         * See DLS::Storage::DeleteChunks() for details.
4689         */
4690        void ScriptGroup::DeleteChunks() {
4691        }
4692    
4693      /**      /**
4694       * 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
4695       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4703  namespace { Line 4814  namespace {
4814          if (lart) {          if (lart) {
4815              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
4816              if (_3ewg) {              if (_3ewg) {
4817                    _3ewg->SetPos(0);
4818    
4819                  EffectSend             = _3ewg->ReadUint16();                  EffectSend             = _3ewg->ReadUint16();
4820                  Attenuation            = _3ewg->ReadInt32();                  Attenuation            = _3ewg->ReadInt32();
4821                  FineTune               = _3ewg->ReadInt16();                  FineTune               = _3ewg->ReadInt16();
# Line 4747  namespace { Line 4860  namespace {
4860                  RIFF::List* rgn = lrgn->GetFirstSubList();                  RIFF::List* rgn = lrgn->GetFirstSubList();
4861                  while (rgn) {                  while (rgn) {
4862                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4863                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                          if (pProgress)
4864                                __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4865                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
4866                      }                      }
4867                      rgn = lrgn->GetNextSubList();                      rgn = lrgn->GetNextSubList();
# Line 4762  namespace { Line 4876  namespace {
4876          if (lst3LS) {          if (lst3LS) {
4877              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4878              if (ckSCSL) {              if (ckSCSL) {
4879                    ckSCSL->SetPos(0);
4880    
4881                  int headerSize = ckSCSL->ReadUint32();                  int headerSize = ckSCSL->ReadUint32();
4882                  int slotCount  = ckSCSL->ReadUint32();                  int slotCount  = ckSCSL->ReadUint32();
4883                  if (slotCount) {                  if (slotCount) {
# Line 4779  namespace { Line 4895  namespace {
4895              }              }
4896          }          }
4897    
4898          __notify_progress(pProgress, 1.0f); // notify done          if (pProgress)
4899                __notify_progress(pProgress, 1.0f); // notify done
4900      }      }
4901    
4902      void Instrument::UpdateRegionKeyTable() {      void Instrument::UpdateRegionKeyTable() {
# Line 5392  namespace { Line 5509  namespace {
5509          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
5510      }      }
5511    
5512        /** @brief Destructor.
5513         *
5514         * Currently this destructor implementation does nothing.
5515         */
5516      Group::~Group() {      Group::~Group() {
5517          // remove the chunk associated with this group (if any)      }
5518          if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);  
5519        /** @brief Remove all RIFF chunks associated with this Group object.
5520         *
5521         * See DLS::Storage::DeleteChunks() for details.
5522         */
5523        void Group::DeleteChunks() {
5524            // handle own RIFF chunks
5525            if (pNameChunk) {
5526                pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5527                pNameChunk = NULL;
5528            }
5529      }      }
5530    
5531      /** @brief Update chunks with current group settings.      /** @brief Update chunks with current group settings.
# Line 5665  namespace { Line 5796  namespace {
5796          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");
5797          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
5798          pSamples->erase(iter);          pSamples->erase(iter);
5799            pSample->DeleteChunks();
5800          delete pSample;          delete pSample;
5801    
5802          SampleList::iterator tmp = SamplesIterator;          SampleList::iterator tmp = SamplesIterator;
# Line 5702  namespace { Line 5834  namespace {
5834          int iSampleIndex  = 0;          int iSampleIndex  = 0;
5835          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5836    
5837          // check if samples should be loaded from extension files          // just for assembling path of optional extension files to be read
5838          // (only for old gig files < 2 GB)          const std::string folder = parentPath(pRIFF->GetFileName());
5839          int lastFileNo = 0;          const std::string baseName = pathWithoutExtension(pRIFF->GetFileName());
5840          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {  
5841              for (int i = 0 ; i < WavePoolCount ; i++) {          // the main gig file and the extension files (.gx01, ... , .gx98) may
5842                  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];          // contain wave data (wave pool)
5843              }          std::vector<RIFF::File*> poolFiles;
5844          }          poolFiles.push_back(pRIFF);
5845          String name(pRIFF->GetFileName());  
5846          int nameLen = (int) name.length();          // get info about all extension files
5847          char suffix[6];          RIFF::Chunk* ckXfil = pRIFF->GetSubChunk(CHUNK_ID_XFIL);
5848          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (ckXfil) { // there are extension files (.gx01, ... , .gx98) ...
5849                const uint32_t n = ckXfil->ReadInt32();
5850          for (int fileNo = 0 ; ; ) {              for (int i = 0; i < n; i++) {
5851                    // read the filename and load the extension file
5852                    std::string name;
5853                    ckXfil->ReadString(name, 128);
5854                    std::string path = concatPath(folder, name);
5855                    RIFF::File* pExtFile = new RIFF::File(path);
5856                    // check that the dlsids match
5857                    RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5858                    if (ckDLSID) {
5859                        ::DLS::dlsid_t idExpected;
5860                        idExpected.ulData1 = ckXfil->ReadInt32();
5861                        idExpected.usData2 = ckXfil->ReadInt16();
5862                        idExpected.usData3 = ckXfil->ReadInt16();
5863                        ckXfil->Read(idExpected.abData, 8, 1);
5864                        ::DLS::dlsid_t idFound;
5865                        ckDLSID->Read(&idFound.ulData1, 1, 4);
5866                        ckDLSID->Read(&idFound.usData2, 1, 2);
5867                        ckDLSID->Read(&idFound.usData3, 1, 2);
5868                        ckDLSID->Read(idFound.abData, 8, 1);
5869                        if (memcmp(&idExpected, &idFound, 16) != 0)
5870                            throw gig::Exception("dlsid mismatch for extension file: %s", path.c_str());
5871                    }
5872                    poolFiles.push_back(pExtFile);
5873                    ExtensionFiles.push_back(pExtFile);
5874                }
5875            }
5876    
5877            // check if a .gx99 (GigaPulse) file exists
5878            RIFF::Chunk* ckDoxf = pRIFF->GetSubChunk(CHUNK_ID_DOXF);
5879            if (ckDoxf) { // there is a .gx99 (GigaPulse) file ...
5880                std::string path = baseName + ".gx99";
5881                RIFF::File* pExtFile = new RIFF::File(path);
5882    
5883                // skip unused int and filename
5884                ckDoxf->SetPos(132, RIFF::stream_curpos);
5885    
5886                // check that the dlsids match
5887                RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5888                if (ckDLSID) {
5889                    ::DLS::dlsid_t idExpected;
5890                    idExpected.ulData1 = ckDoxf->ReadInt32();
5891                    idExpected.usData2 = ckDoxf->ReadInt16();
5892                    idExpected.usData3 = ckDoxf->ReadInt16();
5893                    ckDoxf->Read(idExpected.abData, 8, 1);
5894                    ::DLS::dlsid_t idFound;
5895                    ckDLSID->Read(&idFound.ulData1, 1, 4);
5896                    ckDLSID->Read(&idFound.usData2, 1, 2);
5897                    ckDLSID->Read(&idFound.usData3, 1, 2);
5898                    ckDLSID->Read(idFound.abData, 8, 1);
5899                    if (memcmp(&idExpected, &idFound, 16) != 0)
5900                        throw gig::Exception("dlsid mismatch for GigaPulse file: %s", path.c_str());
5901                }
5902                poolFiles.push_back(pExtFile);
5903                ExtensionFiles.push_back(pExtFile);
5904            }
5905    
5906            // load samples from extension files (if required)
5907            for (int i = 0; i < poolFiles.size(); i++) {
5908                RIFF::File* file = poolFiles[i];
5909              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5910              if (wvpl) {              if (wvpl) {
5911                  file_offset_t wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
5912                                                   wvpl->GetPos(); // should be zero, but just to be sure
5913                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
5914                  while (wave) {                  while (wave) {
5915                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
5916                          // notify current progress                          // notify current progress
5917                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          if (pProgress) {
5918                          __notify_progress(pProgress, subprogress);                              const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5919                                __notify_progress(pProgress, subprogress);
5920                            }
5921    
5922                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5923                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));
5924    
5925                          iSampleIndex++;                          iSampleIndex++;
5926                      }                      }
5927                      wave = wvpl->GetNextSubList();                      wave = wvpl->GetNextSubList();
5928                  }                  }
5929                }
                 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;  
5930          }          }
5931    
5932          __notify_progress(pProgress, 1.0); // notify done          if (pProgress)
5933                __notify_progress(pProgress, 1.0); // notify done
5934      }      }
5935    
5936      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
# Line 5786  namespace { Line 5971  namespace {
5971          if (!pInstruments) {          if (!pInstruments) {
5972              // 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)
5973    
5974              // sample loading subtask              if (pProgress) {
5975              progress_t subprogress;                  // sample loading subtask
5976              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask                  progress_t subprogress;
5977              __notify_progress(&subprogress, 0.0f);                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
5978              if (GetAutoLoad())                  __notify_progress(&subprogress, 0.0f);
5979                  GetFirstSample(&subprogress); // now force all samples to be loaded                  if (GetAutoLoad())
5980              __notify_progress(&subprogress, 1.0f);                      GetFirstSample(&subprogress); // now force all samples to be loaded
5981                    __notify_progress(&subprogress, 1.0f);
5982              // instrument loading subtask  
5983              if (pProgress && pProgress->callback) {                  // instrument loading subtask
5984                  subprogress.__range_min = subprogress.__range_max;                  if (pProgress->callback) {
5985                  subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask                      subprogress.__range_min = subprogress.__range_max;
5986              }                      subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
5987              __notify_progress(&subprogress, 0.0f);                  }
5988              LoadInstruments(&subprogress);                  __notify_progress(&subprogress, 0.0f);
5989              __notify_progress(&subprogress, 1.0f);                  LoadInstruments(&subprogress);
5990                    __notify_progress(&subprogress, 1.0f);
5991                } else {
5992                    // sample loading subtask
5993                    if (GetAutoLoad())
5994                        GetFirstSample(); // now force all samples to be loaded
5995    
5996                    // instrument loading subtask
5997                    LoadInstruments();
5998                }
5999          }          }
6000          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6001          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
# Line 5950  namespace { Line 6144  namespace {
6144          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
6145          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");
6146          pInstruments->erase(iter);          pInstruments->erase(iter);
6147            pInstrument->DeleteChunks();
6148          delete pInstrument;          delete pInstrument;
6149      }      }
6150    
# Line 5965  namespace { Line 6160  namespace {
6160              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
6161              while (lstInstr) {              while (lstInstr) {
6162                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6163                      // notify current progress                      if (pProgress) {
6164                      const float localProgress = (float) iInstrumentIndex / (float) Instruments;                          // notify current progress
6165                      __notify_progress(pProgress, localProgress);                          const float localProgress = (float) iInstrumentIndex / (float) Instruments;
6166                            __notify_progress(pProgress, localProgress);
                     // divide local progress into subprogress for loading current Instrument  
                     progress_t subprogress;  
                     __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);  
6167    
6168                      pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));                          // divide local progress into subprogress for loading current Instrument
6169                            progress_t subprogress;
6170                            __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
6171    
6172                            pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
6173                        } else {
6174                            pInstruments->push_back(new Instrument(this, lstInstr));
6175                        }
6176    
6177                      iInstrumentIndex++;                      iInstrumentIndex++;
6178                  }                  }
6179                  lstInstr = lstInstruments->GetNextSubList();                  lstInstr = lstInstruments->GetNextSubList();
6180              }              }
6181              __notify_progress(pProgress, 1.0); // notify done              if (pProgress)
6182                    __notify_progress(pProgress, 1.0); // notify done
6183          }          }
6184      }      }
6185    
# Line 6209  namespace { Line 6409  namespace {
6409          }          }
6410          // now delete this group object          // now delete this group object
6411          pGroups->erase(iter);          pGroups->erase(iter);
6412            pGroup->DeleteChunks();
6413          delete pGroup;          delete pGroup;
6414      }      }
6415    
# Line 6230  namespace { Line 6431  namespace {
6431          // move all members of this group to another group          // move all members of this group to another group
6432          pGroup->MoveAll();          pGroup->MoveAll();
6433          pGroups->erase(iter);          pGroups->erase(iter);
6434            pGroup->DeleteChunks();
6435          delete pGroup;          delete pGroup;
6436      }      }
6437    
# Line 6329  namespace { Line 6531  namespace {
6531              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
6532          if (pScriptGroup->pList)          if (pScriptGroup->pList)
6533              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
6534            pScriptGroup->DeleteChunks();
6535          delete pScriptGroup;          delete pScriptGroup;
6536      }      }
6537    
# Line 6592  namespace { Line 6795  namespace {
6795      }      }
6796    
6797      /**      /**
6798       * Enable / disable automatic loading. By default this properyt is       * Enable / disable automatic loading. By default this property is
6799       * enabled and all informations are loaded automatically. However       * enabled and every information is loaded automatically. However
6800       * loading all Regions, DimensionRegions and especially samples might       * loading all Regions, DimensionRegions and especially samples might
6801       * 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
6802       * be interested in retrieving very superficial informations like the       * be interested in retrieving very superficial informations like the
# Line 6601  namespace { Line 6804  namespace {
6804       * automatic loading to avoid very slow response times.       * automatic loading to avoid very slow response times.
6805       *       *
6806       * @e CAUTION: by disabling this property many pointers (i.e. sample       * @e CAUTION: by disabling this property many pointers (i.e. sample
6807       * references) and informations will have invalid or even undefined       * references) and attributes will have invalid or even undefined
6808       * data! This feature is currently only intended for retrieving very       * data! This feature is currently only intended for retrieving very
6809       * 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
6810       * details like synthesis informations or even to modify .gig files!       * details like synthesis information or even to modify .gig files!
6811       */       */
6812      void File::SetAutoLoad(bool b) {      void File::SetAutoLoad(bool b) {
6813          bAutoLoad = b;          bAutoLoad = b;
Legend:
Removed from v.3446  
changed lines
  Added in v.3623
  ViewVC Help
Powered by ViewVC