/[svn]/libgig/trunk/src/DLS.cpp

Diff of /libgig/trunk/src/DLS.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 3488 by schoenebeck,
Thu Feb 28 17:49:07 2019 UTC
+revision 3978 by schoenebeck,
Mon Jul 19 14:35:37 2021 UTC
 Line 2
   *                                                                         *
   *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2019 by Christian Schoenebeck                      *
+  *   Copyright (C) 2003-2021 by Christian Schoenebeck                      *
   *                              <cuse@users.sourceforge.net>               *
   *                                                                         *
   *   This library is free software; you can redistribute it and/or modify  *
 Line 189 
 namespace DLS {
          pArticulations = NULL;
      }
+     /**
+      * Returns Articulation at supplied @a pos position within the articulation
+      * list. If supplied @a pos is out of bounds then @c NULL is returned.
+      *
+      * @param pos - position of sought Articulation in articulation list
+      * @returns pointer address to requested articulation or @c NULL if @a pos
+      *          is out of bounds
+      */
+     Articulation* Articulator::GetArticulation(size_t pos) {
+         if (!pArticulations) LoadArticulations();
+         if (!pArticulations) return NULL;
+         if (pos >= pArticulations->size()) return NULL;
+         return (*pArticulations)[pos];
+     }
+     /**
+      * Returns the first Articulation in the list of articulations. You have to
+      * call this method once before you can use GetNextArticulation().
+      *
+      * @returns  pointer address to first Articulation or NULL if there is none
+      * @see      GetNextArticulation()
+      * @deprecated  This method is not reentrant-safe, use GetArticulation()
+      *              instead.
+      */
      Articulation* Articulator::GetFirstArticulation() {
          if (!pArticulations) LoadArticulations();
          if (!pArticulations) return NULL;
-Line 196 
 namespace DLS {
+Line 220 
 namespace DLS {
          return (ArticulationsIterator != pArticulations->end()) ? *ArticulationsIterator : NULL;
      }
+     /**
+      * Returns the next Articulation from the list of articulations. You have
+      * to call GetFirstArticulation() once before you can use this method. By
+      * calling this method multiple times it iterates through the available
+      * articulations.
+      *
+      * @returns  pointer address to the next Articulation or NULL if end reached
+      * @see      GetFirstArticulation()
+      * @deprecated  This method is not reentrant-safe, use GetArticulation()
+      *              instead.
+      */
      Articulation* Articulator::GetNextArticulation() {
          if (!pArticulations) return NULL;
          ArticulationsIterator++;
-Line 209 
 namespace DLS {
+Line 244 
 namespace DLS {
          if (lart) {
              uint32_t artCkType = (lart->GetListType() == LIST_TYPE_LAR2) ? CHUNK_ID_ART2
                                                                           : CHUNK_ID_ARTL;
-             RIFF::Chunk* art = lart->GetFirstSubChunk();
+             size_t i = 0;
-             while (art) {
+             for (RIFF::Chunk* art = lart->GetSubChunkAt(i); art;
+                  art = lart->GetSubChunkAt(++i))
+             {
                  if (art->GetChunkID() == artCkType) {
                      if (!pArticulations) pArticulations = new ArticulationList;
                      pArticulations->push_back(new Articulation(art));
                  }
-                 art = lart->GetNextSubChunk();
              }
          }
      }
-Line 556 
 namespace DLS {
+Line 592 
 namespace DLS {
      }
      void Resource::GenerateDLSID(dlsid_t* pDLSID) {
- #if defined(WIN32) || defined(__APPLE__) || defined(HAVE_UUID_GENERATE)
  #ifdef WIN32
          UUID uuid;
          UuidCreate(&uuid);
-Line 581 
 namespace DLS {
+Line 616 
 namespace DLS {
          pDLSID->abData[5] = uuid.byte13;
          pDLSID->abData[6] = uuid.byte14;
          pDLSID->abData[7] = uuid.byte15;
- #else
+ #elif defined(HAVE_UUID_GENERATE)
          uuid_t uuid;
          uuid_generate(uuid);
          pDLSID->ulData1 = uuid[0] | uuid[1] << 8 | uuid[2] << 16 | uuid[3] << 24;
          pDLSID->usData2 = uuid[4] | uuid[5] << 8;
          pDLSID->usData3 = uuid[6] | uuid[7] << 8;
          memcpy(pDLSID->abData, &uuid[8], 8);
- #endif
+ #else
+ # error "Missing support for uuid generation"
  #endif
      }
-Line 1163 
 namespace DLS {
+Line 1199 
 namespace DLS {
          if (pSample) return pSample;
          File* file = (File*) GetParent()->GetParent();
          uint64_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
-         Sample* sample = file->GetFirstSample();
+         size_t i = 0;
-         while (sample) {
+         for (Sample* sample = file->GetSample(i); sample;
+                      sample = file->GetSample(++i))
+         {
              if (sample->ullWavePoolOffset == soughtoffset) return (pSample = sample);
-             sample = file->GetNextSample();
          }
          return NULL;
      }
-Line 1357 
 namespace DLS {
+Line 1394 
 namespace DLS {
          pRegions = NULL;
      }
+     /**
+      * Returns the amount of regions of this instrument.
+      *
+      * @see GetRegionAt()
+      */
+     size_t Instrument::CountRegions() {
+         if (!pRegions) LoadRegions();
+         if (!pRegions) return 0;
+         return pRegions->size();
+     }
+     /**
+      * Returns Region at supplied @a pos position within the region list of
+      * this instrument. If supplied @a pos is out of bounds then @c NULL is
+      * returned.
+      *
+      * @param pos - position of sought Region in region list
+      * @returns pointer address to requested region or @c NULL if @a pos is
+      *          out of bounds
+      * @see CountRegions()
+      */
+     Region* Instrument::GetRegionAt(size_t pos) {
+         if (!pRegions) LoadRegions();
+         if (!pRegions) return NULL;
+         if (pos >= pRegions->size()) return NULL;
+         return (*pRegions)[pos];
+     }
+     /**
+      * Returns the first Region of the instrument. You have to call this
+      * method once before you use GetNextRegion().
+      *
+      * @returns  pointer address to first region or NULL if there is none
+      * @see      GetNextRegion()
+      * @deprecated  This method is not reentrant-safe, use GetRegionAt()
+      *              instead.
+      */
      Region* Instrument::GetFirstRegion() {
          if (!pRegions) LoadRegions();
          if (!pRegions) return NULL;
-Line 1364 
 namespace DLS {
+Line 1438 
 namespace DLS {
          return (RegionsIterator != pRegions->end()) ? *RegionsIterator : NULL;
      }
+     /**
+      * Returns the next Region of the instrument. You have to call
+      * GetFirstRegion() once before you can use this method. By calling this
+      * method multiple times it iterates through the available Regions.
+      *
+      * @returns  pointer address to the next region or NULL if end reached
+      * @see      GetFirstRegion()
+      * @deprecated  This method is not reentrant-safe, use GetRegionAt()
+      *              instead.
+      */
      Region* Instrument::GetNextRegion() {
          if (!pRegions) return NULL;
          RegionsIterator++;
-Line 1375 
 namespace DLS {
+Line 1459 
 namespace DLS {
          RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
          if (lrgn) {
              uint32_t regionCkType = (lrgn->GetSubList(LIST_TYPE_RGN2)) ? LIST_TYPE_RGN2 : LIST_TYPE_RGN; // prefer regions level 2
-             RIFF::List* rgn = lrgn->GetFirstSubList();
+             size_t i = 0;
-             while (rgn) {
+             for (RIFF::List* rgn = lrgn->GetSubListAt(i); rgn;
+                  rgn = lrgn->GetSubListAt(++i))
+             {
                  if (rgn->GetListType() == regionCkType) {
                      pRegions->push_back(new Region(this, rgn));
                  }
-                 rgn = lrgn->GetNextSubList();
              }
          }
      }
-Line 1391 
 namespace DLS {
+Line 1476 
 namespace DLS {
          if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
          Region* pNewRegion = new Region(this, rgn);
+         const size_t idxIt = RegionsIterator - pRegions->begin();
          pRegions->push_back(pNewRegion);
+         RegionsIterator = pRegions->begin() + std::min(idxIt, pRegions->size()); // avoid iterator invalidation
          Regions = (uint32_t) pRegions->size();
          return pNewRegion;
      }
-Line 1399 
 namespace DLS {
+Line 1486 
 namespace DLS {
      void Instrument::MoveRegion(Region* pSrc, Region* pDst) {
          RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
          lrgn->MoveSubChunk(pSrc->pCkRegion, (RIFF::Chunk*) (pDst ? pDst->pCkRegion : 0));
+         for (size_t i = 0; i < pRegions->size(); ++i) {
-         pRegions->remove(pSrc);
+             if ((*pRegions)[i] == pSrc) {
-         RegionList::iterator iter = find(pRegions->begin(), pRegions->end(), pDst);
+                 const size_t idxIt = RegionsIterator - pRegions->begin();
-         pRegions->insert(iter, pSrc);
+                 pRegions->erase(pRegions->begin() + i);
+                 RegionList::iterator iter = find(pRegions->begin(), pRegions->end(), pDst);
+                 pRegions->insert(iter, pSrc);
+                 RegionsIterator = pRegions->begin() + std::min(idxIt, pRegions->size()); // avoid iterator invalidation
+             }
+         }
      }
      void Instrument::DeleteRegion(Region* pRegion) {
          if (!pRegions) return;
          RegionList::iterator iter = find(pRegions->begin(), pRegions->end(), pRegion);
          if (iter == pRegions->end()) return;
+         const size_t idxIt = RegionsIterator - pRegions->begin();
          pRegions->erase(iter);
+         RegionsIterator = pRegions->begin() + std::min(idxIt, pRegions->size()); // avoid iterator invalidation
          Regions = (uint32_t) pRegions->size();
          pRegion->DeleteChunks();
          delete pRegion;
-Line 1524 
 namespace DLS {
+Line 1618 
 namespace DLS {
      void Instrument::CopyAssign(const Instrument* orig) {
          CopyAssignCore(orig);
          // delete all regions first
-         while (Regions) DeleteRegion(GetFirstRegion());
+         while (Regions) DeleteRegion(GetRegionAt(0));
          // now recreate and copy regions
          {
              RegionList::const_iterator it = orig->pRegions->begin();
-Line 1660 
 namespace DLS {
+Line 1754 
 namespace DLS {
              delete pRIFF;
      }
+     /**
+      * Returns Sample object of @a index.
+      *
+      * @param index - position of sample in sample list (0..n)
+      * @returns sample object or NULL if index is out of bounds
+      */
+     Sample* File::GetSample(size_t index) {
+         if (!pSamples) LoadSamples();
+         if (!pSamples) return NULL;
+         if (index >= pSamples->size()) return NULL;
+         return (*pSamples)[index];
+     }
+     /**
+      * Returns a pointer to the first <i>Sample</i> object of the file,
+      * <i>NULL</i> otherwise.
+      *
+      * @deprecated  This method is not reentrant-safe, use GetSample()
+      *              instead.
+      */
      Sample* File::GetFirstSample() {
          if (!pSamples) LoadSamples();
          if (!pSamples) return NULL;
-Line 1667 
 namespace DLS {
+Line 1781 
 namespace DLS {
          return (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL;
      }
+     /**
+      * Returns a pointer to the next <i>Sample</i> object of the file,
+      * <i>NULL</i> otherwise.
+      *
+      * @deprecated  This method is not reentrant-safe, use GetSample()
+      *              instead.
+      */
      Sample* File::GetNextSample() {
          if (!pSamples) return NULL;
          SamplesIterator++;
-Line 1679 
 namespace DLS {
+Line 1800 
 namespace DLS {
          if (wvpl) {
              file_offset_t wvplFileOffset = wvpl->GetFilePos() -
                                             wvpl->GetPos(); // should be zero, but just to be sure
-             RIFF::List* wave = wvpl->GetFirstSubList();
+             size_t i = 0;
-             while (wave) {
+             for (RIFF::List* wave = wvpl->GetSubListAt(i); wave;
+                  wave = wvpl->GetSubListAt(++i))
+             {
                  if (wave->GetListType() == LIST_TYPE_WAVE) {
                      file_offset_t waveFileOffset = wave->GetFilePos() -
                                                     wave->GetPos(); // should be zero, but just to be sure
                      pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset));
                  }
-                 wave = wvpl->GetNextSubList();
              }
          }
          else { // Seen a dwpl list chunk instead of a wvpl list chunk in some file (officially not DLS compliant)
-Line 1694 
 namespace DLS {
+Line 1816 
 namespace DLS {
              if (dwpl) {
                  file_offset_t dwplFileOffset = dwpl->GetFilePos() -
                                                 dwpl->GetPos(); // should be zero, but just to be sure
-                 RIFF::List* wave = dwpl->GetFirstSubList();
+                 size_t i = 0;
-                 while (wave) {
+                 for (RIFF::List* wave = dwpl->GetSubListAt(i); wave;
+                      wave = dwpl->GetSubListAt(++i))
+                 {
                      if (wave->GetListType() == LIST_TYPE_WAVE) {
                          file_offset_t waveFileOffset = wave->GetFilePos() -
                                                         wave->GetPos(); // should be zero, but just to be sure
                          pSamples->push_back(new Sample(this, wave, waveFileOffset - dwplFileOffset));
                      }
-                     wave = dwpl->GetNextSubList();
                  }
              }
          }
-Line 1721 
 namespace DLS {
+Line 1844 
 namespace DLS {
         // create new Sample object and its respective 'wave' list chunk
         RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);
         Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);
+        const size_t idxIt = SamplesIterator - pSamples->begin();
         pSamples->push_back(pSample);
+        SamplesIterator = pSamples->begin() + std::min(idxIt, pSamples->size()); // avoid iterator invalidation
         return pSample;
      }
-Line 1736 
 namespace DLS {
+Line 1861 
 namespace DLS {
          if (!pSamples) return;
          SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), pSample);
          if (iter == pSamples->end()) return;
+         const size_t idxIt = SamplesIterator - pSamples->begin();
          pSamples->erase(iter);
+         SamplesIterator = pSamples->begin() + std::min(idxIt, pSamples->size()); // avoid iterator invalidation
          pSample->DeleteChunks();
          delete pSample;
      }
+     /**
+      * Returns the instrument with the given @a index from the list of
+      * instruments of this file.
+      *
+      * @param index - number of the sought instrument (0..n)
+      * @returns  sought instrument or NULL if there's no such instrument
+      */
+     Instrument* File::GetInstrument(size_t index) {
+         if (!pInstruments) LoadInstruments();
+         if (!pInstruments) return NULL;
+         if (index >= pInstruments->size()) return NULL;
+         return (*pInstruments)[index];
+     }
+     /**
+      * Returns a pointer to the first <i>Instrument</i> object of the file,
+      * <i>NULL</i> otherwise.
+      *
+      * @deprecated  This method is not reentrant-safe, use GetInstrument()
+      *              instead.
+      */
      Instrument* File::GetFirstInstrument() {
          if (!pInstruments) LoadInstruments();
          if (!pInstruments) return NULL;
-Line 1748 
 namespace DLS {
+Line 1896 
 namespace DLS {
          return (InstrumentsIterator != pInstruments->end()) ? *InstrumentsIterator : NULL;
      }
+     /**
+      * Returns a pointer to the next <i>Instrument</i> object of the file,
+      * <i>NULL</i> otherwise.
+      *
+      * @deprecated  This method is not reentrant-safe, use GetInstrument()
+      *              instead.
+      */
      Instrument* File::GetNextInstrument() {
          if (!pInstruments) return NULL;
          InstrumentsIterator++;
-Line 1758 
 namespace DLS {
+Line 1913 
 namespace DLS {
          if (!pInstruments) pInstruments = new InstrumentList;
          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
          if (lstInstruments) {
-             RIFF::List* lstInstr = lstInstruments->GetFirstSubList();
+             size_t i = 0;
-             while (lstInstr) {
+             for (RIFF::List* lstInstr = lstInstruments->GetSubListAt(i);
+                  lstInstr; lstInstr = lstInstruments->GetSubListAt(++i))
+             {
                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
                      pInstruments->push_back(new Instrument(this, lstInstr));
                  }
-                 lstInstr = lstInstruments->GetNextSubList();
              }
          }
      }
-Line 1781 
 namespace DLS {
+Line 1937 
 namespace DLS {
         RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
         RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);
         Instrument* pInstrument = new Instrument(this, lstInstr);
+        const size_t idxIt = InstrumentsIterator - pInstruments->begin();
         pInstruments->push_back(pInstrument);
+        InstrumentsIterator = pInstruments->begin() + std::min(idxIt, pInstruments->size()); // avoid iterator invalidation
         return pInstrument;
      }
-Line 1796 
 namespace DLS {
+Line 1954 
 namespace DLS {
          if (!pInstruments) return;
          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), pInstrument);
          if (iter == pInstruments->end()) return;
+         const size_t idxIt = InstrumentsIterator - pInstruments->begin();
          pInstruments->erase(iter);
+         InstrumentsIterator = pInstruments->begin() + std::min(idxIt, pInstruments->size()); // avoid iterator invalidation
          pInstrument->DeleteChunks();
          delete pInstrument;
      }

 Legend:



Removed from v.3488
 


changed lines


 
Added in v.3978
 Legend:



Removed from v.3488
 


changed lines


 
Added in v.3978
-Removed from v.3488
+Added in v.3978

	ViewVC Help
Powered by ViewVC