/[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 3928 by schoenebeck, Tue Jun 15 11:38:38 2021 UTC revision 3970 by schoenebeck, Thu Jun 24 11:49:31 2021 UTC
# 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 4325  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 4799  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 4838  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 4853  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 4891  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 4904  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 5308  namespace { Line 5308  namespace {
5308       * @param pos - position of sought Region in region list       * @param pos - position of sought Region in region list
5309       * @returns pointer address to requested region or @c NULL if @a pos is       * @returns pointer address to requested region or @c NULL if @a pos is
5310       *          out of bounds       *          out of bounds
5311         * @see CountRegions()
5312       */       */
5313      Region* Instrument::GetRegionAt(size_t pos) {      Region* Instrument::GetRegionAt(size_t pos) {
5314          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5392  namespace { Line 5393  namespace {
5393       * @param dst - destination instrument at which this instrument will be       * @param dst - destination instrument at which this instrument will be
5394       *              moved to, or pass NULL for moving to end of list       *              moved to, or pass NULL for moving to end of list
5395       * @throw gig::Exception if this instrument and target instrument are not       * @throw gig::Exception if this instrument and target instrument are not
5396       *                       part of the same file       *                       part of the same file, as well as on unexpected
5397         *                       internal error
5398       */       */
5399      void Instrument::MoveTo(Instrument* dst) {      void Instrument::MoveTo(Instrument* dst) {
5400          if (dst && GetParent() != dst->GetParent())          if (dst && GetParent() != dst->GetParent())
# Line 5409  namespace { Line 5411  namespace {
5411    
5412              File::InstrumentList::iterator itFrom =              File::InstrumentList::iterator itFrom =
5413                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
5414                if (itFrom == list.end())
5415                    throw Exception(
5416                        "gig::Instrument::MoveTo(): unexpected missing membership "
5417                        "of this instrument."
5418                    );
5419                list.erase(itFrom);
5420    
5421              File::InstrumentList::iterator itTo =              File::InstrumentList::iterator itTo =
5422                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));                  std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
5423    
5424              list.splice(itTo, list, itFrom);              list.insert(itTo, this);
5425          }          }
5426    
5427          // move the instrument's actual list RIFF chunk appropriately          // move the instrument's actual list RIFF chunk appropriately
# Line 5494  namespace { Line 5502  namespace {
5502          File* pFile = (File*) GetParent();          File* pFile = (File*) GetParent();
5503          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
5504              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
5505              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {              for (size_t i = 0; pFile->GetScriptGroup(i); ++i) {
5506                  ScriptGroup* group = pFile->GetScriptGroup(i);                  ScriptGroup* group = pFile->GetScriptGroup(i);
5507                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
5508                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
# Line 5532  namespace { Line 5540  namespace {
5540       * @param index - instrument script slot index       * @param index - instrument script slot index
5541       * @returns script or NULL if index is out of bounds       * @returns script or NULL if index is out of bounds
5542       */       */
5543      Script* Instrument::GetScriptOfSlot(uint index) {      Script* Instrument::GetScriptOfSlot(size_t index) {
5544          LoadScripts();          LoadScripts();
5545          if (index >= pScriptRefs->size()) return NULL;          if (index >= pScriptRefs->size()) return NULL;
5546          return pScriptRefs->at(index).script;          return pScriptRefs->at(index).script;
# Line 5593  namespace { Line 5601  namespace {
5601       * @param index1 - index of the first script slot to swap       * @param index1 - index of the first script slot to swap
5602       * @param index2 - index of the second script slot to swap       * @param index2 - index of the second script slot to swap
5603       */       */
5604      void Instrument::SwapScriptSlots(uint index1, uint index2) {      void Instrument::SwapScriptSlots(size_t index1, size_t index2) {
5605          LoadScripts();          LoadScripts();
5606          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())          if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
5607              return;              return;
# Line 5608  namespace { Line 5616  namespace {
5616       *       *
5617       * @param index - index of script slot to remove       * @param index - index of script slot to remove
5618       */       */
5619      void Instrument::RemoveScriptSlot(uint index) {      void Instrument::RemoveScriptSlot(size_t index) {
5620          LoadScripts();          LoadScripts();
5621          if (index >= pScriptRefs->size()) return;          if (index >= pScriptRefs->size()) return;
5622          pScriptRefs->erase( pScriptRefs->begin() + index );          pScriptRefs->erase( pScriptRefs->begin() + index );
# Line 5649  namespace { Line 5657  namespace {
5657       * GigaStudio 4 software. It will currently only work with LinuxSampler and       * GigaStudio 4 software. It will currently only work with LinuxSampler and
5658       * gigedit.       * gigedit.
5659       */       */
5660      uint Instrument::ScriptSlotCount() const {      size_t Instrument::ScriptSlotCount() const {
5661          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
5662      }      }
5663    
5664      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5669  namespace { Line 5677  namespace {
5677       * @param index - index of the script slot on this instrument       * @param index - index of the script slot on this instrument
5678       * @see Script::Bypass       * @see Script::Bypass
5679       */       */
5680      bool Instrument::IsScriptSlotBypassed(uint index) {      bool Instrument::IsScriptSlotBypassed(size_t index) {
5681          if (index >= ScriptSlotCount()) return false;          if (index >= ScriptSlotCount()) return false;
5682          return pScriptRefs ? pScriptRefs->at(index).bypass          return pScriptRefs ? pScriptRefs->at(index).bypass
5683                             : scriptPoolFileOffsets.at(index).bypass;                             : scriptPoolFileOffsets.at(index).bypass;
# Line 5689  namespace { Line 5697  namespace {
5697       * @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
5698       * @see Script::Bypass       * @see Script::Bypass
5699       */       */
5700      void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {      void Instrument::SetScriptSlotBypassed(size_t index, bool bBypass) {
5701          if (index >= ScriptSlotCount()) return;          if (index >= ScriptSlotCount()) return;
5702          if (pScriptRefs)          if (pScriptRefs)
5703              pScriptRefs->at(index).bypass = bBypass;              pScriptRefs->at(index).bypass = bBypass;
# Line 5709  namespace { Line 5717  namespace {
5717       * the @c Script identified by passed @p uuid.       * the @c Script identified by passed @p uuid.
5718       */       */
5719      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {      bool Instrument::ReferencesScriptWithUuid(const _UUID& uuid) {
5720          const uint nSlots = ScriptSlotCount();          const size_t nSlots = ScriptSlotCount();
5721          for (uint iSlot = 0; iSlot < nSlots; ++iSlot)          for (size_t iSlot = 0; iSlot < nSlots; ++iSlot)
5722              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)              if (_UUIDFromCArray(&GetScriptOfSlot(iSlot)->Uuid[0]) == uuid)
5723                  return true;                  return true;
5724          return false;          return false;
# Line 5735  namespace { Line 5743  namespace {
5743       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5744       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5745       */       */
5746      bool Instrument::IsScriptPatchVariableSet(int slot, String variable) {      bool Instrument::IsScriptPatchVariableSet(size_t slot, String variable) {
5747          if (variable.empty()) return false;          if (variable.empty()) return false;
5748          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5749          if (!script) return false;          if (!script) return false;
# Line 5769  namespace { Line 5777  namespace {
5777       *       *
5778       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5779       */       */
5780      std::map<String,String> Instrument::GetScriptPatchVariables(int slot) {      std::map<String,String> Instrument::GetScriptPatchVariables(size_t slot) {
5781          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5782          if (!script) return std::map<String,String>();          if (!script) return std::map<String,String>();
5783          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);          const _UUID uuid = _UUIDFromCArray(&script->Uuid[0]);
# Line 5801  namespace { Line 5809  namespace {
5809       * @param slot - script slot index of the variable to be retrieved       * @param slot - script slot index of the variable to be retrieved
5810       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5811       */       */
5812      String Instrument::GetScriptPatchVariable(int slot, String variable) {      String Instrument::GetScriptPatchVariable(size_t slot, String variable) {
5813          std::map<String,String> vars = GetScriptPatchVariables(slot);          std::map<String,String> vars = GetScriptPatchVariables(slot);
5814          return (vars.count(variable)) ? vars.find(variable)->second : "";          return (vars.count(variable)) ? vars.find(variable)->second : "";
5815      }      }
# Line 5828  namespace { Line 5836  namespace {
5836       * @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
5837       *         @p variable name is empty       *         @p variable name is empty
5838       */       */
5839      void Instrument::SetScriptPatchVariable(int slot, String variable, String value) {      void Instrument::SetScriptPatchVariable(size_t slot, String variable, String value) {
5840          if (variable.empty())          if (variable.empty())
5841              throw Exception("Variable name must not be empty");              throw Exception("Variable name must not be empty");
5842          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
# Line 5869  namespace { Line 5877  namespace {
5877       * @param slot - script slot index of the variable to be unset       * @param slot - script slot index of the variable to be unset
5878       * @param variable - name of the 'patch' variable in that script       * @param variable - name of the 'patch' variable in that script
5879       */       */
5880      void Instrument::UnsetScriptPatchVariable(int slot, String variable) {      void Instrument::UnsetScriptPatchVariable(ssize_t slot, String variable) {
5881          Script* script = GetScriptOfSlot(slot);          Script* script = GetScriptOfSlot(slot);
5882    
5883          // option 1: unset a particular variable of one particular script slot          // option 1: unset a particular variable of one particular script slot
# Line 6061  namespace { Line 6069  namespace {
6069      Group::Group(File* file, RIFF::Chunk* ck3gnm) {      Group::Group(File* file, RIFF::Chunk* ck3gnm) {
6070          pFile      = file;          pFile      = file;
6071          pNameChunk = ck3gnm;          pNameChunk = ck3gnm;
6072            SamplesIterator = 0;
6073          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
6074      }      }
6075    
# Line 6119  namespace { Line 6128  namespace {
6128      }      }
6129    
6130      /**      /**
6131         * Returns Sample object at @a index of this sample group.
6132         *
6133         * @param index - position of sample in this sample group's sample list
6134         *                (0..n)
6135         * @returns sample object or NULL if index is out of bounds
6136         */
6137        Sample* Group::GetSample(size_t index) {
6138            if (pFile->pSamples && index >= pFile->pSamples->size()) return NULL;
6139            size_t indexInFile = 0;
6140            size_t indexInGroup = 0;
6141            for (Sample* pSample = pFile->GetSample(indexInFile); pSample;
6142                         pSample = pFile->GetSample(++indexInFile))
6143            {
6144                if (pSample->GetGroup() != this) continue;
6145                if (indexInGroup++ == index) return pSample;
6146            }
6147            return NULL;
6148        }
6149    
6150        /**
6151       * 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
6152       * once before you use GetNextSample().       * once before you use GetNextSample().
6153       *       *
# Line 6128  namespace { Line 6157  namespace {
6157       * @returns  pointer address to first Sample or NULL if there is none       * @returns  pointer address to first Sample or NULL if there is none
6158       *           applied to this Group       *           applied to this Group
6159       * @see      GetNextSample()       * @see      GetNextSample()
6160         * @deprecated  This method is not reentrant-safe, use GetSample()
6161         *              instead.
6162       */       */
6163      Sample* Group::GetFirstSample() {      Sample* Group::GetFirstSample() {
6164          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6165          for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {          i = 0;
6166              if (pSample->GetGroup() == this) return pSample;          for (Sample* pSample = pFile->GetSample(i); pSample;
6167                         pSample = pFile->GetSample(++i))
6168            {
6169                if (pSample->GetGroup() == this)
6170                    return pSample;
6171          }          }
6172          return NULL;          return NULL;
6173      }      }
# Line 6146  namespace { Line 6181  namespace {
6181       * @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
6182       *           end reached       *           end reached
6183       * @see      GetFirstSample()       * @see      GetFirstSample()
6184         * @deprecated  This method is not reentrant-safe, use GetSample()
6185         *              instead.
6186       */       */
6187      Sample* Group::GetNextSample() {      Sample* Group::GetNextSample() {
6188          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6189          for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {          for (Sample* pSample = pFile->GetSample(++i); pSample;
6190              if (pSample->GetGroup() == this) return pSample;                       pSample = pFile->GetSample(++i))
6191            {
6192                if (pSample->GetGroup() == this)
6193                    return pSample;
6194          }          }
6195          return NULL;          return NULL;
6196      }      }
# Line 6170  namespace { Line 6210  namespace {
6210       */       */
6211      void Group::MoveAll() {      void Group::MoveAll() {
6212          // get "that" other group first          // get "that" other group first
6213            size_t i = 0;
6214          Group* pOtherGroup = NULL;          Group* pOtherGroup = NULL;
6215          for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {          for (pOtherGroup = pFile->GetGroup(i); pOtherGroup;
6216                 pOtherGroup = pFile->GetGroup(++i))
6217            {
6218              if (pOtherGroup != this) break;              if (pOtherGroup != this) break;
6219          }          }
6220          if (!pOtherGroup) throw Exception(          if (!pOtherGroup) throw Exception(
# Line 6179  namespace { Line 6222  namespace {
6222              "other Group. This is a bug, report it!"              "other Group. This is a bug, report it!"
6223          );          );
6224          // now move all samples of this group to the other group          // now move all samples of this group to the other group
6225          for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {          Sample* pSample;
6226            while ((pSample = GetSample(0))) {
6227              pOtherGroup->AddSample(pSample);              pOtherGroup->AddSample(pSample);
6228          }          }
6229      }      }
# Line 6251  namespace { Line 6295  namespace {
6295    
6296      File::~File() {      File::~File() {
6297          if (pGroups) {          if (pGroups) {
6298              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
6299              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
6300              while (iter != end) {              while (iter != end) {
6301                  delete *iter;                  delete *iter;
6302                  ++iter;                  ++iter;
# Line 6260  namespace { Line 6304  namespace {
6304              delete pGroups;              delete pGroups;
6305          }          }
6306          if (pScriptGroups) {          if (pScriptGroups) {
6307              std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();              std::vector<ScriptGroup*>::iterator iter = pScriptGroups->begin();
6308              std::list<ScriptGroup*>::iterator end  = pScriptGroups->end();              std::vector<ScriptGroup*>::iterator end  = pScriptGroups->end();
6309              while (iter != end) {              while (iter != end) {
6310                  delete *iter;                  delete *iter;
6311                  ++iter;                  ++iter;
# Line 6367  namespace { Line 6411  namespace {
6411          pSample->DeleteChunks();          pSample->DeleteChunks();
6412          delete pSample;          delete pSample;
6413    
         SampleList::iterator tmp = SamplesIterator;  
6414          // remove all references to the sample          // remove all references to the sample
6415          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          size_t iIns = 0;
6416               instrument = GetNextInstrument()) {          for (Instrument* instrument = GetInstrument(iIns); instrument;
6417                             instrument = GetInstrument(++iIns))
6418            {
6419              size_t iRgn = 0;              size_t iRgn = 0;
6420              for (Region* region = instrument->GetRegionAt(iRgn); region;              for (Region* region = instrument->GetRegionAt(iRgn); region;
6421                   region = instrument->GetRegionAt(++iRgn))                   region = instrument->GetRegionAt(++iRgn))
# Line 6383  namespace { Line 6428  namespace {
6428                  }                  }
6429              }              }
6430          }          }
         SamplesIterator = tmp; // restore iterator  
6431      }      }
6432    
6433      void File::LoadSamples() {      void File::LoadSamples() {
# Line 6470  namespace { Line 6514  namespace {
6514              ExtensionFiles.push_back(pExtFile);              ExtensionFiles.push_back(pExtFile);
6515          }          }
6516    
6517          // load samples from extension files (if required)          // load all samples (both from this/main .gig file as well as from
6518            // extension files if required)
6519          for (int i = 0; i < poolFiles.size(); i++) {          for (int i = 0; i < poolFiles.size(); i++) {
6520              RIFF::File* file = poolFiles[i];              RIFF::File* file = poolFiles[i];
6521              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
6522              if (wvpl) {              if (wvpl) {
6523                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
6524                                                 wvpl->GetPos(); // should be zero, but just to be sure                                                 wvpl->GetPos(); // should be zero, but just to be sure
6525                  size_t i = 0;                  size_t iWaveCk = 0;
6526                  for (RIFF::List* wave = wvpl->GetSubListAt(i); wave;                  for (RIFF::List* wave = wvpl->GetSubListAt(iWaveCk); wave;
6527                       wave = wvpl->GetSubListAt(++i))                       wave = wvpl->GetSubListAt(++iWaveCk))
6528                  {                  {
6529                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
6530                          // notify current progress                          // notify current progress
# Line 6501  namespace { Line 6546  namespace {
6546              __notify_progress(pProgress, 1.0); // notify done              __notify_progress(pProgress, 1.0); // notify done
6547      }      }
6548    
6549        /**
6550         * Returns a pointer to the first <i>Instrument</i> object of the file,
6551         * <i>NULL</i> otherwise.
6552         *
6553         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6554         *              instead.
6555         */
6556      Instrument* File::GetFirstInstrument() {      Instrument* File::GetFirstInstrument() {
6557          if (!pInstruments) LoadInstruments();          if (!pInstruments) LoadInstruments();
6558          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
# Line 6508  namespace { Line 6560  namespace {
6560          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );          return static_cast<gig::Instrument*>( (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL );
6561      }      }
6562    
6563        /**
6564         * Returns a pointer to the next <i>Instrument</i> object of the file,
6565         * <i>NULL</i> otherwise.
6566         *
6567         * @deprecated  This method is not reentrant-safe, use GetInstrument()
6568         *              instead.
6569         */
6570      Instrument* File::GetNextInstrument() {      Instrument* File::GetNextInstrument() {
6571          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6572          InstrumentsIterator++;          InstrumentsIterator++;
# Line 6535  namespace { Line 6594  namespace {
6594       * @param pProgress - optional: callback function for progress notification       * @param pProgress - optional: callback function for progress notification
6595       * @returns  sought instrument or NULL if there's no such instrument       * @returns  sought instrument or NULL if there's no such instrument
6596       */       */
6597      Instrument* File::GetInstrument(uint index, progress_t* pProgress) {      Instrument* File::GetInstrument(size_t index, progress_t* pProgress) {
6598          if (!pInstruments) {          if (!pInstruments) {
6599              // 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)
6600    
# Line 6545  namespace { Line 6604  namespace {
6604                  __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
6605                  __notify_progress(&subprogress, 0.0f);                  __notify_progress(&subprogress, 0.0f);
6606                  if (GetAutoLoad())                  if (GetAutoLoad())
6607                      GetFirstSample(&subprogress); // now force all samples to be loaded                      GetSample(0, &subprogress); // now force all samples to be loaded
6608                  __notify_progress(&subprogress, 1.0f);                  __notify_progress(&subprogress, 1.0f);
6609    
6610                  // instrument loading subtask                  // instrument loading subtask
# Line 6559  namespace { Line 6618  namespace {
6618              } else {              } else {
6619                  // sample loading subtask                  // sample loading subtask
6620                  if (GetAutoLoad())                  if (GetAutoLoad())
6621                      GetFirstSample(); // now force all samples to be loaded                      GetSample(0); // now force all samples to be loaded
6622    
6623                  // instrument loading subtask                  // instrument loading subtask
6624                  LoadInstruments();                  LoadInstruments();
6625              }              }
6626          }          }
6627          if (!pInstruments) return NULL;          if (!pInstruments) return NULL;
6628          InstrumentsIterator = pInstruments->begin();          if (index >= pInstruments->size()) return NULL;
6629          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;  
6630      }      }
6631    
6632      /** @brief Add a new instrument definition.      /** @brief Add a new instrument definition.
# Line 6658  namespace { Line 6713  namespace {
6713          }          }
6714    
6715          // clone script groups and their scripts          // clone script groups and their scripts
6716          for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {          for (size_t iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
6717              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);              ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
6718              ScriptGroup* dg = AddScriptGroup();              ScriptGroup* dg = AddScriptGroup();
6719              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;              dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
# Line 6799  namespace { Line 6854  namespace {
6854      }      }
6855    
6856      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6857          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6858          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
6859          File::SampleList::iterator end  = pSamples->end();          File::SampleList::iterator end  = pSamples->end();
6860          for (int index = 0; iter != end; ++iter, ++index)          for (int index = 0; iter != end; ++iter, ++index)
# Line 6819  namespace { Line 6874  namespace {
6874          if (!_3crc) return false;          if (!_3crc) return false;
6875          if (_3crc->GetNewSize() <= 0) return false;          if (_3crc->GetNewSize() <= 0) return false;
6876          if (_3crc->GetNewSize() % 8) return false;          if (_3crc->GetNewSize() % 8) return false;
6877          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6878          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6879    
6880          const file_offset_t n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
# Line 6853  namespace { Line 6908  namespace {
6908       */       */
6909      bool File::RebuildSampleChecksumTable() {      bool File::RebuildSampleChecksumTable() {
6910          // make sure sample chunks were scanned          // make sure sample chunks were scanned
6911          if (!pSamples) GetFirstSample();          if (!pSamples) GetSample(0);
6912    
6913          bool bRequiresSave = false;          bool bRequiresSave = false;
6914    
# Line 6902  namespace { Line 6957  namespace {
6957          return bRequiresSave;          return bRequiresSave;
6958      }      }
6959    
6960        /**
6961         * Returns a pointer to the first <i>Group</i> object of the file,
6962         * <i>NULL</i> otherwise.
6963         *
6964         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6965         */
6966      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
6967          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6968          // there must always be at least one group          // there must always be at least one group
# Line 6909  namespace { Line 6970  namespace {
6970          return *GroupsIterator;          return *GroupsIterator;
6971      }      }
6972    
6973        /**
6974         * Returns a pointer to the next <i>Group</i> object of the file,
6975         * <i>NULL</i> otherwise.
6976         *
6977         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6978         */
6979      Group* File::GetNextGroup() {      Group* File::GetNextGroup() {
6980          if (!pGroups) return NULL;          if (!pGroups) return NULL;
6981          ++GroupsIterator;          ++GroupsIterator;
# Line 6921  namespace { Line 6988  namespace {
6988       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
6989       * @returns sought group or NULL if there's no such group       * @returns sought group or NULL if there's no such group
6990       */       */
6991      Group* File::GetGroup(uint index) {      Group* File::GetGroup(size_t index) {
6992          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6993          GroupsIterator = pGroups->begin();          if (index >= pGroups->size()) return NULL;
6994          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {          return (*pGroups)[index];
             if (i == index) return *GroupsIterator;  
             ++GroupsIterator;  
         }  
         return NULL;  
6995      }      }
6996    
6997      /**      /**
# Line 6943  namespace { Line 7006  namespace {
7006       */       */
7007      Group* File::GetGroup(String name) {      Group* File::GetGroup(String name) {
7008          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7009          GroupsIterator = pGroups->begin();          size_t i = 0;
7010          for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)          for (Group* pGroup = GetGroup(i); pGroup; pGroup = GetGroup(++i))
7011              if ((*GroupsIterator)->Name == name) return *GroupsIterator;              if (pGroup->Name == name) return pGroup;
7012          return NULL;          return NULL;
7013      }      }
7014    
# Line 6969  namespace { Line 7032  namespace {
7032       */       */
7033      void File::DeleteGroup(Group* pGroup) {      void File::DeleteGroup(Group* pGroup) {
7034          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7035          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7036                find(pGroups->begin(), pGroups->end(), pGroup);
7037          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");
7038          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!");
7039          // delete all members of this group          // delete all members of this group
7040          for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {          Sample* pSample;
7041            while ((pSample = pGroup->GetSample(0))) {
7042              DeleteSample(pSample);              DeleteSample(pSample);
7043          }          }
7044          // now delete this group object          // now delete this group object
# Line 6994  namespace { Line 7059  namespace {
7059       */       */
7060      void File::DeleteGroupOnly(Group* pGroup) {      void File::DeleteGroupOnly(Group* pGroup) {
7061          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7062          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7063                find(pGroups->begin(), pGroups->end(), pGroup);
7064          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");
7065          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!");
7066          // move all members of this group to another group          // move all members of this group to another group
# Line 7005  namespace { Line 7071  namespace {
7071      }      }
7072    
7073      void File::LoadGroups() {      void File::LoadGroups() {
7074          if (!pGroups) pGroups = new std::list<Group*>;          if (!pGroups) pGroups = new std::vector<Group*>;
7075          // try to read defined groups from file          // try to read defined groups from file
7076          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
7077          if (lst3gri) {          if (lst3gri) {
# Line 7039  namespace { Line 7105  namespace {
7105       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
7106       * @returns sought script group or NULL if there's no such group       * @returns sought script group or NULL if there's no such group
7107       */       */
7108      ScriptGroup* File::GetScriptGroup(uint index) {      ScriptGroup* File::GetScriptGroup(size_t index) {
7109          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7110          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          if (index >= pScriptGroups->size()) return NULL;
7111          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)          return (*pScriptGroups)[index];
             if (i == index) return *it;  
         return NULL;  
7112      }      }
7113    
7114      /** @brief Get instrument script group (by name).      /** @brief Get instrument script group (by name).
# Line 7057  namespace { Line 7121  namespace {
7121       */       */
7122      ScriptGroup* File::GetScriptGroup(const String& name) {      ScriptGroup* File::GetScriptGroup(const String& name) {
7123          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7124          std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();          for (size_t i = 0; i < pScriptGroups->size(); ++i) {
7125          for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)              ScriptGroup* pGroup = (*pScriptGroups)[i];
7126              if ((*it)->Name == name) return *it;              if (pGroup->Name == name) return pGroup;
7127            }
7128          return NULL;          return NULL;
7129      }      }
7130    
# Line 7092  namespace { Line 7157  namespace {
7157       */       */
7158      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {      void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
7159          if (!pScriptGroups) LoadScriptGroups();          if (!pScriptGroups) LoadScriptGroups();
7160          std::list<ScriptGroup*>::iterator iter =          std::vector<ScriptGroup*>::iterator iter =
7161              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);              find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
7162          if (iter == pScriptGroups->end())          if (iter == pScriptGroups->end())
7163              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 7107  namespace { Line 7172  namespace {
7172    
7173      void File::LoadScriptGroups() {      void File::LoadScriptGroups() {
7174          if (pScriptGroups) return;          if (pScriptGroups) return;
7175          pScriptGroups = new std::list<ScriptGroup*>;          pScriptGroups = new std::vector<ScriptGroup*>;
7176          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
7177          if (lstLS) {          if (lstLS) {
7178              size_t i = 0;              size_t i = 0;
# Line 7152  namespace { Line 7217  namespace {
7217          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
7218          if (pScriptGroups) {          if (pScriptGroups) {
7219              // Update instrument script (group) chunks.              // Update instrument script (group) chunks.
7220              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();              for (std::vector<ScriptGroup*>::iterator it = pScriptGroups->begin();
7221                   it != pScriptGroups->end(); ++it)                   it != pScriptGroups->end(); ++it)
7222              {              {
7223                  (*it)->UpdateChunks(pProgress);                  (*it)->UpdateChunks(pProgress);
# Line 7204  namespace { Line 7269  namespace {
7269                  }                  }
7270              }              }
7271    
7272              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
7273              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
7274              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
7275                  (*iter)->UpdateChunks(pProgress);                  (*iter)->UpdateChunks(pProgress);
7276              }              }
# Line 7243  namespace { Line 7308  namespace {
7308              uint8_t* pData = (uint8_t*) einf->LoadChunkData();              uint8_t* pData = (uint8_t*) einf->LoadChunkData();
7309    
7310              std::map<gig::Sample*,int> sampleMap;              std::map<gig::Sample*,int> sampleMap;
7311              int sampleIdx = 0;              size_t sampleIdx = 0;
7312              for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {              for (Sample* pSample = GetSample(0); pSample;
7313                  sampleMap[pSample] = sampleIdx++;                           pSample = GetSample(++sampleIdx))
7314                {
7315                    sampleMap[pSample] = sampleIdx;
7316              }              }
7317    
7318              int totnbusedsamples = 0;              int totnbusedsamples = 0;
# Line 7257  namespace { Line 7324  namespace {
7324    
7325              memset(&pData[48], 0, sublen - 48);              memset(&pData[48], 0, sublen - 48);
7326    
7327              for (Instrument* instrument = GetFirstInstrument() ; instrument ;              size_t iIns = 0;
7328                   instrument = GetNextInstrument()) {              for (Instrument* instrument = GetInstrument(iIns); instrument;
7329                                 instrument = GetInstrument(++iIns))
7330                {
7331                  int nbusedsamples = 0;                  int nbusedsamples = 0;
7332                  int nbusedchannels = 0;                  int nbusedchannels = 0;
7333                  int nbdimregions = 0;                  int nbdimregions = 0;
# Line 7363  namespace { Line 7432  namespace {
7432      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
7433          DLS::File::UpdateFileOffsets();          DLS::File::UpdateFileOffsets();
7434    
7435          for (Instrument* instrument = GetFirstInstrument(); instrument;          size_t i = 0;
7436               instrument = GetNextInstrument())          for (Instrument* instrument = GetInstrument(i); instrument;
7437                             instrument = GetInstrument(++i))
7438          {          {
7439              instrument->UpdateScriptFileOffsets();              instrument->UpdateScriptFileOffsets();
7440          }          }
Legend:
Removed from v.3928  
changed lines
  Added in v.3970
  ViewVC Help
Powered by ViewVC