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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1184 by persson,
Sun May 13 13:24:22 2007 UTC
+revision 2698 by schoenebeck,
Sun Jan 11 17:47:57 2015 UTC
 Line 2
   *                                                                         *
   *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2007 by Christian Schoenebeck                      *
+  *   Copyright (C) 2003-2014 by Christian Schoenebeck                      *
   *                              <cuse@users.sourceforge.net>               *
   *                                                                         *
   *   This library is free software; you can redistribute it and/or modify  *
 Line 23
  #include "DLS.h"
+ #include <algorithm>
  #include <time.h>
+ #ifdef __APPLE__
+ #include <CoreFoundation/CFUUID.h>
+ #elif defined(HAVE_UUID_UUID_H)
+ #include <uuid/uuid.h>
+ #endif
  #include "helper.h"
  // macros to decode connection transforms
-Line 137 
 namespace DLS {
+Line 144 
 namespace DLS {
      /**
       * Apply articulation connections to the respective RIFF chunks. You
       * have to call File::Save() to make changes persistent.
+      *
+      * @param pProgress - callback function for progress notification
       */
-     void Articulation::UpdateChunks() {
+     void Articulation::UpdateChunks(progress_t* pProgress) {
          const int iEntrySize = 12; // 12 bytes per connection block
          pArticulationCk->Resize(HeaderSize + Connections * iEntrySize);
          uint8_t* pData = (uint8_t*) pArticulationCk->LoadChunkData();
-Line 210 
 namespace DLS {
+Line 219 
 namespace DLS {
      /**
       * Apply all articulations to the respective RIFF chunks. You have to
       * call File::Save() to make changes persistent.
+      *
+      * @param pProgress - callback function for progress notification
       */
-     void Articulator::UpdateChunks() {
+     void Articulator::UpdateChunks(progress_t* pProgress) {
          if (pArticulations) {
              ArticulationList::iterator iter = pArticulations->begin();
              ArticulationList::iterator end  = pArticulations->end();
              for (; iter != end; ++iter) {
-                 (*iter)->UpdateChunks();
+                 (*iter)->UpdateChunks(pProgress);
              }
          }
      }
+     /**
+      * Not yet implemented in this version, since the .gig format does
+      * not need to copy DLS articulators and so far nobody used pure
+      * DLS instrument AFAIK.
+      */
+     void Articulator::CopyAssign(const Articulator* orig) {
+         //TODO: implement deep copy assignment for this class
+     }
-Line 233 
 namespace DLS {
+Line 253 
 namespace DLS {
       * @param list - pointer to a list chunk which contains an INFO list chunk
       */
      Info::Info(RIFF::List* list) {
-         FixedStringLengths = NULL;
+         pFixedStringLengths = NULL;
          pResourceListChunk = list;
          if (list) {
              RIFF::List* lstINFO = list->GetSubList(LIST_TYPE_INFO);
-Line 262 
 namespace DLS {
+Line 282 
 namespace DLS {
      Info::~Info() {
      }
+     /**
+      * Forces specific Info fields to be of a fixed length when being saved
+      * to a file. By default the respective RIFF chunk of an Info field
+      * will have a size analogue to its actual string length. With this
+      * method however this behavior can be overridden, allowing to force an
+      * arbitrary fixed size individually for each Info field.
+      *
+      * This method is used as a workaround for the gig format, not for DLS.
+      *
+      * @param lengths - NULL terminated array of string_length_t elements
+      */
+     void Info::SetFixedStringLengths(const string_length_t* lengths) {
+         pFixedStringLengths = lengths;
+     }
      /** @brief Load given INFO field.
       *
       * Load INFO field from INFO chunk with chunk ID \a ChunkID from INFO
-Line 289 
 namespace DLS {
+Line 324 
 namespace DLS {
       */
      void Info::SaveString(uint32_t ChunkID, RIFF::List* lstINFO, const String& s, const String& sDefault) {
          int size = 0;
-         if (FixedStringLengths) {
+         if (pFixedStringLengths) {
-             for (int i = 0 ; FixedStringLengths[i].length ; i++) {
+             for (int i = 0 ; pFixedStringLengths[i].length ; i++) {
-                 if (FixedStringLengths[i].chunkId == ChunkID) {
+                 if (pFixedStringLengths[i].chunkId == ChunkID) {
-                     size = FixedStringLengths[i].length;
+                     size = pFixedStringLengths[i].length;
+                     break;
                  }
              }
          }
-Line 304 
 namespace DLS {
+Line 340 
 namespace DLS {
       *
       * Apply current INFO field values to the respective INFO chunks. You
       * have to call File::Save() to make changes persistent.
+      *
+      * @param pProgress - callback function for progress notification
       */
-     void Info::UpdateChunks() {
+     void Info::UpdateChunks(progress_t* pProgress) {
          if (!pResourceListChunk) return;
          // make sure INFO list chunk exists
-Line 360 
 namespace DLS {
+Line 398 
 namespace DLS {
          SaveString(CHUNK_ID_ISRF, lstINFO, SourceForm, String(""));
          SaveString(CHUNK_ID_ITCH, lstINFO, Technician, String(""));
      }
+     /**
+      * Make a deep copy of the Info object given by @a orig and assign it to
+      * this object.
+      *
+      * @param orig - original Info object to be copied from
+      */
+     void Info::CopyAssign(const Info* orig) {
+         Name = orig->Name;
+         ArchivalLocation = orig->ArchivalLocation;
+         CreationDate = orig->CreationDate;
+         Comments = orig->Comments;
+         Product = orig->Product;
+         Copyright = orig->Copyright;
+         Artists = orig->Artists;
+         Genre = orig->Genre;
+         Keywords = orig->Keywords;
+         Engineer = orig->Engineer;
+         Technician = orig->Technician;
+         Software = orig->Software;
+         Medium = orig->Medium;
+         Source = orig->Source;
+         SourceForm = orig->SourceForm;
+         Commissioned = orig->Commissioned;
+         Subject = orig->Subject;
+         //FIXME: hmm, is copying this pointer a good idea?
+         pFixedStringLengths = orig->pFixedStringLengths;
+     }
-Line 404 
 namespace DLS {
+Line 470 
 namespace DLS {
       * will not be applied at the moment (yet).
       *
       * You have to call File::Save() to make changes persistent.
+      *
+      * @param pProgress - callback function for progress notification
       */
-     void Resource::UpdateChunks() {
+     void Resource::UpdateChunks(progress_t* pProgress) {
-         pInfo->UpdateChunks();
+         pInfo->UpdateChunks(pProgress);
-         //TODO: save DLSID
+         if (pDLSID) {
+             // make sure 'dlid' chunk exists
+             RIFF::Chunk* ckDLSID = pResourceList->GetSubChunk(CHUNK_ID_DLID);
+             if (!ckDLSID) ckDLSID = pResourceList->AddSubChunk(CHUNK_ID_DLID, 16);
+             uint8_t* pData = (uint8_t*)ckDLSID->LoadChunkData();
+             // update 'dlid' chunk
+             store32(&pData[0], pDLSID->ulData1);
+             store16(&pData[4], pDLSID->usData2);
+             store16(&pData[6], pDLSID->usData3);
+             memcpy(&pData[8], pDLSID->abData, 8);
+         }
      }
+     /**
+      * Generates a new DLSID for the resource.
+      */
+     void Resource::GenerateDLSID() {
+ #if defined(WIN32) || defined(__APPLE__) || defined(HAVE_UUID_GENERATE)
+         if (!pDLSID) pDLSID = new dlsid_t;
+ #ifdef WIN32
+         UUID uuid;
+         UuidCreate(&uuid);
+         pDLSID->ulData1 = uuid.Data1;
+         pDLSID->usData2 = uuid.Data2;
+         pDLSID->usData3 = uuid.Data3;
+         memcpy(pDLSID->abData, uuid.Data4, 8);
+ #elif defined(__APPLE__)
+         CFUUIDRef uuidRef = CFUUIDCreate(NULL);
+         CFUUIDBytes uuid = CFUUIDGetUUIDBytes(uuidRef);
+         CFRelease(uuidRef);
+         pDLSID->ulData1 = uuid.byte0 | uuid.byte1 << 8 | uuid.byte2 << 16 | uuid.byte3 << 24;
+         pDLSID->usData2 = uuid.byte4 | uuid.byte5 << 8;
+         pDLSID->usData3 = uuid.byte6 | uuid.byte7 << 8;
+         pDLSID->abData[0] = uuid.byte8;
+         pDLSID->abData[1] = uuid.byte9;
+         pDLSID->abData[2] = uuid.byte10;
+         pDLSID->abData[3] = uuid.byte11;
+         pDLSID->abData[4] = uuid.byte12;
+         pDLSID->abData[5] = uuid.byte13;
+         pDLSID->abData[6] = uuid.byte14;
+         pDLSID->abData[7] = uuid.byte15;
+ #else
+         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
+ #endif
+     }
+     /**
+      * Make a deep copy of the Resource object given by @a orig and assign it
+      * to this object.
+      *
+      * @param orig - original Resource object to be copied from
+      */
+     void Resource::CopyAssign(const Resource* orig) {
+         pInfo->CopyAssign(orig->pInfo);
+     }
  // *************** Sampler ***************
-Line 426 
 namespace DLS {
+Line 558 
 namespace DLS {
              SamplerOptions = wsmp->ReadUint32();
              SampleLoops    = wsmp->ReadUint32();
          } else { // 'wsmp' chunk missing
-             uiHeaderSize   = 0;
+             uiHeaderSize   = 20;
-             UnityNote      = 64;
+             UnityNote      = 60;
              FineTune       = 0; // +- 0 cents
              Gain           = 0; // 0 dB
              SamplerOptions = F_WSMP_NO_COMPRESSION;
-Line 451 
 namespace DLS {
+Line 583 
 namespace DLS {
          if (pSampleLoops) delete[] pSampleLoops;
      }
+     void Sampler::SetGain(int32_t gain) {
+         Gain = gain;
+     }
      /**
       * Apply all sample player options to the respective RIFF chunk. You
       * have to call File::Save() to make changes persistent.
+      *
+      * @param pProgress - callback function for progress notification
       */
-     void Sampler::UpdateChunks() {
+     void Sampler::UpdateChunks(progress_t* pProgress) {
          // make sure 'wsmp' chunk exists
          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
+         int wsmpSize = uiHeaderSize + SampleLoops * 16;
          if (!wsmp) {
-             uiHeaderSize = 20;
+             wsmp = pParentList->AddSubChunk(CHUNK_ID_WSMP, wsmpSize);
-             wsmp = pParentList->AddSubChunk(CHUNK_ID_WSMP, uiHeaderSize + SampleLoops * 16);
+         } else if (wsmp->GetSize() != wsmpSize) {
+             wsmp->Resize(wsmpSize);
          }
          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
          // update headers size
-Line 488 
 namespace DLS {
+Line 628 
 namespace DLS {
      /**
       * Adds a new sample loop with the provided loop definition.
       *
-      * @param - points to a loop definition that is to be copied
+      * @param pLoopDef - points to a loop definition that is to be copied
       */
      void Sampler::AddSampleLoop(sample_loop_t* pLoopDef) {
          sample_loop_t* pNewLoops = new sample_loop_t[SampleLoops + 1];
-Line 517 
 namespace DLS {
+Line 657 
 namespace DLS {
          // copy old loops array (skipping given loop)
          for (int i = 0, o = 0; i < SampleLoops; i++) {
              if (&pSampleLoops[i] == pLoopDef) continue;
-             if (o == SampleLoops - 1)
+             if (o == SampleLoops - 1) {
+                 delete[] pNewLoops;
                  throw Exception("Could not delete Sample Loop, because it does not exist");
+             }
              pNewLoops[o] = pSampleLoops[i];
              o++;
          }
-Line 527 
 namespace DLS {
+Line 669 
 namespace DLS {
          pSampleLoops = pNewLoops;
          SampleLoops--;
      }
+     /**
+      * Make a deep copy of the Sampler object given by @a orig and assign it
+      * to this object.
+      *
+      * @param orig - original Sampler object to be copied from
+      */
+     void Sampler::CopyAssign(const Sampler* orig) {
+         // copy trivial scalars
+         UnityNote = orig->UnityNote;
+         FineTune = orig->FineTune;
+         Gain = orig->Gain;
+         NoSampleDepthTruncation = orig->NoSampleDepthTruncation;
+         NoSampleCompression = orig->NoSampleCompression;
+         SamplerOptions = orig->SamplerOptions;
+         // copy sample loops
+         if (SampleLoops) delete[] pSampleLoops;
+         pSampleLoops = new sample_loop_t[orig->SampleLoops];
+         memcpy(pSampleLoops, orig->pSampleLoops, orig->SampleLoops * sizeof(sample_loop_t));
+         SampleLoops = orig->SampleLoops;
+     }
  // *************** Sample ***************
-Line 591 
 namespace DLS {
+Line 754 
 namespace DLS {
          RIFF::List* pParent = pWaveList->GetParent();
          pParent->DeleteSubChunk(pWaveList);
      }
+     /**
+      * Make a deep copy of the Sample object given by @a orig (without the
+      * actual sample waveform data however) and assign it to this object.
+      *
+      * This is a special internal variant of CopyAssign() which only copies the
+      * most mandatory member variables. It will be called by gig::Sample
+      * descendent instead of CopyAssign() since gig::Sample has its own
+      * implementation to access and copy the actual sample waveform data.
+      *
+      * @param orig - original Sample object to be copied from
+      */
+     void Sample::CopyAssignCore(const Sample* orig) {
+         // handle base classes
+         Resource::CopyAssign(orig);
+         // handle actual own attributes of this class
+         FormatTag = orig->FormatTag;
+         Channels = orig->Channels;
+         SamplesPerSecond = orig->SamplesPerSecond;
+         AverageBytesPerSecond = orig->AverageBytesPerSecond;
+         BlockAlign = orig->BlockAlign;
+         BitDepth = orig->BitDepth;
+         SamplesTotal = orig->SamplesTotal;
+         FrameSize = orig->FrameSize;
+     }
+     /**
+      * Make a deep copy of the Sample object given by @a orig and assign it to
+      * this object.
+      *
+      * @param orig - original Sample object to be copied from
+      */
+     void Sample::CopyAssign(const Sample* orig) {
+         CopyAssignCore(orig);
+         // copy sample waveform data (reading directly from disc)
+         Resize(orig->GetSize());
+         char* buf = (char*) LoadSampleData();
+         Sample* pOrig = (Sample*) orig; //HACK: circumventing the constness here for now
+         const unsigned long restorePos = pOrig->pCkData->GetPos();
+         pOrig->SetPos(0);
+         for (unsigned long todo = pOrig->GetSize(), i = 0; todo; ) {
+             const int iReadAtOnce = 64*1024;
+             unsigned long n = (iReadAtOnce < todo) ? iReadAtOnce : todo;
+             n = pOrig->Read(&buf[i], n);
+             if (!n) break;
+             todo -= n;
+             i += (n * pOrig->FrameSize);
+         }
+         pOrig->pCkData->SetPos(restorePos);
+     }
      /** @brief Load sample data into RAM.
       *
-Line 641 
 namespace DLS {
+Line 855 
 namespace DLS {
       * @returns number of sample points or 0 if FormatTag != DLS_WAVE_FORMAT_PCM
       * @see FrameSize, FormatTag
       */
-     unsigned long Sample::GetSize() {
+     unsigned long Sample::GetSize() const {
          if (FormatTag != DLS_WAVE_FORMAT_PCM) return 0;
          return (pCkData) ? pCkData->GetSize() / FrameSize : 0;
      }
-Line 747 
 namespace DLS {
+Line 961 
 namespace DLS {
       * Apply sample and its settings to the respective RIFF chunks. You have
       * to call File::Save() to make changes persistent.
       *
+      * @param pProgress - callback function for progress notification
       * @throws Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
       *                   was provided yet
       */
-     void Sample::UpdateChunks() {
+     void Sample::UpdateChunks(progress_t* pProgress) {
          if (FormatTag != DLS_WAVE_FORMAT_PCM)
              throw Exception("Could not save sample, only PCM format is supported");
          // we refuse to do anything if not sample wave form was provided yet
          if (!pCkData)
              throw Exception("Could not save sample, there is no sample data to save");
          // update chunks of base class as well
-         Resource::UpdateChunks();
+         Resource::UpdateChunks(pProgress);
          // make sure 'fmt' chunk exists
          RIFF::Chunk* pCkFormat = pWaveList->GetSubChunk(CHUNK_ID_FMT);
          if (!pCkFormat) pCkFormat = pWaveList->AddSubChunk(CHUNK_ID_FMT, 16); // assumes PCM format
-Line 852 
 namespace DLS {
+Line 1067 
 namespace DLS {
      }
      /**
+      * Modifies the key range of this Region and makes sure the respective
+      * chunks are in correct order.
+      *
+      * @param Low  - lower end of key range
+      * @param High - upper end of key range
+      */
+     void Region::SetKeyRange(uint16_t Low, uint16_t High) {
+         KeyRange.low  = Low;
+         KeyRange.high = High;
+         // make sure regions are already loaded
+         Instrument* pInstrument = (Instrument*) GetParent();
+         if (!pInstrument->pRegions) pInstrument->LoadRegions();
+         if (!pInstrument->pRegions) return;
+         // find the r which is the first one to the right of this region
+         // at its new position
+         Region* r = NULL;
+         Region* prev_region = NULL;
+         for (
+             Instrument::RegionList::iterator iter = pInstrument->pRegions->begin();
+             iter != pInstrument->pRegions->end(); iter++
+         ) {
+             if ((*iter)->KeyRange.low > this->KeyRange.low) {
+                 r = *iter;
+                 break;
+             }
+             prev_region = *iter;
+         }
+         // place this region before r if it's not already there
+         if (prev_region != this) pInstrument->MoveRegion(this, r);
+     }
+     /**
       * Apply Region settings to the respective RIFF chunks. You have to
       * call File::Save() to make changes persistent.
       *
+      * @param pProgress - callback function for progress notification
       * @throws Exception - if the Region's sample could not be found
       */
-     void Region::UpdateChunks() {
+     void Region::UpdateChunks(progress_t* pProgress) {
          // make sure 'rgnh' chunk exists
          RIFF::Chunk* rgnh = pCkRegion->GetSubChunk(CHUNK_ID_RGNH);
          if (!rgnh) rgnh = pCkRegion->AddSubChunk(CHUNK_ID_RGNH, Layer ? 14 : 12);
-Line 876 
 namespace DLS {
+Line 1127 
 namespace DLS {
          // update chunks of base classes as well (but skip Resource,
          // as a rgn doesn't seem to have dlid and INFO chunks)
-         Articulator::UpdateChunks();
+         Articulator::UpdateChunks(pProgress);
-         Sampler::UpdateChunks();
+         Sampler::UpdateChunks(pProgress);
          // make sure 'wlnk' chunk exists
          RIFF::Chunk* wlnk = pCkRegion->GetSubChunk(CHUNK_ID_WLNK);
-Line 902 
 namespace DLS {
+Line 1153 
 namespace DLS {
                  }
              }
          }
-         if (index < 0) throw Exception("Could not save Region, could not find Region's sample");
          WavePoolTableIndex = index;
          // update 'wlnk' chunk
          store16(&pData[0], WaveLinkOptionFlags);
-Line 910 
 namespace DLS {
+Line 1160 
 namespace DLS {
          store32(&pData[4], Channel);
          store32(&pData[8], WavePoolTableIndex);
      }
+     /**
+      * Make a (semi) deep copy of the Region object given by @a orig and assign
+      * it to this object.
+      *
+      * Note that the sample pointer referenced by @a orig is simply copied as
+      * memory address. Thus the respective sample is shared, not duplicated!
+      *
+      * @param orig - original Region object to be copied from
+      */
+     void Region::CopyAssign(const Region* orig) {
+         // handle base classes
+         Resource::CopyAssign(orig);
+         Articulator::CopyAssign(orig);
+         Sampler::CopyAssign(orig);
+         // handle actual own attributes of this class
+         // (the trivial ones)
+         VelocityRange = orig->VelocityRange;
+         KeyGroup = orig->KeyGroup;
+         Layer = orig->Layer;
+         SelfNonExclusive = orig->SelfNonExclusive;
+         PhaseMaster = orig->PhaseMaster;
+         PhaseGroup = orig->PhaseGroup;
+         MultiChannel = orig->MultiChannel;
+         Channel = orig->Channel;
+         // only take the raw sample reference if the two Region objects are
+         // part of the same file
+         if (GetParent()->GetParent() == orig->GetParent()->GetParent()) {
+             WavePoolTableIndex = orig->WavePoolTableIndex;
+             pSample = orig->pSample;
+         } else {
+             WavePoolTableIndex = -1;
+             pSample = NULL;
+         }
+         FormatOptionFlags = orig->FormatOptionFlags;
+         WaveLinkOptionFlags = orig->WaveLinkOptionFlags;
+         // handle the last, a bit sensible attribute
+         SetKeyRange(orig->KeyRange.low, orig->KeyRange.high);
+     }
  // *************** Instrument ***************
-Line 993 
 namespace DLS {
+Line 1281 
 namespace DLS {
      void Instrument::MoveRegion(Region* pSrc, Region* pDst) {
          RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
-         lrgn->MoveSubChunk(pSrc->pCkRegion, pDst ? pDst->pCkRegion : 0);
+         lrgn->MoveSubChunk(pSrc->pCkRegion, (RIFF::Chunk*) (pDst ? pDst->pCkRegion : 0));
          pRegions->remove(pSrc);
          RegionList::iterator iter = find(pRegions->begin(), pRegions->end(), pDst);
-Line 1013 
 namespace DLS {
+Line 1301 
 namespace DLS {
       * Apply Instrument with all its Regions to the respective RIFF chunks.
       * You have to call File::Save() to make changes persistent.
       *
+      * @param pProgress - callback function for progress notification
       * @throws Exception - on errors
       */
-     void Instrument::UpdateChunks() {
+     void Instrument::UpdateChunks(progress_t* pProgress) {
          // first update base classes' chunks
-         Resource::UpdateChunks();
+         Resource::UpdateChunks(pProgress);
-         Articulator::UpdateChunks();
+         Articulator::UpdateChunks(pProgress);
          // make sure 'insh' chunk exists
          RIFF::Chunk* insh = pCkInstrument->GetSubChunk(CHUNK_ID_INSH);
          if (!insh) insh = pCkInstrument->AddSubChunk(CHUNK_ID_INSH, 12);
-Line 1037 
 namespace DLS {
+Line 1326 
 namespace DLS {
          if (!pRegions) return;
          RegionList::iterator iter = pRegions->begin();
          RegionList::iterator end  = pRegions->end();
-         for (; iter != end; ++iter) {
+         for (int i = 0; iter != end; ++iter, ++i) {
-             (*iter)->UpdateChunks();
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, pRegions->size(), i);
+             // do the actual work
+             (*iter)->UpdateChunks(&subprogress);
          }
+         __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Destructor.
-Line 1061 
 namespace DLS {
+Line 1355 
 namespace DLS {
          RIFF::List* pParent = pCkInstrument->GetParent();
          pParent->DeleteSubChunk(pCkInstrument);
      }
+     void Instrument::CopyAssignCore(const Instrument* orig) {
+         // handle base classes
+         Resource::CopyAssign(orig);
+         Articulator::CopyAssign(orig);
+         // handle actual own attributes of this class
+         // (the trivial ones)
+         IsDrum = orig->IsDrum;
+         MIDIBank = orig->MIDIBank;
+         MIDIBankCoarse = orig->MIDIBankCoarse;
+         MIDIBankFine = orig->MIDIBankFine;
+         MIDIProgram = orig->MIDIProgram;
+     }
+     /**
+      * Make a (semi) deep copy of the Instrument object given by @a orig and assign
+      * it to this object.
+      *
+      * Note that all sample pointers referenced by @a orig are simply copied as
+      * memory address. Thus the respective samples are shared, not duplicated!
+      *
+      * @param orig - original Instrument object to be copied from
+      */
+     void Instrument::CopyAssign(const Instrument* orig) {
+         CopyAssignCore(orig);
+         // delete all regions first
+         while (Regions) DeleteRegion(GetFirstRegion());
+         // now recreate and copy regions
+         {
+             RegionList::const_iterator it = orig->pRegions->begin();
+             for (int i = 0; i < orig->Regions; ++i, ++it) {
+                 Region* dstRgn = AddRegion();
+                 //NOTE: Region does semi-deep copy !
+                 dstRgn->CopyAssign(*it);
+             }
+         }
+     }
  // *************** File ***************
-Line 1314 
 namespace DLS {
+Line 1644 
 namespace DLS {
      }
      /**
+      * Returns extension file of given index. Extension files are used
+      * sometimes to circumvent the 2 GB file size limit of the RIFF format and
+      * of certain operating systems in general. In this case, instead of just
+      * using one file, the content is spread among several files with similar
+      * file name scheme. This is especially used by some GigaStudio sound
+      * libraries.
+      *
+      * @param index - index of extension file
+      * @returns sought extension file, NULL if index out of bounds
+      * @see GetFileName()
+      */
+     RIFF::File* File::GetExtensionFile(int index) {
+         if (index < 0 || index >= ExtensionFiles.size()) return NULL;
+         std::list<RIFF::File*>::iterator iter = ExtensionFiles.begin();
+         for (int i = 0; iter != ExtensionFiles.end(); ++iter, ++i)
+             if (i == index) return *iter;
+         return NULL;
+     }
+     /** @brief File name of this DLS file.
+      *
+      * This method returns the file name as it was provided when loading
+      * the respective DLS file. However in case the File object associates
+      * an empty, that is new DLS file, which was not yet saved to disk,
+      * this method will return an empty string.
+      *
+      * @see GetExtensionFile()
+      */
+     String File::GetFileName() {
+         return pRIFF->GetFileName();
+     }
+     /**
+      * You may call this method store a future file name, so you don't have to
+      * to pass it to the Save() call later on.
+      */
+     void File::SetFileName(const String& name) {
+         pRIFF->SetFileName(name);
+     }
+     /**
       * Apply all the DLS file's current instruments, samples and settings to
       * the respective RIFF chunks. You have to call Save() to make changes
       * persistent.
       *
+      * @param pProgress - callback function for progress notification
       * @throws Exception - on errors
       */
-     void File::UpdateChunks() {
+     void File::UpdateChunks(progress_t* pProgress) {
          // first update base class's chunks
-         Resource::UpdateChunks();
+         Resource::UpdateChunks(pProgress);
          // if version struct exists, update 'vers' chunk
          if (pVersion) {
-Line 1344 
 namespace DLS {
+Line 1716 
 namespace DLS {
          // update instrument's chunks
          if (pInstruments) {
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 20.f, 0.f); // arbitrarily subdivided into 5% of total progress
+             // do the actual work
              InstrumentList::iterator iter = pInstruments->begin();
              InstrumentList::iterator end  = pInstruments->end();
-             for (; iter != end; ++iter) {
+             for (int i = 0; iter != end; ++iter, ++i) {
-                 (*iter)->UpdateChunks();
+                 // divide subprogress into sub-subprogress
+                 progress_t subsubprogress;
+                 __divide_progress(&subprogress, &subsubprogress, pInstruments->size(), i);
+                 // do the actual work
+                 (*iter)->UpdateChunks(&subsubprogress);
              }
+             __notify_progress(&subprogress, 1.0); // notify subprogress done
          }
          // update 'ptbl' chunk
-Line 1366 
 namespace DLS {
+Line 1749 
 namespace DLS {
          // update sample's chunks
          if (pSamples) {
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 20.f, 1.f); // arbitrarily subdivided into 95% of total progress
+             // do the actual work
              SampleList::iterator iter = pSamples->begin();
              SampleList::iterator end  = pSamples->end();
-             for (; iter != end; ++iter) {
+             for (int i = 0; iter != end; ++iter, ++i) {
-                 (*iter)->UpdateChunks();
+                 // divide subprogress into sub-subprogress
+                 progress_t subsubprogress;
+                 __divide_progress(&subprogress, &subsubprogress, pSamples->size(), i);
+                 // do the actual work
+                 (*iter)->UpdateChunks(&subsubprogress);
              }
+             __notify_progress(&subprogress, 1.0); // notify subprogress done
          }
+         __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Save changes to another file.
-Line 1386 
 namespace DLS {
+Line 1782 
 namespace DLS {
       * the new file (given by \a Path) afterwards.
       *
       * @param Path - path and file name where everything should be written to
+      * @param pProgress - optional: callback function for progress notification
       */
-     void File::Save(const String& Path) {
+     void File::Save(const String& Path, progress_t* pProgress) {
-         UpdateChunks();
+         {
-         pRIFF->Save(Path);
+             // divide local progress into subprogress
-         __UpdateWavePoolTableChunk();
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 2.f, 0.f); // arbitrarily subdivided into 50% of total progress
+             // do the actual work
+             UpdateChunks(&subprogress);
+         }
+         {
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 2.f, 1.f); // arbitrarily subdivided into 50% of total progress
+             // do the actual work
+             pRIFF->Save(Path, &subprogress);
+         }
+         UpdateFileOffsets();
+         __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Save changes to same file.
-Line 1399 
 namespace DLS {
+Line 1810 
 namespace DLS {
       * file. The file might temporarily grow to a higher size than it will
       * have at the end of the saving process.
       *
+      * @param pProgress - optional: callback function for progress notification
       * @throws RIFF::Exception if any kind of IO error occured
       * @throws DLS::Exception  if any kind of DLS specific error occured
       */
-     void File::Save() {
+     void File::Save(progress_t* pProgress) {
-         UpdateChunks();
+         {
-         pRIFF->Save();
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 2.f, 0.f); // arbitrarily subdivided into 50% of total progress
+             // do the actual work
+             UpdateChunks(&subprogress);
+         }
+         {
+             // divide local progress into subprogress
+             progress_t subprogress;
+             __divide_progress(pProgress, &subprogress, 2.f, 1.f); // arbitrarily subdivided into 50% of total progress
+             // do the actual work
+             pRIFF->Save(&subprogress);
+         }
+         UpdateFileOffsets();
+         __notify_progress(pProgress, 1.0); // notify done
+     }
+     /** @brief Updates all file offsets stored all over the file.
+      *
+      * This virtual method is called whenever the overall file layout has been
+      * changed (i.e. file or individual RIFF chunks have been resized). It is
+      * then the responsibility of this method to update all file offsets stored
+      * in the file format. For example samples are referenced by instruments by
+      * file offsets. The gig format also stores references to instrument
+      * scripts as file offsets, and thus it overrides this method to update
+      * those file offsets as well.
+      */
+     void File::UpdateFileOffsets() {
          __UpdateWavePoolTableChunk();
      }

 Legend:



Removed from v.1184
 


changed lines


 
Added in v.2698
 Legend:



Removed from v.1184
 


changed lines


 
Added in v.2698
-Removed from v.1184
+Added in v.2698

	ViewVC Help
Powered by ViewVC