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

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

Parent Directory | Revision Log | View Patch Patch

-revision 928 by persson,
Tue Oct 24 19:32:47 2006 UTC
+revision 1106 by schoenebeck,
Sun Mar 18 19:38:47 2007 UTC
 Line 1
  /***************************************************************************
   *                                                                         *
-  *   libgig - C++ cross-platform Gigasampler format file loader library    *
+  *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2005 by Christian Schoenebeck                      *
+  *   Copyright (C) 2003-2007 by Christian Schoenebeck                      *
   *                              <cuse@users.sourceforge.net>               *
   *                                                                         *
   *   This library is free software; you can redistribute it and/or modify  *
 Line 285 
 namespace {
          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
          if (pCk3gix) {
-             SampleGroup = pCk3gix->ReadInt16();
+             uint16_t iSampleGroup = pCk3gix->ReadInt16();
+             pGroup = pFile->GetGroup(iSampleGroup);
          } else { // '3gix' chunk missing
-             // use default value(s)
+             // by default assigned to that mandatory "Default Group"
-             SampleGroup = 0;
+             pGroup = pFile->GetGroup(0);
          }
          pCkSmpl = waveList->GetSubChunk(CHUNK_ID_SMPL);
-Line 363 
 namespace {
+Line 364 
 namespace {
       * Usually there is absolutely no need to call this method explicitly.
       * It will be called automatically when File::Save() was called.
       *
-      * @throws DLS::Exception if FormatTag != WAVE_FORMAT_PCM or no sample data
+      * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
       *                        was provided yet
       * @throws gig::Exception if there is any invalid sample setting
       */
-Line 398 
 namespace {
+Line 399 
 namespace {
          // make sure '3gix' chunk exists
          pCk3gix = pWaveList->GetSubChunk(CHUNK_ID_3GIX);
          if (!pCk3gix) pCk3gix = pWaveList->AddSubChunk(CHUNK_ID_3GIX, 4);
+         // determine appropriate sample group index (to be stored in chunk)
+         uint16_t iSampleGroup = 0; // 0 refers to default sample group
+         File* pFile = static_cast<File*>(pParent);
+         if (pFile->pGroups) {
+             std::list<Group*>::iterator iter = pFile->pGroups->begin();
+             std::list<Group*>::iterator end  = pFile->pGroups->end();
+             for (int i = 0; iter != end; i++, iter++) {
+                 if (*iter == pGroup) {
+                     iSampleGroup = i;
+                     break; // found
+                 }
+             }
+         }
          // update '3gix' chunk
          pData = (uint8_t*) pCk3gix->LoadChunkData();
-         memcpy(&pData[0], &SampleGroup, 2);
+         memcpy(&pData[0], &iSampleGroup, 2);
      }
      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
-Line 621 
 namespace {
+Line 635 
 namespace {
       * enlarged samples before calling File::Save() as this might exceed the
       * current sample's boundary!
       *
-      * Also note: only WAVE_FORMAT_PCM is currently supported, that is
+      * Also note: only DLS_WAVE_FORMAT_PCM is currently supported, that is
-      * FormatTag must be WAVE_FORMAT_PCM. Trying to resize samples with
+      * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
       * other formats will fail!
       *
       * @param iNewSize - new sample wave data size in sample points (must be
       *                   greater than zero)
-      * @throws DLS::Excecption if FormatTag != WAVE_FORMAT_PCM
+      * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
       *                         or if \a iNewSize is less than 1
       * @throws gig::Exception if existing sample is compressed
       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
-Line 1138 
 namespace {
+Line 1152 
 namespace {
          }
      }
+     /**
+      * Returns pointer to the Group this Sample belongs to. In the .gig
+      * format a sample always belongs to one group. If it wasn't explicitly
+      * assigned to a certain group, it will be automatically assigned to a
+      * default group.
+      *
+      * @returns Sample's Group (never NULL)
+      */
+     Group* Sample::GetGroup() const {
+         return pGroup;
+     }
      Sample::~Sample() {
          Instances--;
          if (!Instances && InternalDecompressionBuffer.Size) {
-Line 1312 
 namespace {
+Line 1338 
 namespace {
                  if (lfo3ctrl & 0x40) // bit 6
                      VCFType = vcf_type_lowpassturbo;
              }
+             if (_3ewa->RemainingBytes() >= 8) {
+                 _3ewa->Read(DimensionUpperLimits, 1, 8);
+             } else {
+                 memset(DimensionUpperLimits, 0, 8);
+             }
          } else { // '3ewa' chunk does not exist yet
              // use default values
              LFO3Frequency                   = 1.0;
-Line 1392 
 namespace {
+Line 1423 
 namespace {
              VCFVelocityDynamicRange         = 0x04;
              VCFVelocityCurve                = curve_type_linear;
              VCFType                         = vcf_type_lowpass;
+             memset(DimensionUpperLimits, 0, 8);
          }
          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
-Line 1447 
 namespace {
+Line 1479 
 namespace {
          // update '3ewa' chunk with DimensionRegion's current settings
-         const uint32_t unknown = _3ewa->GetSize(); // unknown, always chunk size ?
+         const uint32_t chunksize = _3ewa->GetSize();
-         memcpy(&pData[0], &unknown, 4);
+         memcpy(&pData[0], &chunksize, 4); // unknown, always chunk size?
          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
          memcpy(&pData[4], &lfo3freq, 4);
-Line 1703 
 namespace {
+Line 1735 
 namespace {
          const uint8_t vcftype = (VCFType == vcf_type_lowpassturbo) ? vcf_type_lowpass : VCFType;
          memcpy(&pData[139], &vcftype, 1);
+         if (chunksize >= 148) {
+             memcpy(&pData[140], DimensionUpperLimits, 8);
+         }
      }
      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
-Line 2084 
 namespace {
+Line 2120 
 namespace {
                                                             dimension == dimension_releasetrigger ||
                                                             dimension == dimension_keyboard ||
                                                             dimension == dimension_roundrobin ||
-                                                            dimension == dimension_random) ? split_type_bit
+                                                            dimension == dimension_random ||
-                                                                                           : split_type_normal;
+                                                            dimension == dimension_smartmidi ||
+                                                            dimension == dimension_roundrobinkeyboard) ? split_type_bit
+                                                                                                       : split_type_normal;
                      pDimensionDefinitions[i].zone_size  =
                          (pDimensionDefinitions[i].split_type == split_type_normal) ? 128.0 / pDimensionDefinitions[i].zones
                                                                                     : 0;
-Line 2114 
 namespace {
+Line 2152 
 namespace {
                  if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
              }
              GetSample(); // load global region sample reference
+         } else {
+             DimensionRegions = 0;
          }
          // make sure there is at least one dimension region
-Line 2136 
 namespace {
+Line 2176 
 namespace {
       * @throws gig::Exception if samples cannot be dereferenced
       */
      void Region::UpdateChunks() {
+         // in the gig format we don't care about the Region's sample reference
+         // but we still have to provide some existing one to not corrupt the
+         // file, so to avoid the latter we simply always assign the sample of
+         // the first dimension region of this region
+         pSample = pDimensionRegions[0]->pSample;
          // first update base class's chunks
          DLS::Region::UpdateChunks();
-Line 2222 
 namespace {
+Line 2268 
 namespace {
          int dim[8] = { 0 };
          for (int i = 0 ; i < DimensionRegions ; i++) {
-             if (pDimensionRegions[i]->VelocityUpperLimit) {
+             if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
+                 pDimensionRegions[i]->VelocityUpperLimit) {
                  // create the velocity table
                  uint8_t* table = pDimensionRegions[i]->VelocityTable;
                  if (!table) {
-Line 2231 
 namespace {
+Line 2278 
 namespace {
                  }
                  int tableidx = 0;
                  int velocityZone = 0;
-                 for (int k = i ; k < end ; k += step) {
+                 if (pDimensionRegions[i]->DimensionUpperLimits[veldim]) { // gig3
-                     DimensionRegion *d = pDimensionRegions[k];
+                     for (int k = i ; k < end ; k += step) {
-                     for (; tableidx <= d->VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
+                         DimensionRegion *d = pDimensionRegions[k];
-                     velocityZone++;
+                         for (; tableidx <= d->DimensionUpperLimits[veldim] ; tableidx++) table[tableidx] = velocityZone;
+                         velocityZone++;
+                     }
+                 } else { // gig2
+                     for (int k = i ; k < end ; k += step) {
+                         DimensionRegion *d = pDimensionRegions[k];
+                         for (; tableidx <= d->VelocityUpperLimit ; tableidx++) table[tableidx] = velocityZone;
+                         velocityZone++;
+                     }
                  }
              } else {
                  if (pDimensionRegions[i]->VelocityTable) {
-Line 2429 
 namespace {
+Line 2484 
 namespace {
              } else {
                  switch (pDimensionDefinitions[i].split_type) {
                      case split_type_normal:
-                         bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
+                         if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
+                             // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
+                             for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
+                                 if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
+                             }
+                         } else {
+                             // gig2: evenly sized zones
+                             bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
+                         }
                          break;
                      case split_type_bit: // the value is already the sought dimension bit number
                          const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
-Line 2443 
 namespace {
+Line 2506 
 namespace {
          DimensionRegion* dimreg = pDimensionRegions[dimregidx];
          if (veldim != -1) {
              // (dimreg is now the dimension region for the lowest velocity)
-             if (dimreg->VelocityUpperLimit) // custom defined zone ranges
+             if (dimreg->VelocityTable) // custom defined zone ranges
                  bits = dimreg->VelocityTable[DimValues[veldim]];
              else // normal split type
                  bits = uint8_t(DimValues[veldim] / pDimensionDefinitions[veldim].zone_size);
-Line 2669 
 namespace {
+Line 2732 
 namespace {
+ // *************** Group ***************
+ // *
+     /** @brief Constructor.
+      *
+      * @param file   - pointer to the gig::File object
+      * @param ck3gnm - pointer to 3gnm chunk associated with this group or
+      *                 NULL if this is a new Group
+      */
+     Group::Group(File* file, RIFF::Chunk* ck3gnm) {
+         pFile      = file;
+         pNameChunk = ck3gnm;
+         ::LoadString(pNameChunk, Name);
+     }
+     Group::~Group() {
+         // remove the chunk associated with this group (if any)
+         if (pNameChunk) pNameChunk->GetParent()->DeleteSubChunk(pNameChunk);
+     }
+     /** @brief Update chunks with current group settings.
+      *
+      * Apply current Group field values to the respective chunks. You have
+      * to call File::Save() to make changes persistent.
+      *
+      * Usually there is absolutely no need to call this method explicitly.
+      * It will be called automatically when File::Save() was called.
+      */
+     void Group::UpdateChunks() {
+         // make sure <3gri> and <3gnl> list chunks exist
+         RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
+         if (!_3gri) _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);
+         RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
+         if (!_3gnl) _3gnl = pFile->pRIFF->AddSubList(LIST_TYPE_3GNL);
+         // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
+         ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
+     }
+     /**
+      * Returns the first Sample of this Group. You have to call this method
+      * once before you use GetNextSample().
+      *
+      * <b>Notice:</b> this method might block for a long time, in case the
+      * samples of this .gig file were not scanned yet
+      *
+      * @returns  pointer address to first Sample or NULL if there is none
+      *           applied to this Group
+      * @see      GetNextSample()
+      */
+     Sample* Group::GetFirstSample() {
+         // FIXME: lazy und unsafe implementation, should be an autonomous iterator
+         for (Sample* pSample = pFile->GetFirstSample(); pSample; pSample = pFile->GetNextSample()) {
+             if (pSample->GetGroup() == this) return pSample;
+         }
+         return NULL;
+     }
+     /**
+      * Returns the next Sample of the Group. You have to call
+      * GetFirstSample() once before you can use this method. By calling this
+      * method multiple times it iterates through the Samples assigned to
+      * this Group.
+      *
+      * @returns  pointer address to the next Sample of this Group or NULL if
+      *           end reached
+      * @see      GetFirstSample()
+      */
+     Sample* Group::GetNextSample() {
+         // FIXME: lazy und unsafe implementation, should be an autonomous iterator
+         for (Sample* pSample = pFile->GetNextSample(); pSample; pSample = pFile->GetNextSample()) {
+             if (pSample->GetGroup() == this) return pSample;
+         }
+         return NULL;
+     }
+     /**
+      * Move Sample given by \a pSample from another Group to this Group.
+      */
+     void Group::AddSample(Sample* pSample) {
+         pSample->pGroup = this;
+     }
+     /**
+      * Move all members of this group to another group (preferably the 1st
+      * one except this). This method is called explicitly by
+      * File::DeleteGroup() thus when a Group was deleted. This code was
+      * intentionally not placed in the destructor!
+      */
+     void Group::MoveAll() {
+         // get "that" other group first
+         Group* pOtherGroup = NULL;
+         for (pOtherGroup = pFile->GetFirstGroup(); pOtherGroup; pOtherGroup = pFile->GetNextGroup()) {
+             if (pOtherGroup != this) break;
+         }
+         if (!pOtherGroup) throw Exception(
+             "Could not move samples to another group, since there is no "
+             "other Group. This is a bug, report it!"
+         );
+         // now move all samples of this group to the other group
+         for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
+             pOtherGroup->AddSample(pSample);
+         }
+     }
  // *************** File ***************
  // *
      File::File() : DLS::File() {
+         pGroups = NULL;
          pInfo->UseFixedLengthStrings = true;
      }
      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
+         pGroups = NULL;
          pInfo->UseFixedLengthStrings = true;
      }
+     File::~File() {
+         if (pGroups) {
+             std::list<Group*>::iterator iter = pGroups->begin();
+             std::list<Group*>::iterator end  = pGroups->end();
+             while (iter != end) {
+                 delete *iter;
+                 ++iter;
+             }
+             delete pGroups;
+         }
+     }
      Sample* File::GetFirstSample(progress_t* pProgress) {
          if (!pSamples) LoadSamples(pProgress);
          if (!pSamples) return NULL;
-Line 2723 
 namespace {
+Line 2906 
 namespace {
          if (!pSamples || !pSamples->size()) throw gig::Exception("Could not delete sample as there are no samples");
          SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), (DLS::Sample*) pSample);
          if (iter == pSamples->end()) throw gig::Exception("Could not delete sample, could not find given sample");
+         if (SamplesIterator != pSamples->end() && *SamplesIterator == pSample) ++SamplesIterator; // avoid iterator invalidation
          pSamples->erase(iter);
          delete pSample;
      }
-Line 2732 
 namespace {
+Line 2916 
 namespace {
      }
      void File::LoadSamples(progress_t* pProgress) {
+         // Groups must be loaded before samples, because samples will try
+         // to resolve the group they belong to
+         LoadGroups();
          if (!pSamples) pSamples = new SampleList;
          RIFF::File* file = pRIFF;
-Line 2855 
 namespace {
+Line 3043 
 namespace {
       * have to call Save() to make this persistent to the file.
       *
       * @param pInstrument - instrument to delete
-      * @throws gig::Excption if given instrument could not be found
+      * @throws gig::Exception if given instrument could not be found
       */
      void File::DeleteInstrument(Instrument* pInstrument) {
          if (!pInstruments) throw gig::Exception("Could not delete instrument as there are no instruments");
-Line 2895 
 namespace {
+Line 3083 
 namespace {
          }
      }
+     Group* File::GetFirstGroup() {
+         if (!pGroups) LoadGroups();
+         // there must always be at least one group
+         GroupsIterator = pGroups->begin();
+         return *GroupsIterator;
+     }
+     Group* File::GetNextGroup() {
+         if (!pGroups) return NULL;
+         ++GroupsIterator;
+         return (GroupsIterator == pGroups->end()) ? NULL : *GroupsIterator;
+     }
+     /**
+      * Returns the group with the given index.
+      *
+      * @param index - number of the sought group (0..n)
+      * @returns sought group or NULL if there's no such group
+      */
+     Group* File::GetGroup(uint index) {
+         if (!pGroups) LoadGroups();
+         GroupsIterator = pGroups->begin();
+         for (uint i = 0; GroupsIterator != pGroups->end(); i++) {
+             if (i == index) return *GroupsIterator;
+             ++GroupsIterator;
+         }
+         return NULL;
+     }
+     Group* File::AddGroup() {
+         if (!pGroups) LoadGroups();
+         // there must always be at least one group
+         __ensureMandatoryChunksExist();
+         Group* pGroup = new Group(this, NULL);
+         pGroups->push_back(pGroup);
+         return pGroup;
+     }
+     /** @brief Delete a group and its samples.
+      *
+      * This will delete the given Group object and all the samples that
+      * belong to this group from the gig file. You have to call Save() to
+      * make this persistent to the file.
+      *
+      * @param pGroup - group to delete
+      * @throws gig::Exception if given group could not be found
+      */
+     void File::DeleteGroup(Group* pGroup) {
+         if (!pGroups) LoadGroups();
+         std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
+         if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
+         if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
+         // delete all members of this group
+         for (Sample* pSample = pGroup->GetFirstSample(); pSample; pSample = pGroup->GetNextSample()) {
+             DeleteSample(pSample);
+         }
+         // now delete this group object
+         pGroups->erase(iter);
+         delete pGroup;
+     }
+     /** @brief Delete a group.
+      *
+      * This will delete the given Group object from the gig file. All the
+      * samples that belong to this group will not be deleted, but instead
+      * be moved to another group. You have to call Save() to make this
+      * persistent to the file.
+      *
+      * @param pGroup - group to delete
+      * @throws gig::Exception if given group could not be found
+      */
+     void File::DeleteGroupOnly(Group* pGroup) {
+         if (!pGroups) LoadGroups();
+         std::list<Group*>::iterator iter = find(pGroups->begin(), pGroups->end(), pGroup);
+         if (iter == pGroups->end()) throw gig::Exception("Could not delete group, could not find given group");
+         if (pGroups->size() == 1) throw gig::Exception("Cannot delete group, there must be at least one default group!");
+         // move all members of this group to another group
+         pGroup->MoveAll();
+         pGroups->erase(iter);
+         delete pGroup;
+     }
+     void File::LoadGroups() {
+         if (!pGroups) pGroups = new std::list<Group*>;
+         // try to read defined groups from file
+         RIFF::List* lst3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
+         if (lst3gri) {
+             RIFF::List* lst3gnl = lst3gri->GetSubList(LIST_TYPE_3GNL);
+             if (lst3gnl) {
+                 RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
+                 while (ck) {
+                     if (ck->GetChunkID() == CHUNK_ID_3GNM) {
+                         pGroups->push_back(new Group(this, ck));
+                     }
+                     ck = lst3gnl->GetNextSubChunk();
+                 }
+             }
+         }
+         // if there were no group(s), create at least the mandatory default group
+         if (!pGroups->size()) {
+             Group* pGroup = new Group(this, NULL);
+             pGroup->Name = "Default Group";
+             pGroups->push_back(pGroup);
+         }
+     }
+     /**
+      * Apply all the gig file's current instruments, samples, groups and settings
+      * to the respective RIFF chunks. You have to call Save() to make changes
+      * persistent.
+      *
+      * Usually there is absolutely no need to call this method explicitly.
+      * It will be called automatically when File::Save() was called.
+      *
+      * @throws Exception - on errors
+      */
+     void File::UpdateChunks() {
+         // first update base class's chunks
+         DLS::File::UpdateChunks();
+         // update group's chunks
+         if (pGroups) {
+             std::list<Group*>::iterator iter = pGroups->begin();
+             std::list<Group*>::iterator end  = pGroups->end();
+             for (; iter != end; ++iter) {
+                 (*iter)->UpdateChunks();
+             }
+         }
+     }
  // *************** Exception ***************

 Legend:



Removed from v.928
 


changed lines


 
Added in v.1106
 Legend:



Removed from v.928
 


changed lines


 
Added in v.1106
-Removed from v.928
+Added in v.1106

	ViewVC Help
Powered by ViewVC