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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1384 by schoenebeck,
Fri Oct  5 11:26:53 2007 UTC
+revision 2394 by schoenebeck,
Mon Jan  7 23:23:58 2013 UTC
 Line 2
   *                                                                         *
   *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2007 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 25
  #include "helper.h"
+ #include <algorithm>
  #include <math.h>
  #include <iostream>
-Line 366 
 namespace {
+Line 367 
 namespace {
       *                         is located, 0 otherwise
       */
      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
-         static const DLS::Info::FixedStringLength fixedStringLengths[] = {
+         static const DLS::Info::string_length_t fixedStringLengths[] = {
              { CHUNK_ID_INAM, 64 },
              { 0, 0 }
          };
-         pInfo->FixedStringLengths = fixedStringLengths;
+         pInfo->SetFixedStringLengths(fixedStringLengths);
          Instances++;
          FileNo = fileNo;
-Line 676 
 namespace {
+Line 677 
 namespace {
          if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
          unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
+         SetPos(0); // reset read position to begin of sample
          RAMCache.pStart            = new int8_t[allocationsize];
          RAMCache.Size              = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
          RAMCache.NullExtensionSize = allocationsize - RAMCache.Size;
-Line 713 
 namespace {
+Line 715 
 namespace {
          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
          RAMCache.pStart = NULL;
          RAMCache.Size   = 0;
+         RAMCache.NullExtensionSize = 0;
      }
      /** @brief Resize sample.
-Line 907 
 namespace {
+Line 910 
 namespace {
                                  }
                                  // reverse the sample frames for backward playback
-                                 SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
+                                 if (totalreadsamples > swapareastart) //FIXME: this if() is just a crash workaround for now (#102), but totalreadsamples <= swapareastart should never be the case, so there's probably still a bug above!
+                                     SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
                              }
                          } while (samplestoread && readsamples);
                          break;
-Line 1577 
 namespace {
+Line 1581 
 namespace {
       */
      DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {
          Instances++;
+         //NOTE: I think we cannot call CopyAssign() here (in a constructor) as long as its a virtual method
          *this = src; // default memberwise shallow copy of all parameters
          pParentList = _3ewl; // restore the chunk pointer
-Line 1592 
 namespace {
+Line 1597 
 namespace {
                  pSampleLoops[k] = src.pSampleLoops[k];
          }
      }
+     /**
+      * Make a (semi) deep copy of the DimensionRegion 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 DimensionRegion object to be copied from
+      */
+     void DimensionRegion::CopyAssign(const DimensionRegion* orig) {
+         // delete all allocated data first
+         if (VelocityTable) delete [] VelocityTable;
+         if (pSampleLoops) delete [] pSampleLoops;
+         // backup parent list pointer
+         RIFF::List* p = pParentList;
+         //NOTE: copy code copied from assignment constructor above, see comment there as well
+         *this = *orig; // default memberwise shallow copy of all parameters
+         pParentList = p; // restore the chunk pointer
+         // deep copy of owned structures
+         if (orig->VelocityTable) {
+             VelocityTable = new uint8_t[128];
+             for (int k = 0 ; k < 128 ; k++)
+                 VelocityTable[k] = orig->VelocityTable[k];
+         }
+         if (orig->pSampleLoops) {
+             pSampleLoops = new DLS::sample_loop_t[orig->SampleLoops];
+             for (int k = 0 ; k < orig->SampleLoops ; k++)
+                 pSampleLoops[k] = orig->pSampleLoops[k];
+         }
+     }
      /**
       * Updates the respective member variable and updates @c SampleAttenuation
-Line 1834 
 namespace {
+Line 1874 
 namespace {
          const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
                                                    : uint16_t(((-EG3Depth) - 1) ^ 0xffff); /* binary complementary for negatives */
-         pData[116] = eg3depth;
+         store16(&pData[116], eg3depth);
          // next 2 bytes unknown
-Line 1881 
 namespace {
+Line 1921 
 namespace {
                                        (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
          pData[137] = vcfbreakpoint;
-         const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 |
+         const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 +
                                      VCFVelocityCurve * 5;
          pData[138] = vcfvelocity;
-Line 2372 
 namespace {
+Line 2412 
 namespace {
          // Actual Loading
+         if (!file->GetAutoLoad()) return;
          LoadDimensionRegions(rgnList);
          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
-Line 2415 
 namespace {
+Line 2457 
 namespace {
              else
                  _3lnk->SetPos(44);
-             // load sample references
+             // load sample references (if auto loading is enabled)
-             for (uint i = 0; i < DimensionRegions; i++) {
+             if (file->GetAutoLoad()) {
-                 uint32_t wavepoolindex = _3lnk->ReadUint32();
+                 for (uint i = 0; i < DimensionRegions; i++) {
-                 if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
+                     uint32_t wavepoolindex = _3lnk->ReadUint32();
+                     if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
+                 }
+                 GetSample(); // load global region sample reference
              }
-             GetSample(); // load global region sample reference
          } else {
              DimensionRegions = 0;
              for (int i = 0 ; i < 8 ; i++) {
-Line 2917 
 namespace {
+Line 2961 
 namespace {
          }
          return NULL;
      }
+     /**
+      * Make a (semi) deep copy of the Region 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 Region object to be copied from
+      */
+     void Region::CopyAssign(const Region* orig) {
+         // handle base classes
+         DLS::Region::CopyAssign(orig);
+         // handle own member variables
+         for (int i = Dimensions - 1; i >= 0; --i) {
+             DeleteDimension(&pDimensionDefinitions[i]);
+         }
+         Layers = 0; // just to be sure
+         for (int i = 0; i < orig->Dimensions; i++) {
+             // we need to copy the dim definition here, to avoid the compiler
+             // complaining about const-ness issue
+             dimension_def_t def = orig->pDimensionDefinitions[i];
+             AddDimension(&def);
+         }
+         for (int i = 0; i < 256; i++) {
+             if (pDimensionRegions[i] && orig->pDimensionRegions[i]) {
+                 pDimensionRegions[i]->CopyAssign(
+                     orig->pDimensionRegions[i]
+                 );
+             }
+         }
+         Layers = orig->Layers;
+     }
+ // *************** MidiRule ***************
+ // *
+ MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {
+     _3ewg->SetPos(36);
+     Triggers = _3ewg->ReadUint8();
+     _3ewg->SetPos(40);
+     ControllerNumber = _3ewg->ReadUint8();
+     _3ewg->SetPos(46);
+     for (int i = 0 ; i < Triggers ; i++) {
+         pTriggers[i].TriggerPoint = _3ewg->ReadUint8();
+         pTriggers[i].Descending = _3ewg->ReadUint8();
+         pTriggers[i].VelSensitivity = _3ewg->ReadUint8();
+         pTriggers[i].Key = _3ewg->ReadUint8();
+         pTriggers[i].NoteOff = _3ewg->ReadUint8();
+         pTriggers[i].Velocity = _3ewg->ReadUint8();
+         pTriggers[i].OverridePedal = _3ewg->ReadUint8();
+         _3ewg->ReadUint8();
+     }
+ }
  // *************** Instrument ***************
  // *
      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {
-         static const DLS::Info::FixedStringLength fixedStringLengths[] = {
+         static const DLS::Info::string_length_t fixedStringLengths[] = {
              { CHUNK_ID_INAM, 64 },
              { CHUNK_ID_ISFT, 12 },
              { 0, 0 }
          };
-         pInfo->FixedStringLengths = fixedStringLengths;
+         pInfo->SetFixedStringLengths(fixedStringLengths);
          // Initialization
          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
-Line 2940 
 namespace {
+Line 3039 
 namespace {
          PianoReleaseMode = false;
          DimensionKeyRange.low = 0;
          DimensionKeyRange.high = 0;
+         pMidiRules = new MidiRule*[3];
+         pMidiRules[0] = NULL;
          // Loading
          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
-Line 2954 
 namespace {
+Line 3055 
 namespace {
                  PianoReleaseMode       = dimkeystart & 0x01;
                  DimensionKeyRange.low  = dimkeystart >> 1;
                  DimensionKeyRange.high = _3ewg->ReadUint8();
+                 if (_3ewg->GetSize() > 32) {
+                     // read MIDI rules
+                     int i = 0;
+                     _3ewg->SetPos(32);
+                     uint8_t id1 = _3ewg->ReadUint8();
+                     uint8_t id2 = _3ewg->ReadUint8();
+                     if (id1 == 4 && id2 == 16) {
+                         pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
+                     }
+                     //TODO: all the other types of rules
+                     pMidiRules[i] = NULL;
+                 }
              }
          }
-         if (!pRegions) pRegions = new RegionList;
+         if (pFile->GetAutoLoad()) {
-         RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
+             if (!pRegions) pRegions = new RegionList;
-         if (lrgn) {
+             RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
-             RIFF::List* rgn = lrgn->GetFirstSubList();
+             if (lrgn) {
-             while (rgn) {
+                 RIFF::List* rgn = lrgn->GetFirstSubList();
-                 if (rgn->GetListType() == LIST_TYPE_RGN) {
+                 while (rgn) {
-                     __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
+                     if (rgn->GetListType() == LIST_TYPE_RGN) {
-                     pRegions->push_back(new Region(this, rgn));
+                         __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
+                         pRegions->push_back(new Region(this, rgn));
+                     }
+                     rgn = lrgn->GetNextSubList();
                  }
-                 rgn = lrgn->GetNextSubList();
+                 // Creating Region Key Table for fast lookup
+                 UpdateRegionKeyTable();
              }
-             // Creating Region Key Table for fast lookup
-             UpdateRegionKeyTable();
          }
          __notify_progress(pProgress, 1.0f); // notify done
-Line 2988 
 namespace {
+Line 3106 
 namespace {
      }
      Instrument::~Instrument() {
+         for (int i = 0 ; pMidiRules[i] ; i++) {
+             delete pMidiRules[i];
+         }
+         delete[] pMidiRules;
      }
      /**
-Line 3102 
 namespace {
+Line 3224 
 namespace {
          UpdateRegionKeyTable();
      }
+     /**
+      * Returns a MIDI rule of the instrument.
+      *
+      * The list of MIDI rules, at least in gig v3, always contains at
+      * most two rules. The second rule can only be the DEF filter
+      * (which currently isn't supported by libgig).
+      *
+      * @param i - MIDI rule number
+      * @returns   pointer address to MIDI rule number i or NULL if there is none
+      */
+     MidiRule* Instrument::GetMidiRule(int i) {
+         return pMidiRules[i];
+     }
+     /**
+      * 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) {
+         // handle base class
+         // (without copying DLS region stuff)
+         DLS::Instrument::CopyAssignCore(orig);
+         // handle own member variables
+         Attenuation = orig->Attenuation;
+         EffectSend = orig->EffectSend;
+         FineTune = orig->FineTune;
+         PitchbendRange = orig->PitchbendRange;
+         PianoReleaseMode = orig->PianoReleaseMode;
+         DimensionKeyRange = orig->DimensionKeyRange;
+         // free old midi rules
+         for (int i = 0 ; pMidiRules[i] ; i++) {
+             delete pMidiRules[i];
+         }
+         //TODO: MIDI rule copying
+         pMidiRules[0] = NULL;
+         // delete all old regions
+         while (Regions) DeleteRegion(GetFirstRegion());
+         // create new regions and copy them from original
+         {
+             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(
+                     static_cast<gig::Region*>(*it)
+                 );
+             }
+         }
+         UpdateRegionKeyTable();
+     }
  // *************** Group ***************
-Line 3237 
 namespace {
+Line 3418 
 namespace {
 , 3, 20030331 & 0xffff, 20030331 >> 16
      };
-     const DLS::Info::FixedStringLength File::FixedStringLengths[] = {
+     static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
          { CHUNK_ID_IARL, 256 },
          { CHUNK_ID_IART, 128 },
          { CHUNK_ID_ICMS, 128 },
-Line 3259 
 namespace {
+Line 3440 
 namespace {
      };
      File::File() : DLS::File() {
+         bAutoLoad = true;
          *pVersion = VERSION_3;
          pGroups = NULL;
-         pInfo->FixedStringLengths = FixedStringLengths;
+         pInfo->SetFixedStringLengths(_FileFixedStringLengths);
          pInfo->ArchivalLocation = String(256, ' ');
          // add some mandatory chunks to get the file chunks in right
-Line 3274 
 namespace {
+Line 3456 
 namespace {
      }
      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
+         bAutoLoad = true;
          pGroups = NULL;
-         pInfo->FixedStringLengths = FixedStringLengths;
+         pInfo->SetFixedStringLengths(_FileFixedStringLengths);
      }
      File::~File() {
-Line 3343 
 namespace {
+Line 3526 
 namespace {
          pSamples->erase(iter);
          delete pSample;
+         SampleList::iterator tmp = SamplesIterator;
          // remove all references to the sample
          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
               instrument = GetNextInstrument()) {
-Line 3357 
 namespace {
+Line 3541 
 namespace {
                  }
              }
          }
+         SamplesIterator = tmp; // restore iterator
      }
      void File::LoadSamples() {
-Line 3447 
 namespace {
+Line 3632 
 namespace {
              progress_t subprogress;
              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
              __notify_progress(&subprogress, 0.0f);
-             GetFirstSample(&subprogress); // now force all samples to be loaded
+             if (GetAutoLoad())
+                 GetFirstSample(&subprogress); // now force all samples to be loaded
              __notify_progress(&subprogress, 1.0f);
              // instrument loading subtask
-Line 3496 
 namespace {
+Line 3682 
 namespace {
         pInstruments->push_back(pInstrument);
         return pInstrument;
      }
+     /** @brief Add a duplicate of an existing instrument.
+      *
+      * Duplicates the instrument definition given by @a orig and adds it
+      * to this file. This allows in an instrument editor application to
+      * easily create variations of an instrument, which will be stored in
+      * the same .gig file, sharing i.e. the same samples.
+      *
+      * Note that all sample pointers referenced by @a orig are simply copied as
+      * memory address. Thus the respective samples are shared, not duplicated!
+      *
+      * You have to call Save() to make this persistent to the file.
+      *
+      * @param orig - original instrument to be copied
+      * @returns duplicated copy of the given instrument
+      */
+     Instrument* File::AddDuplicateInstrument(const Instrument* orig) {
+         Instrument* instr = AddInstrument();
+         instr->CopyAssign(orig);
+         return instr;
+     }
      /** @brief Delete an instrument.
       *
-Line 3854 
 namespace {
+Line 4061 
 namespace {
          }
      }
+     /**
+      * Enable / disable automatic loading. By default this properyt is
+      * enabled and all informations are loaded automatically. However
+      * loading all Regions, DimensionRegions and especially samples might
+      * take a long time for large .gig files, and sometimes one might only
+      * be interested in retrieving very superficial informations like the
+      * amount of instruments and their names. In this case one might disable
+      * automatic loading to avoid very slow response times.
+      *
+      * @e CAUTION: by disabling this property many pointers (i.e. sample
+      * references) and informations will have invalid or even undefined
+      * data! This feature is currently only intended for retrieving very
+      * superficial informations in a very fast way. Don't use it to retrieve
+      * details like synthesis informations or even to modify .gig files!
+      */
+     void File::SetAutoLoad(bool b) {
+         bAutoLoad = b;
+     }
+     /**
+      * Returns whether automatic loading is enabled.
+      * @see SetAutoLoad()
+      */
+     bool File::GetAutoLoad() {
+         return bAutoLoad;
+     }
  // *************** Exception ***************

 Legend:



Removed from v.1384
 


changed lines


 
Added in v.2394
 Legend:



Removed from v.1384
 


changed lines


 
Added in v.2394
-Removed from v.1384
+Added in v.2394

	ViewVC Help
Powered by ViewVC