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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1050 by schoenebeck,
Fri Mar  2 01:04:45 2007 UTC
+revision 1106 by schoenebeck,
Sun Mar 18 19:38:47 2007 UTC
 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 1418 
 namespace {
+Line 1423 
 namespace {
              VCFVelocityDynamicRange         = 0x04;
              VCFVelocityCurve                = curve_type_linear;
              VCFType                         = vcf_type_lowpass;
+             memset(DimensionUpperLimits, 0, 8);
          }
          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
-Line 1473 
 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 1729 
 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 2110 
 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 2140 
 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 2162 
 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 2248 
 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 2257 
 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 2455 
 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 2469 
 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 2711 
 namespace {
+Line 2748 
 namespace {
      }
      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. You have to call
+      * Apply current Group field values to the respective chunks. You have
-      * File::Save() to make changes persistent.
+      * 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
-Line 2864 
 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 3000 
 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 3078 
 namespace {
+Line 3121 
 namespace {
          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);
-Line 3113 
 namespace {
+Line 3189 
 namespace {
          }
      }
+     /**
+      * 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.1050
 


changed lines


 
Added in v.1106
 Legend:



Removed from v.1050
 


changed lines


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

	ViewVC Help
Powered by ViewVC