/[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 3903 by schoenebeck, Wed May 12 18:31:25 2021 UTC revision 3929 by schoenebeck, Tue Jun 15 12:22:26 2021 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2020 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2021 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 482  namespace { Line 482  namespace {
482              ScanCompressedSample();              ScanCompressedSample();
483          }          }
484    
485          // we use a buffer for decompression and for truncating 24 bit samples to 16 bit          // we use a buffer for decompression only
486          if ((Compressed || BitDepth == 24) && !InternalDecompressionBuffer.Size) {          if (Compressed && !InternalDecompressionBuffer.Size) {
487              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];              InternalDecompressionBuffer.pStart = new unsigned char[INITIAL_SAMPLE_BUFFER_SIZE];
488              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;              InternalDecompressionBuffer.Size   = INITIAL_SAMPLE_BUFFER_SIZE;
489          }          }
# Line 3498  namespace { Line 3498  namespace {
3498          RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);          RIFF::List* _3prg = rgn->GetSubList(LIST_TYPE_3PRG);
3499          if (_3prg) {          if (_3prg) {
3500              int dimensionRegionNr = 0;              int dimensionRegionNr = 0;
3501              RIFF::List* _3ewl = _3prg->GetFirstSubList();              size_t i = 0;
3502              while (_3ewl) {              for (RIFF::List* _3ewl = _3prg->GetSubListAt(i); _3ewl;
3503                     _3ewl = _3prg->GetSubListAt(++i))
3504                {
3505                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {                  if (_3ewl->GetListType() == LIST_TYPE_3EWL) {
3506                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);                      pDimensionRegions[dimensionRegionNr] = new DimensionRegion(this, _3ewl);
3507                      dimensionRegionNr++;                      dimensionRegionNr++;
3508                  }                  }
                 _3ewl = _3prg->GetNextSubList();  
3509              }              }
3510              if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");              if (dimensionRegionNr == 0) throw gig::Exception("No dimension region found.");
3511          }          }
# Line 3951  namespace { Line 3952  namespace {
3952       * @throws gig::Exception if requested zone could not be splitted       * @throws gig::Exception if requested zone could not be splitted
3953       */       */
3954      void Region::SplitDimensionZone(dimension_t type, int zone) {      void Region::SplitDimensionZone(dimension_t type, int zone) {
3955            if (!Dimensions)
3956                throw gig::Exception("Could not split dimension zone, because there is no dimension at all.");
3957          dimension_def_t* oldDef = GetDimensionDefinition(type);          dimension_def_t* oldDef = GetDimensionDefinition(type);
3958          if (!oldDef)          if (!oldDef)
3959              throw gig::Exception("Could not split dimension zone, no such dimension of given type");              throw gig::Exception("Could not split dimension zone, no such dimension of given type");
# Line 3977  namespace { Line 3980  namespace {
3980          // requested by the arguments of this method call) to the temporary          // requested by the arguments of this method call) to the temporary
3981          // region, and don't use Region::CopyAssign() here for this task, since          // region, and don't use Region::CopyAssign() here for this task, since
3982          // it would also alter fast lookup helper variables here and there          // it would also alter fast lookup helper variables here and there
3983          dimension_def_t newDef;          dimension_def_t newDef = {};
3984          for (int i = 0; i < Dimensions; ++i) {          for (int i = 0; i < Dimensions; ++i) {
3985              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference              dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
3986              // is this the dimension requested by the method arguments? ...              // is this the dimension requested by the method arguments? ...
# Line 3988  namespace { Line 3991  namespace {
3991              }              }
3992              tempRgn->AddDimension(&def);              tempRgn->AddDimension(&def);
3993          }          }
3994            // silence clang sanitizer warning
3995            if (newDef.dimension == dimension_none)
3996                throw gig::Exception("Unexpected internal failure resolving dimension in SplitDimensionZone() [this is a bug].");
3997    
3998          // find the dimension index in the tempRegion which is the dimension          // find the dimension index in the tempRegion which is the dimension
3999          // type passed to this method (paranoidly expecting different order)          // type passed to this method (paranoidly expecting different order)
# Line 4319  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 4901  namespace { Line 4909  namespace {
4909          pScripts = new std::list<Script*>;          pScripts = new std::list<Script*>;
4910          if (!pList) return;          if (!pList) return;
4911    
4912          for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;          size_t i = 0;
4913               ck = pList->GetNextSubChunk())          for (RIFF::Chunk* ck = pList->GetSubChunkAt(i); ck;
4914                 ck = pList->GetSubChunkAt(++i))
4915          {          {
4916              if (ck->GetChunkID() == CHUNK_ID_SCRI) {              if (ck->GetChunkID() == CHUNK_ID_SCRI) {
4917                  pScripts->push_back(new Script(this, ck));                  pScripts->push_back(new Script(this, ck));
# Line 4982  namespace { Line 4991  namespace {
4991              if (!pRegions) pRegions = new RegionList;              if (!pRegions) pRegions = new RegionList;
4992              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
4993              if (lrgn) {              if (lrgn) {
4994                  RIFF::List* rgn = lrgn->GetFirstSubList();                  size_t i = 0;
4995                  while (rgn) {                  for (RIFF::List* rgn = lrgn->GetSubListAt(i); rgn;
4996                         rgn = lrgn->GetSubListAt(++i))
4997                    {
4998                      if (rgn->GetListType() == LIST_TYPE_RGN) {                      if (rgn->GetListType() == LIST_TYPE_RGN) {
4999                          if (pProgress)                          if (pProgress)
5000                              __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                              __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
5001                          pRegions->push_back(new Region(this, rgn));                          pRegions->push_back(new Region(this, rgn));
5002                      }                      }
                     rgn = lrgn->GetNextSubList();  
5003                  }                  }
5004                  // Creating Region Key Table for fast lookup                  // Creating Region Key Table for fast lookup
5005                  UpdateRegionKeyTable();                  UpdateRegionKeyTable();
# Line 5293  namespace { Line 5303  namespace {
5303      }      }
5304    
5305      /**      /**
5306         * Returns Region at supplied @a pos position within the region list of
5307         * this instrument. If supplied @a pos is out of bounds then @c NULL is
5308         * returned.
5309         *
5310         * @param pos - position of sought Region in region list
5311         * @returns pointer address to requested region or @c NULL if @a pos is
5312         *          out of bounds
5313         */
5314        Region* Instrument::GetRegionAt(size_t pos) {
5315            if (!pRegions) return NULL;
5316            if (pos >= pRegions->size()) return NULL;
5317            return static_cast<gig::Region*>( (*pRegions)[pos] );
5318        }
5319    
5320        /**
5321       * Returns the first Region of the instrument. You have to call this       * Returns the first Region of the instrument. You have to call this
5322       * method once before you use GetNextRegion().       * method once before you use GetNextRegion().
5323       *       *
5324       * @returns  pointer address to first region or NULL if there is none       * @returns  pointer address to first region or NULL if there is none
5325       * @see      GetNextRegion()       * @see      GetNextRegion()
5326         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5327         *              instead.
5328       */       */
5329      Region* Instrument::GetFirstRegion() {      Region* Instrument::GetFirstRegion() {
5330          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5312  namespace { Line 5339  namespace {
5339       *       *
5340       * @returns  pointer address to the next region or NULL if end reached       * @returns  pointer address to the next region or NULL if end reached
5341       * @see      GetFirstRegion()       * @see      GetFirstRegion()
5342         * @deprecated  This method is not reentrant-safe, use GetRegionAt()
5343         *              instead.
5344       */       */
5345      Region* Instrument::GetNextRegion() {      Region* Instrument::GetNextRegion() {
5346          if (!pRegions) return NULL;          if (!pRegions) return NULL;
# Line 5978  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 6034  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 6078  namespace { Line 6108  namespace {
6108    
6109          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
6110              // v3 has a fixed list of 128 strings, find a free one              // v3 has a fixed list of 128 strings, find a free one
6111              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {              size_t i = 0;
6112                for (RIFF::Chunk* ck = _3gnl->GetSubChunkAt(i); ck; ck = _3gnl->GetSubChunkAt(++i)) {
6113                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
6114                      pNameChunk = ck;                      pNameChunk = ck;
6115                      break;                      break;
# Line 6102  namespace { Line 6133  namespace {
6133       * @see      GetNextSample()       * @see      GetNextSample()
6134       */       */
6135      Sample* Group::GetFirstSample() {      Sample* Group::GetFirstSample() {
6136          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6137          for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {          i = 0;
6138              if (pSample->GetGroup() == this) return pSample;          for (Sample* pSample = pFile->GetSample(i); pSample;
6139                         pSample = pFile->GetSample(++i))
6140            {
6141                if (pSample->GetGroup() == this)
6142                    return pSample;
6143          }          }
6144          return NULL;          return NULL;
6145      }      }
# Line 6120  namespace { Line 6155  namespace {
6155       * @see      GetFirstSample()       * @see      GetFirstSample()
6156       */       */
6157      Sample* Group::GetNextSample() {      Sample* Group::GetNextSample() {
6158          // FIXME: lazy und unsafe implementation, should be an autonomous iterator          size_t& i = this->SamplesIterator;
6159          for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {          for (Sample* pSample = pFile->GetSample(++i); pSample;
6160              if (pSample->GetGroup() == this) return pSample;                       pSample = pFile->GetSample(++i))
6161            {
6162                if (pSample->GetGroup() == this)
6163                    return pSample;
6164          }          }
6165          return NULL;          return NULL;
6166      }      }
# Line 6242  namespace { Line 6280  namespace {
6280          }          }
6281      }      }
6282    
6283        /**
6284         * Returns a pointer to the first <i>Sample</i> object of the file,
6285         * <i>NULL</i> otherwise.
6286         *
6287         * @param pProgress - optional: callback function for progress notification
6288         * @deprecated  This method is not reentrant-safe, use GetSample()
6289         *              instead.
6290         */
6291      Sample* File::GetFirstSample(progress_t* pProgress) {      Sample* File::GetFirstSample(progress_t* pProgress) {
6292          if (!pSamples) LoadSamples(pProgress);          if (!pSamples) LoadSamples(pProgress);
6293          if (!pSamples) return NULL;          if (!pSamples) return NULL;
# Line 6249  namespace { Line 6295  namespace {
6295          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
6296      }      }
6297    
6298        /**
6299         * Returns a pointer to the next <i>Sample</i> object of the file,
6300         * <i>NULL</i> otherwise.
6301         *
6302         * @deprecated  This method is not reentrant-safe, use GetSample()
6303         *              instead.
6304         */
6305      Sample* File::GetNextSample() {      Sample* File::GetNextSample() {
6306          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6307          SamplesIterator++;          SamplesIterator++;
# Line 6258  namespace { Line 6311  namespace {
6311      /**      /**
6312       * Returns Sample object of @a index.       * Returns Sample object of @a index.
6313       *       *
6314         * @param index - position of sample in sample list (0..n)
6315         * @param pProgress - optional: callback function for progress notification
6316       * @returns sample object or NULL if index is out of bounds       * @returns sample object or NULL if index is out of bounds
6317       */       */
6318      Sample* File::GetSample(uint index) {      Sample* File::GetSample(size_t index, progress_t* pProgress) {
6319          if (!pSamples) LoadSamples();          if (!pSamples) LoadSamples(pProgress);
6320          if (!pSamples) return NULL;          if (!pSamples) return NULL;
6321          DLS::File::SampleList::iterator it = pSamples->begin();          if (index >= pSamples->size()) return NULL;
6322          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 );  
6323      }      }
6324    
6325      /**      /**
# Line 6331  namespace { Line 6381  namespace {
6381          // remove all references to the sample          // remove all references to the sample
6382          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
6383               instrument = GetNextInstrument()) {               instrument = GetNextInstrument()) {
6384              for (Region* region = instrument->GetFirstRegion() ; region ;              size_t iRgn = 0;
6385                   region = instrument->GetNextRegion()) {              for (Region* region = instrument->GetRegionAt(iRgn); region;
6386                     region = instrument->GetRegionAt(++iRgn))
6387                {
6388                  if (region->GetSample() == pSample) region->SetSample(NULL);                  if (region->GetSample() == pSample) region->SetSample(NULL);
6389    
6390                  for (int i = 0 ; i < region->DimensionRegions ; i++) {                  for (int i = 0 ; i < region->DimensionRegions ; i++) {
# Line 6356  namespace { Line 6407  namespace {
6407    
6408          if (!pSamples) pSamples = new SampleList;          if (!pSamples) pSamples = new SampleList;
6409    
         RIFF::File* file = pRIFF;  
   
6410          // just for progress calculation          // just for progress calculation
6411          int iSampleIndex  = 0;          int iSampleIndex  = 0;
6412          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
# Line 6438  namespace { Line 6487  namespace {
6487              if (wvpl) {              if (wvpl) {
6488                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -                  file_offset_t wvplFileOffset = wvpl->GetFilePos() -
6489                                                 wvpl->GetPos(); // should be zero, but just to be sure                                                 wvpl->GetPos(); // should be zero, but just to be sure
6490                  RIFF::List* wave = wvpl->GetFirstSubList();                  size_t i = 0;
6491                  while (wave) {                  for (RIFF::List* wave = wvpl->GetSubListAt(i); wave;
6492                         wave = wvpl->GetSubListAt(++i))
6493                    {
6494                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
6495                          // notify current progress                          // notify current progress
6496                          if (pProgress) {                          if (pProgress) {
# Line 6452  namespace { Line 6503  namespace {
6503    
6504                          iSampleIndex++;                          iSampleIndex++;
6505                      }                      }
                     wave = wvpl->GetNextSubList();  
6506                  }                  }
6507              }              }
6508          }          }
# Line 6505  namespace { Line 6555  namespace {
6555                  __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
6556                  __notify_progress(&subprogress, 0.0f);                  __notify_progress(&subprogress, 0.0f);
6557                  if (GetAutoLoad())                  if (GetAutoLoad())
6558                      GetFirstSample(&subprogress); // now force all samples to be loaded                      GetSample(0, &subprogress); // now force all samples to be loaded
6559                  __notify_progress(&subprogress, 1.0f);                  __notify_progress(&subprogress, 1.0f);
6560    
6561                  // instrument loading subtask                  // instrument loading subtask
# Line 6519  namespace { Line 6569  namespace {
6569              } else {              } else {
6570                  // sample loading subtask                  // sample loading subtask
6571                  if (GetAutoLoad())                  if (GetAutoLoad())
6572                      GetFirstSample(); // now force all samples to be loaded                      GetSample(0); // now force all samples to be loaded
6573    
6574                  // instrument loading subtask                  // instrument loading subtask
6575                  LoadInstruments();                  LoadInstruments();
# Line 6685  namespace { Line 6735  namespace {
6735          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);          RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
6736          if (lstInstruments) {          if (lstInstruments) {
6737              int iInstrumentIndex = 0;              int iInstrumentIndex = 0;
6738              RIFF::List* lstInstr = lstInstruments->GetFirstSubList();              size_t i = 0;
6739              while (lstInstr) {              for (RIFF::List* lstInstr = lstInstruments->GetSubListAt(i);
6740                     lstInstr; lstInstr = lstInstruments->GetSubListAt(++i))
6741                {
6742                  if (lstInstr->GetListType() == LIST_TYPE_INS) {                  if (lstInstr->GetListType() == LIST_TYPE_INS) {
6743                      if (pProgress) {                      if (pProgress) {
6744                          // notify current progress                          // notify current progress
# Line 6704  namespace { Line 6756  namespace {
6756    
6757                      iInstrumentIndex++;                      iInstrumentIndex++;
6758                  }                  }
                 lstInstr = lstInstruments->GetNextSubList();  
6759              }              }
6760              if (pProgress)              if (pProgress)
6761                  __notify_progress(pProgress, 1.0); // notify done                  __notify_progress(pProgress, 1.0); // notify done
# Line 6758  namespace { Line 6809  namespace {
6809      }      }
6810    
6811      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6812          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6813          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
6814          File::SampleList::iterator end  = pSamples->end();          File::SampleList::iterator end  = pSamples->end();
6815          for (int index = 0; iter != end; ++iter, ++index)          for (int index = 0; iter != end; ++iter, ++index)
# Line 6778  namespace { Line 6829  namespace {
6829          if (!_3crc) return false;          if (!_3crc) return false;
6830          if (_3crc->GetNewSize() <= 0) return false;          if (_3crc->GetNewSize() <= 0) return false;
6831          if (_3crc->GetNewSize() % 8) return false;          if (_3crc->GetNewSize() % 8) return false;
6832          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetSample(0); // make sure sample chunks were scanned
6833          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6834    
6835          const file_offset_t n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
# Line 6812  namespace { Line 6863  namespace {
6863       */       */
6864      bool File::RebuildSampleChecksumTable() {      bool File::RebuildSampleChecksumTable() {
6865          // make sure sample chunks were scanned          // make sure sample chunks were scanned
6866          if (!pSamples) GetFirstSample();          if (!pSamples) GetSample(0);
6867    
6868          bool bRequiresSave = false;          bool bRequiresSave = false;
6869    
# Line 6970  namespace { Line 7021  namespace {
7021          if (lst3gri) {          if (lst3gri) {
7022              RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);              RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
7023              if (lst3gnl) {              if (lst3gnl) {
7024                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  size_t i = 0;
7025                  while (ck) {                  for (RIFF::Chunk* ck = lst3gnl->GetSubChunkAt(i); ck;
7026                         ck = lst3gnl->GetSubChunkAt(++i))
7027                    {
7028                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
7029                          if (pVersion && pVersion->major > 2 &&                          if (pVersion && pVersion->major > 2 &&
7030                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
7031    
7032                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
7033                      }                      }
                     ck = lst3gnl->GetNextSubChunk();  
7034                  }                  }
7035              }              }
7036          }          }
# Line 7068  namespace { Line 7120  namespace {
7120          pScriptGroups = new std::list<ScriptGroup*>;          pScriptGroups = new std::list<ScriptGroup*>;
7121          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);          RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
7122          if (lstLS) {          if (lstLS) {
7123              for (RIFF::List* lst = lstLS->GetFirstSubList(); lst;              size_t i = 0;
7124                   lst = lstLS->GetNextSubList())              for (RIFF::List* lst = lstLS->GetSubListAt(i); lst;
7125                     lst = lstLS->GetSubListAt(++i))
7126              {              {
7127                  if (lst->GetListType() == LIST_TYPE_RTIS) {                  if (lst->GetListType() == LIST_TYPE_RTIS) {
7128                      pScriptGroups->push_back(new ScriptGroup(this, lst));                      pScriptGroups->push_back(new ScriptGroup(this, lst));
# Line 7130  namespace { Line 7183  namespace {
7183              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
7184              // is placed first in file              // is placed first in file
7185              RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);              RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);
7186              RIFF::Chunk* first = pRIFF->GetFirstSubChunk();              RIFF::Chunk* first = pRIFF->GetSubChunkAt(0);
7187              if (first != info) {              if (first != info) {
7188                  pRIFF->MoveSubChunk(info, first);                  pRIFF->MoveSubChunk(info, first);
7189              }              }
# Line 7151  namespace { Line 7204  namespace {
7204              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
7205              // (before updating the Group chunks)              // (before updating the Group chunks)
7206              if (pVersion && pVersion->major > 2) {              if (pVersion && pVersion->major > 2) {
7207                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  size_t i = 0;
7208                  for (int i = 0 ; i < 128 ; i++) {                  for (RIFF::Chunk* _3gnm = _3gnl->GetSubChunkAt(i); i < 128;
7209                         _3gnm = _3gnl->GetSubChunkAt(++i))
7210                    {
7211                      // create 128 empty placeholder strings which will either                      // create 128 empty placeholder strings which will either
7212                      // be filled by Group::UpdateChunks below or left empty.                      // be filled by Group::UpdateChunks below or left empty.
7213                      ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
                     if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();  
7214                  }                  }
7215              }              }
7216    
# Line 7199  namespace { Line 7253  namespace {
7253              uint8_t* pData = (uint8_t*) einf->LoadChunkData();              uint8_t* pData = (uint8_t*) einf->LoadChunkData();
7254    
7255              std::map<gig::Sample*,int> sampleMap;              std::map<gig::Sample*,int> sampleMap;
7256              int sampleIdx = 0;              size_t sampleIdx = 0;
7257              for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {              for (Sample* pSample = GetSample(0); pSample;
7258                  sampleMap[pSample] = sampleIdx++;                           pSample = GetSample(++sampleIdx))
7259                {
7260                    sampleMap[pSample] = sampleIdx;
7261              }              }
7262    
7263              int totnbusedsamples = 0;              int totnbusedsamples = 0;
# Line 7222  namespace { Line 7278  namespace {
7278    
7279                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);                  memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
7280    
7281                  for (Region* region = instrument->GetFirstRegion() ; region ;                  size_t iRgn = 0;
7282                       region = instrument->GetNextRegion()) {                  for (Region* region = instrument->GetRegionAt(iRgn); region;
7283                         region = instrument->GetRegionAt(++iRgn))
7284                    {
7285                      for (int i = 0 ; i < region->DimensionRegions ; i++) {                      for (int i = 0 ; i < region->DimensionRegions ; i++) {
7286                          gig::DimensionRegion *d = region->pDimensionRegions[i];                          gig::DimensionRegion *d = region->pDimensionRegions[i];
7287                          if (d->pSample) {                          if (d->pSample) {
Legend:
Removed from v.3903  
changed lines
  Added in v.3929
  ViewVC Help
Powered by ViewVC