/[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 3442 by schoenebeck, Sat Dec 22 18:59:29 2018 UTC revision 3488 by schoenebeck, Thu Feb 28 17:49:07 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 1735  namespace { Line 1743  namespace {
1743          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !          // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1744          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1745          if (lsde) { // format extension for EG behavior options          if (lsde) { // format extension for EG behavior options
1746                lsde->SetPos(0);
1747    
1748              eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };              eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1749              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
1750                  unsigned char byte = lsde->ReadUint8();                  unsigned char byte = lsde->ReadUint8();
# Line 1748  namespace { Line 1758  namespace {
1758          // format extension for sustain pedal up effect on release trigger samples          // format extension for sustain pedal up effect on release trigger samples
1759          if (lsde && lsde->GetSize() > 3) { // NOTE: we reserved the 3rd byte for a potential future EG3 option          if (lsde && lsde->GetSize() > 3) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
1760              lsde->SetPos(3);              lsde->SetPos(3);
1761              SustainReleaseTrigger = static_cast<sust_rel_trg_t>(lsde->ReadUint8());              uint8_t byte = lsde->ReadUint8();
1762          } else SustainReleaseTrigger = sust_rel_trg_none;              SustainReleaseTrigger   = static_cast<sust_rel_trg_t>(byte & 0x03);
1763                NoNoteOffReleaseTrigger = byte >> 7;
1764            } else {
1765                SustainReleaseTrigger   = sust_rel_trg_none;
1766                NoNoteOffReleaseTrigger = false;
1767            }
1768    
1769          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1770                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
# Line 1941  namespace { Line 1956  namespace {
1956          SRLZ(EG1Options);          SRLZ(EG1Options);
1957          SRLZ(EG2Options);          SRLZ(EG2Options);
1958          SRLZ(SustainReleaseTrigger);          SRLZ(SustainReleaseTrigger);
1959            SRLZ(NoNoteOffReleaseTrigger);
1960    
1961          // derived attributes from DLS::Sampler          // derived attributes from DLS::Sampler
1962          SRLZ(FineTune);          SRLZ(FineTune);
# Line 2253  namespace { Line 2269  namespace {
2269          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);          RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2270          const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option          const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option
2271          if (!lsde) {          if (!lsde) {
2272              // only add this "LSDE" chunk if either EG options or sustain              // only add this "LSDE" chunk if either EG options or release
2273              // release trigger option deviate from their default behaviour              // trigger options deviate from their default behaviour
2274              eg_opt_t defaultOpt;              eg_opt_t defaultOpt;
2275              if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||              if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2276                  memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||                  memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||
2277                  SustainReleaseTrigger)                  SustainReleaseTrigger || NoNoteOffReleaseTrigger)
2278              {              {
2279                  lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);                  lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2280                  // move LSDE chunk to the end of parent list                  // move LSDE chunk to the end of parent list
# Line 2279  namespace { Line 2295  namespace {
2295                      (pEGOpts[i]->Decay2Cancel     ? (1<<3) : 0) |                      (pEGOpts[i]->Decay2Cancel     ? (1<<3) : 0) |
2296                      (pEGOpts[i]->ReleaseCancel    ? (1<<4) : 0);                      (pEGOpts[i]->ReleaseCancel    ? (1<<4) : 0);
2297              }              }
2298              // format extension for effect of sustain pedal up event on release trigger samples              // format extension for release trigger options
2299              pData[3] = static_cast<uint8_t>(SustainReleaseTrigger);              pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2300          }          }
2301      }      }
2302    
# Line 3230  namespace { Line 3246  namespace {
3246    
3247          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
3248          if (_3lnk) {          if (_3lnk) {
3249                _3lnk->SetPos(0);
3250    
3251              DimensionRegions = _3lnk->ReadUint32();              DimensionRegions = _3lnk->ReadUint32();
3252              for (int i = 0; i < dimensionBits; i++) {              for (int i = 0; i < dimensionBits; i++) {
3253                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
# Line 3789  namespace { Line 3807  namespace {
3807          }          }
3808    
3809          // delete temporary region          // delete temporary region
3810            tempRgn->DeleteChunks();
3811          delete tempRgn;          delete tempRgn;
3812    
3813          UpdateVelocityTable();          UpdateVelocityTable();
# Line 3928  namespace { Line 3947  namespace {
3947          }          }
3948    
3949          // delete temporary region          // delete temporary region
3950            tempRgn->DeleteChunks();
3951          delete tempRgn;          delete tempRgn;
3952    
3953          UpdateVelocityTable();          UpdateVelocityTable();
# Line 4406  namespace { Line 4426  namespace {
4426          pGroup = group;          pGroup = group;
4427          pChunk = ckScri;          pChunk = ckScri;
4428          if (ckScri) { // object is loaded from file ...          if (ckScri) { // object is loaded from file ...
4429                ckScri->SetPos(0);
4430    
4431              // read header              // read header
4432              uint32_t headerSize = ckScri->ReadUint32();              uint32_t headerSize = ckScri->ReadUint32();
4433              Compression = (Compression_t) ckScri->ReadUint32();              Compression = (Compression_t) ckScri->ReadUint32();
# Line 4458  namespace { Line 4480  namespace {
4480          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4481      }      }
4482    
4483        /** @brief Remove all RIFF chunks associated with this Script object.
4484         *
4485         * At the moment Script::DeleteChunks() does nothing. It is
4486         * recommended to call this method explicitly though from deriving classes's
4487         * own overridden implementation of this method to avoid potential future
4488         * compatiblity issues.
4489         *
4490         * See DLS::Storage::DeleteChunks() for details.
4491         */
4492        void Script::DeleteChunks() {
4493        }
4494    
4495      /**      /**
4496       * Apply this script to the respective RIFF chunks. You have to call       * Apply this script to the respective RIFF chunks. You have to call
4497       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4573  namespace { Line 4607  namespace {
4607          }          }
4608      }      }
4609    
4610        /** @brief Remove all RIFF chunks associated with this ScriptGroup object.
4611         *
4612         * At the moment ScriptGroup::DeleteChunks() does nothing. It is
4613         * recommended to call this method explicitly though from deriving classes's
4614         * own overridden implementation of this method to avoid potential future
4615         * compatiblity issues.
4616         *
4617         * See DLS::Storage::DeleteChunks() for details.
4618         */
4619        void ScriptGroup::DeleteChunks() {
4620        }
4621    
4622      /**      /**
4623       * 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
4624       * File::Save() to make changes persistent.       * File::Save() to make changes persistent.
# Line 4697  namespace { Line 4743  namespace {
4743          if (lart) {          if (lart) {
4744              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);              RIFF::Chunk* _3ewg = lart->GetSubChunk(CHUNK_ID_3EWG);
4745              if (_3ewg) {              if (_3ewg) {
4746                    _3ewg->SetPos(0);
4747    
4748                  EffectSend             = _3ewg->ReadUint16();                  EffectSend             = _3ewg->ReadUint16();
4749                  Attenuation            = _3ewg->ReadInt32();                  Attenuation            = _3ewg->ReadInt32();
4750                  FineTune               = _3ewg->ReadInt16();                  FineTune               = _3ewg->ReadInt16();
# Line 4741  namespace { Line 4789  namespace {
4789                  RIFF::List* rgn = lrgn->GetFirstSubList();                  RIFF::List* rgn = lrgn->GetFirstSubList();
4790                  while (rgn) {                  while (rgn) {
4791                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4792                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                          if (pProgress)
4793                                __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4794                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
4795                      }                      }
4796                      rgn = lrgn->GetNextSubList();                      rgn = lrgn->GetNextSubList();
# Line 4756  namespace { Line 4805  namespace {
4805          if (lst3LS) {          if (lst3LS) {
4806              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4807              if (ckSCSL) {              if (ckSCSL) {
4808                    ckSCSL->SetPos(0);
4809    
4810                  int headerSize = ckSCSL->ReadUint32();                  int headerSize = ckSCSL->ReadUint32();
4811                  int slotCount  = ckSCSL->ReadUint32();                  int slotCount  = ckSCSL->ReadUint32();
4812                  if (slotCount) {                  if (slotCount) {
# Line 4773  namespace { Line 4824  namespace {
4824              }              }
4825          }          }
4826    
4827          __notify_progress(pProgress, 1.0f); // notify done          if (pProgress)
4828                __notify_progress(pProgress, 1.0f); // notify done
4829      }      }
4830    
4831      void Instrument::UpdateRegionKeyTable() {      void Instrument::UpdateRegionKeyTable() {
# Line 5386  namespace { Line 5438  namespace {
5438          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
5439      }      }
5440    
5441        /** @brief Destructor.
5442         *
5443         * Currently this destructor implementation does nothing.
5444         */
5445      Group::~Group() {      Group::~Group() {
5446          // remove the chunk associated with this group (if any)      }
5447          if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);  
5448        /** @brief Remove all RIFF chunks associated with this Group object.
5449         *
5450         * See DLS::Storage::DeleteChunks() for details.
5451         */
5452        void Group::DeleteChunks() {
5453            // handle own RIFF chunks
5454            if (pNameChunk) {
5455                pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
5456                pNameChunk = NULL;
5457            }
5458      }      }
5459    
5460      /** @brief Update chunks with current group settings.      /** @brief Update chunks with current group settings.
# Line 5659  namespace { Line 5725  namespace {
5725          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");
5726          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
5727          pSamples->erase(iter);          pSamples->erase(iter);
5728            pSample->DeleteChunks();
5729          delete pSample;          delete pSample;
5730    
5731          SampleList::iterator tmp = SamplesIterator;          SampleList::iterator tmp = SamplesIterator;
# Line 5696  namespace { Line 5763  namespace {
5763          int iSampleIndex  = 0;          int iSampleIndex  = 0;
5764          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5765    
5766          // check if samples should be loaded from extension files          // just for assembling path of optional extension files to be read
5767          // (only for old gig files < 2 GB)          const std::string folder = parentPath(pRIFF->GetFileName());
5768          int lastFileNo = 0;          const std::string baseName = pathWithoutExtension(pRIFF->GetFileName());
5769          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {  
5770              for (int i = 0 ; i < WavePoolCount ; i++) {          // the main gig file and the extension files (.gx01, ... , .gx98) may
5771                  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];          // contain wave data (wave pool)
5772              }          std::vector<RIFF::File*> poolFiles;
5773          }          poolFiles.push_back(pRIFF);
5774          String name(pRIFF->GetFileName());  
5775          int nameLen = (int) name.length();          // get info about all extension files
5776          char suffix[6];          RIFF::Chunk* ckXfil = pRIFF->GetSubChunk(CHUNK_ID_XFIL);
5777          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (ckXfil) { // there are extension files (.gx01, ... , .gx98) ...
5778                const uint32_t n = ckXfil->ReadInt32();
5779          for (int fileNo = 0 ; ; ) {              for (int i = 0; i < n; i++) {
5780                    // read the filename and load the extension file
5781                    std::string name;
5782                    ckXfil->ReadString(name, 128);
5783                    std::string path = concatPath(folder, name);
5784                    RIFF::File* pExtFile = new RIFF::File(path);
5785                    // check that the dlsids match
5786                    RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5787                    if (ckDLSID) {
5788                        ::DLS::dlsid_t idExpected;
5789                        idExpected.ulData1 = ckXfil->ReadInt32();
5790                        idExpected.usData2 = ckXfil->ReadInt16();
5791                        idExpected.usData3 = ckXfil->ReadInt16();
5792                        ckXfil->Read(idExpected.abData, 8, 1);
5793                        ::DLS::dlsid_t idFound;
5794                        ckDLSID->Read(&idFound.ulData1, 1, 4);
5795                        ckDLSID->Read(&idFound.usData2, 1, 2);
5796                        ckDLSID->Read(&idFound.usData3, 1, 2);
5797                        ckDLSID->Read(idFound.abData, 8, 1);
5798                        if (memcmp(&idExpected, &idFound, 16) != 0)
5799                            throw gig::Exception("dlsid mismatch for extension file: %s", path.c_str());
5800                    }
5801                    poolFiles.push_back(pExtFile);
5802                    ExtensionFiles.push_back(pExtFile);
5803                }
5804            }
5805    
5806            // check if a .gx99 (GigaPulse) file exists
5807            RIFF::Chunk* ckDoxf = pRIFF->GetSubChunk(CHUNK_ID_DOXF);
5808            if (ckDoxf) { // there is a .gx99 (GigaPulse) file ...
5809                std::string path = baseName + ".gx99";
5810                RIFF::File* pExtFile = new RIFF::File(path);
5811    
5812                // skip unused int and filename
5813                ckDoxf->SetPos(132, RIFF::stream_curpos);
5814    
5815                // check that the dlsids match
5816                RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5817                if (ckDLSID) {
5818                    ::DLS::dlsid_t idExpected;
5819                    idExpected.ulData1 = ckDoxf->ReadInt32();
5820                    idExpected.usData2 = ckDoxf->ReadInt16();
5821                    idExpected.usData3 = ckDoxf->ReadInt16();
5822                    ckDoxf->Read(idExpected.abData, 8, 1);
5823                    ::DLS::dlsid_t idFound;
5824                    ckDLSID->Read(&idFound.ulData1, 1, 4);
5825                    ckDLSID->Read(&idFound.usData2, 1, 2);
5826                    ckDLSID->Read(&idFound.usData3, 1, 2);
5827                    ckDLSID->Read(idFound.abData, 8, 1);
5828                    if (memcmp(&idExpected, &idFound, 16) != 0)
5829                        throw gig::Exception("dlsid mismatch for GigaPulse file: %s", path.c_str());
5830                }
5831                poolFiles.push_back(pExtFile);
5832                ExtensionFiles.push_back(pExtFile);
5833            }
5834    
5835            // load samples from extension files (if required)
5836            for (int i = 0; i < poolFiles.size(); i++) {
5837                RIFF::File* file = poolFiles[i];
5838              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5839              if (wvpl) {              if (wvpl) {
5840                  file_offset_t wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
5841                                                   wvpl->GetPos(); // should be zero, but just to be sure
5842                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
5843                  while (wave) {                  while (wave) {
5844                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
5845                          // notify current progress                          // notify current progress
5846                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          if (pProgress) {
5847                          __notify_progress(pProgress, subprogress);                              const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5848                                __notify_progress(pProgress, subprogress);
5849                            }
5850    
5851                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5852                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));
5853    
5854                          iSampleIndex++;                          iSampleIndex++;
5855                      }                      }
5856                      wave = wvpl->GetNextSubList();                      wave = wvpl->GetNextSubList();
5857                  }                  }
5858                }
                 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;  
5859          }          }
5860    
5861          __notify_progress(pProgress, 1.0); // notify done          if (pProgress)
5862                __notify_progress(pProgress, 1.0); // notify done
5863      }      }
5864    
5865      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
# Line 5780  namespace { Line 5900  namespace {
5900          if (!pInstruments) {          if (!pInstruments) {
5901              // 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)
5902    
5903              // sample loading subtask              if (pProgress) {
5904              progress_t subprogress;                  // sample loading subtask
5905              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask                  progress_t subprogress;
5906              __notify_progress(&subprogress, 0.0f);                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
5907              if (GetAutoLoad())                  __notify_progress(&subprogress, 0.0f);
5908                  GetFirstSample(&subprogress); // now force all samples to be loaded                  if (GetAutoLoad())
5909              __notify_progress(&subprogress, 1.0f);                      GetFirstSample(&subprogress); // now force all samples to be loaded
5910                    __notify_progress(&subprogress, 1.0f);
5911              // instrument loading subtask  
5912              if (pProgress && pProgress->callback) {                  // instrument loading subtask
5913                  subprogress.__range_min = subprogress.__range_max;                  if (pProgress->callback) {
5914                  subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask                      subprogress.__range_min = subprogress.__range_max;
5915              }                      subprogress.__range_max = pProgress->__range_max; // schedule remaining percentage for this subtask
5916              __notify_progress(&subprogress, 0.0f);                  }
5917              LoadInstruments(&subprogress);                  __notify_progress(&subprogress, 0.0f);
5918              __notify_progress(&subprogress, 1.0f);                  LoadInstruments(&subprogress);
5919                    __notify_progress(&subprogress, 1.0f);
5920                } else {
5921                    // sample loading subtask
5922                    if (GetAutoLoad())
5923                        GetFirstSample(); // now force all samples to be loaded
5924    
5925                    // instrument loading subtask
5926                    LoadInstruments();
5927                }
5928          }          }
5929          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
5930          InstrumentsIterator = pInstruments->begin();          InstrumentsIterator = pInstruments->begin();
# Line 5944  namespace { Line 6073  namespace {
6073          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
6074          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");
6075          pInstruments->erase(iter);          pInstruments->erase(iter);
6076            pInstrument->DeleteChunks();
6077          delete pInstrument;          delete pInstrument;
6078      }      }
6079    
# Line 5959  namespace { Line 6089  namespace {
6089              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
6090              while (lstInstr) {              while (lstInstr) {
6091                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6092                      // notify current progress                      if (pProgress) {
6093                      const float localProgress = (float) iInstrumentIndex / (float) Instruments;                          // notify current progress
6094                      __notify_progress(pProgress, localProgress);                          const float localProgress = (float) iInstrumentIndex / (float) Instruments;
6095                            __notify_progress(pProgress, localProgress);
                     // divide local progress into subprogress for loading current Instrument  
                     progress_t subprogress;  
                     __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);  
6096    
6097                      pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));                          // divide local progress into subprogress for loading current Instrument
6098                            progress_t subprogress;
6099                            __divide_progress(pProgress, &subprogress, Instruments, iInstrumentIndex);
6100    
6101                            pInstruments->push_back(new Instrument(this, lstInstr, &subprogress));
6102                        } else {
6103                            pInstruments->push_back(new Instrument(this, lstInstr));
6104                        }
6105    
6106                      iInstrumentIndex++;                      iInstrumentIndex++;
6107                  }                  }
6108                  lstInstr = lstInstruments->GetNextSubList();                  lstInstr = lstInstruments->GetNextSubList();
6109              }              }
6110              __notify_progress(pProgress, 1.0); // notify done              if (pProgress)
6111                    __notify_progress(pProgress, 1.0); // notify done
6112          }          }
6113      }      }
6114    
# Line 6203  namespace { Line 6338  namespace {
6338          }          }
6339          // now delete this group object          // now delete this group object
6340          pGroups->erase(iter);          pGroups->erase(iter);
6341            pGroup->DeleteChunks();
6342          delete pGroup;          delete pGroup;
6343      }      }
6344    
# Line 6224  namespace { Line 6360  namespace {
6360          // move all members of this group to another group          // move all members of this group to another group
6361          pGroup->MoveAll();          pGroup->MoveAll();
6362          pGroups->erase(iter);          pGroups->erase(iter);
6363            pGroup->DeleteChunks();
6364          delete pGroup;          delete pGroup;
6365      }      }
6366    
# Line 6323  namespace { Line 6460  namespace {
6460              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));              pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
6461          if (pScriptGroup->pList)          if (pScriptGroup->pList)
6462              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);              pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
6463            pScriptGroup->DeleteChunks();
6464          delete pScriptGroup;          delete pScriptGroup;
6465      }      }
6466    
# Line 6586  namespace { Line 6724  namespace {
6724      }      }
6725    
6726      /**      /**
6727       * Enable / disable automatic loading. By default this properyt is       * Enable / disable automatic loading. By default this property is
6728       * enabled and all informations are loaded automatically. However       * enabled and every information is loaded automatically. However
6729       * loading all Regions, DimensionRegions and especially samples might       * loading all Regions, DimensionRegions and especially samples might
6730       * 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
6731       * be interested in retrieving very superficial informations like the       * be interested in retrieving very superficial informations like the
# Line 6595  namespace { Line 6733  namespace {
6733       * automatic loading to avoid very slow response times.       * automatic loading to avoid very slow response times.
6734       *       *
6735       * @e CAUTION: by disabling this property many pointers (i.e. sample       * @e CAUTION: by disabling this property many pointers (i.e. sample
6736       * references) and informations will have invalid or even undefined       * references) and attributes will have invalid or even undefined
6737       * data! This feature is currently only intended for retrieving very       * data! This feature is currently only intended for retrieving very
6738       * 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
6739       * details like synthesis informations or even to modify .gig files!       * details like synthesis information or even to modify .gig files!
6740       */       */
6741      void File::SetAutoLoad(bool b) {      void File::SetAutoLoad(bool b) {
6742          bAutoLoad = b;          bAutoLoad = b;
Legend:
Removed from v.3442  
changed lines
  Added in v.3488
  ViewVC Help
Powered by ViewVC