/[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 2601 by schoenebeck, Sat Jun 7 15:19:58 2014 UTC revision 2836 by persson, Sun Aug 23 05:57:18 2015 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-2014 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2015 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 53  Line 53 
53    
54  namespace gig {  namespace gig {
55    
 // *************** progress_t ***************  
 // *  
   
     progress_t::progress_t() {  
         callback    = NULL;  
         custom      = NULL;  
         __range_min = 0.0f;  
         __range_max = 1.0f;  
     }  
   
     // private helper function to convert progress of a subprocess into the global progress  
     static void __notify_progress(progress_t* pProgress, float subprogress) {  
         if (pProgress && pProgress->callback) {  
             const float totalrange    = pProgress->__range_max - pProgress->__range_min;  
             const float totalprogress = pProgress->__range_min + subprogress * totalrange;  
             pProgress->factor         = totalprogress;  
             pProgress->callback(pProgress); // now actually notify about the progress  
         }  
     }  
   
     // private helper function to divide a progress into subprogresses  
     static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress, float totalTasks, float currentTask) {  
         if (pParentProgress && pParentProgress->callback) {  
             const float totalrange    = pParentProgress->__range_max - pParentProgress->__range_min;  
             pSubProgress->callback    = pParentProgress->callback;  
             pSubProgress->custom      = pParentProgress->custom;  
             pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;  
             pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;  
         }  
     }  
   
   
56  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
57  // *  // *
58    
# Line 528  namespace { Line 496  namespace {
496       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
497       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
498       *       *
499         * @param pProgress - callback function for progress notification
500       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
501       *                        was provided yet       *                        was provided yet
502       * @throws gig::Exception if there is any invalid sample setting       * @throws gig::Exception if there is any invalid sample setting
503       */       */
504      void Sample::UpdateChunks() {      void Sample::UpdateChunks(progress_t* pProgress) {
505          // first update base class's chunks          // first update base class's chunks
506          DLS::Sample::UpdateChunks();          DLS::Sample::UpdateChunks(pProgress);
507    
508          // make sure 'smpl' chunk exists          // make sure 'smpl' chunk exists
509          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
# Line 1752  namespace { Line 1721  namespace {
1721       *       *
1722       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
1723       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
1724         *
1725         * @param pProgress - callback function for progress notification
1726       */       */
1727      void DimensionRegion::UpdateChunks() {      void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1728          // first update base class's chunk          // first update base class's chunk
1729          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks(pProgress);
1730    
1731          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1732          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
# Line 3026  namespace { Line 2997  namespace {
2997       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
2998       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
2999       *       *
3000         * @param pProgress - callback function for progress notification
3001       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
3002       */       */
3003      void Region::UpdateChunks() {      void Region::UpdateChunks(progress_t* pProgress) {
3004          // in the gig format we don't care about the Region's sample reference          // in the gig format we don't care about the Region's sample reference
3005          // but we still have to provide some existing one to not corrupt the          // but we still have to provide some existing one to not corrupt the
3006          // file, so to avoid the latter we simply always assign the sample of          // file, so to avoid the latter we simply always assign the sample of
# Line 3036  namespace { Line 3008  namespace {
3008          pSample = pDimensionRegions[0]->pSample;          pSample = pDimensionRegions[0]->pSample;
3009    
3010          // first update base class's chunks          // first update base class's chunks
3011          DLS::Region::UpdateChunks();          DLS::Region::UpdateChunks(pProgress);
3012    
3013          // update dimension region's chunks          // update dimension region's chunks
3014          for (int i = 0; i < DimensionRegions; i++) {          for (int i = 0; i < DimensionRegions; i++) {
3015              pDimensionRegions[i]->UpdateChunks();              pDimensionRegions[i]->UpdateChunks(pProgress);
3016          }          }
3017    
3018          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
# Line 3652  namespace { Line 3624  namespace {
3624          UpdateVelocityTable();          UpdateVelocityTable();
3625      }      }
3626    
3627        /** @brief Change type of an existing dimension.
3628         *
3629         * Alters the dimension type of a dimension already existing on this
3630         * region. If there is currently no dimension on this Region with type
3631         * @a oldType, then this call with throw an Exception. Likewise there are
3632         * cases where the requested dimension type cannot be performed. For example
3633         * if the new dimension type shall be gig::dimension_samplechannel, and the
3634         * current dimension has more than 2 zones. In such cases an Exception is
3635         * thrown as well.
3636         *
3637         * @param oldType - identifies the existing dimension to be changed
3638         * @param newType - to which dimension type it should be changed to
3639         * @throws gig::Exception if requested change cannot be performed
3640         */
3641        void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
3642            if (oldType == newType) return;
3643            dimension_def_t* def = GetDimensionDefinition(oldType);
3644            if (!def)
3645                throw gig::Exception("No dimension with provided old dimension type exists on this region");
3646            if (newType == dimension_samplechannel && def->zones != 2)
3647                throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3648            if (GetDimensionDefinition(newType))
3649                throw gig::Exception("There is already a dimension with requested new dimension type on this region");
3650            def->dimension  = newType;
3651            def->split_type = __resolveSplitType(newType);
3652        }
3653    
3654      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {
3655          uint8_t bits[8] = {};          uint8_t bits[8] = {};
3656          for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();          for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
# Line 4094  namespace { Line 4093  namespace {
4093              for (int i = 0; i < nameSize; ++i)              for (int i = 0; i < nameSize; ++i)
4094                  Name[i] = ckScri->ReadUint8();                  Name[i] = ckScri->ReadUint8();
4095              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4096              ckScri->SetPos(headerSize - 6*sizeof(int32_t) + nameSize, RIFF::stream_curpos);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4097              // read actual script data              // read actual script data
4098              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();
4099              data.resize(scriptSize);              data.resize(scriptSize);
# Line 4134  namespace { Line 4133  namespace {
4133          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4134      }      }
4135    
4136      void Script::UpdateChunks() {      /**
4137         * Apply this script to the respective RIFF chunks. You have to call
4138         * File::Save() to make changes persistent.
4139         *
4140         * Usually there is absolutely no need to call this method explicitly.
4141         * It will be called automatically when File::Save() was called.
4142         *
4143         * @param pProgress - callback function for progress notification
4144         */
4145        void Script::UpdateChunks(progress_t* pProgress) {
4146          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4147          __resetCRC(crc);          __resetCRC(crc);
4148          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
# Line 4173  namespace { Line 4181  namespace {
4181       * @param pGroup - script's new group       * @param pGroup - script's new group
4182       */       */
4183      void Script::SetGroup(ScriptGroup* pGroup) {      void Script::SetGroup(ScriptGroup* pGroup) {
4184          if (this->pGroup = pGroup) return;          if (this->pGroup == pGroup) return;
4185          if (pChunk)          if (pChunk)
4186              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4187          this->pGroup = pGroup;          this->pGroup = pGroup;
# Line 4224  namespace { Line 4232  namespace {
4232          }          }
4233      }      }
4234    
4235      void ScriptGroup::UpdateChunks() {      /**
4236         * Apply this script group to the respective RIFF chunks. You have to call
4237         * File::Save() to make changes persistent.
4238         *
4239         * Usually there is absolutely no need to call this method explicitly.
4240         * It will be called automatically when File::Save() was called.
4241         *
4242         * @param pProgress - callback function for progress notification
4243         */
4244        void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4245          if (pScripts) {          if (pScripts) {
4246              if (!pList)              if (!pList)
4247                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
# Line 4235  namespace { Line 4252  namespace {
4252              for (std::list<Script*>::iterator it = pScripts->begin();              for (std::list<Script*>::iterator it = pScripts->begin();
4253                   it != pScripts->end(); ++it)                   it != pScripts->end(); ++it)
4254              {              {
4255                  (*it)->UpdateChunks();                  (*it)->UpdateChunks(pProgress);
4256              }              }
4257          }          }
4258      }      }
# Line 4398  namespace { Line 4415  namespace {
4415          if (lst3LS) {          if (lst3LS) {
4416              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4417              if (ckSCSL) {              if (ckSCSL) {
4418                  int slotCount = ckSCSL->ReadUint32();                  int headerSize = ckSCSL->ReadUint32();
4419                  int slotSize  = ckSCSL->ReadUint32();                  int slotCount  = ckSCSL->ReadUint32();
4420                  int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future extensions                  if (slotCount) {
4421                  for (int i = 0; i < slotCount; ++i) {                      int slotSize  = ckSCSL->ReadUint32();
4422                      _ScriptPooolEntry e;                      ckSCSL->SetPos(headerSize); // in case of future header extensions
4423                      e.fileOffset = ckSCSL->ReadUint32();                      int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions
4424                      e.bypass     = ckSCSL->ReadUint32() & 1;                      for (int i = 0; i < slotCount; ++i) {
4425                      if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions                          _ScriptPooolEntry e;
4426                      scriptPoolFileOffsets.push_back(e);                          e.fileOffset = ckSCSL->ReadUint32();
4427                            e.bypass     = ckSCSL->ReadUint32() & 1;
4428                            if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions
4429                            scriptPoolFileOffsets.push_back(e);
4430                        }
4431                  }                  }
4432              }              }
4433          }          }
# Line 4441  namespace { Line 4462  namespace {
4462       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
4463       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
4464       *       *
4465         * @param pProgress - callback function for progress notification
4466       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
4467       */       */
4468      void Instrument::UpdateChunks() {      void Instrument::UpdateChunks(progress_t* pProgress) {
4469          // first update base classes' chunks          // first update base classes' chunks
4470          DLS::Instrument::UpdateChunks();          DLS::Instrument::UpdateChunks(pProgress);
4471    
4472          // update Regions' chunks          // update Regions' chunks
4473          {          {
4474              RegionList::iterator iter = pRegions->begin();              RegionList::iterator iter = pRegions->begin();
4475              RegionList::iterator end  = pRegions->end();              RegionList::iterator end  = pRegions->end();
4476              for (; iter != end; ++iter)              for (; iter != end; ++iter)
4477                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
4478          }          }
4479    
4480          // make sure 'lart' RIFF list chunk exists          // make sure 'lart' RIFF list chunk exists
# Line 4489  namespace { Line 4511  namespace {
4511          }          }
4512    
4513          // own gig format extensions          // own gig format extensions
4514         if (pScriptRefs) {         if (ScriptSlotCount()) {
4515               // make sure we have converted the original loaded script file
4516               // offsets into valid Script object pointers
4517               LoadScripts();
4518    
4519             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4520             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4521             const int totalSize = pScriptRefs->size() * 2*sizeof(uint32_t);             const int slotCount = pScriptRefs->size();
4522               const int headerSize = 3 * sizeof(uint32_t);
4523               const int slotSize  = 2 * sizeof(uint32_t);
4524               const int totalChunkSize = headerSize + slotCount * slotSize;
4525             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4526             if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalSize);             if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
4527             else ckSCSL->Resize(totalSize);             else ckSCSL->Resize(totalChunkSize);
4528             uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();             uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();
4529             for (int i = 0, pos = 0; i < pScriptRefs->size(); ++i) {             int pos = 0;
4530                 int fileOffset =             store32(&pData[pos], headerSize);
4531                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -             pos += sizeof(uint32_t);
4532                      (*pScriptRefs)[i].script->pChunk->GetPos() -             store32(&pData[pos], slotCount);
4533                      CHUNK_HEADER_SIZE;             pos += sizeof(uint32_t);
4534                 store32(&pData[pos], fileOffset);             store32(&pData[pos], slotSize);
4535               pos += sizeof(uint32_t);
4536               for (int i = 0; i < slotCount; ++i) {
4537                   // arbitrary value, the actual file offset will be updated in
4538                   // UpdateScriptFileOffsets() after the file has been resized
4539                   int bogusFileOffset = 0;
4540                   store32(&pData[pos], bogusFileOffset);
4541                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
4542                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4543                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
4544             }             }
4545           } else {
4546               // no script slots, so get rid of any LS custom RIFF chunks (if any)
4547               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4548               if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS);
4549         }         }
4550      }      }
4551    
4552        void Instrument::UpdateScriptFileOffsets() {
4553           // own gig format extensions
4554           if (pScriptRefs && pScriptRefs->size() > 0) {
4555               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4556               RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4557               const int slotCount = pScriptRefs->size();
4558               const int headerSize = 3 * sizeof(uint32_t);
4559               ckSCSL->SetPos(headerSize);
4560               for (int i = 0; i < slotCount; ++i) {
4561                   uint32_t fileOffset =
4562                        (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4563                        (*pScriptRefs)[i].script->pChunk->GetPos() -
4564                        CHUNK_HEADER_SIZE;
4565                   ckSCSL->WriteUint32(&fileOffset);
4566                   // jump over flags entry (containing the bypass flag)
4567                   ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
4568               }
4569           }        
4570        }
4571    
4572      /**      /**
4573       * Returns the appropriate Region for a triggered note.       * Returns the appropriate Region for a triggered note.
4574       *       *
# Line 4577  namespace { Line 4636  namespace {
4636      }      }
4637    
4638      /**      /**
4639         * Move this instrument at the position before @arg dst.
4640         *
4641         * This method can be used to reorder the sequence of instruments in a
4642         * .gig file. This might be helpful especially on large .gig files which
4643         * contain a large number of instruments within the same .gig file. So
4644         * grouping such instruments to similar ones, can help to keep track of them
4645         * when working with such complex .gig files.
4646         *
4647         * When calling this method, this instrument will be removed from in its
4648         * current position in the instruments list and moved to the requested
4649         * target position provided by @param dst. You may also pass NULL as
4650         * argument to this method, in that case this intrument will be moved to the
4651         * very end of the .gig file's instrument list.
4652         *
4653         * You have to call Save() to make the order change persistent to the .gig
4654         * file.
4655         *
4656         * Currently this method is limited to moving the instrument within the same
4657         * .gig file. Trying to move it to another .gig file by calling this method
4658         * will throw an exception.
4659         *
4660         * @param dst - destination instrument at which this instrument will be
4661         *              moved to, or pass NULL for moving to end of list
4662         * @throw gig::Exception if this instrument and target instrument are not
4663         *                       part of the same file
4664         */
4665        void Instrument::MoveTo(Instrument* dst) {
4666            if (dst && GetParent() != dst->GetParent())
4667                throw Exception(
4668                    "gig::Instrument::MoveTo() can only be used for moving within "
4669                    "the same gig file."
4670                );
4671    
4672            File* pFile = (File*) GetParent();
4673    
4674            // move this instrument within the instrument list
4675            {
4676                File::InstrumentList& list = *pFile->pInstruments;
4677    
4678                File::InstrumentList::iterator itFrom =
4679                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
4680    
4681                File::InstrumentList::iterator itTo =
4682                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
4683    
4684                list.splice(itTo, list, itFrom);
4685            }
4686    
4687            // move the instrument's actual list RIFF chunk appropriately
4688            RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS);
4689            lstCkInstruments->MoveSubChunk(
4690                this->pCkInstrument,
4691                (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
4692            );
4693        }
4694    
4695        /**
4696       * Returns a MIDI rule of the instrument.       * Returns a MIDI rule of the instrument.
4697       *       *
4698       * The list of MIDI rules, at least in gig v3, always contains at       * The list of MIDI rules, at least in gig v3, always contains at
# Line 4645  namespace { Line 4761  namespace {
4761          if (scriptPoolFileOffsets.empty()) return;          if (scriptPoolFileOffsets.empty()) return;
4762          File* pFile = (File*) GetParent();          File* pFile = (File*) GetParent();
4763          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4764              uint32_t offset = scriptPoolFileOffsets[k].fileOffset;              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4765              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
4766                  ScriptGroup* group = pFile->GetScriptGroup(i);                  ScriptGroup* group = pFile->GetScriptGroup(i);
4767                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
4768                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
4769                      if (script->pChunk) {                      if (script->pChunk) {
4770                          script->pChunk->SetPos(0);                          uint32_t offset = script->pChunk->GetFilePos() -
4771                          if (script->pChunk->GetFilePos() -                                            script->pChunk->GetPos() -
4772                              script->pChunk->GetPos() -                                            CHUNK_HEADER_SIZE;
4773                              CHUNK_HEADER_SIZE == offset)                          if (offset == soughtOffset)
4774                          {                          {
4775                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
4776                              ref.script = script;                              ref.script = script;
# Line 4936  namespace { Line 5052  namespace {
5052       *       *
5053       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5054       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5055         *
5056         * @param pProgress - callback function for progress notification
5057       */       */
5058      void Group::UpdateChunks() {      void Group::UpdateChunks(progress_t* pProgress) {
5059          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
5060          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5061          if (!_3gri) {          if (!_3gri) {
# Line 5713  namespace { Line 5831  namespace {
5831       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5832       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5833       *       *
5834         * @param pProgress - callback function for progress notification
5835       * @throws Exception - on errors       * @throws Exception - on errors
5836       */       */
5837      void File::UpdateChunks() {      void File::UpdateChunks(progress_t* pProgress) {
5838          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
5839    
5840          b64BitWavePoolOffsets = pVersion && pVersion->major == 3;          b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
# Line 5738  namespace { Line 5857  namespace {
5857                  for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();                  for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5858                       it != pScriptGroups->end(); ++it)                       it != pScriptGroups->end(); ++it)
5859                  {                  {
5860                      (*it)->UpdateChunks();                      (*it)->UpdateChunks(pProgress);
5861                  }                  }
5862              }              }
5863          }          }
5864    
5865          // first update base class's chunks          // first update base class's chunks
5866          DLS::File::UpdateChunks();          DLS::File::UpdateChunks(pProgress);
5867    
5868          if (newFile) {          if (newFile) {
5869              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
# Line 5781  namespace { Line 5900  namespace {
5900              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
5901              std::list<Group*>::iterator end  = pGroups->end();              std::list<Group*>::iterator end  = pGroups->end();
5902              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
5903                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
5904              }              }
5905          }          }
5906    
# Line 5913  namespace { Line 6032  namespace {
6032              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6033          }          }
6034      }      }
6035        
6036        void File::UpdateFileOffsets() {
6037            DLS::File::UpdateFileOffsets();
6038    
6039            for (Instrument* instrument = GetFirstInstrument(); instrument;
6040                 instrument = GetNextInstrument())
6041            {
6042                instrument->UpdateScriptFileOffsets();
6043            }
6044        }
6045    
6046      /**      /**
6047       * Enable / disable automatic loading. By default this properyt is       * Enable / disable automatic loading. By default this properyt is
Legend:
Removed from v.2601  
changed lines
  Added in v.2836
  ViewVC Help
Powered by ViewVC