/[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 3924 by schoenebeck, Mon Jun 14 12:07:47 2021 UTC revision 3951 by schoenebeck, Sat Jun 19 09:07:16 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 5301  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         */
5312        Region* Instrument::GetRegionAt(size_t pos) {
5313            if (!pRegions) return NULL;
5314            if (pos >= pRegions->size()) return NULL;
5315            return static_cast<gig::Region*>( (*pRegions)[pos] );
5316        }
5317    
5318        /**
5319       * Returns the first Region of the instrument. You have to call this       * Returns the first Region of the instrument. You have to call this
5320       * method once before you use GetNextRegion().       * method once before you use GetNextRegion().
5321       *       *
5322       * @returns  pointer address to first region or NULL if there is none       * @returns  pointer address to first region or NULL if there is none
5323       * @see      GetNextRegion()       * @see      GetNextRegion()
5324         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5325         *              instead.
5326       */       */
5327      Region* Instrument::GetFirstRegion() {      Region* Instrument::GetFirstRegion() {
5328          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5320  namespace { Line 5337  namespace {
5337       *       *
5338       * @returns  pointer address to the next region or NULL if end reached       * @returns  pointer address to the next region or NULL if end reached
5339       * @see      GetFirstRegion()       * @see      GetFirstRegion()
5340         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5341         *              instead.
5342       */       */
5343      Region* Instrument::GetNextRegion() {      Region* Instrument::GetNextRegion() {
5344          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5373  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 5390  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 5475  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 5986  namespace { Line 6012  namespace {
6012          pMidiRules[0] = NULL;          pMidiRules[0] = NULL;
6013                    
6014          // delete all old regions          // delete all old regions
6015          while (Regions) DeleteRegion(GetFirstRegion());          while (Regions) DeleteRegion(GetRegionAt(0));
6016          // create new regions and copy them from original          // create new regions and copy them from original
6017          {          {
6018              RegionList::const_iterator it = orig->pRegions->begin();              RegionList::const_iterator it = orig->pRegions->begin();
# Line 6042  namespace { Line 6068  namespace {
6068      Group::Group(File* file, RIFF::Chunk* ck3gnm) {      Group::Group(File* file, RIFF::Chunk* ck3gnm) {
6069          pFile      = file;          pFile      = file;
6070          pNameChunk = ck3gnm;          pNameChunk = ck3gnm;
6071            SamplesIterator = 0;
6072          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
6073      }      }
6074    
# Line 6100  namespace { Line 6127  namespace {
6127      }      }
6128    
6129      /**      /**
6130         * Returns Sample object at @a index of this sample group.
6131         *
6132         * @param index - position of sample in this sample group's sample list
6133         *                (0..n)
6134         * @returns sample object or NULL if index is out of bounds
6135         */
6136        Sample* Group::GetSample(size_t index) {
6137            if (pFile->pSamples && index >= pFile->pSamples->size()) return NULL;
6138            size_t indexInFile = 0;
6139            size_t indexInGroup = 0;
6140            for (Sample* pSample = pFile->GetSample(indexInFile); pSample;
6141                         pSample = pFile->GetSample(++indexInFile))
6142            {
6143                if (pSample->GetGroup() != this) continue;
6144                if (indexInGroup++ == index) return pSample;
6145            }
6146            return NULL;
6147        }
6148    
6149        /**
6150       * 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
6151       * once before you use GetNextSample().       * once before you use GetNextSample().
6152       *       *
# Line 6109  namespace { Line 6156  namespace {
6156       * @returns  pointer address to first Sample or NULL if there is none       * @returns  pointer address to first Sample or NULL if there is none
6157       *           applied to this Group       *           applied to this Group
6158       * @see      GetNextSample()       * @see      GetNextSample()
6159         * @deprecated  This method is not reentrant-safe, use GetSample()
6160         *              instead.
6161       */       */
6162      Sample* Group::GetFirstSample() {      Sample* Group::GetFirstSample() {
6163          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6164          for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {          i = 0;
6165              if (pSample->GetGroup() == this) return pSample;          for (Sample* pSample = pFile->GetSample(i); pSample;
6166                         pSample = pFile->GetSample(++i))
6167            {
6168                if (pSample->GetGroup() == this)
6169                    return pSample;
6170          }          }
6171          return NULL;          return NULL;
6172      }      }
# Line 6127  namespace { Line 6180  namespace {
6180       * @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
6181       *           end reached       *           end reached
6182       * @see      GetFirstSample()       * @see      GetFirstSample()
6183         * @deprecated  This method is not reentrant-safe, use GetSample()
6184         *              instead.
6185       */       */
6186      Sample* Group::GetNextSample() {      Sample* Group::GetNextSample() {
6187          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6188          for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {          for (Sample* pSample = pFile->GetSample(++i); pSample;
6189              if (pSample->GetGroup() == this) return pSample;                       pSample = pFile->GetSample(++i))
6190            {
6191                if (pSample->GetGroup() == this)
6192                    return pSample;
6193          }          }
6194          return NULL;          return NULL;
6195      }      }
# Line 6151  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 6160  namespace { Line 6221  namespace {
6221              "other Group. This is a bug, report it!"              "other Group. This is a bug, report it!"
6222          );          );
6223          // now move all samples of this group to the other group          // now move all samples of this group to the other group
6224          for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {          Sample* pSample;
6225            while ((pSample = GetSample(0))) {
6226              pOtherGroup->AddSample(pSample);              pOtherGroup->AddSample(pSample);
6227          }          }
6228      }      }
# Line 6232  namespace { Line 6294  namespace {
6294    
6295      File::~File() {      File::~File() {
6296          if (pGroups) {          if (pGroups) {
6297              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
6298              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
6299              while (iter != end) {              while (iter != end) {
6300                  delete *iter;                  delete *iter;
6301                  ++iter;                  ++iter;
# Line 6241  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 6251  namespace { Line 6313  namespace {
6313          }          }
6314      }      }
6315    
6316        /**
6317         * Returns a pointer to the first <i>Sample</i> object of the file,
6318         * <i>NULL</i> otherwise.
6319         *
6320         * @param pProgress - optional: callback function for progress notification
6321         * @deprecated  This method is not reentrant-safe, use GetSample()
6322         *              instead.
6323         */
6324      Sample* File::GetFirstSample(progress_t* pProgress) {      Sample* File::GetFirstSample(progress_t* pProgress) {
6325          if (!pSamples) LoadSamples(pProgress);          if (!pSamples) LoadSamples(pProgress);
6326          if (!pSamples) return NULL;          if (!pSamples) return NULL;
# Line 6258  namespace { Line 6328  namespace {
6328          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
6329      }      }
6330    
6331        /**
6332         * Returns a pointer to the next <i>Sample</i> object of the file,
6333         * <i>NULL</i> otherwise.
6334         *
6335         * @deprecated  This method is not reentrant-safe, use GetSample()
6336         *              instead.
6337         */
6338      Sample* File::GetNextSample() {      Sample* File::GetNextSample() {
6339          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6340          SamplesIterator++;          SamplesIterator++;
# Line 6267  namespace { Line 6344  namespace {
6344      /**      /**
6345       * Returns Sample object of @a index.       * Returns Sample object of @a index.
6346       *       *
6347         * @param index - position of sample in sample list (0..n)
6348         * @param pProgress - optional: callback function for progress notification
6349       * @returns sample object or NULL if index is out of bounds       * @returns sample object or NULL if index is out of bounds
6350       */       */
6351      Sample* File::GetSample(uint index) {      Sample* File::GetSample(size_t index, progress_t* pProgress) {
6352          if (!pSamples) LoadSamples();          if (!pSamples) LoadSamples(pProgress);
6353          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6354          DLS::File::SampleList::iterator it = pSamples->begin();          if (index >= pSamples->size()) return NULL;
6355          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 );  
6356      }      }
6357    
6358      /**      /**
# Line 6336  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              for (Region* region = instrument->GetFirstRegion() ; region ;                           instrument = GetInstrument(++iIns))
6417                   region = instrument->GetNextRegion()) {          {
6418                size_t iRgn = 0;
6419                for (Region* region = instrument->GetRegionAt(iRgn); region;
6420                     region = instrument->GetRegionAt(++iRgn))
6421                {
6422                  if (region->GetSample() == pSample) region->SetSample(NULL);                  if (region->GetSample() == pSample) region->SetSample(NULL);
6423    
6424                  for (int i = 0 ; i < region->DimensionRegions ; i++) {                  for (int i = 0 ; i < region->DimensionRegions ; i++) {
# Line 6351  namespace { Line 6427  namespace {
6427                  }                  }
6428              }              }
6429          }          }
         SamplesIterator = tmp; // restore iterator  
6430      }      }
6431    
6432      void File::LoadSamples() {      void File::LoadSamples() {
# Line 6365  namespace { Line 6440  namespace {
6440    
6441          if (!pSamples) pSamples = new SampleList;          if (!pSamples) pSamples = new SampleList;
6442    
         RIFF::File* file = pRIFF;  
   
6443          // just for progress calculation          // just for progress calculation
6444          int iSampleIndex  = 0;          int iSampleIndex  = 0;
6445          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
# Line 6471  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 6478  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 6505  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 6515  namespace { Line 6602  namespace {
6602                  __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
6603                  __notify_progress(&subprogress, 0.0f);                  __notify_progress(&subprogress, 0.0f);
6604                  if (GetAutoLoad())                  if (GetAutoLoad())
6605                      GetFirstSample(&subprogress); // now force all samples to be loaded                      GetSample(0, &subprogress); // now force all samples to be loaded
6606                  __notify_progress(&subprogress, 1.0f);                  __notify_progress(&subprogress, 1.0f);
6607    
6608                  // instrument loading subtask                  // instrument loading subtask
# Line 6529  namespace { Line 6616  namespace {
6616              } else {              } else {
6617                  // sample loading subtask                  // sample loading subtask
6618                  if (GetAutoLoad())                  if (GetAutoLoad())
6619                      GetFirstSample(); // now force all samples to be loaded                      GetSample(0); // now force all samples to be loaded
6620    
6621                  // instrument loading subtask                  // instrument loading subtask
6622                  LoadInstruments();                  LoadInstruments();
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 6628  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 6769  namespace { Line 6852  namespace {
6852      }      }
6853    
6854      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6855          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6856          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
6857          File::SampleList::iterator end  = pSamples->end();          File::SampleList::iterator end  = pSamples->end();
6858          for (int index = 0; iter != end; ++iter, ++index)          for (int index = 0; iter != end; ++iter, ++index)
# Line 6789  namespace { Line 6872  namespace {
6872          if (!_3crc) return false;          if (!_3crc) return false;
6873          if (_3crc->GetNewSize() <= 0) return false;          if (_3crc->GetNewSize() <= 0) return false;
6874          if (_3crc->GetNewSize() % 8) return false;          if (_3crc->GetNewSize() % 8) return false;
6875          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6876          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6877    
6878          const file_offset_t n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
# Line 6823  namespace { Line 6906  namespace {
6906       */       */
6907      bool File::RebuildSampleChecksumTable() {      bool File::RebuildSampleChecksumTable() {
6908          // make sure sample chunks were scanned          // make sure sample chunks were scanned
6909          if (!pSamples) GetFirstSample();          if (!pSamples) GetSample(0);
6910    
6911          bool bRequiresSave = false;          bool bRequiresSave = false;
6912    
# Line 6872  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 6879  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 6891  namespace { Line 6986  namespace {
6986       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
6987       * @returns sought group or NULL if there's no such group       * @returns sought group or NULL if there's no such group
6988       */       */
6989      Group* File::GetGroup(uint index) {      Group* File::GetGroup(size_t index) {
6990          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6991          GroupsIterator = pGroups->begin();          if (index >= pGroups->size()) return NULL;
6992          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {          return (*pGroups)[index];
             if (i == index) return *GroupsIterator;  
             ++GroupsIterator;  
         }  
         return NULL;  
6993      }      }
6994    
6995      /**      /**
# Line 6913  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 6939  namespace { Line 7030  namespace {
7030       */       */
7031      void File::DeleteGroup(Group* pGroup) {      void File::DeleteGroup(Group* pGroup) {
7032          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7033          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7034                find(pGroups->begin(), pGroups->end(), pGroup);
7035          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");
7036          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!");
7037          // delete all members of this group          // delete all members of this group
7038          for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {          Sample* pSample;
7039            while ((pSample = pGroup->GetSample(0))) {
7040              DeleteSample(pSample);              DeleteSample(pSample);
7041          }          }
7042          // now delete this group object          // now delete this group object
# Line 6964  namespace { Line 7057  namespace {
7057       */       */
7058      void File::DeleteGroupOnly(Group* pGroup) {      void File::DeleteGroupOnly(Group* pGroup) {
7059          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7060          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7061                find(pGroups->begin(), pGroups->end(), pGroup);
7062          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");
7063          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!");
7064          // move all members of this group to another group          // move all members of this group to another group
# Line 6975  namespace { Line 7069  namespace {
7069      }      }
7070    
7071      void File::LoadGroups() {      void File::LoadGroups() {
7072          if (!pGroups) pGroups = new std::list<Group*>;          if (!pGroups) pGroups = new std::vector<Group*>;
7073          // try to read defined groups from file          // try to read defined groups from file
7074          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
7075          if (lst3gri) {          if (lst3gri) {
# Line 7009  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 7027  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 7062  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 7077  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 7122  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 7174  namespace { Line 7267  namespace {
7267                  }                  }
7268              }              }
7269    
7270              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
7271              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
7272              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
7273                  (*iter)->UpdateChunks(pProgress);                  (*iter)->UpdateChunks(pProgress);
7274              }              }
# Line 7213  namespace { Line 7306  namespace {
7306              uint8_t* pData = (uint8_t*) einf->LoadChunkData();              uint8_t* pData = (uint8_t*) einf->LoadChunkData();
7307    
7308              std::map<gig::Sample*,int> sampleMap;              std::map<gig::Sample*,int> sampleMap;
7309              int sampleIdx = 0;              size_t sampleIdx = 0;
7310              for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {              for (Sample* pSample = GetSample(0); pSample;
7311                  sampleMap[pSample] = sampleIdx++;                           pSample = GetSample(++sampleIdx))
7312                {
7313                    sampleMap[pSample] = sampleIdx;
7314              }              }
7315    
7316              int totnbusedsamples = 0;              int totnbusedsamples = 0;
# Line 7227  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 7236  namespace { Line 7333  namespace {
7333    
7334                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
7335    
7336                  for (Region* region = instrument->GetFirstRegion() ; region ;                  size_t iRgn = 0;
7337                       region = instrument->GetNextRegion()) {                  for (Region* region = instrument->GetRegionAt(iRgn); region;
7338                         region = instrument->GetRegionAt(++iRgn))
7339                    {
7340                      for (int i = 0 ; i < region->DimensionRegions ; i++) {                      for (int i = 0 ; i < region->DimensionRegions ; i++) {
7341                          gig::DimensionRegion *d = region->pDimensionRegions[i];                          gig::DimensionRegion *d = region->pDimensionRegions[i];
7342                          if (d->pSample) {                          if (d->pSample) {
# Line 7331  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.3924  
changed lines
  Added in v.3951
  ViewVC Help
Powered by ViewVC