/[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 3731 by schoenebeck, Sat Feb 1 15:35:07 2020 UTC revision 3979 by schoenebeck, Mon Jul 19 14:43:22 2021 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-2020 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2021 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 482  namespace { Line 482  namespace {
482              ScanCompressedSample();              ScanCompressedSample();
483          }          }
484    
485          // we use a buffer for decompression and for truncating 24 bit samples to 16 bit          // we use a buffer for decompression only
486          if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {          if (Compressed && !InternalDecompressionBuffer.Size) {
487              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
488              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;
489          }          }
# Line 609  namespace { Line 609  namespace {
609          uint16_t iSampleGroup = 0; // 0 refers to default sample group          uint16_t iSampleGroup = 0; // 0 refers to default sample group
610          File* pFile = static_cast<File*>(pParent);          File* pFile = static_cast<File*>(pParent);
611          if (pFile->pGroups) {          if (pFile->pGroups) {
612              std::list<Group*>::iterator iter = pFile->pGroups->begin();              std::vector<Group*>::iterator iter = pFile->pGroups->begin();
613              std::list<Group*>::iterator end  = pFile->pGroups->end();              std::vector<Group*>::iterator end  = pFile->pGroups->end();
614              for (int i = 0; iter != end; i++, iter++) {              for (int i = 0; iter != end; i++, iter++) {
615                  if (*iter == pGroup) {                  if (*iter == pGroup) {
616                      iSampleGroup = i;                      iSampleGroup = i;
# Line 1346  namespace { Line 1346  namespace {
1346    
1347          // if this is the last write, update the checksum chunk in the          // if this is the last write, update the checksum chunk in the
1348          // file          // file
1349          if (pCkData->GetPos() == pCkData->GetSize()) {          if (pCkData->GetPos() == std::min(pCkData->GetSize(), pCkData->GetNewSize())) {
1350              __finalizeCRC(crc);              __finalizeCRC(crc);
1351              File* pFile = static_cast<File*>(GetParent());              File* pFile = static_cast<File*>(GetParent());
1352              pFile->SetSampleChecksum(this, crc);              pFile->SetSampleChecksum(this, crc);
# Line 3498  namespace { Line 3498  namespace {
3498          RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);          RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);
3499          if (_3prg) {          if (_3prg) {
3500              int dimensionRegionNr = 0;              int dimensionRegionNr = 0;
3501              RIFF::List* _3ewl = _3prg->GetFirstSubList();              size_t i = 0;
3502              while (_3ewl) {              for (RIFF::List* _3ewl = _3prg->GetSubListAt(i); _3ewl;
3503                     _3ewl = _3prg->GetSubListAt(++i))
3504                {
3505                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
3506                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);
3507                      dimensionRegionNr++;                      dimensionRegionNr++;
3508                  }                  }
                 _3ewl = _3prg->GetNextSubList();  
3509              }              }
3510              if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");              if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");
3511          }          }
# Line 3807  namespace { Line 3808  namespace {
3808       * @throws gig::Exception if requested zone could not be deleted       * @throws gig::Exception if requested zone could not be deleted
3809       */       */
3810      void Region::DeleteDimensionZone(dimension_t type, int zone) {      void Region::DeleteDimensionZone(dimension_t type, int zone) {
3811            if (!Dimensions)
3812                throw gig::Exception("Could not delete dimension zone, because there is no dimension at all.");
3813          dimension_def_t* oldDef = GetDimensionDefinition(type);          dimension_def_t* oldDef = GetDimensionDefinition(type);
3814          if (!oldDef)          if (!oldDef)
3815              throw gig::Exception("Could not delete dimension zone, no such dimension of given type");              throw gig::Exception("Could not delete dimension zone, no such dimension of given type");
# Line 3835  namespace { Line 3838  namespace {
3838          // requested by the arguments of this method call) to the temporary          // requested by the arguments of this method call) to the temporary
3839          // region, and don't use Region::CopyAssign() here for this task, since          // region, and don't use Region::CopyAssign() here for this task, since
3840          // it would also alter fast lookup helper variables here and there          // it would also alter fast lookup helper variables here and there
3841          dimension_def_t newDef;          dimension_def_t newDef = {};
3842          for (int i = 0; i < Dimensions; ++i) {          for (int i = 0; i < Dimensions; ++i) {
3843              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
3844              // is this the dimension requested by the method arguments? ...              // is this the dimension requested by the method arguments? ...
# Line 3846  namespace { Line 3849  namespace {
3849              }              }
3850              tempRgn->AddDimension(&def);              tempRgn->AddDimension(&def);
3851          }          }
3852            // silence clang sanitizer warning
3853            if (newDef.dimension == dimension_none)
3854                throw gig::Exception("Unexpected internal failure resolving dimension in DeleteDimensionZone() [this is a bug].");
3855    
3856          // find the dimension index in the tempRegion which is the dimension          // find the dimension index in the tempRegion which is the dimension
3857          // type passed to this method (paranoidly expecting different order)          // type passed to this method (paranoidly expecting different order)
# Line 3946  namespace { Line 3952  namespace {
3952       * @throws gig::Exception if requested zone could not be splitted       * @throws gig::Exception if requested zone could not be splitted
3953       */       */
3954      void Region::SplitDimensionZone(dimension_t type, int zone) {      void Region::SplitDimensionZone(dimension_t type, int zone) {
3955            if (!Dimensions)
3956                throw gig::Exception("Could not split dimension zone, because there is no dimension at all.");
3957          dimension_def_t* oldDef = GetDimensionDefinition(type);          dimension_def_t* oldDef = GetDimensionDefinition(type);
3958          if (!oldDef)          if (!oldDef)
3959              throw gig::Exception("Could not split dimension zone, no such dimension of given type");              throw gig::Exception("Could not split dimension zone, no such dimension of given type");
# Line 3972  namespace { Line 3980  namespace {
3980          // requested by the arguments of this method call) to the temporary          // requested by the arguments of this method call) to the temporary
3981          // region, and don't use Region::CopyAssign() here for this task, since          // region, and don't use Region::CopyAssign() here for this task, since
3982          // it would also alter fast lookup helper variables here and there          // it would also alter fast lookup helper variables here and there
3983          dimension_def_t newDef;          dimension_def_t newDef = {};
3984          for (int i = 0; i < Dimensions; ++i) {          for (int i = 0; i < Dimensions; ++i) {
3985              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
3986              // is this the dimension requested by the method arguments? ...              // is this the dimension requested by the method arguments? ...
# Line 3983  namespace { Line 3991  namespace {
3991              }              }
3992              tempRgn->AddDimension(&def);              tempRgn->AddDimension(&def);
3993          }          }
3994            // silence clang sanitizer warning
3995            if (newDef.dimension == dimension_none)
3996                throw gig::Exception("Unexpected internal failure resolving dimension in SplitDimensionZone() [this is a bug].");
3997    
3998          // find the dimension index in the tempRegion which is the dimension          // find the dimension index in the tempRegion which is the dimension
3999          // type passed to this method (paranoidly expecting different order)          // type passed to this method (paranoidly expecting different order)
# Line 4314  namespace { Line 4325  namespace {
4325              uint64_t soughtoffset =              uint64_t soughtoffset =
4326                  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |                  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
4327                  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;                  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
4328              Sample* sample = file->GetFirstSample(pProgress);              size_t i = 0;
4329              while (sample) {              for (Sample* sample = file->GetSample(i, pProgress); sample;
4330                             sample = file->GetSample(++i))
4331                {
4332                  if (sample->ullWavePoolOffset == soughtoffset)                  if (sample->ullWavePoolOffset == soughtoffset)
4333                      return static_cast<gig::Sample*>(sample);                      return sample;
                 sample = file->GetNextSample();  
4334              }              }
4335          } else {          } else {
4336              // use extension files and 32 bit wave pool offsets              // use extension files and 32 bit wave pool offsets
4337              file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];              file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
4338              file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];              file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
4339              Sample* sample = file->GetFirstSample(pProgress);              size_t i = 0;
4340              while (sample) {              for (Sample* sample = file->GetSample(i, pProgress); sample;
4341                             sample = file->GetSample(++i))
4342                {
4343                  if (sample->ullWavePoolOffset == soughtoffset &&                  if (sample->ullWavePoolOffset == soughtoffset &&
4344                      sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);                      sample->FileNo == soughtfileno) return sample;
                 sample = file->GetNextSample();  
4345              }              }
4346          }          }
4347          return NULL;          return NULL;
# Line 4788  namespace { Line 4801  namespace {
4801    
4802      ScriptGroup::~ScriptGroup() {      ScriptGroup::~ScriptGroup() {
4803          if (pScripts) {          if (pScripts) {
4804              std::list<Script*>::iterator iter = pScripts->begin();              std::vector<Script*>::iterator iter = pScripts->begin();
4805              std::list<Script*>::iterator end  = pScripts->end();              std::vector<Script*>::iterator end  = pScripts->end();
4806              while (iter != end) {              while (iter != end) {
4807                  delete *iter;                  delete *iter;
4808                  ++iter;                  ++iter;
# Line 4827  namespace { Line 4840  namespace {
4840              // now store the name of this group as <LSNM> chunk as subchunk of the <RTIS> list chunk              // now store the name of this group as <LSNM> chunk as subchunk of the <RTIS> list chunk
4841              ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64);              ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64);
4842    
4843              for (std::list<Script*>::iterator it = pScripts->begin();              for (std::vector<Script*>::iterator it = pScripts->begin();
4844                   it != pScripts->end(); ++it)                   it != pScripts->end(); ++it)
4845              {              {
4846                  (*it)->UpdateChunks(pProgress);                  (*it)->UpdateChunks(pProgress);
# Line 4842  namespace { Line 4855  namespace {
4855       * @param index - number of the sought script (0..n)       * @param index - number of the sought script (0..n)
4856       * @returns sought script or NULL if there's no such script       * @returns sought script or NULL if there's no such script
4857       */       */
4858      Script* ScriptGroup::GetScript(uint index) {      Script* ScriptGroup::GetScript(size_t index) {
4859          if (!pScripts) LoadScripts();          if (!pScripts) LoadScripts();
4860          std::list<Script*>::iterator it = pScripts->begin();          if (index >= pScripts->size()) return NULL;
4861          for (uint i = 0; it != pScripts->end(); ++i, ++it)          return (*pScripts)[index];
             if (i == index) return *it;  
         return NULL;  
4862      }      }
4863    
4864      /** @brief Add new instrument script.      /** @brief Add new instrument script.
# Line 4880  namespace { Line 4891  namespace {
4891       */       */
4892      void ScriptGroup::DeleteScript(Script* pScript) {      void ScriptGroup::DeleteScript(Script* pScript) {
4893          if (!pScripts) LoadScripts();          if (!pScripts) LoadScripts();
4894          std::list<Script*>::iterator iter =          std::vector<Script*>::iterator iter =
4895              find(pScripts->begin(), pScripts->end(), pScript);              find(pScripts->begin(), pScripts->end(), pScript);
4896          if (iter == pScripts->end())          if (iter == pScripts->end())
4897              throw gig::Exception("Could not delete script, could not find given script");              throw gig::Exception("Could not delete script, could not find given script");
# Line 4893  namespace { Line 4904  namespace {
4904    
4905      void ScriptGroup::LoadScripts() {      void ScriptGroup::LoadScripts() {
4906          if (pScripts) return;          if (pScripts) return;
4907          pScripts = new std::list<Script*>;          pScripts = new std::vector<Script*>;
4908          if (!pList) return;          if (!pList) return;
4909    
4910          for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;          size_t i = 0;
4911               ck = pList->GetNextSubChunk())          for (RIFF::Chunk* ck = pList->GetSubChunkAt(i); ck;
4912                 ck = pList->GetSubChunkAt(++i))
4913          {          {
4914              if (ck->GetChunkID() == CHUNK_ID_SCRI) {              if (ck->GetChunkID() == CHUNK_ID_SCRI) {
4915                  pScripts->push_back(new Script(this, ck));                  pScripts->push_back(new Script(this, ck));
# Line 4977  namespace { Line 4989  namespace {
4989              if (!pRegions) pRegions = new RegionList;              if (!pRegions) pRegions = new RegionList;
4990              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
4991              if (lrgn) {              if (lrgn) {
4992                  RIFF::List* rgn = lrgn->GetFirstSubList();                  size_t i = 0;
4993                  while (rgn) {                  for (RIFF::List* rgn = lrgn->GetSubListAt(i); rgn;
4994                         rgn = lrgn->GetSubListAt(++i))
4995                    {
4996                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4997                          if (pProgress)                          if (pProgress)
4998                              __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                              __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
4999                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
5000                      }                      }
                     rgn = lrgn->GetNextSubList();  
5001                  }                  }
5002                  // Creating Region Key Table for fast lookup                  // Creating Region Key Table for fast lookup
5003                  UpdateRegionKeyTable();                  UpdateRegionKeyTable();
# Line 5288  namespace { Line 5301  namespace {
5301      }      }
5302    
5303      /**      /**
5304         * Returns Region at supplied @a pos position within the region list of
5305         * this instrument. If supplied @a pos is out of bounds then @c NULL is
5306         * returned.
5307         *
5308         * @param pos - position of sought Region in region list
5309         * @returns pointer address to requested region or @c NULL if @a pos is
5310         *          out of bounds
5311         * @see CountRegions()
5312         */
5313        Region* Instrument::GetRegionAt(size_t pos) {
5314            if (!pRegions) return NULL;
5315            if (pos >= pRegions->size()) return NULL;
5316            return static_cast<gig::Region*>( (*pRegions)[pos] );
5317        }
5318    
5319        /**
5320       * Returns the first Region of the instrument. You have to call this       * Returns the first Region of the instrument. You have to call this
5321       * method once before you use GetNextRegion().       * method once before you use GetNextRegion().
5322       *       *
5323       * @returns  pointer address to first region or NULL if there is none       * @returns  pointer address to first region or NULL if there is none
5324       * @see      GetNextRegion()       * @see      GetNextRegion()
5325         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5326         *              instead.
5327       */       */
5328      Region* Instrument::GetFirstRegion() {      Region* Instrument::GetFirstRegion() {
5329          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5307  namespace { Line 5338  namespace {
5338       *       *
5339       * @returns  pointer address to the next region or NULL if end reached       * @returns  pointer address to the next region or NULL if end reached
5340       * @see      GetFirstRegion()       * @see      GetFirstRegion()
5341         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5342         *              instead.
5343       */       */
5344      Region* Instrument::GetNextRegion() {      Region* Instrument::GetNextRegion() {
5345          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5320  namespace { Line 5353  namespace {
5353          if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);          if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
5354          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
5355          Region* pNewRegion = new Region(this, rgn);          Region* pNewRegion = new Region(this, rgn);
5356            const size_t idxIt = RegionsIterator - pRegions->begin();
5357          pRegions->push_back(pNewRegion);          pRegions->push_back(pNewRegion);
5358            RegionsIterator = pRegions->begin() + std::min(idxIt, pRegions->size()); // avoid iterator invalidation
5359          Regions = (uint32_t) pRegions->size();          Regions = (uint32_t) pRegions->size();
5360          // update Region key table for fast lookup          // update Region key table for fast lookup
5361          UpdateRegionKeyTable();          UpdateRegionKeyTable();
# Line 5360  namespace { Line 5395  namespace {
5395       * @param dst - destination instrument at which this instrument will be       * @param dst - destination instrument at which this instrument will be
5396       *              moved to, or pass NULL for moving to end of list       *              moved to, or pass NULL for moving to end of list
5397       * @throw gig::Exception if this instrument and target instrument are not       * @throw gig::Exception if this instrument and target instrument are not
5398       *                       part of the same file       *                       part of the same file, as well as on unexpected
5399         *                       internal error
5400       */       */
5401      void Instrument::MoveTo(Instrument* dst) {      void Instrument::MoveTo(Instrument* dst) {
5402          if (dst && GetParent() != dst->GetParent())          if (dst && GetParent() != dst->GetParent())
# Line 5377  namespace { Line 5413  namespace {
5413    
5414              File::InstrumentList::iterator itFrom =              File::InstrumentList::iterator itFrom =
5415                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
5416                if (itFrom == list.end())
5417                    throw Exception(
5418                        "gig::Instrument::MoveTo(): unexpected missing membership "
5419                        "of this instrument."
5420                    );
5421                list.erase(itFrom);
5422    
5423              File::InstrumentList::iterator itTo =              File::InstrumentList::iterator itTo =
5424                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
5425    
5426              list.splice(itTo, list, itFrom);              list.insert(itTo, this);
5427          }          }
5428    
5429          // move the instrument's actual list RIFF chunk appropriately          // move the instrument's actual list RIFF chunk appropriately
# Line 5462  namespace { Line 5504  namespace {
5504          File* pFile = (File*) GetParent();          File* pFile = (File*) GetParent();
5505          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
5506              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
5507              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {              for (size_t i = 0; pFile->GetScriptGroup(i); ++i) {
5508                  ScriptGroup* group = pFile->GetScriptGroup(i);                  ScriptGroup* group = pFile->GetScriptGroup(i);
5509                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
5510                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
# Line 5500  namespace { Line 5542  namespace {
5542       * @param index - instrument script slot index       * @param index - instrument script slot index
5543       * @returns script or NULL if index is out of bounds       * @returns script or NULL if index is out of bounds
5544       */       */
5545      Script* Instrument::GetScriptOfSlot(uint index) {      Script* Instrument::GetScriptOfSlot(size_t index) {
5546          LoadScripts();          LoadScripts();
5547          if (index >= pScriptRefs->size()) return NULL;          if (index >= pScriptRefs->size()) return NULL;
5548          return pScriptRefs->at(index).script;          return pScriptRefs->at(index).script;
# Line 5561  namespace { Line 5603  namespace {
5603       * @param index1 - index of the first script slot to swap       * @param index1 - index of the first script slot to swap
5604       * @param index2 - index of the second script slot to swap       * @param index2 - index of the second script slot to swap
5605       */       */
5606      void Instrument::SwapScriptSlots(uint index1, uint index2) {      void Instrument::SwapScriptSlots(size_t index1, size_t index2) {
5607          LoadScripts();          LoadScripts();
5608          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
5609              return;              return;
# Line 5576  namespace { Line 5618  namespace {
5618       *       *
5619       * @param index - index of script slot to remove       * @param index - index of script slot to remove
5620       */       */
5621      void Instrument::RemoveScriptSlot(uint index) {      void Instrument::RemoveScriptSlot(size_t index) {
5622          LoadScripts();          LoadScripts();
5623          if (index >= pScriptRefs->size()) return;          if (index >= pScriptRefs->size()) return;
5624          pScriptRefs->erase( pScriptRefs->begin() + index );          pScriptRefs->erase( pScriptRefs->begin() + index );
# Line 5617  namespace { Line 5659  namespace {
5659       * GigaStudio 4 software. It will currently only work with LinuxSampler and       * GigaStudio 4 software. It will currently only work with LinuxSampler and
5660       * gigedit.       * gigedit.
5661       */       */
5662      uint Instrument::ScriptSlotCount() const {      size_t Instrument::ScriptSlotCount() const {
5663          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
5664      }      }
5665    
5666      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5637  namespace { Line 5679  namespace {
5679       * @param index - index of the script slot on this instrument       * @param index - index of the script slot on this instrument
5680       * @see Script::Bypass       * @see Script::Bypass
5681       */       */
5682      bool Instrument::IsScriptSlotBypassed(uint index) {      bool Instrument::IsScriptSlotBypassed(size_t index) {
5683          if (index >= ScriptSlotCount()) return false;          if (index >= ScriptSlotCount()) return false;
5684          return pScriptRefs ? pScriptRefs->at(index).bypass          return pScriptRefs ? pScriptRefs->at(index).bypass
5685                             : scriptPoolFileOffsets.at(index).bypass;                             : scriptPoolFileOffsets.at(index).bypass;
# Line 5657  namespace { Line 5699  namespace {
5699       * @param bBypass - if true, the script slot will be skipped by the sampler       * @param bBypass - if true, the script slot will be skipped by the sampler
5700       * @see Script::Bypass       * @see Script::Bypass
5701       */       */
5702      void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {      void Instrument::SetScriptSlotBypassed(size_t index, bool bBypass) {
5703          if (index >= ScriptSlotCount()) return;          if (index >= ScriptSlotCount()) return;
5704          if (pScriptRefs)          if (pScriptRefs)
5705              pScriptRefs->at(index).bypass = bBypass;              pScriptRefs->at(index).bypass = bBypass;
# Line 5677  namespace { Line 5719  namespace {
5719       * the @c Script identified by passed @p uuid.       * the @c Script identified by passed @p uuid.
5720       */       */
5721      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {
5722          const uint nSlots = ScriptSlotCount();          const size_t nSlots = ScriptSlotCount();
5723          for (uint iSlot = 0; iSlot < nSlots; ++iSlot)          for (size_t iSlot = 0; iSlot < nSlots; ++iSlot)
5724              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)
5725                  return true;                  return true;
5726          return false;          return false;
# Line 5696  namespace { Line 5738  namespace {
5738       * still being able to fine tune certain aspects of the script for each       * still being able to fine tune certain aspects of the script for each
5739       * instrument individually.       * instrument individually.
5740       *       *
5741         * @note This is an own format extension which did not exist i.e. in the
5742         * GigaStudio 4 software. It will currently only work with LinuxSampler and
5743         * Gigedit.
5744         *
5745       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5746       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5747       */       */
5748      bool Instrument::IsScriptPatchVariableSet(int slot, String variable) {      bool Instrument::IsScriptPatchVariableSet(size_t slot, String variable) {
5749          if (variable.empty()) return false;          if (variable.empty()) return false;
5750          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5751          if (!script) return false;          if (!script) return false;
# Line 5727  namespace { Line 5773  namespace {
5773       * still being able to fine tune certain aspects of the script for each       * still being able to fine tune certain aspects of the script for each
5774       * instrument individually.       * instrument individually.
5775       *       *
5776         * @note This is an own format extension which did not exist i.e. in the
5777         * GigaStudio 4 software. It will currently only work with LinuxSampler and
5778         * Gigedit.
5779         *
5780       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5781       */       */
5782      std::map<String,String> Instrument::GetScriptPatchVariables(int slot) {      std::map<String,String> Instrument::GetScriptPatchVariables(size_t slot) {
5783          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5784          if (!script) return std::map<String,String>();          if (!script) return std::map<String,String>();
5785          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
# Line 5754  namespace { Line 5804  namespace {
5804       * still being able to fine tune certain aspects of the script for each       * still being able to fine tune certain aspects of the script for each
5805       * instrument individually.       * instrument individually.
5806       *       *
5807         * @note This is an own format extension which did not exist i.e. in the
5808         * GigaStudio 4 software. It will currently only work with LinuxSampler and
5809         * Gigedit.
5810         *
5811       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5812       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5813       */       */
5814      String Instrument::GetScriptPatchVariable(int slot, String variable) {      String Instrument::GetScriptPatchVariable(size_t slot, String variable) {
5815          std::map<String,String> vars = GetScriptPatchVariables(slot);          std::map<String,String> vars = GetScriptPatchVariables(slot);
5816          return (vars.count(variable)) ? vars.find(variable)->second : "";          return (vars.count(variable)) ? vars.find(variable)->second : "";
5817      }      }
# Line 5774  namespace { Line 5828  namespace {
5828       * still being able to fine tune certain aspects of the script for each       * still being able to fine tune certain aspects of the script for each
5829       * instrument individually.       * instrument individually.
5830       *       *
5831         * @note This is an own format extension which did not exist i.e. in the
5832         * GigaStudio 4 software. It will currently only work with LinuxSampler and
5833         * Gigedit.
5834         *
5835       * @param slot - script slot index of the variable to be set       * @param slot - script slot index of the variable to be set
5836       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5837       * @param value - overridden initial value for that script variable       * @param value - overridden initial value for that script variable
5838       * @throws gig::Exception if given script @p slot index is invalid or given       * @throws gig::Exception if given script @p slot index is invalid or given
5839       *         @p variable name is empty       *         @p variable name is empty
5840       */       */
5841      void Instrument::SetScriptPatchVariable(int slot, String variable, String value) {      void Instrument::SetScriptPatchVariable(size_t slot, String variable, String value) {
5842          if (variable.empty())          if (variable.empty())
5843              throw Exception("Variable name must not be empty");              throw Exception("Variable name must not be empty");
5844          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
# Line 5814  namespace { Line 5872  namespace {
5872       * still being able to fine tune certain aspects of the script for each       * still being able to fine tune certain aspects of the script for each
5873       * instrument individually.       * instrument individually.
5874       *       *
5875         * @note This is an own format extension which did not exist i.e. in the
5876         * GigaStudio 4 software. It will currently only work with LinuxSampler and
5877         * Gigedit.
5878         *
5879       * @param slot - script slot index of the variable to be unset       * @param slot - script slot index of the variable to be unset
5880       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5881       */       */
5882      void Instrument::UnsetScriptPatchVariable(int slot, String variable) {      void Instrument::UnsetScriptPatchVariable(ssize_t slot, String variable) {
5883          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5884    
5885          // option 1: unset a particular variable of one particular script slot          // option 1: unset a particular variable of one particular script slot
# Line 5938  namespace { Line 6000  namespace {
6000          PianoReleaseMode = orig->PianoReleaseMode;          PianoReleaseMode = orig->PianoReleaseMode;
6001          DimensionKeyRange = orig->DimensionKeyRange;          DimensionKeyRange = orig->DimensionKeyRange;
6002          scriptPoolFileOffsets = orig->scriptPoolFileOffsets;          scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
6003          pScriptRefs = orig->pScriptRefs;          // deep copy of pScriptRefs required (to avoid undefined behaviour)
6004            if (pScriptRefs) delete pScriptRefs;
6005            pScriptRefs = new std::vector<_ScriptPooolRef>;
6006            if (orig->pScriptRefs)
6007                *pScriptRefs = *orig->pScriptRefs;
6008          scriptVars = orig->scriptVars;          scriptVars = orig->scriptVars;
6009                    
6010          // free old midi rules          // free old midi rules
# Line 5949  namespace { Line 6015  namespace {
6015          pMidiRules[0] = NULL;          pMidiRules[0] = NULL;
6016                    
6017          // delete all old regions          // delete all old regions
6018          while (Regions) DeleteRegion(GetFirstRegion());          while (Regions) DeleteRegion(GetRegionAt(0));
6019          // create new regions and copy them from original          // create new regions and copy them from original
6020          {          {
6021              RegionList::const_iterator it = orig->pRegions->begin();              RegionList::const_iterator it = orig->pRegions->begin();
# Line 6005  namespace { Line 6071  namespace {
6071      Group::Group(File* file, RIFF::Chunk* ck3gnm) {      Group::Group(File* file, RIFF::Chunk* ck3gnm) {
6072          pFile      = file;          pFile      = file;
6073          pNameChunk = ck3gnm;          pNameChunk = ck3gnm;
6074            SamplesIterator = 0;
6075          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
6076      }      }
6077    
# Line 6049  namespace { Line 6116  namespace {
6116    
6117          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
6118              // v3 has a fixed list of 128 strings, find a free one              // v3 has a fixed list of 128 strings, find a free one
6119              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {              size_t i = 0;
6120                for (RIFF::Chunk* ck = _3gnl->GetSubChunkAt(i); ck; ck = _3gnl->GetSubChunkAt(++i)) {
6121                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
6122                      pNameChunk = ck;                      pNameChunk = ck;
6123                      break;                      break;
# Line 6062  namespace { Line 6130  namespace {
6130      }      }
6131    
6132      /**      /**
6133         * Returns Sample object at @a index of this sample group.
6134         *
6135         * @param index - position of sample in this sample group's sample list
6136         *                (0..n)
6137         * @returns sample object or NULL if index is out of bounds
6138         */
6139        Sample* Group::GetSample(size_t index) {
6140            if (pFile->pSamples && index >= pFile->pSamples->size()) return NULL;
6141            size_t indexInFile = 0;
6142            size_t indexInGroup = 0;
6143            for (Sample* pSample = pFile->GetSample(indexInFile); pSample;
6144                         pSample = pFile->GetSample(++indexInFile))
6145            {
6146                if (pSample->GetGroup() != this) continue;
6147                if (indexInGroup++ == index) return pSample;
6148            }
6149            return NULL;
6150        }
6151    
6152        /**
6153       * Returns the first Sample of this Group. You have to call this method       * Returns the first Sample of this Group. You have to call this method
6154       * once before you use GetNextSample().       * once before you use GetNextSample().
6155       *       *
# Line 6071  namespace { Line 6159  namespace {
6159       * @returns  pointer address to first Sample or NULL if there is none       * @returns  pointer address to first Sample or NULL if there is none
6160       *           applied to this Group       *           applied to this Group
6161       * @see      GetNextSample()       * @see      GetNextSample()
6162         * @deprecated  This method is not reentrant-safe, use GetSample()
6163         *              instead.
6164       */       */
6165      Sample* Group::GetFirstSample() {      Sample* Group::GetFirstSample() {
6166          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6167          for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {          i = 0;
6168              if (pSample->GetGroup() == this) return pSample;          for (Sample* pSample = pFile->GetSample(i); pSample;
6169                         pSample = pFile->GetSample(++i))
6170            {
6171                if (pSample->GetGroup() == this)
6172                    return pSample;
6173          }          }
6174          return NULL;          return NULL;
6175      }      }
# Line 6089  namespace { Line 6183  namespace {
6183       * @returns  pointer address to the next Sample of this Group or NULL if       * @returns  pointer address to the next Sample of this Group or NULL if
6184       *           end reached       *           end reached
6185       * @see      GetFirstSample()       * @see      GetFirstSample()
6186         * @deprecated  This method is not reentrant-safe, use GetSample()
6187         *              instead.
6188       */       */
6189      Sample* Group::GetNextSample() {      Sample* Group::GetNextSample() {
6190          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6191          for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {          for (Sample* pSample = pFile->GetSample(++i); pSample;
6192              if (pSample->GetGroup() == this) return pSample;                       pSample = pFile->GetSample(++i))
6193            {
6194                if (pSample->GetGroup() == this)
6195                    return pSample;
6196          }          }
6197          return NULL;          return NULL;
6198      }      }
# Line 6113  namespace { Line 6212  namespace {
6212       */       */
6213      void Group::MoveAll() {      void Group::MoveAll() {
6214          // get "that" other group first          // get "that" other group first
6215            size_t i = 0;
6216          Group* pOtherGroup = NULL;          Group* pOtherGroup = NULL;
6217          for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {          for (pOtherGroup = pFile->GetGroup(i); pOtherGroup;
6218                 pOtherGroup = pFile->GetGroup(++i))
6219            {
6220              if (pOtherGroup != this) break;              if (pOtherGroup != this) break;
6221          }          }
6222          if (!pOtherGroup) throw Exception(          if (!pOtherGroup) throw Exception(
# Line 6122  namespace { Line 6224  namespace {
6224              "other Group. This is a bug, report it!"              "other Group. This is a bug, report it!"
6225          );          );
6226          // now move all samples of this group to the other group          // now move all samples of this group to the other group
6227          for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {          Sample* pSample;
6228            while ((pSample = GetSample(0))) {
6229              pOtherGroup->AddSample(pSample);              pOtherGroup->AddSample(pSample);
6230          }          }
6231      }      }
# Line 6194  namespace { Line 6297  namespace {
6297    
6298      File::~File() {      File::~File() {
6299          if (pGroups) {          if (pGroups) {
6300              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
6301              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
6302              while (iter != end) {              while (iter != end) {
6303                  delete *iter;                  delete *iter;
6304                  ++iter;                  ++iter;
# Line 6203  namespace { Line 6306  namespace {
6306              delete pGroups;              delete pGroups;
6307          }          }
6308          if (pScriptGroups) {          if (pScriptGroups) {
6309              std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();              std::vector<ScriptGroup*>::iterator iter = pScriptGroups->begin();
6310              std::list<ScriptGroup*>::iterator end  = pScriptGroups->end();              std::vector<ScriptGroup*>::iterator end  = pScriptGroups->end();
6311              while (iter != end) {              while (iter != end) {
6312                  delete *iter;                  delete *iter;
6313                  ++iter;                  ++iter;
# Line 6213  namespace { Line 6316  namespace {
6316          }          }
6317      }      }
6318    
6319        /**
6320         * Returns a pointer to the first <i>Sample</i> object of the file,
6321         * <i>NULL</i> otherwise.
6322         *
6323         * @param pProgress - optional: callback function for progress notification
6324         * @deprecated  This method is not reentrant-safe, use GetSample()
6325         *              instead.
6326         */
6327      Sample* File::GetFirstSample(progress_t* pProgress) {      Sample* File::GetFirstSample(progress_t* pProgress) {
6328          if (!pSamples) LoadSamples(pProgress);          if (!pSamples) LoadSamples(pProgress);
6329          if (!pSamples) return NULL;          if (!pSamples) return NULL;
# Line 6220  namespace { Line 6331  namespace {
6331          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
6332      }      }
6333    
6334        /**
6335         * Returns a pointer to the next <i>Sample</i> object of the file,
6336         * <i>NULL</i> otherwise.
6337         *
6338         * @deprecated  This method is not reentrant-safe, use GetSample()
6339         *              instead.
6340         */
6341      Sample* File::GetNextSample() {      Sample* File::GetNextSample() {
6342          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6343          SamplesIterator++;          SamplesIterator++;
# Line 6229  namespace { Line 6347  namespace {
6347      /**      /**
6348       * Returns Sample object of @a index.       * Returns Sample object of @a index.
6349       *       *
6350         * @param index - position of sample in sample list (0..n)
6351         * @param pProgress - optional: callback function for progress notification
6352       * @returns sample object or NULL if index is out of bounds       * @returns sample object or NULL if index is out of bounds
6353       */       */
6354      Sample* File::GetSample(uint index) {      Sample* File::GetSample(size_t index, progress_t* pProgress) {
6355          if (!pSamples) LoadSamples();          if (!pSamples) LoadSamples(pProgress);
6356          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6357          DLS::File::SampleList::iterator it = pSamples->begin();          if (index >= pSamples->size()) return NULL;
6358          for (int i = 0; i < index; ++i) {          return static_cast<gig::Sample*>( (*pSamples)[index] );
             ++it;  
             if (it == pSamples->end()) return NULL;  
         }  
         if (it == pSamples->end()) return NULL;  
         return static_cast<gig::Sample*>( *it );  
6359      }      }
6360    
6361      /**      /**
# Line 6276  namespace { Line 6391  namespace {
6391         wave->AddSubChunk(CHUNK_ID_FMT, 16);         wave->AddSubChunk(CHUNK_ID_FMT, 16);
6392         wave->AddSubList(LIST_TYPE_INFO);         wave->AddSubList(LIST_TYPE_INFO);
6393    
6394           const size_t idxIt = SamplesIterator - pSamples->begin();
6395         pSamples->push_back(pSample);         pSamples->push_back(pSample);
6396           SamplesIterator = pSamples->begin() + std::min(idxIt, pSamples->size()); // avoid iterator invalidation
6397         return pSample;         return pSample;
6398      }      }
6399    
# Line 6293  namespace { Line 6410  namespace {
6410          if (!pSamples || !pSamples->size()) throw gig::Exception("Could not delete sample as there are no samples");          if (!pSamples || !pSamples->size()) throw gig::Exception("Could not delete sample as there are no samples");
6411          SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (DLS::Sample*) pSample);          SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (DLS::Sample*) pSample);
6412          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");
6413          if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation          const size_t idxIt = SamplesIterator - pSamples->begin();
6414          pSamples->erase(iter);          pSamples->erase(iter);
6415            SamplesIterator = pSamples->begin() + std::min(idxIt, pSamples->size()); // avoid iterator invalidation
6416          pSample->DeleteChunks();          pSample->DeleteChunks();
6417          delete pSample;          delete pSample;
6418    
         SampleList::iterator tmp = SamplesIterator;  
6419          // remove all references to the sample          // remove all references to the sample
6420          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          size_t iIns = 0;
6421               instrument = GetNextInstrument()) {          for (Instrument* instrument = GetInstrument(iIns); instrument;
6422              for (Region* region = instrument->GetFirstRegion() ; region ;                           instrument = GetInstrument(++iIns))
6423                   region = instrument->GetNextRegion()) {          {
6424                size_t iRgn = 0;
6425                for (Region* region = instrument->GetRegionAt(iRgn); region;
6426                     region = instrument->GetRegionAt(++iRgn))
6427                {
6428                  if (region->GetSample() == pSample) region->SetSample(NULL);                  if (region->GetSample() == pSample) region->SetSample(NULL);
6429    
6430                  for (int i = 0 ; i < region->DimensionRegions ; i++) {                  for (int i = 0 ; i < region->DimensionRegions ; i++) {
# Line 6313  namespace { Line 6433  namespace {
6433                  }                  }
6434              }              }
6435          }          }
         SamplesIterator = tmp; // restore iterator  
6436      }      }
6437    
6438      void File::LoadSamples() {      void File::LoadSamples() {
# Line 6327  namespace { Line 6446  namespace {
6446    
6447          if (!pSamples) pSamples = new SampleList;          if (!pSamples) pSamples = new SampleList;
6448    
         RIFF::File* file = pRIFF;  
   
6449          // just for progress calculation          // just for progress calculation
6450          int iSampleIndex  = 0;          int iSampleIndex  = 0;
6451          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
# Line 6402  namespace { Line 6519  namespace {
6519              ExtensionFiles.push_back(pExtFile);              ExtensionFiles.push_back(pExtFile);
6520          }          }
6521    
6522          // load samples from extension files (if required)          // load all samples (both from this/main .gig file as well as from
6523            // extension files if required)
6524          for (int i = 0; i < poolFiles.size(); i++) {          for (int i = 0; i < poolFiles.size(); i++) {
6525              RIFF::File* file = poolFiles[i];              RIFF::File* file = poolFiles[i];
6526              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
6527              if (wvpl) {              if (wvpl) {
6528                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
6529                                                 wvpl->GetPos(); // should be zero, but just to be sure                                                 wvpl->GetPos(); // should be zero, but just to be sure
6530                  RIFF::List* wave = wvpl->GetFirstSubList();                  size_t iWaveCk = 0;
6531                  while (wave) {                  for (RIFF::List* wave = wvpl->GetSubListAt(iWaveCk); wave;
6532                         wave = wvpl->GetSubListAt(++iWaveCk))
6533                    {
6534                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
6535                          // notify current progress                          // notify current progress
6536                          if (pProgress) {                          if (pProgress) {
# Line 6423  namespace { Line 6543  namespace {
6543    
6544                          iSampleIndex++;                          iSampleIndex++;
6545                      }                      }
                     wave = wvpl->GetNextSubList();  
6546                  }                  }
6547              }              }
6548          }          }
# Line 6432  namespace { Line 6551  namespace {
6551              __notify_progress(pProgress, 1.0); // notify done              __notify_progress(pProgress, 1.0); // notify done
6552      }      }
6553    
6554        /**
6555         * Returns a pointer to the first <i>Instrument</i> object of the file,
6556         * <i>NULL</i> otherwise.
6557         *
6558         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6559         *              instead.
6560         */
6561      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
6562          if (!pInstruments) LoadInstruments();          if (!pInstruments) LoadInstruments();
6563          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
# Line 6439  namespace { Line 6565  namespace {
6565          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
6566      }      }
6567    
6568        /**
6569         * Returns a pointer to the next <i>Instrument</i> object of the file,
6570         * <i>NULL</i> otherwise.
6571         *
6572         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6573         *              instead.
6574         */
6575      Instrument* File::GetNextInstrument() {      Instrument* File::GetNextInstrument() {
6576          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6577          InstrumentsIterator++;          InstrumentsIterator++;
# Line 6466  namespace { Line 6599  namespace {
6599       * @param pProgress - optional: callback function for progress notification       * @param pProgress - optional: callback function for progress notification
6600       * @returns  sought instrument or NULL if there's no such instrument       * @returns  sought instrument or NULL if there's no such instrument
6601       */       */
6602      Instrument* File::GetInstrument(uint index, progress_t* pProgress) {      Instrument* File::GetInstrument(size_t index, progress_t* pProgress) {
6603          if (!pInstruments) {          if (!pInstruments) {
6604              // 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)
6605    
# Line 6476  namespace { Line 6609  namespace {
6609                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask                  __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
6610                  __notify_progress(&subprogress, 0.0f);                  __notify_progress(&subprogress, 0.0f);
6611                  if (GetAutoLoad())                  if (GetAutoLoad())
6612                      GetFirstSample(&subprogress); // now force all samples to be loaded                      GetSample(0, &subprogress); // now force all samples to be loaded
6613                  __notify_progress(&subprogress, 1.0f);                  __notify_progress(&subprogress, 1.0f);
6614    
6615                  // instrument loading subtask                  // instrument loading subtask
# Line 6490  namespace { Line 6623  namespace {
6623              } else {              } else {
6624                  // sample loading subtask                  // sample loading subtask
6625                  if (GetAutoLoad())                  if (GetAutoLoad())
6626                      GetFirstSample(); // now force all samples to be loaded                      GetSample(0); // now force all samples to be loaded
6627    
6628                  // instrument loading subtask                  // instrument loading subtask
6629                  LoadInstruments();                  LoadInstruments();
6630              }              }
6631          }          }
6632          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6633          InstrumentsIterator = pInstruments->begin();          if (index >= pInstruments->size()) return NULL;
6634          for (uint i = 0; InstrumentsIterator != pInstruments->end(); i++) {          return static_cast<gig::Instrument*>( (*pInstruments)[index] );
             if (i == index) return static_cast<gig::Instrument*>( *InstrumentsIterator );  
             InstrumentsIterator++;  
         }  
         return NULL;  
6635      }      }
6636    
6637      /** @brief Add a new instrument definition.      /** @brief Add a new instrument definition.
# Line 6530  namespace { Line 6659  namespace {
6659         // this string is needed for the gig to be loadable in GSt:         // this string is needed for the gig to be loadable in GSt:
6660         pInstrument->pInfo->Software = "Endless Wave";         pInstrument->pInfo->Software = "Endless Wave";
6661    
6662           const size_t idxIt = InstrumentsIterator - pInstruments->begin();
6663         pInstruments->push_back(pInstrument);         pInstruments->push_back(pInstrument);
6664           InstrumentsIterator = pInstruments->begin() + std::min(idxIt, pInstruments->size()); // avoid iterator invalidation
6665         return pInstrument;         return pInstrument;
6666      }      }
6667            
# Line 6589  namespace { Line 6720  namespace {
6720          }          }
6721    
6722          // clone script groups and their scripts          // clone script groups and their scripts
6723          for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {          for (size_t iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
6724              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
6725              ScriptGroup* dg = AddScriptGroup();              ScriptGroup* dg = AddScriptGroup();
6726              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
# Line 6642  namespace { Line 6773  namespace {
6773          if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");          if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");
6774          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), (DLS::Instrument*) pInstrument);
6775          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");
6776            const size_t idxIt = InstrumentsIterator - pInstruments->begin();
6777          pInstruments->erase(iter);          pInstruments->erase(iter);
6778            InstrumentsIterator = pInstruments->begin() + std::min(idxIt, pInstruments->size()); // avoid iterator invalidation
6779          pInstrument->DeleteChunks();          pInstrument->DeleteChunks();
6780          delete pInstrument;          delete pInstrument;
6781      }      }
# Line 6656  namespace { Line 6789  namespace {
6789          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
6790          if (lstInstruments) {          if (lstInstruments) {
6791              int iInstrumentIndex = 0;              int iInstrumentIndex = 0;
6792              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              size_t i = 0;
6793              while (lstInstr) {              for (RIFF::List* lstInstr = lstInstruments->GetSubListAt(i);
6794                     lstInstr; lstInstr = lstInstruments->GetSubListAt(++i))
6795                {
6796                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6797                      if (pProgress) {                      if (pProgress) {
6798                          // notify current progress                          // notify current progress
# Line 6675  namespace { Line 6810  namespace {
6810    
6811                      iInstrumentIndex++;                      iInstrumentIndex++;
6812                  }                  }
                 lstInstr = lstInstruments->GetNextSubList();  
6813              }              }
6814              if (pProgress)              if (pProgress)
6815                  __notify_progress(pProgress, 1.0); // notify done                  __notify_progress(pProgress, 1.0); // notify done
# Line 6729  namespace { Line 6863  namespace {
6863      }      }
6864    
6865      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6866          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6867          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
6868          File::SampleList::iterator end  = pSamples->end();          File::SampleList::iterator end  = pSamples->end();
6869          for (int index = 0; iter != end; ++iter, ++index)          for (int index = 0; iter != end; ++iter, ++index)
# Line 6749  namespace { Line 6883  namespace {
6883          if (!_3crc) return false;          if (!_3crc) return false;
6884          if (_3crc->GetNewSize() <= 0) return false;          if (_3crc->GetNewSize() <= 0) return false;
6885          if (_3crc->GetNewSize() % 8) return false;          if (_3crc->GetNewSize() % 8) return false;
6886          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6887          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6888    
6889          const file_offset_t n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
# Line 6783  namespace { Line 6917  namespace {
6917       */       */
6918      bool File::RebuildSampleChecksumTable() {      bool File::RebuildSampleChecksumTable() {
6919          // make sure sample chunks were scanned          // make sure sample chunks were scanned
6920          if (!pSamples) GetFirstSample();          if (!pSamples) GetSample(0);
6921    
6922          bool bRequiresSave = false;          bool bRequiresSave = false;
6923    
# Line 6832  namespace { Line 6966  namespace {
6966          return bRequiresSave;          return bRequiresSave;
6967      }      }
6968    
6969        /**
6970         * Returns a pointer to the first <i>Group</i> object of the file,
6971         * <i>NULL</i> otherwise.
6972         *
6973         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6974         */
6975      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
6976          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6977          // there must always be at least one group          // there must always be at least one group
# Line 6839  namespace { Line 6979  namespace {
6979          return *GroupsIterator;          return *GroupsIterator;
6980      }      }
6981    
6982        /**
6983         * Returns a pointer to the next <i>Group</i> object of the file,
6984         * <i>NULL</i> otherwise.
6985         *
6986         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6987         */
6988      Group* File::GetNextGroup() {      Group* File::GetNextGroup() {
6989          if (!pGroups) return NULL;          if (!pGroups) return NULL;
6990          ++GroupsIterator;          ++GroupsIterator;
# Line 6851  namespace { Line 6997  namespace {
6997       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
6998       * @returns sought group or NULL if there's no such group       * @returns sought group or NULL if there's no such group
6999       */       */
7000      Group* File::GetGroup(uint index) {      Group* File::GetGroup(size_t index) {
7001          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7002          GroupsIterator = pGroups->begin();          if (index >= pGroups->size()) return NULL;
7003          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {          return (*pGroups)[index];
             if (i == index) return *GroupsIterator;  
             ++GroupsIterator;  
         }  
         return NULL;  
7004      }      }
7005    
7006      /**      /**
# Line 6873  namespace { Line 7015  namespace {
7015       */       */
7016      Group* File::GetGroup(String name) {      Group* File::GetGroup(String name) {
7017          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7018          GroupsIterator = pGroups->begin();          size_t i = 0;
7019          for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)          for (Group* pGroup = GetGroup(i); pGroup; pGroup = GetGroup(++i))
7020              if ((*GroupsIterator)->Name == name) return *GroupsIterator;              if (pGroup->Name == name) return pGroup;
7021          return NULL;          return NULL;
7022      }      }
7023    
# Line 6899  namespace { Line 7041  namespace {
7041       */       */
7042      void File::DeleteGroup(Group* pGroup) {      void File::DeleteGroup(Group* pGroup) {
7043          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7044          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7045                find(pGroups->begin(), pGroups->end(), pGroup);
7046          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
7047          if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");          if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
7048          // delete all members of this group          // delete all members of this group
7049          for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {          Sample* pSample;
7050            while ((pSample = pGroup->GetSample(0))) {
7051              DeleteSample(pSample);              DeleteSample(pSample);
7052          }          }
7053          // now delete this group object          // now delete this group object
# Line 6924  namespace { Line 7068  namespace {
7068       */       */
7069      void File::DeleteGroupOnly(Group* pGroup) {      void File::DeleteGroupOnly(Group* pGroup) {
7070          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7071          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7072                find(pGroups->begin(), pGroups->end(), pGroup);
7073          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");          if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
7074          if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");          if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
7075          // move all members of this group to another group          // move all members of this group to another group
# Line 6935  namespace { Line 7080  namespace {
7080      }      }
7081    
7082      void File::LoadGroups() {      void File::LoadGroups() {
7083          if (!pGroups) pGroups = new std::list<Group*>;          if (!pGroups) pGroups = new std::vector<Group*>;
7084          // try to read defined groups from file          // try to read defined groups from file
7085          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
7086          if (lst3gri) {          if (lst3gri) {
7087              RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);              RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
7088              if (lst3gnl) {              if (lst3gnl) {
7089                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  size_t i = 0;
7090                  while (ck) {                  for (RIFF::Chunk* ck = lst3gnl->GetSubChunkAt(i); ck;
7091                         ck = lst3gnl->GetSubChunkAt(++i))
7092                    {
7093                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
7094                          if (pVersion && pVersion->major > 2 &&                          if (pVersion && pVersion->major > 2 &&
7095                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
7096    
7097                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
7098                      }                      }
                     ck = lst3gnl->GetNextSubChunk();  
7099                  }                  }
7100              }              }
7101          }          }
# Line 6968  namespace { Line 7114  namespace {
7114       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
7115       * @returns sought script group or NULL if there's no such group       * @returns sought script group or NULL if there's no such group
7116       */       */
7117      ScriptGroup* File::GetScriptGroup(uint index) {      ScriptGroup* File::GetScriptGroup(size_t index) {
7118          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7119          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          if (index >= pScriptGroups->size()) return NULL;
7120          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)          return (*pScriptGroups)[index];
             if (i == index) return *it;  
         return NULL;  
7121      }      }
7122    
7123      /** @brief Get instrument script group (by name).      /** @brief Get instrument script group (by name).
# Line 6986  namespace { Line 7130  namespace {
7130       */       */
7131      ScriptGroup* File::GetScriptGroup(const String& name) {      ScriptGroup* File::GetScriptGroup(const String& name) {
7132          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7133          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          for (size_t i = 0; i < pScriptGroups->size(); ++i) {
7134          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)              ScriptGroup* pGroup = (*pScriptGroups)[i];
7135              if ((*it)->Name == name) return *it;              if (pGroup->Name == name) return pGroup;
7136            }
7137          return NULL;          return NULL;
7138      }      }
7139    
# Line 7021  namespace { Line 7166  namespace {
7166       */       */
7167      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
7168          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7169          std::list<ScriptGroup*>::iterator iter =          std::vector<ScriptGroup*>::iterator iter =
7170              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
7171          if (iter == pScriptGroups->end())          if (iter == pScriptGroups->end())
7172              throw gig::Exception("Could not delete script group, could not find given script group");              throw gig::Exception("Could not delete script group, could not find given script group");
# Line 7036  namespace { Line 7181  namespace {
7181    
7182      void File::LoadScriptGroups() {      void File::LoadScriptGroups() {
7183          if (pScriptGroups) return;          if (pScriptGroups) return;
7184          pScriptGroups = new std::list<ScriptGroup*>;          pScriptGroups = new std::vector<ScriptGroup*>;
7185          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
7186          if (lstLS) {          if (lstLS) {
7187              for (RIFF::List* lst = lstLS->GetFirstSubList(); lst;              size_t i = 0;
7188                   lst = lstLS->GetNextSubList())              for (RIFF::List* lst = lstLS->GetSubListAt(i); lst;
7189                     lst = lstLS->GetSubListAt(++i))
7190              {              {
7191                  if (lst->GetListType() == LIST_TYPE_RTIS) {                  if (lst->GetListType() == LIST_TYPE_RTIS) {
7192                      pScriptGroups->push_back(new ScriptGroup(this, lst));                      pScriptGroups->push_back(new ScriptGroup(this, lst));
# Line 7080  namespace { Line 7226  namespace {
7226          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
7227          if (pScriptGroups) {          if (pScriptGroups) {
7228              // Update instrument script (group) chunks.              // Update instrument script (group) chunks.
7229              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();              for (std::vector<ScriptGroup*>::iterator it = pScriptGroups->begin();
7230                   it != pScriptGroups->end(); ++it)                   it != pScriptGroups->end(); ++it)
7231              {              {
7232                  (*it)->UpdateChunks(pProgress);                  (*it)->UpdateChunks(pProgress);
# Line 7101  namespace { Line 7247  namespace {
7247              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
7248              // is placed first in file              // is placed first in file
7249              RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);              RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);
7250              RIFF::Chunk* first = pRIFF->GetFirstSubChunk();              RIFF::Chunk* first = pRIFF->GetSubChunkAt(0);
7251              if (first != info) {              if (first != info) {
7252                  pRIFF->MoveSubChunk(info, first);                  pRIFF->MoveSubChunk(info, first);
7253              }              }
# Line 7122  namespace { Line 7268  namespace {
7268              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
7269              // (before updating the Group chunks)              // (before updating the Group chunks)
7270              if (pVersion && pVersion->major > 2) {              if (pVersion && pVersion->major > 2) {
7271                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  size_t i = 0;
7272                  for (int i = 0 ; i < 128 ; i++) {                  for (RIFF::Chunk* _3gnm = _3gnl->GetSubChunkAt(i); i < 128;
7273                         _3gnm = _3gnl->GetSubChunkAt(++i))
7274                    {
7275                      // create 128 empty placeholder strings which will either                      // create 128 empty placeholder strings which will either
7276                      // be filled by Group::UpdateChunks below or left empty.                      // be filled by Group::UpdateChunks below or left empty.
7277                      ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
                     if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();  
7278                  }                  }
7279              }              }
7280    
7281              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
7282              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
7283              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
7284                  (*iter)->UpdateChunks(pProgress);                  (*iter)->UpdateChunks(pProgress);
7285              }              }
# Line 7170  namespace { Line 7317  namespace {
7317              uint8_t* pData = (uint8_t*) einf->LoadChunkData();              uint8_t* pData = (uint8_t*) einf->LoadChunkData();
7318    
7319              std::map<gig::Sample*,int> sampleMap;              std::map<gig::Sample*,int> sampleMap;
7320              int sampleIdx = 0;              size_t sampleIdx = 0;
7321              for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {              for (Sample* pSample = GetSample(0); pSample;
7322                  sampleMap[pSample] = sampleIdx++;                           pSample = GetSample(++sampleIdx))
7323                {
7324                    sampleMap[pSample] = sampleIdx;
7325              }              }
7326    
7327              int totnbusedsamples = 0;              int totnbusedsamples = 0;
# Line 7184  namespace { Line 7333  namespace {
7333    
7334              memset(&pData[48], 0, sublen - 48);              memset(&pData[48], 0, sublen - 48);
7335    
7336              for (Instrument* instrument = GetFirstInstrument() ; instrument ;              size_t iIns = 0;
7337                   instrument = GetNextInstrument()) {              for (Instrument* instrument = GetInstrument(iIns); instrument;
7338                                 instrument = GetInstrument(++iIns))
7339                {
7340                  int nbusedsamples = 0;                  int nbusedsamples = 0;
7341                  int nbusedchannels = 0;                  int nbusedchannels = 0;
7342                  int nbdimregions = 0;                  int nbdimregions = 0;
# Line 7193  namespace { Line 7344  namespace {
7344    
7345                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
7346    
7347                  for (Region* region = instrument->GetFirstRegion() ; region ;                  size_t iRgn = 0;
7348                       region = instrument->GetNextRegion()) {                  for (Region* region = instrument->GetRegionAt(iRgn); region;
7349                         region = instrument->GetRegionAt(++iRgn))
7350                    {
7351                      for (int i = 0 ; i < region->DimensionRegions ; i++) {                      for (int i = 0 ; i < region->DimensionRegions ; i++) {
7352                          gig::DimensionRegion *d = region->pDimensionRegions[i];                          gig::DimensionRegion *d = region->pDimensionRegions[i];
7353                          if (d->pSample) {                          if (d->pSample) {
# Line 7288  namespace { Line 7441  namespace {
7441      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
7442          DLS::File::UpdateFileOffsets();          DLS::File::UpdateFileOffsets();
7443    
7444          for (Instrument* instrument = GetFirstInstrument(); instrument;          size_t i = 0;
7445               instrument = GetNextInstrument())          for (Instrument* instrument = GetInstrument(i); instrument;
7446                             instrument = GetInstrument(++i))
7447          {          {
7448              instrument->UpdateScriptFileOffsets();              instrument->UpdateScriptFileOffsets();
7449          }          }
Legend:
Removed from v.3731  
changed lines
  Added in v.3979
  ViewVC Help
Powered by ViewVC