/[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 3936 by schoenebeck, Thu Jun 17 10:29:54 2021 UTC revision 3961 by schoenebeck, Sat Jun 19 11:01:40 2021 UTC
# Line 4801  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 4840  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 4855  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 4893  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 4906  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          size_t i = 0;          size_t i = 0;
# Line 5394  namespace { Line 5392  namespace {
5392       * @param dst - destination instrument at which this instrument will be       * @param dst - destination instrument at which this instrument will be
5393       *              moved to, or pass NULL for moving to end of list       *              moved to, or pass NULL for moving to end of list
5394       * @throw gig::Exception if this instrument and target instrument are not       * @throw gig::Exception if this instrument and target instrument are not
5395       *                       part of the same file       *                       part of the same file, as well as on unexpected
5396         *                       internal error
5397       */       */
5398      void Instrument::MoveTo(Instrument* dst) {      void Instrument::MoveTo(Instrument* dst) {
5399          if (dst && GetParent() != dst->GetParent())          if (dst && GetParent() != dst->GetParent())
# Line 5411  namespace { Line 5410  namespace {
5410    
5411              File::InstrumentList::iterator itFrom =              File::InstrumentList::iterator itFrom =
5412                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
5413                if (itFrom == list.end())
5414                    throw Exception(
5415                        "gig::Instrument::MoveTo(): unexpected missing membership "
5416                        "of this instrument."
5417                    );
5418                list.erase(itFrom);
5419    
5420              File::InstrumentList::iterator itTo =              File::InstrumentList::iterator itTo =
5421                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
5422    
5423              list.splice(itTo, list, itFrom);              list.insert(itTo, this);
5424          }          }
5425    
5426          // move the instrument's actual list RIFF chunk appropriately          // move the instrument's actual list RIFF chunk appropriately
# Line 5496  namespace { Line 5501  namespace {
5501          File* pFile = (File*) GetParent();          File* pFile = (File*) GetParent();
5502          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
5503              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
5504              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {              for (size_t i = 0; pFile->GetScriptGroup(i); ++i) {
5505                  ScriptGroup* group = pFile->GetScriptGroup(i);                  ScriptGroup* group = pFile->GetScriptGroup(i);
5506                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
5507                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
# Line 5534  namespace { Line 5539  namespace {
5539       * @param index - instrument script slot index       * @param index - instrument script slot index
5540       * @returns script or NULL if index is out of bounds       * @returns script or NULL if index is out of bounds
5541       */       */
5542      Script* Instrument::GetScriptOfSlot(uint index) {      Script* Instrument::GetScriptOfSlot(size_t index) {
5543          LoadScripts();          LoadScripts();
5544          if (index >= pScriptRefs->size()) return NULL;          if (index >= pScriptRefs->size()) return NULL;
5545          return pScriptRefs->at(index).script;          return pScriptRefs->at(index).script;
# Line 5595  namespace { Line 5600  namespace {
5600       * @param index1 - index of the first script slot to swap       * @param index1 - index of the first script slot to swap
5601       * @param index2 - index of the second script slot to swap       * @param index2 - index of the second script slot to swap
5602       */       */
5603      void Instrument::SwapScriptSlots(uint index1, uint index2) {      void Instrument::SwapScriptSlots(size_t index1, size_t index2) {
5604          LoadScripts();          LoadScripts();
5605          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
5606              return;              return;
# Line 5610  namespace { Line 5615  namespace {
5615       *       *
5616       * @param index - index of script slot to remove       * @param index - index of script slot to remove
5617       */       */
5618      void Instrument::RemoveScriptSlot(uint index) {      void Instrument::RemoveScriptSlot(size_t index) {
5619          LoadScripts();          LoadScripts();
5620          if (index >= pScriptRefs->size()) return;          if (index >= pScriptRefs->size()) return;
5621          pScriptRefs->erase( pScriptRefs->begin() + index );          pScriptRefs->erase( pScriptRefs->begin() + index );
# Line 5651  namespace { Line 5656  namespace {
5656       * GigaStudio 4 software. It will currently only work with LinuxSampler and       * GigaStudio 4 software. It will currently only work with LinuxSampler and
5657       * gigedit.       * gigedit.
5658       */       */
5659      uint Instrument::ScriptSlotCount() const {      size_t Instrument::ScriptSlotCount() const {
5660          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
5661      }      }
5662    
5663      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5671  namespace { Line 5676  namespace {
5676       * @param index - index of the script slot on this instrument       * @param index - index of the script slot on this instrument
5677       * @see Script::Bypass       * @see Script::Bypass
5678       */       */
5679      bool Instrument::IsScriptSlotBypassed(uint index) {      bool Instrument::IsScriptSlotBypassed(size_t index) {
5680          if (index >= ScriptSlotCount()) return false;          if (index >= ScriptSlotCount()) return false;
5681          return pScriptRefs ? pScriptRefs->at(index).bypass          return pScriptRefs ? pScriptRefs->at(index).bypass
5682                             : scriptPoolFileOffsets.at(index).bypass;                             : scriptPoolFileOffsets.at(index).bypass;
# Line 5691  namespace { Line 5696  namespace {
5696       * @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
5697       * @see Script::Bypass       * @see Script::Bypass
5698       */       */
5699      void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {      void Instrument::SetScriptSlotBypassed(size_t index, bool bBypass) {
5700          if (index >= ScriptSlotCount()) return;          if (index >= ScriptSlotCount()) return;
5701          if (pScriptRefs)          if (pScriptRefs)
5702              pScriptRefs->at(index).bypass = bBypass;              pScriptRefs->at(index).bypass = bBypass;
# Line 5711  namespace { Line 5716  namespace {
5716       * the @c Script identified by passed @p uuid.       * the @c Script identified by passed @p uuid.
5717       */       */
5718      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {
5719          const uint nSlots = ScriptSlotCount();          const size_t nSlots = ScriptSlotCount();
5720          for (uint iSlot = 0; iSlot < nSlots; ++iSlot)          for (size_t iSlot = 0; iSlot < nSlots; ++iSlot)
5721              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)
5722                  return true;                  return true;
5723          return false;          return false;
# Line 5737  namespace { Line 5742  namespace {
5742       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5743       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5744       */       */
5745      bool Instrument::IsScriptPatchVariableSet(int slot, String variable) {      bool Instrument::IsScriptPatchVariableSet(size_t slot, String variable) {
5746          if (variable.empty()) return false;          if (variable.empty()) return false;
5747          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5748          if (!script) return false;          if (!script) return false;
# Line 5771  namespace { Line 5776  namespace {
5776       *       *
5777       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5778       */       */
5779      std::map<String,String> Instrument::GetScriptPatchVariables(int slot) {      std::map<String,String> Instrument::GetScriptPatchVariables(size_t slot) {
5780          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5781          if (!script) return std::map<String,String>();          if (!script) return std::map<String,String>();
5782          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
# Line 5803  namespace { Line 5808  namespace {
5808       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5809       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5810       */       */
5811      String Instrument::GetScriptPatchVariable(int slot, String variable) {      String Instrument::GetScriptPatchVariable(size_t slot, String variable) {
5812          std::map<String,String> vars = GetScriptPatchVariables(slot);          std::map<String,String> vars = GetScriptPatchVariables(slot);
5813          return (vars.count(variable)) ? vars.find(variable)->second : "";          return (vars.count(variable)) ? vars.find(variable)->second : "";
5814      }      }
# Line 5830  namespace { Line 5835  namespace {
5835       * @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
5836       *         @p variable name is empty       *         @p variable name is empty
5837       */       */
5838      void Instrument::SetScriptPatchVariable(int slot, String variable, String value) {      void Instrument::SetScriptPatchVariable(size_t slot, String variable, String value) {
5839          if (variable.empty())          if (variable.empty())
5840              throw Exception("Variable name must not be empty");              throw Exception("Variable name must not be empty");
5841          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
# Line 6204  namespace { Line 6209  namespace {
6209       */       */
6210      void Group::MoveAll() {      void Group::MoveAll() {
6211          // get "that" other group first          // get "that" other group first
6212            size_t i = 0;
6213          Group* pOtherGroup = NULL;          Group* pOtherGroup = NULL;
6214          for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {          for (pOtherGroup = pFile->GetGroup(i); pOtherGroup;
6215                 pOtherGroup = pFile->GetGroup(++i))
6216            {
6217              if (pOtherGroup != this) break;              if (pOtherGroup != this) break;
6218          }          }
6219          if (!pOtherGroup) throw Exception(          if (!pOtherGroup) throw Exception(
# Line 6295  namespace { Line 6303  namespace {
6303              delete pGroups;              delete pGroups;
6304          }          }
6305          if (pScriptGroups) {          if (pScriptGroups) {
6306              std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();              std::vector<ScriptGroup*>::iterator iter = pScriptGroups->begin();
6307              std::list<ScriptGroup*>::iterator end  = pScriptGroups->end();              std::vector<ScriptGroup*>::iterator end  = pScriptGroups->end();
6308              while (iter != end) {              while (iter != end) {
6309                  delete *iter;                  delete *iter;
6310                  ++iter;                  ++iter;
# Line 6402  namespace { Line 6410  namespace {
6410          pSample->DeleteChunks();          pSample->DeleteChunks();
6411          delete pSample;          delete pSample;
6412    
         SampleList::iterator tmp = SamplesIterator;  
6413          // remove all references to the sample          // remove all references to the sample
6414          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          size_t iIns = 0;
6415               instrument = GetNextInstrument()) {          for (Instrument* instrument = GetInstrument(iIns); instrument;
6416                             instrument = GetInstrument(++iIns))
6417            {
6418              size_t iRgn = 0;              size_t iRgn = 0;
6419              for (Region* region = instrument->GetRegionAt(iRgn); region;              for (Region* region = instrument->GetRegionAt(iRgn); region;
6420                   region = instrument->GetRegionAt(++iRgn))                   region = instrument->GetRegionAt(++iRgn))
# Line 6418  namespace { Line 6427  namespace {
6427                  }                  }
6428              }              }
6429          }          }
         SamplesIterator = tmp; // restore iterator  
6430      }      }
6431    
6432      void File::LoadSamples() {      void File::LoadSamples() {
# Line 6536  namespace { Line 6544  namespace {
6544              __notify_progress(pProgress, 1.0); // notify done              __notify_progress(pProgress, 1.0); // notify done
6545      }      }
6546    
6547        /**
6548         * Returns a pointer to the first <i>Instrument</i> object of the file,
6549         * <i>NULL</i> otherwise.
6550         *
6551         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6552         *              instead.
6553         */
6554      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
6555          if (!pInstruments) LoadInstruments();          if (!pInstruments) LoadInstruments();
6556          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
# Line 6543  namespace { Line 6558  namespace {
6558          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
6559      }      }
6560    
6561        /**
6562         * Returns a pointer to the next <i>Instrument</i> object of the file,
6563         * <i>NULL</i> otherwise.
6564         *
6565         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6566         *              instead.
6567         */
6568      Instrument* File::GetNextInstrument() {      Instrument* File::GetNextInstrument() {
6569          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6570          InstrumentsIterator++;          InstrumentsIterator++;
# Line 6570  namespace { Line 6592  namespace {
6592       * @param pProgress - optional: callback function for progress notification       * @param pProgress - optional: callback function for progress notification
6593       * @returns  sought instrument or NULL if there's no such instrument       * @returns  sought instrument or NULL if there's no such instrument
6594       */       */
6595      Instrument* File::GetInstrument(uint index, progress_t* pProgress) {      Instrument* File::GetInstrument(size_t index, progress_t* pProgress) {
6596          if (!pInstruments) {          if (!pInstruments) {
6597              // 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)
6598    
# Line 6601  namespace { Line 6623  namespace {
6623              }              }
6624          }          }
6625          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6626          InstrumentsIterator = pInstruments->begin();          if (index >= pInstruments->size()) return NULL;
6627          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;  
6628      }      }
6629    
6630      /** @brief Add a new instrument definition.      /** @brief Add a new instrument definition.
# Line 6693  namespace { Line 6711  namespace {
6711          }          }
6712    
6713          // clone script groups and their scripts          // clone script groups and their scripts
6714          for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {          for (size_t iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
6715              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
6716              ScriptGroup* dg = AddScriptGroup();              ScriptGroup* dg = AddScriptGroup();
6717              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
# Line 6937  namespace { Line 6955  namespace {
6955          return bRequiresSave;          return bRequiresSave;
6956      }      }
6957    
6958        /**
6959         * Returns a pointer to the first <i>Group</i> object of the file,
6960         * <i>NULL</i> otherwise.
6961         *
6962         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6963         */
6964      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
6965          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6966          // there must always be at least one group          // there must always be at least one group
# Line 6944  namespace { Line 6968  namespace {
6968          return *GroupsIterator;          return *GroupsIterator;
6969      }      }
6970    
6971        /**
6972         * Returns a pointer to the next <i>Group</i> object of the file,
6973         * <i>NULL</i> otherwise.
6974         *
6975         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6976         */
6977      Group* File::GetNextGroup() {      Group* File::GetNextGroup() {
6978          if (!pGroups) return NULL;          if (!pGroups) return NULL;
6979          ++GroupsIterator;          ++GroupsIterator;
# Line 6974  namespace { Line 7004  namespace {
7004       */       */
7005      Group* File::GetGroup(String name) {      Group* File::GetGroup(String name) {
7006          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7007          GroupsIterator = pGroups->begin();          size_t i = 0;
7008          for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)          for (Group* pGroup = GetGroup(i); pGroup; pGroup = GetGroup(++i))
7009              if ((*GroupsIterator)->Name == name) return *GroupsIterator;              if (pGroup->Name == name) return pGroup;
7010          return NULL;          return NULL;
7011      }      }
7012    
# Line 7073  namespace { Line 7103  namespace {
7103       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
7104       * @returns sought script group or NULL if there's no such group       * @returns sought script group or NULL if there's no such group
7105       */       */
7106      ScriptGroup* File::GetScriptGroup(uint index) {      ScriptGroup* File::GetScriptGroup(size_t index) {
7107          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7108          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          if (index >= pScriptGroups->size()) return NULL;
7109          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)          return (*pScriptGroups)[index];
             if (i == index) return *it;  
         return NULL;  
7110      }      }
7111    
7112      /** @brief Get instrument script group (by name).      /** @brief Get instrument script group (by name).
# Line 7091  namespace { Line 7119  namespace {
7119       */       */
7120      ScriptGroup* File::GetScriptGroup(const String& name) {      ScriptGroup* File::GetScriptGroup(const String& name) {
7121          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7122          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          for (size_t i = 0; i < pScriptGroups->size(); ++i) {
7123          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)              ScriptGroup* pGroup = (*pScriptGroups)[i];
7124              if ((*it)->Name == name) return *it;              if (pGroup->Name == name) return pGroup;
7125            }
7126          return NULL;          return NULL;
7127      }      }
7128    
# Line 7126  namespace { Line 7155  namespace {
7155       */       */
7156      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
7157          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7158          std::list<ScriptGroup*>::iterator iter =          std::vector<ScriptGroup*>::iterator iter =
7159              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
7160          if (iter == pScriptGroups->end())          if (iter == pScriptGroups->end())
7161              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 7141  namespace { Line 7170  namespace {
7170    
7171      void File::LoadScriptGroups() {      void File::LoadScriptGroups() {
7172          if (pScriptGroups) return;          if (pScriptGroups) return;
7173          pScriptGroups = new std::list<ScriptGroup*>;          pScriptGroups = new std::vector<ScriptGroup*>;
7174          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
7175          if (lstLS) {          if (lstLS) {
7176              size_t i = 0;              size_t i = 0;
# Line 7186  namespace { Line 7215  namespace {
7215          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
7216          if (pScriptGroups) {          if (pScriptGroups) {
7217              // Update instrument script (group) chunks.              // Update instrument script (group) chunks.
7218              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();              for (std::vector<ScriptGroup*>::iterator it = pScriptGroups->begin();
7219                   it != pScriptGroups->end(); ++it)                   it != pScriptGroups->end(); ++it)
7220              {              {
7221                  (*it)->UpdateChunks(pProgress);                  (*it)->UpdateChunks(pProgress);
# Line 7293  namespace { Line 7322  namespace {
7322    
7323              memset(&pData[48], 0, sublen - 48);              memset(&pData[48], 0, sublen - 48);
7324    
7325              for (Instrument* instrument = GetFirstInstrument() ; instrument ;              size_t iIns = 0;
7326                   instrument = GetNextInstrument()) {              for (Instrument* instrument = GetInstrument(iIns); instrument;
7327                                 instrument = GetInstrument(++iIns))
7328                {
7329                  int nbusedsamples = 0;                  int nbusedsamples = 0;
7330                  int nbusedchannels = 0;                  int nbusedchannels = 0;
7331                  int nbdimregions = 0;                  int nbdimregions = 0;
# Line 7399  namespace { Line 7430  namespace {
7430      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
7431          DLS::File::UpdateFileOffsets();          DLS::File::UpdateFileOffsets();
7432    
7433          for (Instrument* instrument = GetFirstInstrument(); instrument;          size_t i = 0;
7434               instrument = GetNextInstrument())          for (Instrument* instrument = GetInstrument(i); instrument;
7435                             instrument = GetInstrument(++i))
7436          {          {
7437              instrument->UpdateScriptFileOffsets();              instrument->UpdateScriptFileOffsets();
7438          }          }
Legend:
Removed from v.3936  
changed lines
  Added in v.3961
  ViewVC Help
Powered by ViewVC