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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2599 by schoenebeck, Sat Jun 7 00:00:10 2014 UTC revision 2990 by schoenebeck, Sat Sep 24 15:02:28 2016 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2014 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2016 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 30  Line 30 
30  #include <iostream>  #include <iostream>
31  #include <assert.h>  #include <assert.h>
32    
33    /// libgig's current file format version (for extending the original Giga file
34    /// format with libgig's own custom data / custom features).
35    #define GIG_FILE_EXT_VERSION    2
36    
37  /// Initial size of the sample buffer which is used for decompression of  /// Initial size of the sample buffer which is used for decompression of
38  /// compressed sample wave streams - this value should always be bigger than  /// compressed sample wave streams - this value should always be bigger than
39  /// the biggest sample piece expected to be read by the sampler engine,  /// the biggest sample piece expected to be read by the sampler engine,
# Line 53  Line 57 
57    
58  namespace gig {  namespace gig {
59    
 // *************** progress_t ***************  
 // *  
   
     progress_t::progress_t() {  
         callback    = NULL;  
         custom      = NULL;  
         __range_min = 0.0f;  
         __range_max = 1.0f;  
     }  
   
     // private helper function to convert progress of a subprocess into the global progress  
     static void __notify_progress(progress_t* pProgress, float subprogress) {  
         if (pProgress && pProgress->callback) {  
             const float totalrange    = pProgress->__range_max - pProgress->__range_min;  
             const float totalprogress = pProgress->__range_min + subprogress * totalrange;  
             pProgress->factor         = totalprogress;  
             pProgress->callback(pProgress); // now actually notify about the progress  
         }  
     }  
   
     // private helper function to divide a progress into subprogresses  
     static void __divide_progress(progress_t* pParentProgress, progress_t* pSubProgress, float totalTasks, float currentTask) {  
         if (pParentProgress && pParentProgress->callback) {  
             const float totalrange    = pParentProgress->__range_max - pParentProgress->__range_min;  
             pSubProgress->callback    = pParentProgress->callback;  
             pSubProgress->custom      = pParentProgress->custom;  
             pSubProgress->__range_min = pParentProgress->__range_min + totalrange * currentTask / totalTasks;  
             pSubProgress->__range_max = pSubProgress->__range_min + totalrange / totalTasks;  
         }  
     }  
   
   
60  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
61  // *  // *
62    
# Line 123  namespace { Line 95  namespace {
95      void Decompress16(int compressionmode, const unsigned char* params,      void Decompress16(int compressionmode, const unsigned char* params,
96                        int srcStep, int dstStep,                        int srcStep, int dstStep,
97                        const unsigned char* pSrc, int16_t* pDst,                        const unsigned char* pSrc, int16_t* pDst,
98                        unsigned long currentframeoffset,                        file_offset_t currentframeoffset,
99                        unsigned long copysamples)                        file_offset_t copysamples)
100      {      {
101          switch (compressionmode) {          switch (compressionmode) {
102              case 0: // 16 bit uncompressed              case 0: // 16 bit uncompressed
# Line 160  namespace { Line 132  namespace {
132    
133      void Decompress24(int compressionmode, const unsigned char* params,      void Decompress24(int compressionmode, const unsigned char* params,
134                        int dstStep, const unsigned char* pSrc, uint8_t* pDst,                        int dstStep, const unsigned char* pSrc, uint8_t* pDst,
135                        unsigned long currentframeoffset,                        file_offset_t currentframeoffset,
136                        unsigned long copysamples, int truncatedBits)                        file_offset_t copysamples, int truncatedBits)
137      {      {
138          int y, dy, ddy, dddy;          int y, dy, ddy, dddy;
139    
# Line 346  namespace { Line 318  namespace {
318  // *************** Sample ***************  // *************** Sample ***************
319  // *  // *
320    
321      unsigned int Sample::Instances = 0;      size_t       Sample::Instances = 0;
322      buffer_t     Sample::InternalDecompressionBuffer;      buffer_t     Sample::InternalDecompressionBuffer;
323    
324      /** @brief Constructor.      /** @brief Constructor.
# Line 366  namespace { Line 338  namespace {
338       *                         ('wvpl') list chunk       *                         ('wvpl') list chunk
339       * @param fileNo         - number of an extension file where this sample       * @param fileNo         - number of an extension file where this sample
340       *                         is located, 0 otherwise       *                         is located, 0 otherwise
341         * @param index          - wave pool index of sample (may be -1 on new sample)
342       */       */
343      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {      Sample::Sample(File* pFile, RIFF::List* waveList, file_offset_t WavePoolOffset, unsigned long fileNo, int index)
344            : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset)
345        {
346          static const DLS::Info::string_length_t fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
347              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
348              { 0, 0 }              { 0, 0 }
# Line 377  namespace { Line 352  namespace {
352          FileNo = fileNo;          FileNo = fileNo;
353    
354          __resetCRC(crc);          __resetCRC(crc);
355            // if this is not a new sample, try to get the sample's already existing
356            // CRC32 checksum from disk, this checksum will reflect the sample's CRC32
357            // checksum of the time when the sample was consciously modified by the
358            // user for the last time (by calling Sample::Write() that is).
359            if (index >= 0) { // not a new file ...
360                try {
361                    uint32_t crc = pFile->GetSampleChecksumByIndex(index);
362                    this->crc = crc;
363                } catch (...) {}
364            }
365    
366          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
367          if (pCk3gix) {          if (pCk3gix) {
# Line 509  namespace { Line 494  namespace {
494          const int iReadAtOnce = 32*1024;          const int iReadAtOnce = 32*1024;
495          char* buf = new char[iReadAtOnce * orig->FrameSize];          char* buf = new char[iReadAtOnce * orig->FrameSize];
496          Sample* pOrig = (Sample*) orig; //HACK: remove constness for now          Sample* pOrig = (Sample*) orig; //HACK: remove constness for now
497          unsigned long restorePos = pOrig->GetPos();          file_offset_t restorePos = pOrig->GetPos();
498          pOrig->SetPos(0);          pOrig->SetPos(0);
499          SetPos(0);          SetPos(0);
500          for (unsigned long n = pOrig->Read(buf, iReadAtOnce); n;          for (file_offset_t n = pOrig->Read(buf, iReadAtOnce); n;
501                             n = pOrig->Read(buf, iReadAtOnce))                             n = pOrig->Read(buf, iReadAtOnce))
502          {          {
503              Write(buf, n);              Write(buf, n);
# Line 528  namespace { Line 513  namespace {
513       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
514       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
515       *       *
516         * @param pProgress - callback function for progress notification
517       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data       * @throws DLS::Exception if FormatTag != DLS_WAVE_FORMAT_PCM or no sample data
518       *                        was provided yet       *                        was provided yet
519       * @throws gig::Exception if there is any invalid sample setting       * @throws gig::Exception if there is any invalid sample setting
520       */       */
521      void Sample::UpdateChunks() {      void Sample::UpdateChunks(progress_t* pProgress) {
522          // first update base class's chunks          // first update base class's chunks
523          DLS::Sample::UpdateChunks();          DLS::Sample::UpdateChunks(pProgress);
524    
525          // make sure 'smpl' chunk exists          // make sure 'smpl' chunk exists
526          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
# Line 596  namespace { Line 582  namespace {
582      void Sample::ScanCompressedSample() {      void Sample::ScanCompressedSample() {
583          //TODO: we have to add some more scans here (e.g. determine compression rate)          //TODO: we have to add some more scans here (e.g. determine compression rate)
584          this->SamplesTotal = 0;          this->SamplesTotal = 0;
585          std::list<unsigned long> frameOffsets;          std::list<file_offset_t> frameOffsets;
586    
587          SamplesPerFrame = BitDepth == 24 ? 256 : 2048;          SamplesPerFrame = BitDepth == 24 ? 256 : 2048;
588          WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag          WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag
# Line 612  namespace { Line 598  namespace {
598                  const int mode_l = pCkData->ReadUint8();                  const int mode_l = pCkData->ReadUint8();
599                  const int mode_r = pCkData->ReadUint8();                  const int mode_r = pCkData->ReadUint8();
600                  if (mode_l > 5 || mode_r > 5) throw gig::Exception("Unknown compression mode");                  if (mode_l > 5 || mode_r > 5) throw gig::Exception("Unknown compression mode");
601                  const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];                  const file_offset_t frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
602    
603                  if (pCkData->RemainingBytes() <= frameSize) {                  if (pCkData->RemainingBytes() <= frameSize) {
604                      SamplesInLastFrame =                      SamplesInLastFrame =
# Line 631  namespace { Line 617  namespace {
617    
618                  const int mode = pCkData->ReadUint8();                  const int mode = pCkData->ReadUint8();
619                  if (mode > 5) throw gig::Exception("Unknown compression mode");                  if (mode > 5) throw gig::Exception("Unknown compression mode");
620                  const unsigned long frameSize = bytesPerFrame[mode];                  const file_offset_t frameSize = bytesPerFrame[mode];
621    
622                  if (pCkData->RemainingBytes() <= frameSize) {                  if (pCkData->RemainingBytes() <= frameSize) {
623                      SamplesInLastFrame =                      SamplesInLastFrame =
# Line 647  namespace { Line 633  namespace {
633    
634          // Build the frames table (which is used for fast resolving of a frame's chunk offset)          // Build the frames table (which is used for fast resolving of a frame's chunk offset)
635          if (FrameTable) delete[] FrameTable;          if (FrameTable) delete[] FrameTable;
636          FrameTable = new unsigned long[frameOffsets.size()];          FrameTable = new file_offset_t[frameOffsets.size()];
637          std::list<unsigned long>::iterator end  = frameOffsets.end();          std::list<file_offset_t>::iterator end  = frameOffsets.end();
638          std::list<unsigned long>::iterator iter = frameOffsets.begin();          std::list<file_offset_t>::iterator iter = frameOffsets.begin();
639          for (int i = 0; iter != end; i++, iter++) {          for (int i = 0; iter != end; i++, iter++) {
640              FrameTable[i] = *iter;              FrameTable[i] = *iter;
641          }          }
# Line 690  namespace { Line 676  namespace {
676       *                      the cached sample data in bytes       *                      the cached sample data in bytes
677       * @see                 ReleaseSampleData(), Read(), SetPos()       * @see                 ReleaseSampleData(), Read(), SetPos()
678       */       */
679      buffer_t Sample::LoadSampleData(unsigned long SampleCount) {      buffer_t Sample::LoadSampleData(file_offset_t SampleCount) {
680          return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples          return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
681      }      }
682    
# Line 749  namespace { Line 735  namespace {
735       *                           size of the cached sample data in bytes       *                           size of the cached sample data in bytes
736       * @see                      ReleaseSampleData(), Read(), SetPos()       * @see                      ReleaseSampleData(), Read(), SetPos()
737       */       */
738      buffer_t Sample::LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount) {      buffer_t Sample::LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount) {
739          if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;          if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
740          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
741          unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;          file_offset_t allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
742          SetPos(0); // reset read position to begin of sample          SetPos(0); // reset read position to begin of sample
743          RAMCache.pStart            = new int8_t[allocationsize];          RAMCache.pStart            = new int8_t[allocationsize];
744          RAMCache.Size              = Read(RAMCache.pStart, SampleCount) * this->FrameSize;          RAMCache.Size              = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
# Line 816  namespace { Line 802  namespace {
802       * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with       * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
803       * other formats will fail!       * other formats will fail!
804       *       *
805       * @param iNewSize - new sample wave data size in sample points (must be       * @param NewSize - new sample wave data size in sample points (must be
806       *                   greater than zero)       *                  greater than zero)
807       * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM       * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
808       *                         or if \a iNewSize is less than 1       * @throws DLS::Exception if \a NewSize is less than 1 or unrealistic large
809       * @throws gig::Exception if existing sample is compressed       * @throws gig::Exception if existing sample is compressed
810       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
811       *      DLS::Sample::FormatTag, File::Save()       *      DLS::Sample::FormatTag, File::Save()
812       */       */
813      void Sample::Resize(int iNewSize) {      void Sample::Resize(file_offset_t NewSize) {
814          if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");          if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
815          DLS::Sample::Resize(iNewSize);          DLS::Sample::Resize(NewSize);
816      }      }
817    
818      /**      /**
# Line 850  namespace { Line 836  namespace {
836       * @returns            the new sample position       * @returns            the new sample position
837       * @see                Read()       * @see                Read()
838       */       */
839      unsigned long Sample::SetPos(unsigned long SampleCount, RIFF::stream_whence_t Whence) {      file_offset_t Sample::SetPos(file_offset_t SampleCount, RIFF::stream_whence_t Whence) {
840          if (Compressed) {          if (Compressed) {
841              switch (Whence) {              switch (Whence) {
842                  case RIFF::stream_curpos:                  case RIFF::stream_curpos:
# Line 868  namespace { Line 854  namespace {
854              }              }
855              if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;              if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
856    
857              unsigned long frame = this->SamplePos / 2048; // to which frame to jump              file_offset_t frame = this->SamplePos / 2048; // to which frame to jump
858              this->FrameOffset   = this->SamplePos % 2048; // offset (in sample points) within that frame              this->FrameOffset   = this->SamplePos % 2048; // offset (in sample points) within that frame
859              pCkData->SetPos(FrameTable[frame]);           // set chunk pointer to the start of sought frame              pCkData->SetPos(FrameTable[frame]);           // set chunk pointer to the start of sought frame
860              return this->SamplePos;              return this->SamplePos;
861          }          }
862          else { // not compressed          else { // not compressed
863              unsigned long orderedBytes = SampleCount * this->FrameSize;              file_offset_t orderedBytes = SampleCount * this->FrameSize;
864              unsigned long result = pCkData->SetPos(orderedBytes, Whence);              file_offset_t result = pCkData->SetPos(orderedBytes, Whence);
865              return (result == orderedBytes) ? SampleCount              return (result == orderedBytes) ? SampleCount
866                                              : result / this->FrameSize;                                              : result / this->FrameSize;
867          }          }
# Line 884  namespace { Line 870  namespace {
870      /**      /**
871       * Returns the current position in the sample (in sample points).       * Returns the current position in the sample (in sample points).
872       */       */
873      unsigned long Sample::GetPos() const {      file_offset_t Sample::GetPos() const {
874          if (Compressed) return SamplePos;          if (Compressed) return SamplePos;
875          else            return pCkData->GetPos() / FrameSize;          else            return pCkData->GetPos() / FrameSize;
876      }      }
# Line 923  namespace { Line 909  namespace {
909       * @returns                number of successfully read sample points       * @returns                number of successfully read sample points
910       * @see                    CreateDecompressionBuffer()       * @see                    CreateDecompressionBuffer()
911       */       */
912      unsigned long Sample::ReadAndLoop(void* pBuffer, unsigned long SampleCount, playback_state_t* pPlaybackState,      file_offset_t Sample::ReadAndLoop(void* pBuffer, file_offset_t SampleCount, playback_state_t* pPlaybackState,
913                                        DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {                                        DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
914          unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;          file_offset_t samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
915          uint8_t* pDst = (uint8_t*) pBuffer;          uint8_t* pDst = (uint8_t*) pBuffer;
916    
917          SetPos(pPlaybackState->position); // recover position from the last time          SetPos(pPlaybackState->position); // recover position from the last time
# Line 963  namespace { Line 949  namespace {
949                                  // reading, swap all sample frames so it reflects                                  // reading, swap all sample frames so it reflects
950                                  // backward playback                                  // backward playback
951    
952                                  unsigned long swapareastart       = totalreadsamples;                                  file_offset_t swapareastart       = totalreadsamples;
953                                  unsigned long loopoffset          = GetPos() - loop.LoopStart;                                  file_offset_t loopoffset          = GetPos() - loop.LoopStart;
954                                  unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);                                  file_offset_t samplestoreadinloop = Min(samplestoread, loopoffset);
955                                  unsigned long reverseplaybackend  = GetPos() - samplestoreadinloop;                                  file_offset_t reverseplaybackend  = GetPos() - samplestoreadinloop;
956    
957                                  SetPos(reverseplaybackend);                                  SetPos(reverseplaybackend);
958    
# Line 1014  namespace { Line 1000  namespace {
1000                          // reading, swap all sample frames so it reflects                          // reading, swap all sample frames so it reflects
1001                          // backward playback                          // backward playback
1002    
1003                          unsigned long swapareastart       = totalreadsamples;                          file_offset_t swapareastart       = totalreadsamples;
1004                          unsigned long loopoffset          = GetPos() - loop.LoopStart;                          file_offset_t loopoffset          = GetPos() - loop.LoopStart;
1005                          unsigned long samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.LoopLength - loopoffset)                          file_offset_t samplestoreadinloop = (this->LoopPlayCount) ? Min(samplestoread, pPlaybackState->loop_cycles_left * loop.LoopLength - loopoffset)
1006                                                                                    : samplestoread;                                                                                    : samplestoread;
1007                          unsigned long reverseplaybackend  = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);                          file_offset_t reverseplaybackend  = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);
1008    
1009                          SetPos(reverseplaybackend);                          SetPos(reverseplaybackend);
1010    
# Line 1098  namespace { Line 1084  namespace {
1084       * @returns            number of successfully read sample points       * @returns            number of successfully read sample points
1085       * @see                SetPos(), CreateDecompressionBuffer()       * @see                SetPos(), CreateDecompressionBuffer()
1086       */       */
1087      unsigned long Sample::Read(void* pBuffer, unsigned long SampleCount, buffer_t* pExternalDecompressionBuffer) {      file_offset_t Sample::Read(void* pBuffer, file_offset_t SampleCount, buffer_t* pExternalDecompressionBuffer) {
1088          if (SampleCount == 0) return 0;          if (SampleCount == 0) return 0;
1089          if (!Compressed) {          if (!Compressed) {
1090              if (BitDepth == 24) {              if (BitDepth == 24) {
# Line 1113  namespace { Line 1099  namespace {
1099          else {          else {
1100              if (this->SamplePos >= this->SamplesTotal) return 0;              if (this->SamplePos >= this->SamplesTotal) return 0;
1101              //TODO: efficiency: maybe we should test for an average compression rate              //TODO: efficiency: maybe we should test for an average compression rate
1102              unsigned long assumedsize      = GuessSize(SampleCount),              file_offset_t assumedsize      = GuessSize(SampleCount),
1103                            remainingbytes   = 0,           // remaining bytes in the local buffer                            remainingbytes   = 0,           // remaining bytes in the local buffer
1104                            remainingsamples = SampleCount,                            remainingsamples = SampleCount,
1105                            copysamples, skipsamples,                            copysamples, skipsamples,
# Line 1136  namespace { Line 1122  namespace {
1122              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
1123    
1124              while (remainingsamples && remainingbytes) {              while (remainingsamples && remainingbytes) {
1125                  unsigned long framesamples = SamplesPerFrame;                  file_offset_t framesamples = SamplesPerFrame;
1126                  unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;                  file_offset_t framebytes, rightChannelOffset = 0, nextFrameOffset;
1127    
1128                  int mode_l = *pSrc++, mode_r = 0;                  int mode_l = *pSrc++, mode_r = 0;
1129    
# Line 1287  namespace { Line 1273  namespace {
1273       * @throws gig::Exception if sample is compressed       * @throws gig::Exception if sample is compressed
1274       * @see DLS::LoadSampleData()       * @see DLS::LoadSampleData()
1275       */       */
1276      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {      file_offset_t Sample::Write(void* pBuffer, file_offset_t SampleCount) {
1277          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1278    
1279          // if this is the first write in this sample, reset the          // if this is the first write in this sample, reset the
# Line 1296  namespace { Line 1282  namespace {
1282              __resetCRC(crc);              __resetCRC(crc);
1283          }          }
1284          if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");          if (GetSize() < SampleCount) throw Exception("Could not write sample data, current sample size to small");
1285          unsigned long res;          file_offset_t res;
1286          if (BitDepth == 24) {          if (BitDepth == 24) {
1287              res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;              res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1288          } else { // 16 bit          } else { // 16 bit
# Line 1330  namespace { Line 1316  namespace {
1316       * @returns allocated decompression buffer       * @returns allocated decompression buffer
1317       * @see DestroyDecompressionBuffer()       * @see DestroyDecompressionBuffer()
1318       */       */
1319      buffer_t Sample::CreateDecompressionBuffer(unsigned long MaxReadSize) {      buffer_t Sample::CreateDecompressionBuffer(file_offset_t MaxReadSize) {
1320          buffer_t result;          buffer_t result;
1321          const double worstCaseHeaderOverhead =          const double worstCaseHeaderOverhead =
1322                  (256.0 /*frame size*/ + 12.0 /*header*/ + 2.0 /*compression type flag (stereo)*/) / 256.0;                  (256.0 /*frame size*/ + 12.0 /*header*/ + 2.0 /*compression type flag (stereo)*/) / 256.0;
1323          result.Size              = (unsigned long) (double(MaxReadSize) * 3.0 /*(24 Bit)*/ * 2.0 /*stereo*/ * worstCaseHeaderOverhead);          result.Size              = (file_offset_t) (double(MaxReadSize) * 3.0 /*(24 Bit)*/ * 2.0 /*stereo*/ * worstCaseHeaderOverhead);
1324          result.pStart            = new int8_t[result.Size];          result.pStart            = new int8_t[result.Size];
1325          result.NullExtensionSize = 0;          result.NullExtensionSize = 0;
1326          return result;          return result;
# Line 1368  namespace { Line 1354  namespace {
1354          return pGroup;          return pGroup;
1355      }      }
1356    
1357        /**
1358         * Returns the CRC-32 checksum of the sample's raw wave form data at the
1359         * time when this sample's wave form data was modified for the last time
1360         * by calling Write(). This checksum only covers the raw wave form data,
1361         * not any meta informations like i.e. bit depth or loop points. Since
1362         * this method just returns the checksum stored for this sample i.e. when
1363         * the gig file was loaded, this method returns immediately. So it does no
1364         * recalcuation of the checksum with the currently available sample wave
1365         * form data.
1366         *
1367         * @see VerifyWaveData()
1368         */
1369        uint32_t Sample::GetWaveDataCRC32Checksum() {
1370            return crc;
1371        }
1372    
1373        /**
1374         * Checks the integrity of this sample's raw audio wave data. Whenever a
1375         * Sample's raw wave data is intentionally modified (i.e. by calling
1376         * Write() and supplying the new raw audio wave form data) a CRC32 checksum
1377         * is calculated and stored/updated for this sample, along to the sample's
1378         * meta informations.
1379         *
1380         * Now by calling this method the current raw audio wave data is checked
1381         * against the already stored CRC32 check sum in order to check whether the
1382         * sample data had been damaged unintentionally for some reason. Since by
1383         * calling this method always the entire raw audio wave data has to be
1384         * read, verifying all samples this way may take a long time accordingly.
1385         * And that's also the reason why the sample integrity is not checked by
1386         * default whenever a gig file is loaded. So this method must be called
1387         * explicitly to fulfill this task.
1388         *
1389         * @param pActually - (optional) if provided, will be set to the actually
1390         *                    calculated checksum of the current raw wave form data,
1391         *                    you can get the expected checksum instead by calling
1392         *                    GetWaveDataCRC32Checksum()
1393         * @returns true if sample is OK or false if the sample is damaged
1394         * @throws Exception if no checksum had been stored to disk for this
1395         *         sample yet, or on I/O issues
1396         * @see GetWaveDataCRC32Checksum()
1397         */
1398        bool Sample::VerifyWaveData(uint32_t* pActually) {
1399            File* pFile = static_cast<File*>(GetParent());
1400            uint32_t crc = CalculateWaveDataChecksum();
1401            if (pActually) *pActually = crc;
1402            return crc == this->crc;
1403        }
1404    
1405        uint32_t Sample::CalculateWaveDataChecksum() {
1406            const size_t sz = 20*1024; // 20kB buffer size
1407            std::vector<uint8_t> buffer(sz);
1408            buffer.resize(sz);
1409    
1410            const size_t n = sz / FrameSize;
1411            SetPos(0);
1412            uint32_t crc = 0;
1413            __resetCRC(crc);
1414            while (true) {
1415                file_offset_t nRead = Read(&buffer[0], n);
1416                if (nRead <= 0) break;
1417                __calculateCRC(&buffer[0], nRead * FrameSize, crc);
1418            }
1419            __encodeCRC(crc);
1420            return crc;
1421        }
1422    
1423      Sample::~Sample() {      Sample::~Sample() {
1424          Instances--;          Instances--;
1425          if (!Instances && InternalDecompressionBuffer.Size) {          if (!Instances && InternalDecompressionBuffer.Size) {
# Line 1384  namespace { Line 1436  namespace {
1436  // *************** DimensionRegion ***************  // *************** DimensionRegion ***************
1437  // *  // *
1438    
1439      uint                               DimensionRegion::Instances       = 0;      size_t                             DimensionRegion::Instances       = 0;
1440      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1441    
1442      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
# Line 1578  namespace { Line 1630  namespace {
1630              EG2Attack                       = 0.0;              EG2Attack                       = 0.0;
1631              EG2Decay1                       = 0.005;              EG2Decay1                       = 0.005;
1632              EG2Sustain                      = 1000;              EG2Sustain                      = 1000;
1633              EG2Release                      = 0.3;              EG2Release                      = 60;
1634              LFO2ControlDepth                = 0;              LFO2ControlDepth                = 0;
1635              LFO2Frequency                   = 1.0;              LFO2Frequency                   = 1.0;
1636              LFO2InternalDepth               = 0;              LFO2InternalDepth               = 0;
# Line 1752  namespace { Line 1804  namespace {
1804       *       *
1805       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
1806       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
1807         *
1808         * @param pProgress - callback function for progress notification
1809       */       */
1810      void DimensionRegion::UpdateChunks() {      void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1811          // first update base class's chunk          // first update base class's chunk
1812          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks(pProgress);
1813    
1814          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1815          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
# Line 3026  namespace { Line 3080  namespace {
3080       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
3081       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
3082       *       *
3083         * @param pProgress - callback function for progress notification
3084       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
3085       */       */
3086      void Region::UpdateChunks() {      void Region::UpdateChunks(progress_t* pProgress) {
3087          // in the gig format we don't care about the Region's sample reference          // in the gig format we don't care about the Region's sample reference
3088          // but we still have to provide some existing one to not corrupt the          // but we still have to provide some existing one to not corrupt the
3089          // file, so to avoid the latter we simply always assign the sample of          // file, so to avoid the latter we simply always assign the sample of
# Line 3036  namespace { Line 3091  namespace {
3091          pSample = pDimensionRegions[0]->pSample;          pSample = pDimensionRegions[0]->pSample;
3092    
3093          // first update base class's chunks          // first update base class's chunks
3094          DLS::Region::UpdateChunks();          DLS::Region::UpdateChunks(pProgress);
3095    
3096          // update dimension region's chunks          // update dimension region's chunks
3097          for (int i = 0; i < DimensionRegions; i++) {          for (int i = 0; i < DimensionRegions; i++) {
3098              pDimensionRegions[i]->UpdateChunks();              pDimensionRegions[i]->UpdateChunks(pProgress);
3099          }          }
3100    
3101          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
# Line 3130  namespace { Line 3185  namespace {
3185          int step = 1;          int step = 1;
3186          for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;          for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
3187          int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;          int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
         int end = step * pDimensionDefinitions[veldim].zones;  
3188    
3189          // loop through all dimension regions for all dimensions except the velocity dimension          // loop through all dimension regions for all dimensions except the velocity dimension
3190          int dim[8] = { 0 };          int dim[8] = { 0 };
3191          for (int i = 0 ; i < DimensionRegions ; i++) {          for (int i = 0 ; i < DimensionRegions ; i++) {
3192                const int end = i + step * pDimensionDefinitions[veldim].zones;
3193    
3194                // create a velocity table for all cases where the velocity zone is zero
3195              if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||              if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
3196                  pDimensionRegions[i]->VelocityUpperLimit) {                  pDimensionRegions[i]->VelocityUpperLimit) {
3197                  // create the velocity table                  // create the velocity table
# Line 3166  namespace { Line 3222  namespace {
3222                  }                  }
3223              }              }
3224    
3225                // jump to the next case where the velocity zone is zero
3226              int j;              int j;
3227              int shift = 0;              int shift = 0;
3228              for (j = 0 ; j < Dimensions ; j++) {              for (j = 0 ; j < Dimensions ; j++) {
# Line 3652  namespace { Line 3709  namespace {
3709          UpdateVelocityTable();          UpdateVelocityTable();
3710      }      }
3711    
3712        /** @brief Change type of an existing dimension.
3713         *
3714         * Alters the dimension type of a dimension already existing on this
3715         * region. If there is currently no dimension on this Region with type
3716         * @a oldType, then this call with throw an Exception. Likewise there are
3717         * cases where the requested dimension type cannot be performed. For example
3718         * if the new dimension type shall be gig::dimension_samplechannel, and the
3719         * current dimension has more than 2 zones. In such cases an Exception is
3720         * thrown as well.
3721         *
3722         * @param oldType - identifies the existing dimension to be changed
3723         * @param newType - to which dimension type it should be changed to
3724         * @throws gig::Exception if requested change cannot be performed
3725         */
3726        void Region::SetDimensionType(dimension_t oldType, dimension_t newType) {
3727            if (oldType == newType) return;
3728            dimension_def_t* def = GetDimensionDefinition(oldType);
3729            if (!def)
3730                throw gig::Exception("No dimension with provided old dimension type exists on this region");
3731            if (newType == dimension_samplechannel && def->zones != 2)
3732                throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3733            if (GetDimensionDefinition(newType))
3734                throw gig::Exception("There is already a dimension with requested new dimension type on this region");
3735            def->dimension  = newType;
3736            def->split_type = __resolveSplitType(newType);
3737        }
3738    
3739      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {      DimensionRegion* Region::GetDimensionRegionByBit(const std::map<dimension_t,int>& DimCase) {
3740          uint8_t bits[8] = {};          uint8_t bits[8] = {};
3741          for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();          for (std::map<dimension_t,int>::const_iterator it = DimCase.begin();
# Line 3847  namespace { Line 3931  namespace {
3931          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
3932          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3933          if (!file->pWavePoolTable) return NULL;          if (!file->pWavePoolTable) return NULL;
3934          unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];          // for new files or files >= 2 GB use 64 bit wave pool offsets
3935          unsigned long soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
3936          Sample* sample = file->GetFirstSample(pProgress);              // use 64 bit wave pool offsets (treating this as large file)
3937          while (sample) {              uint64_t soughtoffset =
3938              if (sample->ulWavePoolOffset == soughtoffset &&                  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
3939                  sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);                  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
3940              sample = file->GetNextSample();              Sample* sample = file->GetFirstSample(pProgress);
3941                while (sample) {
3942                    if (sample->ullWavePoolOffset == soughtoffset)
3943                        return static_cast<gig::Sample*>(sample);
3944                    sample = file->GetNextSample();
3945                }
3946            } else {
3947                // use extension files and 32 bit wave pool offsets
3948                file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
3949                file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
3950                Sample* sample = file->GetFirstSample(pProgress);
3951                while (sample) {
3952                    if (sample->ullWavePoolOffset == soughtoffset &&
3953                        sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);
3954                    sample = file->GetNextSample();
3955                }
3956          }          }
3957          return NULL;          return NULL;
3958      }      }
# Line 4094  namespace { Line 4193  namespace {
4193              for (int i = 0; i < nameSize; ++i)              for (int i = 0; i < nameSize; ++i)
4194                  Name[i] = ckScri->ReadUint8();                  Name[i] = ckScri->ReadUint8();
4195              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4196              ckScri->SetPos(headerSize - 6*sizeof(int32_t) + nameSize, RIFF::stream_curpos);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4197              // read actual script data              // read actual script data
4198              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();
4199              data.resize(scriptSize);              data.resize(scriptSize);
# Line 4134  namespace { Line 4233  namespace {
4233          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4234      }      }
4235    
4236      void Script::UpdateChunks() {      /**
4237         * Apply this script to the respective RIFF chunks. You have to call
4238         * File::Save() to make changes persistent.
4239         *
4240         * Usually there is absolutely no need to call this method explicitly.
4241         * It will be called automatically when File::Save() was called.
4242         *
4243         * @param pProgress - callback function for progress notification
4244         */
4245        void Script::UpdateChunks(progress_t* pProgress) {
4246          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4247          __resetCRC(crc);          __resetCRC(crc);
4248          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
# Line 4173  namespace { Line 4281  namespace {
4281       * @param pGroup - script's new group       * @param pGroup - script's new group
4282       */       */
4283      void Script::SetGroup(ScriptGroup* pGroup) {      void Script::SetGroup(ScriptGroup* pGroup) {
4284          if (this->pGroup = pGroup) return;          if (this->pGroup == pGroup) return;
4285          if (pChunk)          if (pChunk)
4286              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4287          this->pGroup = pGroup;          this->pGroup = pGroup;
4288      }      }
4289    
4290        /**
4291         * Returns the script group this script currently belongs to. Each script
4292         * is a member of exactly one ScriptGroup.
4293         *
4294         * @returns current script group
4295         */
4296        ScriptGroup* Script::GetGroup() const {
4297            return pGroup;
4298        }
4299    
4300      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4301          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4302          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4214  namespace { Line 4332  namespace {
4332          }          }
4333      }      }
4334    
4335      void ScriptGroup::UpdateChunks() {      /**
4336         * Apply this script group to the respective RIFF chunks. You have to call
4337         * File::Save() to make changes persistent.
4338         *
4339         * Usually there is absolutely no need to call this method explicitly.
4340         * It will be called automatically when File::Save() was called.
4341         *
4342         * @param pProgress - callback function for progress notification
4343         */
4344        void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4345          if (pScripts) {          if (pScripts) {
4346              if (!pList)              if (!pList)
4347                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
# Line 4225  namespace { Line 4352  namespace {
4352              for (std::list<Script*>::iterator it = pScripts->begin();              for (std::list<Script*>::iterator it = pScripts->begin();
4353                   it != pScripts->end(); ++it)                   it != pScripts->end(); ++it)
4354              {              {
4355                  (*it)->UpdateChunks();                  (*it)->UpdateChunks(pProgress);
4356              }              }
4357          }          }
4358      }      }
# Line 4388  namespace { Line 4515  namespace {
4515          if (lst3LS) {          if (lst3LS) {
4516              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);              RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4517              if (ckSCSL) {              if (ckSCSL) {
4518                  int slotCount = ckSCSL->ReadUint32();                  int headerSize = ckSCSL->ReadUint32();
4519                  int slotSize  = ckSCSL->ReadUint32();                  int slotCount  = ckSCSL->ReadUint32();
4520                  int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future extensions                  if (slotCount) {
4521                  for (int i = 0; i < slotCount; ++i) {                      int slotSize  = ckSCSL->ReadUint32();
4522                      _ScriptPooolEntry e;                      ckSCSL->SetPos(headerSize); // in case of future header extensions
4523                      e.fileOffset = ckSCSL->ReadUint32();                      int unknownSpace = slotSize - 2*sizeof(uint32_t); // in case of future slot extensions
4524                      e.bypass     = ckSCSL->ReadUint32() & 1;                      for (int i = 0; i < slotCount; ++i) {
4525                      if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions                          _ScriptPooolEntry e;
4526                      scriptPoolFileOffsets.push_back(e);                          e.fileOffset = ckSCSL->ReadUint32();
4527                            e.bypass     = ckSCSL->ReadUint32() & 1;
4528                            if (unknownSpace) ckSCSL->SetPos(unknownSpace, RIFF::stream_curpos); // in case of future extensions
4529                            scriptPoolFileOffsets.push_back(e);
4530                        }
4531                  }                  }
4532              }              }
4533          }          }
# Line 4431  namespace { Line 4562  namespace {
4562       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
4563       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
4564       *       *
4565         * @param pProgress - callback function for progress notification
4566       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
4567       */       */
4568      void Instrument::UpdateChunks() {      void Instrument::UpdateChunks(progress_t* pProgress) {
4569          // first update base classes' chunks          // first update base classes' chunks
4570          DLS::Instrument::UpdateChunks();          DLS::Instrument::UpdateChunks(pProgress);
4571    
4572          // update Regions' chunks          // update Regions' chunks
4573          {          {
4574              RegionList::iterator iter = pRegions->begin();              RegionList::iterator iter = pRegions->begin();
4575              RegionList::iterator end  = pRegions->end();              RegionList::iterator end  = pRegions->end();
4576              for (; iter != end; ++iter)              for (; iter != end; ++iter)
4577                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
4578          }          }
4579    
4580          // make sure 'lart' RIFF list chunk exists          // make sure 'lart' RIFF list chunk exists
# Line 4479  namespace { Line 4611  namespace {
4611          }          }
4612    
4613          // own gig format extensions          // own gig format extensions
4614         if (pScriptRefs) {         if (ScriptSlotCount()) {
4615               // make sure we have converted the original loaded script file
4616               // offsets into valid Script object pointers
4617               LoadScripts();
4618    
4619             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4620             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4621             const int totalSize = pScriptRefs->size() * 2*sizeof(uint32_t);             const int slotCount = pScriptRefs->size();
4622               const int headerSize = 3 * sizeof(uint32_t);
4623               const int slotSize  = 2 * sizeof(uint32_t);
4624               const int totalChunkSize = headerSize + slotCount * slotSize;
4625             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4626             if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalSize);             if (!ckSCSL) ckSCSL = lst3LS->AddSubChunk(CHUNK_ID_SCSL, totalChunkSize);
4627             else ckSCSL->Resize(totalSize);             else ckSCSL->Resize(totalChunkSize);
4628             uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();             uint8_t* pData = (uint8_t*) ckSCSL->LoadChunkData();
4629             for (int i = 0, pos = 0; i < pScriptRefs->size(); ++i) {             int pos = 0;
4630                 int fileOffset =             store32(&pData[pos], headerSize);
4631                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -             pos += sizeof(uint32_t);
4632                      (*pScriptRefs)[i].script->pChunk->GetPos() -             store32(&pData[pos], slotCount);
4633                      CHUNK_HEADER_SIZE;             pos += sizeof(uint32_t);
4634                 store32(&pData[pos], fileOffset);             store32(&pData[pos], slotSize);
4635               pos += sizeof(uint32_t);
4636               for (int i = 0; i < slotCount; ++i) {
4637                   // arbitrary value, the actual file offset will be updated in
4638                   // UpdateScriptFileOffsets() after the file has been resized
4639                   int bogusFileOffset = 0;
4640                   store32(&pData[pos], bogusFileOffset);
4641                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
4642                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4643                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
4644             }             }
4645           } else {
4646               // no script slots, so get rid of any LS custom RIFF chunks (if any)
4647               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4648               if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS);
4649         }         }
4650      }      }
4651    
4652        void Instrument::UpdateScriptFileOffsets() {
4653           // own gig format extensions
4654           if (pScriptRefs && pScriptRefs->size() > 0) {
4655               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4656               RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4657               const int slotCount = pScriptRefs->size();
4658               const int headerSize = 3 * sizeof(uint32_t);
4659               ckSCSL->SetPos(headerSize);
4660               for (int i = 0; i < slotCount; ++i) {
4661                   uint32_t fileOffset =
4662                        (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4663                        (*pScriptRefs)[i].script->pChunk->GetPos() -
4664                        CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());
4665                   ckSCSL->WriteUint32(&fileOffset);
4666                   // jump over flags entry (containing the bypass flag)
4667                   ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
4668               }
4669           }        
4670        }
4671    
4672      /**      /**
4673       * Returns the appropriate Region for a triggered note.       * Returns the appropriate Region for a triggered note.
4674       *       *
# Line 4567  namespace { Line 4736  namespace {
4736      }      }
4737    
4738      /**      /**
4739         * Move this instrument at the position before @arg dst.
4740         *
4741         * This method can be used to reorder the sequence of instruments in a
4742         * .gig file. This might be helpful especially on large .gig files which
4743         * contain a large number of instruments within the same .gig file. So
4744         * grouping such instruments to similar ones, can help to keep track of them
4745         * when working with such complex .gig files.
4746         *
4747         * When calling this method, this instrument will be removed from in its
4748         * current position in the instruments list and moved to the requested
4749         * target position provided by @param dst. You may also pass NULL as
4750         * argument to this method, in that case this intrument will be moved to the
4751         * very end of the .gig file's instrument list.
4752         *
4753         * You have to call Save() to make the order change persistent to the .gig
4754         * file.
4755         *
4756         * Currently this method is limited to moving the instrument within the same
4757         * .gig file. Trying to move it to another .gig file by calling this method
4758         * will throw an exception.
4759         *
4760         * @param dst - destination instrument at which this instrument will be
4761         *              moved to, or pass NULL for moving to end of list
4762         * @throw gig::Exception if this instrument and target instrument are not
4763         *                       part of the same file
4764         */
4765        void Instrument::MoveTo(Instrument* dst) {
4766            if (dst && GetParent() != dst->GetParent())
4767                throw Exception(
4768                    "gig::Instrument::MoveTo() can only be used for moving within "
4769                    "the same gig file."
4770                );
4771    
4772            File* pFile = (File*) GetParent();
4773    
4774            // move this instrument within the instrument list
4775            {
4776                File::InstrumentList& list = *pFile->pInstruments;
4777    
4778                File::InstrumentList::iterator itFrom =
4779                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
4780    
4781                File::InstrumentList::iterator itTo =
4782                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
4783    
4784                list.splice(itTo, list, itFrom);
4785            }
4786    
4787            // move the instrument's actual list RIFF chunk appropriately
4788            RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS);
4789            lstCkInstruments->MoveSubChunk(
4790                this->pCkInstrument,
4791                (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
4792            );
4793        }
4794    
4795        /**
4796       * Returns a MIDI rule of the instrument.       * Returns a MIDI rule of the instrument.
4797       *       *
4798       * The list of MIDI rules, at least in gig v3, always contains at       * The list of MIDI rules, at least in gig v3, always contains at
# Line 4635  namespace { Line 4861  namespace {
4861          if (scriptPoolFileOffsets.empty()) return;          if (scriptPoolFileOffsets.empty()) return;
4862          File* pFile = (File*) GetParent();          File* pFile = (File*) GetParent();
4863          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {          for (uint k = 0; k < scriptPoolFileOffsets.size(); ++k) {
4864              uint32_t offset = scriptPoolFileOffsets[k].fileOffset;              uint32_t soughtOffset = scriptPoolFileOffsets[k].fileOffset;
4865              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {              for (uint i = 0; pFile->GetScriptGroup(i); ++i) {
4866                  ScriptGroup* group = pFile->GetScriptGroup(i);                  ScriptGroup* group = pFile->GetScriptGroup(i);
4867                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
4868                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
4869                      if (script->pChunk) {                      if (script->pChunk) {
4870                          script->pChunk->SetPos(0);                          uint32_t offset = script->pChunk->GetFilePos() -
4871                          if (script->pChunk->GetFilePos() -                                            script->pChunk->GetPos() -
4872                              script->pChunk->GetPos() -                                            CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());
4873                              CHUNK_HEADER_SIZE == offset)                          if (offset == soughtOffset)
4874                          {                          {
4875                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
4876                              ref.script = script;                              ref.script = script;
# Line 4926  namespace { Line 5152  namespace {
5152       *       *
5153       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5154       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5155         *
5156         * @param pProgress - callback function for progress notification
5157       */       */
5158      void Group::UpdateChunks() {      void Group::UpdateChunks(progress_t* pProgress) {
5159          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
5160          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5161          if (!_3gri) {          if (!_3gri) {
# Line 5204  namespace { Line 5432  namespace {
5432          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5433    
5434          // check if samples should be loaded from extension files          // check if samples should be loaded from extension files
5435            // (only for old gig files < 2 GB)
5436          int lastFileNo = 0;          int lastFileNo = 0;
5437          for (int i = 0 ; i < WavePoolCount ; i++) {          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {
5438              if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];              for (int i = 0 ; i < WavePoolCount ; i++) {
5439                    if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
5440                }
5441          }          }
5442          String name(pRIFF->GetFileName());          String name(pRIFF->GetFileName());
5443          int nameLen = name.length();          int nameLen = name.length();
# Line 5216  namespace { Line 5447  namespace {
5447          for (int fileNo = 0 ; ; ) {          for (int fileNo = 0 ; ; ) {
5448              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5449              if (wvpl) {              if (wvpl) {
5450                  unsigned long wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos();
5451                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
5452                  while (wave) {                  while (wave) {
5453                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
# Line 5224  namespace { Line 5455  namespace {
5455                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5456                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5457    
5458                          unsigned long waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5459                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5460    
5461                          iSampleIndex++;                          iSampleIndex++;
5462                      }                      }
# Line 5463  namespace { Line 5694  namespace {
5694          if (!_3crc) return;          if (!_3crc) return;
5695    
5696          // get the index of the sample          // get the index of the sample
5697          int iWaveIndex = -1;          int iWaveIndex = GetWaveTableIndexOf(pSample);
         File::SampleList::iterator iter = pSamples->begin();  
         File::SampleList::iterator end  = pSamples->end();  
         for (int index = 0; iter != end; ++iter, ++index) {  
             if (*iter == pSample) {  
                 iWaveIndex = index;  
                 break;  
             }  
         }  
5698          if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");          if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
5699    
5700          // write the CRC-32 checksum to disk          // write the CRC-32 checksum to disk
5701          _3crc->SetPos(iWaveIndex * 8);          _3crc->SetPos(iWaveIndex * 8);
5702          uint32_t tmp = 1;          uint32_t one = 1;
5703          _3crc->WriteUint32(&tmp); // unknown, always 1?          _3crc->WriteUint32(&one); // always 1
5704          _3crc->WriteUint32(&crc);          _3crc->WriteUint32(&crc);
5705      }      }
5706    
5707        uint32_t File::GetSampleChecksum(Sample* pSample) {
5708            // get the index of the sample
5709            int iWaveIndex = GetWaveTableIndexOf(pSample);
5710            if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
5711    
5712            return GetSampleChecksumByIndex(iWaveIndex);
5713        }
5714    
5715        uint32_t File::GetSampleChecksumByIndex(int index) {
5716            if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
5717    
5718            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5719            if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5720            uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
5721            if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5722    
5723            // read the CRC-32 checksum directly from disk
5724            size_t pos = index * 8;
5725            if (pos + 8 > _3crc->GetNewSize())
5726                throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
5727    
5728            uint32_t one = load32(&pData[pos]); // always 1
5729            if (one != 1)
5730                throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
5731    
5732            return load32(&pData[pos+4]);
5733        }
5734    
5735        int File::GetWaveTableIndexOf(gig::Sample* pSample) {
5736            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5737            File::SampleList::iterator iter = pSamples->begin();
5738            File::SampleList::iterator end  = pSamples->end();
5739            for (int index = 0; iter != end; ++iter, ++index)
5740                if (*iter == pSample)
5741                    return index;
5742            return -1;
5743        }
5744    
5745        /**
5746         * Checks whether the file's "3CRC" chunk was damaged. This chunk contains
5747         * the CRC32 check sums of all samples' raw wave data.
5748         *
5749         * @return true if 3CRC chunk is OK, or false if 3CRC chunk is damaged
5750         */
5751        bool File::VerifySampleChecksumTable() {
5752            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5753            if (!_3crc) return false;
5754            if (_3crc->GetNewSize() <= 0) return false;
5755            if (_3crc->GetNewSize() % 8) return false;
5756            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5757            if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
5758    
5759            const int n = _3crc->GetNewSize() / 8;
5760    
5761            uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
5762            if (!pData) return false;
5763    
5764            for (int i = 0; i < n; ++i) {
5765                uint32_t one = pData[i*2];
5766                if (one != 1) return false;
5767            }
5768    
5769            return true;
5770        }
5771    
5772        /**
5773         * Recalculates CRC32 checksums for all samples and rebuilds this gig
5774         * file's checksum table with those new checksums. This might usually
5775         * just be necessary if the checksum table was damaged.
5776         *
5777         * @e IMPORTANT: The current implementation of this method only works
5778         * with files that have not been modified since it was loaded, because
5779         * it expects that no externally caused file structure changes are
5780         * required!
5781         *
5782         * Due to the expectation above, this method is currently protected
5783         * and actually only used by the command line tool "gigdump" yet.
5784         *
5785         * @returns true if Save() is required to be called after this call,
5786         *          false if no further action is required
5787         */
5788        bool File::RebuildSampleChecksumTable() {
5789            // make sure sample chunks were scanned
5790            if (!pSamples) GetFirstSample();
5791    
5792            bool bRequiresSave = false;
5793    
5794            // make sure "3CRC" chunk exists with required size
5795            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5796            if (!_3crc) {
5797                _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
5798                // the order of einf and 3crc is not the same in v2 and v3
5799                RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
5800                if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
5801                bRequiresSave = true;
5802            } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
5803                _3crc->Resize(pSamples->size() * 8);
5804                bRequiresSave = true;
5805            }
5806    
5807            if (bRequiresSave) { // refill CRC table for all samples in RAM ...
5808                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
5809                {
5810                    File::SampleList::iterator iter = pSamples->begin();
5811                    File::SampleList::iterator end  = pSamples->end();
5812                    for (; iter != end; ++iter) {
5813                        gig::Sample* pSample = (gig::Sample*) *iter;
5814                        int index = GetWaveTableIndexOf(pSample);
5815                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
5816                        pData[index*2]   = 1; // always 1
5817                        pData[index*2+1] = pSample->CalculateWaveDataChecksum();
5818                    }
5819                }
5820            } else { // no file structure changes necessary, so directly write to disk and we are done ...
5821                // make sure file is in write mode
5822                pRIFF->SetMode(RIFF::stream_mode_read_write);
5823                {
5824                    File::SampleList::iterator iter = pSamples->begin();
5825                    File::SampleList::iterator end  = pSamples->end();
5826                    for (; iter != end; ++iter) {
5827                        gig::Sample* pSample = (gig::Sample*) *iter;
5828                        int index = GetWaveTableIndexOf(pSample);
5829                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
5830                        pSample->crc  = pSample->CalculateWaveDataChecksum();
5831                        SetSampleChecksum(pSample, pSample->crc);
5832                    }
5833                }
5834            }
5835    
5836            return bRequiresSave;
5837        }
5838    
5839      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
5840          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
5841          // there must always be at least one group          // there must always be at least one group
# Line 5703  namespace { Line 6058  namespace {
6058       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
6059       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
6060       *       *
6061         * @param pProgress - callback function for progress notification
6062       * @throws Exception - on errors       * @throws Exception - on errors
6063       */       */
6064      void File::UpdateChunks() {      void File::UpdateChunks(progress_t* pProgress) {
6065          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
6066    
         b64BitWavePoolOffsets = pVersion && pVersion->major == 3;  
   
6067          // update own gig format extension chunks          // update own gig format extension chunks
6068          // (not part of the GigaStudio 4 format)          // (not part of the GigaStudio 4 format)
6069          //          RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
6070            if (!lst3LS) {
6071                lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
6072            }
6073            // Make sure <3LS > chunk is placed before <ptbl> chunk. The precise
6074            // location of <3LS > is irrelevant, however it should be located
6075            // before  the actual wave data
6076            RIFF::Chunk* ckPTBL = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
6077            pRIFF->MoveSubChunk(lst3LS, ckPTBL);
6078    
6079          // This must be performed before writing the chunks for instruments,          // This must be performed before writing the chunks for instruments,
6080          // because the instruments' script slots will write the file offsets          // because the instruments' script slots will write the file offsets
6081          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
6082          if (pScriptGroups) {          if (pScriptGroups) {
6083              RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);              // Update instrument script (group) chunks.
6084              if (pScriptGroups->empty()) {              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6085                  if (lst3LS) pRIFF->DeleteSubChunk(lst3LS);                   it != pScriptGroups->end(); ++it)
6086              } else {              {
6087                  if (!lst3LS) lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);                  (*it)->UpdateChunks(pProgress);
   
                 // Update instrument script (group) chunks.  
   
                 for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();  
                      it != pScriptGroups->end(); ++it)  
                 {  
                     (*it)->UpdateChunks();  
                 }  
6088              }              }
6089          }          }
6090    
6091            // in case no libgig custom format data was added, then remove the
6092            // custom "3LS " chunk again
6093            if (!lst3LS->CountSubChunks()) {
6094                pRIFF->DeleteSubChunk(lst3LS);
6095                lst3LS = NULL;
6096            }
6097    
6098          // first update base class's chunks          // first update base class's chunks
6099          DLS::File::UpdateChunks();          DLS::File::UpdateChunks(pProgress);
6100    
6101          if (newFile) {          if (newFile) {
6102              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
# Line 5771  namespace { Line 6133  namespace {
6133              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
6134              std::list<Group*>::iterator end  = pGroups->end();              std::list<Group*>::iterator end  = pGroups->end();
6135              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
6136                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
6137              }              }
6138          }          }
6139    
# Line 5889  namespace { Line 6251  namespace {
6251          // update 3crc chunk          // update 3crc chunk
6252    
6253          // The 3crc chunk contains CRC-32 checksums for the          // The 3crc chunk contains CRC-32 checksums for the
6254          // samples. The actual checksum values will be filled in          // samples. When saving a gig file to disk, we first update the 3CRC
6255          // later, by Sample::Write.          // chunk here (in RAM) with the old crc values which we read from the
6256            // 3CRC chunk when we opened the file (available with gig::Sample::crc
6257            // member variable). This step is required, because samples might have
6258            // been deleted by the user since the file was opened, which in turn
6259            // changes the order of the (i.e. old) checksums within the 3crc chunk.
6260            // If a sample was conciously modified by the user (that is if
6261            // Sample::Write() was called later on) then Sample::Write() will just
6262            // update the respective individual checksum(s) directly on disk and
6263            // leaves all other sample checksums untouched.
6264    
6265          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6266          if (_3crc) {          if (_3crc) {
6267              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
6268          } else if (newFile) {          } else /*if (newFile)*/ {
6269              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
             _3crc->LoadChunkData();  
   
6270              // the order of einf and 3crc is not the same in v2 and v3              // the order of einf and 3crc is not the same in v2 and v3
6271              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6272          }          }
6273            { // must be performed in RAM here ...
6274                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6275                if (pData) {
6276                    File::SampleList::iterator iter = pSamples->begin();
6277                    File::SampleList::iterator end  = pSamples->end();
6278                    for (int index = 0; iter != end; ++iter, ++index) {
6279                        gig::Sample* pSample = (gig::Sample*) *iter;
6280                        pData[index*2]   = 1; // always 1
6281                        pData[index*2+1] = pSample->crc;
6282                    }
6283                }
6284            }
6285        }
6286        
6287        void File::UpdateFileOffsets() {
6288            DLS::File::UpdateFileOffsets();
6289    
6290            for (Instrument* instrument = GetFirstInstrument(); instrument;
6291                 instrument = GetNextInstrument())
6292            {
6293                instrument->UpdateScriptFileOffsets();
6294            }
6295      }      }
6296    
6297      /**      /**
Legend:
Removed from v.2599  
changed lines
  Added in v.2990
  ViewVC Help
Powered by ViewVC