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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1953 by schoenebeck,
Thu Jul 30 08:16:02 2009 UTC
+revision 2482 by schoenebeck,
Mon Nov 25 02:22:38 2013 UTC
 Line 2
   *                                                                         *
   *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2009 by Christian Schoenebeck                      *
+  *   Copyright (C) 2003-2013 by Christian Schoenebeck                      *
   *                              <cuse@users.sourceforge.net>               *
   *                                                                         *
   *   This library is free software; you can redistribute it and/or modify  *
 Line 227 
 namespace DLS {
              }
          }
      }
+     /**
+      * 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 383 
 namespace DLS {
+Line 392 
 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 487 
 namespace DLS {
+Line 524 
 namespace DLS {
  #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 600 
 namespace DLS {
+Line 647 
 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 610 
 namespace DLS {
+Line 659 
 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 674 
 namespace DLS {
+Line 744 
 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 724 
 namespace DLS {
+Line 845 
 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 1027 
 namespace DLS {
+Line 1148 
 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 1178 
 namespace DLS {
+Line 1337 
 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 1431 
 namespace DLS {
+Line 1626 
 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.

 Legend:



Removed from v.1953
 


changed lines


 
Added in v.2482
 Legend:



Removed from v.1953
 


changed lines


 
Added in v.2482
-Removed from v.1953
+Added in v.2482

	ViewVC Help
Powered by ViewVC