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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1627 by persson,
Sun Jan  6 10:53:53 2008 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 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 2921 
 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 ***************
-Line 2965 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3039 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
          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 2982 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3058 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
                  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) {
-                         MidiRules.push_back(new MidiRuleCtrlTrigger(_3ewg));
+                         pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
                      }
                      //TODO: all the other types of rules
+                     pMidiRules[i] = NULL;
                  }
              }
          }
-Line 3027 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3106 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
      }
      Instrument::~Instrument() {
+         for (int i = 0 ; pMidiRules[i] ; i++) {
+             delete pMidiRules[i];
+         }
+         delete[] pMidiRules;
      }
      /**
-Line 3142 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3225 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
      }
      /**
-      * Returns the first MIDI rule of the instrument. You have to call
+      * Returns a MIDI rule of the instrument.
-      * this method once before you use GetNextMidiRule().
       *
       * 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).
       *
-      * @returns  pointer address to first MIDI rule or NULL if there is none
+      * @param i - MIDI rule number
-      * @see      GetNextMidiRule()
+      * @returns   pointer address to MIDI rule number i or NULL if there is none
       */
-     MidiRule* Instrument::GetFirstMidiRule() {
+     MidiRule* Instrument::GetMidiRule(int i) {
-         MidiRulesIterator = MidiRules.begin();
+         return pMidiRules[i];
-         return MidiRulesIterator != MidiRules.end() ? *MidiRulesIterator : NULL;
      }
      /**
-      * Returns the next MIDI rule of the instrument. You have to call
+      * Make a (semi) deep copy of the Instrument object given by @a orig
-      * GetFirstMidiRule() once before you can use this method. By
+      * and assign it to this object.
-      * calling this method multiple times it iterates through the
+      *
-      * available rules.
+      * Note that all sample pointers referenced by @a orig are simply copied as
-      *
+      * memory address. Thus the respective samples are shared, not duplicated!
-      * @returns  pointer address to the next MIDI rule or NULL if end reached
+      *
-      * @see      GetFirstMidiRule()
+      * @param orig - original Instrument object to be copied from
       */
-     MidiRule* Instrument::GetNextMidiRule() {
+     void Instrument::CopyAssign(const Instrument* orig) {
-         MidiRulesIterator++;
+         // handle base class
-         return MidiRulesIterator != MidiRules.end() ? *MidiRulesIterator : NULL;
+         // (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();
      }
-Line 3413 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3526 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
          pSamples->erase(iter);
          delete pSample;
+         SampleList::iterator tmp = SamplesIterator;
          // remove all references to the sample
          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
               instrument = GetNextInstrument()) {
-Line 3427 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3541 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
                  }
              }
          }
+         SamplesIterator = tmp; // restore iterator
      }
      void File::LoadSamples() {
-Line 3567 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
+Line 3682 
 MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
         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.
       *

 Legend:



Removed from v.1627
 


changed lines


 
Added in v.2394
 Legend:



Removed from v.1627
 


changed lines


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

	ViewVC Help
Powered by ViewVC