/[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 3926 by schoenebeck, Tue Jun 15 10:16:40 2021 UTC revision 3939 by schoenebeck, Thu Jun 17 12:04:54 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 6005  namespace { Line 6007  namespace {
6007          pMidiRules[0] = NULL;          pMidiRules[0] = NULL;
6008                    
6009          // delete all old regions          // delete all old regions
6010          while (Regions) DeleteRegion(GetFirstRegion());          while (Regions) DeleteRegion(GetRegionAt(0));
6011          // create new regions and copy them from original          // create new regions and copy them from original
6012          {          {
6013              RegionList::const_iterator it = orig->pRegions->begin();              RegionList::const_iterator it = orig->pRegions->begin();
# Line 6061  namespace { Line 6063  namespace {
6063      Group::Group(File* file, RIFF::Chunk* ck3gnm) {      Group::Group(File* file, RIFF::Chunk* ck3gnm) {
6064          pFile      = file;          pFile      = file;
6065          pNameChunk = ck3gnm;          pNameChunk = ck3gnm;
6066            SamplesIterator = 0;
6067          ::LoadString(pNameChunk, Name);          ::LoadString(pNameChunk, Name);
6068      }      }
6069    
# Line 6119  namespace { Line 6122  namespace {
6122      }      }
6123    
6124      /**      /**
6125         * Returns Sample object at @a index of this sample group.
6126         *
6127         * @param index - position of sample in this sample group's sample list
6128         *                (0..n)
6129         * @returns sample object or NULL if index is out of bounds
6130         */
6131        Sample* Group::GetSample(size_t index) {
6132            if (pFile->pSamples && index >= pFile->pSamples->size()) return NULL;
6133            size_t indexInFile = 0;
6134            size_t indexInGroup = 0;
6135            for (Sample* pSample = pFile->GetSample(indexInFile); pSample;
6136                         pSample = pFile->GetSample(++indexInFile))
6137            {
6138                if (pSample->GetGroup() != this) continue;
6139                if (indexInGroup++ == index) return pSample;
6140            }
6141            return NULL;
6142        }
6143    
6144        /**
6145       * 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
6146       * once before you use GetNextSample().       * once before you use GetNextSample().
6147       *       *
# Line 6128  namespace { Line 6151  namespace {
6151       * @returns  pointer address to first Sample or NULL if there is none       * @returns  pointer address to first Sample or NULL if there is none
6152       *           applied to this Group       *           applied to this Group
6153       * @see      GetNextSample()       * @see      GetNextSample()
6154         * @deprecated  This method is not reentrant-safe, use GetSample()
6155         *              instead.
6156       */       */
6157      Sample* Group::GetFirstSample() {      Sample* Group::GetFirstSample() {
6158          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6159          for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {          i = 0;
6160              if (pSample->GetGroup() == this) return pSample;          for (Sample* pSample = pFile->GetSample(i); pSample;
6161                         pSample = pFile->GetSample(++i))
6162            {
6163                if (pSample->GetGroup() == this)
6164                    return pSample;
6165          }          }
6166          return NULL;          return NULL;
6167      }      }
# Line 6146  namespace { Line 6175  namespace {
6175       * @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
6176       *           end reached       *           end reached
6177       * @see      GetFirstSample()       * @see      GetFirstSample()
6178         * @deprecated  This method is not reentrant-safe, use GetSample()
6179         *              instead.
6180       */       */
6181      Sample* Group::GetNextSample() {      Sample* Group::GetNextSample() {
6182          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6183          for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {          for (Sample* pSample = pFile->GetSample(++i); pSample;
6184              if (pSample->GetGroup() == this) return pSample;                       pSample = pFile->GetSample(++i))
6185            {
6186                if (pSample->GetGroup() == this)
6187                    return pSample;
6188          }          }
6189          return NULL;          return NULL;
6190      }      }
# Line 6170  namespace { Line 6204  namespace {
6204       */       */
6205      void Group::MoveAll() {      void Group::MoveAll() {
6206          // get "that" other group first          // get "that" other group first
6207            size_t i = 0;
6208          Group* pOtherGroup = NULL;          Group* pOtherGroup = NULL;
6209          for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {          for (pOtherGroup = pFile->GetGroup(i); pOtherGroup;
6210                 pOtherGroup = pFile->GetGroup(++i))
6211            {
6212              if (pOtherGroup != this) break;              if (pOtherGroup != this) break;
6213          }          }
6214          if (!pOtherGroup) throw Exception(          if (!pOtherGroup) throw Exception(
# Line 6179  namespace { Line 6216  namespace {
6216              "other Group. This is a bug, report it!"              "other Group. This is a bug, report it!"
6217          );          );
6218          // now move all samples of this group to the other group          // now move all samples of this group to the other group
6219          for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {          Sample* pSample;
6220            while ((pSample = GetSample(0))) {
6221              pOtherGroup->AddSample(pSample);              pOtherGroup->AddSample(pSample);
6222          }          }
6223      }      }
# Line 6251  namespace { Line 6289  namespace {
6289    
6290      File::~File() {      File::~File() {
6291          if (pGroups) {          if (pGroups) {
6292              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
6293              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
6294              while (iter != end) {              while (iter != end) {
6295                  delete *iter;                  delete *iter;
6296                  ++iter;                  ++iter;
# Line 6270  namespace { Line 6308  namespace {
6308          }          }
6309      }      }
6310    
6311        /**
6312         * Returns a pointer to the first <i>Sample</i> object of the file,
6313         * <i>NULL</i> otherwise.
6314         *
6315         * @param pProgress - optional: callback function for progress notification
6316         * @deprecated  This method is not reentrant-safe, use GetSample()
6317         *              instead.
6318         */
6319      Sample* File::GetFirstSample(progress_t* pProgress) {      Sample* File::GetFirstSample(progress_t* pProgress) {
6320          if (!pSamples) LoadSamples(pProgress);          if (!pSamples) LoadSamples(pProgress);
6321          if (!pSamples) return NULL;          if (!pSamples) return NULL;
# Line 6277  namespace { Line 6323  namespace {
6323          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
6324      }      }
6325    
6326        /**
6327         * Returns a pointer to the next <i>Sample</i> object of the file,
6328         * <i>NULL</i> otherwise.
6329         *
6330         * @deprecated  This method is not reentrant-safe, use GetSample()
6331         *              instead.
6332         */
6333      Sample* File::GetNextSample() {      Sample* File::GetNextSample() {
6334          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6335          SamplesIterator++;          SamplesIterator++;
# Line 6286  namespace { Line 6339  namespace {
6339      /**      /**
6340       * Returns Sample object of @a index.       * Returns Sample object of @a index.
6341       *       *
6342         * @param index - position of sample in sample list (0..n)
6343         * @param pProgress - optional: callback function for progress notification
6344       * @returns sample object or NULL if index is out of bounds       * @returns sample object or NULL if index is out of bounds
6345       */       */
6346      Sample* File::GetSample(uint index) {      Sample* File::GetSample(size_t index, progress_t* pProgress) {
6347          if (!pSamples) LoadSamples();          if (!pSamples) LoadSamples(pProgress);
6348          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6349          DLS::File::SampleList::iterator it = pSamples->begin();          if (index >= pSamples->size()) return NULL;
6350          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 );  
6351      }      }
6352    
6353      /**      /**
# Line 6359  namespace { Line 6409  namespace {
6409          // remove all references to the sample          // remove all references to the sample
6410          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
6411               instrument = GetNextInstrument()) {               instrument = GetNextInstrument()) {
6412              for (Region* region = instrument->GetFirstRegion() ; region ;              size_t iRgn = 0;
6413                   region = instrument->GetNextRegion()) {              for (Region* region = instrument->GetRegionAt(iRgn); region;
6414                     region = instrument->GetRegionAt(++iRgn))
6415                {
6416                  if (region->GetSample() == pSample) region->SetSample(NULL);                  if (region->GetSample() == pSample) region->SetSample(NULL);
6417    
6418                  for (int i = 0 ; i < region->DimensionRegions ; i++) {                  for (int i = 0 ; i < region->DimensionRegions ; i++) {
# Line 6532  namespace { Line 6583  namespace {
6583                  __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
6584                  __notify_progress(&subprogress, 0.0f);                  __notify_progress(&subprogress, 0.0f);
6585                  if (GetAutoLoad())                  if (GetAutoLoad())
6586                      GetFirstSample(&subprogress); // now force all samples to be loaded                      GetSample(0, &subprogress); // now force all samples to be loaded
6587                  __notify_progress(&subprogress, 1.0f);                  __notify_progress(&subprogress, 1.0f);
6588    
6589                  // instrument loading subtask                  // instrument loading subtask
# Line 6546  namespace { Line 6597  namespace {
6597              } else {              } else {
6598                  // sample loading subtask                  // sample loading subtask
6599                  if (GetAutoLoad())                  if (GetAutoLoad())
6600                      GetFirstSample(); // now force all samples to be loaded                      GetSample(0); // now force all samples to be loaded
6601    
6602                  // instrument loading subtask                  // instrument loading subtask
6603                  LoadInstruments();                  LoadInstruments();
# Line 6786  namespace { Line 6837  namespace {
6837      }      }
6838    
6839      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6840          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6841          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
6842          File::SampleList::iterator end  = pSamples->end();          File::SampleList::iterator end  = pSamples->end();
6843          for (int index = 0; iter != end; ++iter, ++index)          for (int index = 0; iter != end; ++iter, ++index)
# Line 6806  namespace { Line 6857  namespace {
6857          if (!_3crc) return false;          if (!_3crc) return false;
6858          if (_3crc->GetNewSize() <= 0) return false;          if (_3crc->GetNewSize() <= 0) return false;
6859          if (_3crc->GetNewSize() % 8) return false;          if (_3crc->GetNewSize() % 8) return false;
6860          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6861          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6862    
6863          const file_offset_t n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
# Line 6840  namespace { Line 6891  namespace {
6891       */       */
6892      bool File::RebuildSampleChecksumTable() {      bool File::RebuildSampleChecksumTable() {
6893          // make sure sample chunks were scanned          // make sure sample chunks were scanned
6894          if (!pSamples) GetFirstSample();          if (!pSamples) GetSample(0);
6895    
6896          bool bRequiresSave = false;          bool bRequiresSave = false;
6897    
# Line 6889  namespace { Line 6940  namespace {
6940          return bRequiresSave;          return bRequiresSave;
6941      }      }
6942    
6943        /**
6944         * Returns a pointer to the first <i>Group</i> object of the file,
6945         * <i>NULL</i> otherwise.
6946         *
6947         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6948         */
6949      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
6950          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6951          // there must always be at least one group          // there must always be at least one group
# Line 6896  namespace { Line 6953  namespace {
6953          return *GroupsIterator;          return *GroupsIterator;
6954      }      }
6955    
6956        /**
6957         * Returns a pointer to the next <i>Group</i> object of the file,
6958         * <i>NULL</i> otherwise.
6959         *
6960         * @deprecated  This method is not reentrant-safe, use GetGroup() instead.
6961         */
6962      Group* File::GetNextGroup() {      Group* File::GetNextGroup() {
6963          if (!pGroups) return NULL;          if (!pGroups) return NULL;
6964          ++GroupsIterator;          ++GroupsIterator;
# Line 6908  namespace { Line 6971  namespace {
6971       * @param index - number of the sought group (0..n)       * @param index - number of the sought group (0..n)
6972       * @returns sought group or NULL if there's no such group       * @returns sought group or NULL if there's no such group
6973       */       */
6974      Group* File::GetGroup(uint index) {      Group* File::GetGroup(size_t index) {
6975          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6976          GroupsIterator = pGroups->begin();          if (index >= pGroups->size()) return NULL;
6977          for (uint i = 0; GroupsIterator != pGroups->end(); i++) {          return (*pGroups)[index];
             if (i == index) return *GroupsIterator;  
             ++GroupsIterator;  
         }  
         return NULL;  
6978      }      }
6979    
6980      /**      /**
# Line 6930  namespace { Line 6989  namespace {
6989       */       */
6990      Group* File::GetGroup(String name) {      Group* File::GetGroup(String name) {
6991          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6992          GroupsIterator = pGroups->begin();          size_t i = 0;
6993          for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)          for (Group* pGroup = GetGroup(i); pGroup; pGroup = GetGroup(++i))
6994              if ((*GroupsIterator)->Name == name) return *GroupsIterator;              if (pGroup->Name == name) return pGroup;
6995          return NULL;          return NULL;
6996      }      }
6997    
# Line 6956  namespace { Line 7015  namespace {
7015       */       */
7016      void File::DeleteGroup(Group* pGroup) {      void File::DeleteGroup(Group* pGroup) {
7017          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7018          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7019                find(pGroups->begin(), pGroups->end(), pGroup);
7020          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");
7021          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!");
7022          // delete all members of this group          // delete all members of this group
7023          for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {          Sample* pSample;
7024            while ((pSample = pGroup->GetSample(0))) {
7025              DeleteSample(pSample);              DeleteSample(pSample);
7026          }          }
7027          // now delete this group object          // now delete this group object
# Line 6981  namespace { Line 7042  namespace {
7042       */       */
7043      void File::DeleteGroupOnly(Group* pGroup) {      void File::DeleteGroupOnly(Group* pGroup) {
7044          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
7045          std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);          std::vector<Group*>::iterator iter =
7046                find(pGroups->begin(), pGroups->end(), pGroup);
7047          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");
7048          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!");
7049          // move all members of this group to another group          // move all members of this group to another group
# Line 6992  namespace { Line 7054  namespace {
7054      }      }
7055    
7056      void File::LoadGroups() {      void File::LoadGroups() {
7057          if (!pGroups) pGroups = new std::list<Group*>;          if (!pGroups) pGroups = new std::vector<Group*>;
7058          // try to read defined groups from file          // try to read defined groups from file
7059          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
7060          if (lst3gri) {          if (lst3gri) {
# Line 7191  namespace { Line 7253  namespace {
7253                  }                  }
7254              }              }
7255    
7256              std::list<Group*>::iterator iter = pGroups->begin();              std::vector<Group*>::iterator iter = pGroups->begin();
7257              std::list<Group*>::iterator end  = pGroups->end();              std::vector<Group*>::iterator end  = pGroups->end();
7258              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
7259                  (*iter)->UpdateChunks(pProgress);                  (*iter)->UpdateChunks(pProgress);
7260              }              }
# Line 7230  namespace { Line 7292  namespace {
7292              uint8_t* pData = (uint8_t*) einf->LoadChunkData();              uint8_t* pData = (uint8_t*) einf->LoadChunkData();
7293    
7294              std::map<gig::Sample*,int> sampleMap;              std::map<gig::Sample*,int> sampleMap;
7295              int sampleIdx = 0;              size_t sampleIdx = 0;
7296              for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {              for (Sample* pSample = GetSample(0); pSample;
7297                  sampleMap[pSample] = sampleIdx++;                           pSample = GetSample(++sampleIdx))
7298                {
7299                    sampleMap[pSample] = sampleIdx;
7300              }              }
7301    
7302              int totnbusedsamples = 0;              int totnbusedsamples = 0;
# Line 7253  namespace { Line 7317  namespace {
7317    
7318                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
7319    
7320                  for (Region* region = instrument->GetFirstRegion() ; region ;                  size_t iRgn = 0;
7321                       region = instrument->GetNextRegion()) {                  for (Region* region = instrument->GetRegionAt(iRgn); region;
7322                         region = instrument->GetRegionAt(++iRgn))
7323                    {
7324                      for (int i = 0 ; i < region->DimensionRegions ; i++) {                      for (int i = 0 ; i < region->DimensionRegions ; i++) {
7325                          gig::DimensionRegion *d = region->pDimensionRegions[i];                          gig::DimensionRegion *d = region->pDimensionRegions[i];
7326                          if (d->pSample) {                          if (d->pSample) {
Legend:
Removed from v.3926  
changed lines
  Added in v.3939
  ViewVC Help
Powered by ViewVC