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

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

Parent Directory | Revision Log | View Patch Patch

-revision 2543 by schoenebeck,
Sat May 10 02:06:58 2014 UTC
+revision 2640 by schoenebeck,
Mon Jun 16 14:54:06 2014 UTC
 Line 28
  #include <algorithm>
  #include <math.h>
  #include <iostream>
+ #include <assert.h>
  /// Initial size of the sample buffer which is used for decompression of
  /// compressed sample wave streams - this value should always be bigger than
-Line 1708 
 namespace {
+Line 1709 
 namespace {
          //NOTE: copy code copied from assignment constructor above, see comment there as well
          *this = *orig; // default memberwise shallow copy of all parameters
+         // restore members that shall not be altered
          pParentList = p; // restore the chunk pointer
+         pRegion = pOriginalRegion;
-         // only take the raw sample reference & parent region reference if the
+         // only take the raw sample reference reference if the
          // two DimensionRegion objects are part of the same file
          if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {
-             pRegion = pOriginalRegion;
              pSample = pOriginalSample;
          }
-Line 3053 
 namespace {
+Line 3056 
 namespace {
              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
              // move 3prg to last position
-             pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), 0);
+             pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), (RIFF::Chunk*)NULL);
          }
          // update dimension definitions in '3lnk' chunk
-Line 3199 
 namespace {
+Line 3202 
 namespace {
       *                        dimension bits limit is violated
       */
      void Region::AddDimension(dimension_def_t* pDimDef) {
+         // some initial sanity checks of the given dimension definition
+         if (pDimDef->zones < 2)
+             throw gig::Exception("Could not add new dimension, amount of requested zones must always be at least two");
+         if (pDimDef->bits < 1)
+             throw gig::Exception("Could not add new dimension, amount of requested requested zone bits must always be at least one");
+         if (pDimDef->dimension == dimension_samplechannel) {
+             if (pDimDef->zones != 2)
+                 throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
+             if (pDimDef->bits != 1)
+                 throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
+         }
          // check if max. amount of dimensions reached
          File* file = (File*) GetParent()->GetParent();
          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
-Line 3374 
 namespace {
+Line 3389 
 namespace {
          if (pDimDef->dimension == dimension_layer) Layers = 1;
      }
+     /** @brief Delete one split zone of a dimension (decrement zone amount).
+      *
+      * Instead of deleting an entire dimensions, this method will only delete
+      * one particular split zone given by @a zone of the Region's dimension
+      * given by @a type. So this method will simply decrement the amount of
+      * zones by one of the dimension in question. To be able to do that, the
+      * respective dimension must exist on this Region and it must have at least
+      * 3 zones. All DimensionRegion objects associated with the zone will be
+      * deleted.
+      *
+      * @param type - identifies the dimension where a zone shall be deleted
+      * @param zone - index of the dimension split zone that shall be deleted
+      * @throws gig::Exception if requested zone could not be deleted
+      */
+     void Region::DeleteDimensionZone(dimension_t type, int zone) {
+         dimension_def_t* oldDef = GetDimensionDefinition(type);
+         if (!oldDef)
+             throw gig::Exception("Could not delete dimension zone, no such dimension of given type");
+         if (oldDef->zones <= 2)
+             throw gig::Exception("Could not delete dimension zone, because it would end up with only one zone.");
+         if (zone < 0 || zone >= oldDef->zones)
+             throw gig::Exception("Could not delete dimension zone, requested zone index out of bounds.");
+         const int newZoneSize = oldDef->zones - 1;
+         // create a temporary Region which just acts as a temporary copy
+         // container and will be deleted at the end of this function and will
+         // also not be visible through the API during this process
+         gig::Region* tempRgn = NULL;
+         {
+             // adding these temporary chunks is probably not even necessary
+             Instrument* instr = static_cast<Instrument*>(GetParent());
+             RIFF::List* pCkInstrument = instr->pCkInstrument;
+             RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
+             if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
+             RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
+             tempRgn = new Region(instr, rgn);
+         }
+         // copy this region's dimensions (with already the dimension split size
+         // requested by the arguments of this method call) to the temporary
+         // region, and don't use Region::CopyAssign() here for this task, since
+         // it would also alter fast lookup helper variables here and there
+         dimension_def_t newDef;
+         for (int i = 0; i < Dimensions; ++i) {
+             dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
+             // is this the dimension requested by the method arguments? ...
+             if (def.dimension == type) { // ... if yes, decrement zone amount by one
+                 def.zones = newZoneSize;
+                 if ((1 << (def.bits - 1)) == def.zones) def.bits--;
+                 newDef = def;
+             }
+             tempRgn->AddDimension(&def);
+         }
+         // find the dimension index in the tempRegion which is the dimension
+         // type passed to this method (paranoidly expecting different order)
+         int tempReducedDimensionIndex = -1;
+         for (int d = 0; d < tempRgn->Dimensions; ++d) {
+             if (tempRgn->pDimensionDefinitions[d].dimension == type) {
+                 tempReducedDimensionIndex = d;
+                 break;
+             }
+         }
+         // copy dimension regions from this region to the temporary region
+         for (int iDst = 0; iDst < 256; ++iDst) {
+             DimensionRegion* dstDimRgn = tempRgn->pDimensionRegions[iDst];
+             if (!dstDimRgn) continue;
+             std::map<dimension_t,int> dimCase;
+             bool isValidZone = true;
+             for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
+                 const int dstBits = tempRgn->pDimensionDefinitions[d].bits;
+                 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
+                     (iDst >> baseBits) & ((1 << dstBits) - 1);
+                 baseBits += dstBits;
+                 // there are also DimensionRegion objects of unused zones, skip them
+                 if (dimCase[tempRgn->pDimensionDefinitions[d].dimension] >= tempRgn->pDimensionDefinitions[d].zones) {
+                     isValidZone = false;
+                     break;
+                 }
+             }
+             if (!isValidZone) continue;
+             // a bit paranoid: cope with the chance that the dimensions would
+             // have different order in source and destination regions
+             const bool isLastZone = (dimCase[type] == newZoneSize - 1);
+             if (dimCase[type] >= zone) dimCase[type]++;
+             DimensionRegion* srcDimRgn = GetDimensionRegionByBit(dimCase);
+             dstDimRgn->CopyAssign(srcDimRgn);
+             // if this is the upper most zone of the dimension passed to this
+             // method, then correct (raise) its upper limit to 127
+             if (newDef.split_type == split_type_normal && isLastZone)
+                 dstDimRgn->DimensionUpperLimits[tempReducedDimensionIndex] = 127;
+         }
+         // now tempRegion's dimensions and DimensionRegions basically reflect
+         // what we wanted to get for this actual Region here, so we now just
+         // delete and recreate the dimension in question with the new amount
+         // zones and then copy back from tempRegion
+         DeleteDimension(oldDef);
+         AddDimension(&newDef);
+         for (int iSrc = 0; iSrc < 256; ++iSrc) {
+             DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
+             if (!srcDimRgn) continue;
+             std::map<dimension_t,int> dimCase;
+             for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
+                 const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
+                 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
+                     (iSrc >> baseBits) & ((1 << srcBits) - 1);
+                 baseBits += srcBits;
+             }
+             // a bit paranoid: cope with the chance that the dimensions would
+             // have different order in source and destination regions
+             DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
+             if (!dstDimRgn) continue;
+             dstDimRgn->CopyAssign(srcDimRgn);
+         }
+         // delete temporary region
+         delete tempRgn;
+         UpdateVelocityTable();
+     }
+     /** @brief Divide split zone of a dimension in two (increment zone amount).
+      *
+      * This will increment the amount of zones for the dimension (given by
+      * @a type) by one. It will do so by dividing the zone (given by @a zone)
+      * in the middle of its zone range in two. So the two zones resulting from
+      * the zone being splitted, will be an equivalent copy regarding all their
+      * articulation informations and sample reference. The two zones will only
+      * differ in their zone's upper limit
+      * (DimensionRegion::DimensionUpperLimits).
+      *
+      * @param type - identifies the dimension where a zone shall be splitted
+      * @param zone - index of the dimension split zone that shall be splitted
+      * @throws gig::Exception if requested zone could not be splitted
+      */
+     void Region::SplitDimensionZone(dimension_t type, int zone) {
+         dimension_def_t* oldDef = GetDimensionDefinition(type);
+         if (!oldDef)
+             throw gig::Exception("Could not split dimension zone, no such dimension of given type");
+         if (zone < 0 || zone >= oldDef->zones)
+             throw gig::Exception("Could not split dimension zone, requested zone index out of bounds.");
+         const int newZoneSize = oldDef->zones + 1;
+         // create a temporary Region which just acts as a temporary copy
+         // container and will be deleted at the end of this function and will
+         // also not be visible through the API during this process
+         gig::Region* tempRgn = NULL;
+         {
+             // adding these temporary chunks is probably not even necessary
+             Instrument* instr = static_cast<Instrument*>(GetParent());
+             RIFF::List* pCkInstrument = instr->pCkInstrument;
+             RIFF::List* lrgn = pCkInstrument->GetSubList(LIST_TYPE_LRGN);
+             if (!lrgn)  lrgn = pCkInstrument->AddSubList(LIST_TYPE_LRGN);
+             RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
+             tempRgn = new Region(instr, rgn);
+         }
+         // copy this region's dimensions (with already the dimension split size
+         // requested by the arguments of this method call) to the temporary
+         // region, and don't use Region::CopyAssign() here for this task, since
+         // it would also alter fast lookup helper variables here and there
+         dimension_def_t newDef;
+         for (int i = 0; i < Dimensions; ++i) {
+             dimension_def_t def = pDimensionDefinitions[i]; // copy, don't reference
+             // is this the dimension requested by the method arguments? ...
+             if (def.dimension == type) { // ... if yes, increment zone amount by one
+                 def.zones = newZoneSize;
+                 if ((1 << oldDef->bits) < newZoneSize) def.bits++;
+                 newDef = def;
+             }
+             tempRgn->AddDimension(&def);
+         }
+         // find the dimension index in the tempRegion which is the dimension
+         // type passed to this method (paranoidly expecting different order)
+         int tempIncreasedDimensionIndex = -1;
+         for (int d = 0; d < tempRgn->Dimensions; ++d) {
+             if (tempRgn->pDimensionDefinitions[d].dimension == type) {
+                 tempIncreasedDimensionIndex = d;
+                 break;
+             }
+         }
+         // copy dimension regions from this region to the temporary region
+         for (int iSrc = 0; iSrc < 256; ++iSrc) {
+             DimensionRegion* srcDimRgn = pDimensionRegions[iSrc];
+             if (!srcDimRgn) continue;
+             std::map<dimension_t,int> dimCase;
+             bool isValidZone = true;
+             for (int d = 0, baseBits = 0; d < Dimensions; ++d) {
+                 const int srcBits = pDimensionDefinitions[d].bits;
+                 dimCase[pDimensionDefinitions[d].dimension] =
+                     (iSrc >> baseBits) & ((1 << srcBits) - 1);
+                 // there are also DimensionRegion objects for unused zones, skip them
+                 if (dimCase[pDimensionDefinitions[d].dimension] >= pDimensionDefinitions[d].zones) {
+                     isValidZone = false;
+                     break;
+                 }
+                 baseBits += srcBits;
+             }
+             if (!isValidZone) continue;
+             // a bit paranoid: cope with the chance that the dimensions would
+             // have different order in source and destination regions
+             if (dimCase[type] > zone) dimCase[type]++;
+             DimensionRegion* dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
+             dstDimRgn->CopyAssign(srcDimRgn);
+             // if this is the requested zone to be splitted, then also copy
+             // the source DimensionRegion to the newly created target zone
+             // and set the old zones upper limit lower
+             if (dimCase[type] == zone) {
+                 // lower old zones upper limit
+                 if (newDef.split_type == split_type_normal) {
+                     const int high =
+                         dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex];
+                     int low = 0;
+                     if (zone > 0) {
+                         std::map<dimension_t,int> lowerCase = dimCase;
+                         lowerCase[type]--;
+                         DimensionRegion* dstDimRgnLow = tempRgn->GetDimensionRegionByBit(lowerCase);
+                         low = dstDimRgnLow->DimensionUpperLimits[tempIncreasedDimensionIndex];
+                     }
+                     dstDimRgn->DimensionUpperLimits[tempIncreasedDimensionIndex] = low + (high - low) / 2;
+                 }
+                 // fill the newly created zone of the divided zone as well
+                 dimCase[type]++;
+                 dstDimRgn = tempRgn->GetDimensionRegionByBit(dimCase);
+                 dstDimRgn->CopyAssign(srcDimRgn);
+             }
+         }
+         // now tempRegion's dimensions and DimensionRegions basically reflect
+         // what we wanted to get for this actual Region here, so we now just
+         // delete and recreate the dimension in question with the new amount
+         // zones and then copy back from tempRegion
+         DeleteDimension(oldDef);
+         AddDimension(&newDef);
+         for (int iSrc = 0; iSrc < 256; ++iSrc) {
+             DimensionRegion* srcDimRgn = tempRgn->pDimensionRegions[iSrc];
+             if (!srcDimRgn) continue;
+             std::map<dimension_t,int> dimCase;
+             for (int d = 0, baseBits = 0; d < tempRgn->Dimensions; ++d) {
+                 const int srcBits = tempRgn->pDimensionDefinitions[d].bits;
+                 dimCase[tempRgn->pDimensionDefinitions[d].dimension] =
+                     (iSrc >> baseBits) & ((1 << srcBits) - 1);
+                 baseBits += srcBits;
+             }
+             // a bit paranoid: cope with the chance that the dimensions would
+             // have different order in source and destination regions
+             DimensionRegion* dstDimRgn = GetDimensionRegionByBit(dimCase);
+             if (!dstDimRgn) continue;
+             dstDimRgn->CopyAssign(srcDimRgn);
+         }
+         // delete temporary region
+         delete tempRgn;
+         UpdateVelocityTable();
+     }
+     /** @brief Change type of an existing dimension.
+      *
+      * Alters the dimension type of a dimension already existing on this
+      * region. If there is currently no dimension on this Region with type
+      * @a oldType, then this call with throw an Exception. Likewise there are
+      * cases where the requested dimension type cannot be performed. For example
+      * if the new dimension type shall be gig::dimension_samplechannel, and the
+      * current dimension has more than 2 zones. In such cases an Exception is
+      * thrown as well.
+      *
+      * @param oldType - identifies the existing dimension to be changed
+      * @param newType - to which dimension type it should be changed to
+      * @throws gig::Exception if requested change cannot be performed
+      */
+     void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
+         if (oldType == newType) return;
+         dimension_def_t* def = GetDimensionDefinition(oldType);
+         if (!def)
+             throw gig::Exception("No dimension with provided old dimension type exists on this region");
+         if (newType == dimension_samplechannel && def->zones != 2)
+             throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
+         if (GetDimensionDefinition(newType))
+             throw gig::Exception("There is already a dimension with requested new dimension type on this region");
+         def->dimension  = newType;
+         def->split_type = __resolveSplitType(newType);
+     }
+     DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {
+         uint8_t bits[8] = {};
+         for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
+              it != DimCase.end(); ++it)
+         {
+             for (int d = 0; d < Dimensions; ++d) {
+                 if (pDimensionDefinitions[d].dimension == it->first) {
+                     bits[d] = it->second;
+                     goto nextDimCaseSlice;
+                 }
+             }
+             assert(false); // do crash ... too harsh maybe ? ignore it instead ?
+             nextDimCaseSlice:
+             ; // noop
+         }
+         return GetDimensionRegionByBit(bits);
+     }
+     /**
+      * Searches in the current Region for a dimension of the given dimension
+      * type and returns the precise configuration of that dimension in this
+      * Region.
+      *
+      * @param type - dimension type of the sought dimension
+      * @returns dimension definition or NULL if there is no dimension with
+      *          sought type in this Region.
+      */
+     dimension_def_t* Region::GetDimensionDefinition(dimension_t type) {
+         for (int i = 0; i < Dimensions; ++i)
+             if (pDimensionDefinitions[i].dimension == type)
+                 return &pDimensionDefinitions[i];
+         return NULL;
+     }
      Region::~Region() {
          for (int i = 0; i < 256; i++) {
              if (pDimensionRegions[i]) delete pDimensionRegions[i];
-Line 3431 
 namespace {
+Line 3770 
 namespace {
              }
              bitpos += pDimensionDefinitions[i].bits;
          }
-         DimensionRegion* dimreg = pDimensionRegions[dimregidx];
+         DimensionRegion* dimreg = pDimensionRegions[dimregidx & 255];
+         if (!dimreg) return NULL;
          if (veldim != -1) {
              // (dimreg is now the dimension region for the lowest velocity)
              if (dimreg->VelocityTable) // custom defined zone ranges
-                 bits = dimreg->VelocityTable[DimValues[veldim]];
+                 bits = dimreg->VelocityTable[DimValues[veldim] & 127];
              else // normal split type
-                 bits = uint8_t(DimValues[veldim] / pDimensionDefinitions[veldim].zone_size);
+                 bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
-             dimregidx |= bits << velbitpos;
+             const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
-             dimreg = pDimensionRegions[dimregidx];
+             dimregidx |= (bits & limiter_mask) << velbitpos;
+             dimreg = pDimensionRegions[dimregidx & 255];
          }
          return dimreg;
      }
+     int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
+         uint8_t bits;
+         int veldim = -1;
+         int velbitpos;
+         int bitpos = 0;
+         int dimregidx = 0;
+         for (uint i = 0; i < Dimensions; i++) {
+             if (pDimensionDefinitions[i].dimension == dimension_velocity) {
+                 // the velocity dimension must be handled after the other dimensions
+                 veldim = i;
+                 velbitpos = bitpos;
+             } else {
+                 switch (pDimensionDefinitions[i].split_type) {
+                     case split_type_normal:
+                         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;
+                         bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
+                         break;
+                 }
+                 dimregidx |= bits << bitpos;
+             }
+             bitpos += pDimensionDefinitions[i].bits;
+         }
+         dimregidx &= 255;
+         DimensionRegion* dimreg = pDimensionRegions[dimregidx];
+         if (!dimreg) return -1;
+         if (veldim != -1) {
+             // (dimreg is now the dimension region for the lowest velocity)
+             if (dimreg->VelocityTable) // custom defined zone ranges
+                 bits = dimreg->VelocityTable[DimValues[veldim] & 127];
+             else // normal split type
+                 bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
+             const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
+             dimregidx |= (bits & limiter_mask) << velbitpos;
+             dimregidx &= 255;
+         }
+         return dimregidx;
+     }
      /**
       * Returns the appropriate DimensionRegion for the given dimension bit
       * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>
-Line 3711 
 namespace {
+Line 4102 
 namespace {
          }
      }
+ // *************** Script ***************
+ // *
+     Script::Script(ScriptGroup* group, RIFF::Chunk* ckScri) {
+         pGroup = group;
+         pChunk = ckScri;
+         if (ckScri) { // object is loaded from file ...
+             // read header
+             uint32_t headerSize = ckScri->ReadUint32();
+             Compression = (Compression_t) ckScri->ReadUint32();
+             Encoding    = (Encoding_t) ckScri->ReadUint32();
+             Language    = (Language_t) ckScri->ReadUint32();
+             Bypass      = (Language_t) ckScri->ReadUint32() & 1;
+             crc         = ckScri->ReadUint32();
+             uint32_t nameSize = ckScri->ReadUint32();
+             Name.resize(nameSize, ' ');
+             for (int i = 0; i < nameSize; ++i)
+                 Name[i] = ckScri->ReadUint8();
+             // to handle potential future extensions of the header
+             ckScri->SetPos(sizeof(int32_t) + headerSize);
+             // read actual script data
+             uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();
+             data.resize(scriptSize);
+             for (int i = 0; i < scriptSize; ++i)
+                 data[i] = ckScri->ReadUint8();
+         } else { // this is a new script object, so just initialize it as such ...
+             Compression = COMPRESSION_NONE;
+             Encoding = ENCODING_ASCII;
+             Language = LANGUAGE_NKSP;
+             Bypass   = false;
+             crc      = 0;
+             Name     = "Unnamed Script";
+         }
+     }
+     Script::~Script() {
+     }
+     /**
+      * Returns the current script (i.e. as source code) in text format.
+      */
+     String Script::GetScriptAsText() {
+         String s;
+         s.resize(data.size(), ' ');
+         memcpy(&s[0], &data[0], data.size());
+         return s;
+     }
+     /**
+      * Replaces the current script with the new script source code text given
+      * by @a text.
+      *
+      * @param text - new script source code
+      */
+     void Script::SetScriptAsText(const String& text) {
+         data.resize(text.size());
+         memcpy(&data[0], &text[0], text.size());
+     }
+     void Script::UpdateChunks() {
+         // recalculate CRC32 check sum
+         __resetCRC(crc);
+         __calculateCRC(&data[0], data.size(), crc);
+         __encodeCRC(crc);
+         // make sure chunk exists and has the required size
+         const int chunkSize = 7*sizeof(int32_t) + Name.size() + data.size();
+         if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
+         else pChunk->Resize(chunkSize);
+         // fill the chunk data to be written to disk
+         uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
+         int pos = 0;
+         store32(&pData[pos], 6*sizeof(int32_t) + Name.size()); // total header size
+         pos += sizeof(int32_t);
+         store32(&pData[pos], Compression);
+         pos += sizeof(int32_t);
+         store32(&pData[pos], Encoding);
+         pos += sizeof(int32_t);
+         store32(&pData[pos], Language);
+         pos += sizeof(int32_t);
+         store32(&pData[pos], Bypass ? 1 : 0);
+         pos += sizeof(int32_t);
+         store32(&pData[pos], crc);
+         pos += sizeof(int32_t);
+         store32(&pData[pos], Name.size());
+         pos += sizeof(int32_t);
+         for (int i = 0; i < Name.size(); ++i, ++pos)
+             pData[pos] = Name[i];
+         for (int i = 0; i < data.size(); ++i, ++pos)
+             pData[pos] = data[i];
+     }
+     /**
+      * Move this script from its current ScriptGroup to another ScriptGroup
+      * given by @a pGroup.
+      *
+      * @param pGroup - script's new group
+      */
+     void Script::SetGroup(ScriptGroup* pGroup) {
+         if (this->pGroup = pGroup) return;
+         if (pChunk)
+             pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
+         this->pGroup = pGroup;
+     }
+     /**
+      * Returns the script group this script currently belongs to. Each script
+      * is a member of exactly one ScriptGroup.
+      *
+      * @returns current script group
+      */
+     ScriptGroup* Script::GetGroup() const {
+         return pGroup;
+     }
+     void Script::RemoveAllScriptReferences() {
+         File* pFile = pGroup->pFile;
+         for (int i = 0; pFile->GetInstrument(i); ++i) {
+             Instrument* instr = pFile->GetInstrument(i);
+             instr->RemoveScript(this);
+         }
+     }
+ // *************** ScriptGroup ***************
+ // *
+     ScriptGroup::ScriptGroup(File* file, RIFF::List* lstRTIS) {
+         pFile = file;
+         pList = lstRTIS;
+         pScripts = NULL;
+         if (lstRTIS) {
+             RIFF::Chunk* ckName = lstRTIS->GetSubChunk(CHUNK_ID_LSNM);
+             ::LoadString(ckName, Name);
+         } else {
+             Name = "Default Group";
+         }
+     }
+     ScriptGroup::~ScriptGroup() {
+         if (pScripts) {
+             std::list<Script*>::iterator iter = pScripts->begin();
+             std::list<Script*>::iterator end  = pScripts->end();
+             while (iter != end) {
+                 delete *iter;
+                 ++iter;
+             }
+             delete pScripts;
+         }
+     }
+     void ScriptGroup::UpdateChunks() {
+         if (pScripts) {
+             if (!pList)
+                 pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
+             // now store the name of this group as <LSNM> chunk as subchunk of the <RTIS> list chunk
+             ::SaveString(CHUNK_ID_LSNM, NULL, pList, Name, String("Unnamed Group"), true, 64);
+             for (std::list<Script*>::iterator it = pScripts->begin();
+                  it != pScripts->end(); ++it)
+             {
+                 (*it)->UpdateChunks();
+             }
+         }
+     }
+     /** @brief Get instrument script.
+      *
+      * Returns the real-time instrument script with the given index.
+      *
+      * @param index - number of the sought script (0..n)
+      * @returns sought script or NULL if there's no such script
+      */
+     Script* ScriptGroup::GetScript(uint index) {
+         if (!pScripts) LoadScripts();
+         std::list<Script*>::iterator it = pScripts->begin();
+         for (uint i = 0; it != pScripts->end(); ++i, ++it)
+             if (i == index) return *it;
+         return NULL;
+     }
+     /** @brief Add new instrument script.
+      *
+      * Adds a new real-time instrument script to the file. The script is not
+      * actually used / executed unless it is referenced by an instrument to be
+      * used. This is similar to samples, which you can add to a file, without
+      * an instrument necessarily actually using it.
+      *
+      * You have to call Save() to make this persistent to the file.
+      *
+      * @return new empty script object
+      */
+     Script* ScriptGroup::AddScript() {
+         if (!pScripts) LoadScripts();
+         Script* pScript = new Script(this, NULL);
+         pScripts->push_back(pScript);
+         return pScript;
+     }
+     /** @brief Delete an instrument script.
+      *
+      * This will delete the given real-time instrument script. References of
+      * instruments that are using that script will be removed accordingly.
+      *
+      * You have to call Save() to make this persistent to the file.
+      *
+      * @param pScript - script to delete
+      * @throws gig::Exception if given script could not be found
+      */
+     void ScriptGroup::DeleteScript(Script* pScript) {
+         if (!pScripts) LoadScripts();
+         std::list<Script*>::iterator iter =
+             find(pScripts->begin(), pScripts->end(), pScript);
+         if (iter == pScripts->end())
+             throw gig::Exception("Could not delete script, could not find given script");
+         pScripts->erase(iter);
+         pScript->RemoveAllScriptReferences();
+         if (pScript->pChunk)
+             pScript->pChunk->GetParent()->DeleteSubChunk(pScript->pChunk);
+         delete pScript;
+     }
+     void ScriptGroup::LoadScripts() {
+         if (pScripts) return;
+         pScripts = new std::list<Script*>;
+         if (!pList) return;
+         for (RIFF::Chunk* ck = pList->GetFirstSubChunk(); ck;
+              ck = pList->GetNextSubChunk())
+         {
+             if (ck->GetChunkID() == CHUNK_ID_SCRI) {
+                 pScripts->push_back(new Script(this, ck));
+             }
+         }
+     }
  // *************** Instrument ***************
  // *
-Line 3733 
 namespace {
+Line 4359 
 namespace {
          DimensionKeyRange.high = 0;
          pMidiRules = new MidiRule*[3];
          pMidiRules[0] = NULL;
+         pScriptRefs = NULL;
          // Loading
          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
-Line 3793 
 namespace {
+Line 4420 
 namespace {
              }
          }
+         // own gig format extensions
+         RIFF::List* lst3LS = insList->GetSubList(LIST_TYPE_3LS);
+         if (lst3LS) {
+             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
+             if (ckSCSL) {
+                 int headerSize = ckSCSL->ReadUint32();
+                 int slotCount  = ckSCSL->ReadUint32();
+                 if (slotCount) {
+                     int slotSize  = ckSCSL->ReadUint32();
+                     ckSCSL->SetPos(headerSize); // in case of future header extensions
+                     int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions
+                     for (int i = 0; i < slotCount; ++i) {
+                         _ScriptPooolEntry e;
+                         e.fileOffset = ckSCSL->ReadUint32();
+                         e.bypass     = ckSCSL->ReadUint32() & 1;
+                         if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions
+                         scriptPoolFileOffsets.push_back(e);
+                     }
+                 }
+             }
+         }
          __notify_progress(pProgress, 1.0f); // notify done
      }
-Line 3813 
 namespace {
+Line 4462 
 namespace {
              delete pMidiRules[i];
          }
          delete[] pMidiRules;
+         if (pScriptRefs) delete pScriptRefs;
      }
      /**
-Line 3868 
 namespace {
+Line 4518 
 namespace {
                  pMidiRules[i]->UpdateChunks(pData);
              }
          }
+         // own gig format extensions
+        if (pScriptRefs) {
+            RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
+            if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
+            const int slotCount = pScriptRefs->size();
+            const int headerSize = 3 * sizeof(uint32_t);
+            const int slotSize  = 2 * sizeof(uint32_t);
+            const int totalChunkSize = headerSize + slotCount * slotSize;
+            RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
+            if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
+            else ckSCSL->Resize(totalChunkSize);
+            uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();
+            int pos = 0;
+            store32(&pData[pos], headerSize);
+            pos += sizeof(uint32_t);
+            store32(&pData[pos], slotCount);
+            pos += sizeof(uint32_t);
+            store32(&pData[pos], slotSize);
+            pos += sizeof(uint32_t);
+            for (int i = 0; i < slotCount; ++i) {
+                // arbitrary value, the actual file offset will be updated in
+                // UpdateScriptFileOffsets() after the file has been resized
+                int bogusFileOffset = 0;
+                store32(&pData[pos], bogusFileOffset);
+                pos += sizeof(uint32_t);
+                store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
+                pos += sizeof(uint32_t);
+            }
+        }
+     }
+     void Instrument::UpdateScriptFileOffsets() {
+        // own gig format extensions
+        if (pScriptRefs) {
+            RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
+            RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
+            const int slotCount = pScriptRefs->size();
+            const int headerSize = 3 * sizeof(uint32_t);
+            ckSCSL->SetPos(headerSize);
+            for (int i = 0; i < slotCount; ++i) {
+                uint32_t fileOffset =
+                     (*pScriptRefs)[i].script->pChunk->GetFilePos() -
+                     (*pScriptRefs)[i].script->pChunk->GetPos() -
+                     CHUNK_HEADER_SIZE;
+                ckSCSL->WriteUint32(&fileOffset);
+                // jump over flags entry (containing the bypass flag)
+                ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
+            }
+        }
      }
      /**
-Line 3999 
 namespace {
+Line 4699 
 namespace {
          pMidiRules[i] = 0;
      }
+     void Instrument::LoadScripts() {
+         if (pScriptRefs) return;
+         pScriptRefs = new std::vector<_ScriptPooolRef>;
+         if (scriptPoolFileOffsets.empty()) return;
+         File* pFile = (File*) GetParent();
+         for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
+             uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
+             for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
+                 ScriptGroup* group = pFile->GetScriptGroup(i);
+                 for (uint s = 0; group->GetScript(s); ++s) {
+                     Script* script = group->GetScript(s);
+                     if (script->pChunk) {
+                         uint32_t offset = script->pChunk->GetFilePos() -
+                                           script->pChunk->GetPos() -
+                                           CHUNK_HEADER_SIZE;
+                         if (offset == soughtOffset)
+                         {
+                             _ScriptPooolRef ref;
+                             ref.script = script;
+                             ref.bypass = scriptPoolFileOffsets[k].bypass;
+                             pScriptRefs->push_back(ref);
+                             break;
+                         }
+                     }
+                 }
+             }
+         }
+         // we don't need that anymore
+         scriptPoolFileOffsets.clear();
+     }
+     /** @brief Get instrument script (gig format extension).
+      *
+      * Returns the real-time instrument script of instrument script slot
+      * @a index.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param index - instrument script slot index
+      * @returns script or NULL if index is out of bounds
+      */
+     Script* Instrument::GetScriptOfSlot(uint index) {
+         LoadScripts();
+         if (index >= pScriptRefs->size()) return NULL;
+         return pScriptRefs->at(index).script;
+     }
+     /** @brief Add new instrument script slot (gig format extension).
+      *
+      * Add the given real-time instrument script reference to this instrument,
+      * which shall be executed by the sampler for for this instrument. The
+      * script will be added to the end of the script list of this instrument.
+      * The positions of the scripts in the Instrument's Script list are
+      * relevant, because they define in which order they shall be executed by
+      * the sampler. For this reason it is also legal to add the same script
+      * twice to an instrument, for example you might have a script called
+      * "MyFilter" which performs an event filter task, and you might have
+      * another script called "MyNoteTrigger" which triggers new notes, then you
+      * might for example have the following list of scripts on the instrument:
+      *
+      * 1. Script "MyFilter"
+      * 2. Script "MyNoteTrigger"
+      * 3. Script "MyFilter"
+      *
+      * Which would make sense, because the 2nd script launched new events, which
+      * you might need to filter as well.
+      *
+      * There are two ways to disable / "bypass" scripts. You can either disable
+      * a script locally for the respective script slot on an instrument (i.e. by
+      * passing @c false to the 2nd argument of this method, or by calling
+      * SetScriptBypassed()). Or you can disable a script globally for all slots
+      * and all instruments by setting Script::Bypass.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param pScript - script that shall be executed for this instrument
+      * @param bypass  - if enabled, the sampler shall skip executing this
+      *                  script (in the respective list position)
+      * @see SetScriptBypassed()
+      */
+     void Instrument::AddScriptSlot(Script* pScript, bool bypass) {
+         LoadScripts();
+         _ScriptPooolRef ref = { pScript, bypass };
+         pScriptRefs->push_back(ref);
+     }
+     /** @brief Flip two script slots with each other (gig format extension).
+      *
+      * Swaps the position of the two given scripts in the Instrument's Script
+      * list. The positions of the scripts in the Instrument's Script list are
+      * relevant, because they define in which order they shall be executed by
+      * the sampler.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param index1 - index of the first script slot to swap
+      * @param index2 - index of the second script slot to swap
+      */
+     void Instrument::SwapScriptSlots(uint index1, uint index2) {
+         LoadScripts();
+         if (index1 >= pScriptRefs->size() || index2 >= pScriptRefs->size())
+             return;
+         _ScriptPooolRef tmp = (*pScriptRefs)[index1];
+         (*pScriptRefs)[index1] = (*pScriptRefs)[index2];
+         (*pScriptRefs)[index2] = tmp;
+     }
+     /** @brief Remove script slot.
+      *
+      * Removes the script slot with the given slot index.
+      *
+      * @param index - index of script slot to remove
+      */
+     void Instrument::RemoveScriptSlot(uint index) {
+         LoadScripts();
+         if (index >= pScriptRefs->size()) return;
+         pScriptRefs->erase( pScriptRefs->begin() + index );
+     }
+     /** @brief Remove reference to given Script (gig format extension).
+      *
+      * This will remove all script slots on the instrument which are referencing
+      * the given script.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param pScript - script reference to remove from this instrument
+      * @see RemoveScriptSlot()
+      */
+     void Instrument::RemoveScript(Script* pScript) {
+         LoadScripts();
+         for (int i = pScriptRefs->size() - 1; i >= 0; --i) {
+             if ((*pScriptRefs)[i].script == pScript) {
+                 pScriptRefs->erase( pScriptRefs->begin() + i );
+             }
+         }
+     }
+     /** @brief Instrument's amount of script slots.
+      *
+      * This method returns the amount of script slots this instrument currently
+      * uses.
+      *
+      * A script slot is a reference of a real-time instrument script to be
+      * executed by the sampler. The scripts will be executed by the sampler in
+      * sequence of the slots. One (same) script may be referenced multiple
+      * times in different slots.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      */
+     uint Instrument::ScriptSlotCount() const {
+         return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
+     }
+     /** @brief Whether script execution shall be skipped.
+      *
+      * Defines locally for the Script reference slot in the Instrument's Script
+      * list, whether the script shall be skipped by the sampler regarding
+      * execution.
+      *
+      * It is also possible to ignore exeuction of the script globally, for all
+      * slots and for all instruments by setting Script::Bypass.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param index - index of the script slot on this instrument
+      * @see Script::Bypass
+      */
+     bool Instrument::IsScriptSlotBypassed(uint index) {
+         if (index >= ScriptSlotCount()) return false;
+         return pScriptRefs ? pScriptRefs->at(index).bypass
+                            : scriptPoolFileOffsets.at(index).bypass;
+     }
+     /** @brief Defines whether execution shall be skipped.
+      *
+      * You can call this method to define locally whether or whether not the
+      * given script slot shall be executed by the sampler.
+      *
+      * @note This is an own format extension which did not exist i.e. in the
+      * GigaStudio 4 software. It will currently only work with LinuxSampler and
+      * gigedit.
+      *
+      * @param index - script slot index on this instrument
+      * @param bBypass - if true, the script slot will be skipped by the sampler
+      * @see Script::Bypass
+      */
+     void Instrument::SetScriptSlotBypassed(uint index, bool bBypass) {
+         if (index >= ScriptSlotCount()) return;
+         if (pScriptRefs)
+             pScriptRefs->at(index).bypass = bBypass;
+         else
+             scriptPoolFileOffsets.at(index).bypass = bBypass;
+     }
      /**
       * Make a (semi) deep copy of the Instrument object given by @a orig
       * and assign it to this object.
-Line 4032 
 namespace {
+Line 4940 
 namespace {
          PitchbendRange = orig->PitchbendRange;
          PianoReleaseMode = orig->PianoReleaseMode;
          DimensionKeyRange = orig->DimensionKeyRange;
+         scriptPoolFileOffsets = orig->scriptPoolFileOffsets;
+         pScriptRefs = orig->pScriptRefs;
          // free old midi rules
          for (int i = 0 ; pMidiRules[i] ; i++) {
-Line 4217 
 namespace {
+Line 5127 
 namespace {
          bAutoLoad = true;
          *pVersion = VERSION_3;
          pGroups = NULL;
+         pScriptGroups = NULL;
          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
          pInfo->ArchivalLocation = String(256, ' ');
-Line 4232 
 namespace {
+Line 5143 
 namespace {
      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
          bAutoLoad = true;
          pGroups = NULL;
+         pScriptGroups = NULL;
          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
      }
-Line 4245 
 namespace {
+Line 5157 
 namespace {
              }
              delete pGroups;
          }
+         if (pScriptGroups) {
+             std::list<ScriptGroup*>::iterator iter = pScriptGroups->begin();
+             std::list<ScriptGroup*>::iterator end  = pScriptGroups->end();
+             while (iter != end) {
+                 delete *iter;
+                 ++iter;
+             }
+             delete pScriptGroups;
+         }
      }
      Sample* File::GetFirstSample(progress_t* pProgress) {
-Line 4757 
 namespace {
+Line 5678 
 namespace {
          }
      }
+     /** @brief Get instrument script group (by index).
+      *
+      * Returns the real-time instrument script group with the given index.
+      *
+      * @param index - number of the sought group (0..n)
+      * @returns sought script group or NULL if there's no such group
+      */
+     ScriptGroup* File::GetScriptGroup(uint index) {
+         if (!pScriptGroups) LoadScriptGroups();
+         std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
+         for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
+             if (i == index) return *it;
+         return NULL;
+     }
+     /** @brief Get instrument script group (by name).
+      *
+      * Returns the first real-time instrument script group found with the given
+      * group name. Note that group names may not necessarily be unique.
+      *
+      * @param name - name of the sought script group
+      * @returns sought script group or NULL if there's no such group
+      */
+     ScriptGroup* File::GetScriptGroup(const String& name) {
+         if (!pScriptGroups) LoadScriptGroups();
+         std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
+         for (uint i = 0; it != pScriptGroups->end(); ++i, ++it)
+             if ((*it)->Name == name) return *it;
+         return NULL;
+     }
+     /** @brief Add new instrument script group.
+      *
+      * Adds a new, empty real-time instrument script group to the file.
+      *
+      * You have to call Save() to make this persistent to the file.
+      *
+      * @return new empty script group
+      */
+     ScriptGroup* File::AddScriptGroup() {
+         if (!pScriptGroups) LoadScriptGroups();
+         ScriptGroup* pScriptGroup = new ScriptGroup(this, NULL);
+         pScriptGroups->push_back(pScriptGroup);
+         return pScriptGroup;
+     }
+     /** @brief Delete an instrument script group.
+      *
+      * This will delete the given real-time instrument script group and all its
+      * instrument scripts it contains. References inside instruments that are
+      * using the deleted scripts will be removed from the respective instruments
+      * accordingly.
+      *
+      * You have to call Save() to make this persistent to the file.
+      *
+      * @param pScriptGroup - script group to delete
+      * @throws gig::Exception if given script group could not be found
+      */
+     void File::DeleteScriptGroup(ScriptGroup* pScriptGroup) {
+         if (!pScriptGroups) LoadScriptGroups();
+         std::list<ScriptGroup*>::iterator iter =
+             find(pScriptGroups->begin(), pScriptGroups->end(), pScriptGroup);
+         if (iter == pScriptGroups->end())
+             throw gig::Exception("Could not delete script group, could not find given script group");
+         pScriptGroups->erase(iter);
+         for (int i = 0; pScriptGroup->GetScript(i); ++i)
+             pScriptGroup->DeleteScript(pScriptGroup->GetScript(i));
+         if (pScriptGroup->pList)
+             pScriptGroup->pList->GetParent()->DeleteSubChunk(pScriptGroup->pList);
+         delete pScriptGroup;
+     }
+     void File::LoadScriptGroups() {
+         if (pScriptGroups) return;
+         pScriptGroups = new std::list<ScriptGroup*>;
+         RIFF::List* lstLS = pRIFF->GetSubList(LIST_TYPE_3LS);
+         if (lstLS) {
+             for (RIFF::List* lst = lstLS->GetFirstSubList(); lst;
+                  lst = lstLS->GetNextSubList())
+             {
+                 if (lst->GetListType() == LIST_TYPE_RTIS) {
+                     pScriptGroups->push_back(new ScriptGroup(this, lst));
+                 }
+             }
+         }
+     }
      /**
       * 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
-Line 4772 
 namespace {
+Line 5780 
 namespace {
          b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
+         // update own gig format extension chunks
+         // (not part of the GigaStudio 4 format)
+         //
+         // This must be performed before writing the chunks for instruments,
+         // because the instruments' script slots will write the file offsets
+         // of the respective instrument script chunk as reference.
+         if (pScriptGroups) {
+             RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
+             if (pScriptGroups->empty()) {
+                 if (lst3LS) pRIFF->DeleteSubChunk(lst3LS);
+             } else {
+                 if (!lst3LS) lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
+                 // Update instrument script (group) chunks.
+                 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
+                      it != pScriptGroups->end(); ++it)
+                 {
+                     (*it)->UpdateChunks();
+                 }
+             }
+         }
          // first update base class's chunks
          DLS::File::UpdateChunks();
-Line 4942 
 namespace {
+Line 5973 
 namespace {
              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
          }
      }
+     void File::UpdateFileOffsets() {
+         DLS::File::UpdateFileOffsets();
+         for (Instrument* instrument = GetFirstInstrument(); instrument;
+              instrument = GetNextInstrument())
+         {
+             instrument->UpdateScriptFileOffsets();
+         }
+     }
      /**
       * Enable / disable automatic loading. By default this properyt is

 Legend:



Removed from v.2543
 


changed lines


 
Added in v.2640
 Legend:



Removed from v.2543
 


changed lines


 
Added in v.2640
-Removed from v.2543
+Added in v.2640

	ViewVC Help
Powered by ViewVC