/[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 2667 by schoenebeck, Mon Jul 7 15:20:22 2014 UTC revision 3112 by schoenebeck, Wed Feb 15 13:21:31 2017 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 303  namespace { Line 275  namespace {
275       * @param bufSize - size of the data to be processed       * @param bufSize - size of the data to be processed
276       * @param crc     - variable the CRC sum shall be stored to       * @param crc     - variable the CRC sum shall be stored to
277       */       */
278      static void __calculateCRC(unsigned char* buf, int bufSize, uint32_t& crc) {      static void __calculateCRC(unsigned char* buf, size_t bufSize, uint32_t& crc) {
279          for (int i = 0 ; i < bufSize ; i++) {          for (size_t i = 0 ; i < bufSize ; i++) {
280              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
281          }          }
282      }      }
# 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 1775  namespace { Line 1829  namespace {
1829    
1830          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1831    
1832          const uint32_t chunksize = _3ewa->GetNewSize();          const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
1833          store32(&pData[0], chunksize); // unknown, always chunk size?          store32(&pData[0], chunksize); // unknown, always chunk size?
1834    
1835          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
# 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 3740  namespace { Line 3797  namespace {
3797      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
3798          uint8_t bits;          uint8_t bits;
3799          int veldim = -1;          int veldim = -1;
3800          int velbitpos;          int velbitpos = 0;
3801          int bitpos = 0;          int bitpos = 0;
3802          int dimregidx = 0;          int dimregidx = 0;
3803          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3789  namespace { Line 3846  namespace {
3846      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
3847          uint8_t bits;          uint8_t bits;
3848          int veldim = -1;          int veldim = -1;
3849          int velbitpos;          int velbitpos = 0;
3850          int bitpos = 0;          int bitpos = 0;
3851          int dimregidx = 0;          int dimregidx = 0;
3852          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3874  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 4123  namespace { Line 4195  namespace {
4195              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4196              ckScri->SetPos(sizeof(int32_t) + headerSize);              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 = uint32_t(ckScri->GetSize() - ckScri->GetPos());
4199              data.resize(scriptSize);              data.resize(scriptSize);
4200              for (int i = 0; i < scriptSize; ++i)              for (int i = 0; i < scriptSize; ++i)
4201                  data[i] = ckScri->ReadUint8();                  data[i] = ckScri->ReadUint8();
# Line 4161  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);
4249          __encodeCRC(crc);          __encodeCRC(crc);
4250          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4251          const int chunkSize = 7*sizeof(int32_t) + Name.size() + data.size();          const file_offset_t chunkSize = (file_offset_t) 7*sizeof(int32_t) + Name.size() + data.size();
4252          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4253          else pChunk->Resize(chunkSize);          else pChunk->Resize(chunkSize);
4254          // fill the chunk data to be written to disk          // fill the chunk data to be written to disk
4255          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4256          int pos = 0;          int pos = 0;
4257          store32(&pData[pos], 6*sizeof(int32_t) + Name.size()); // total header size          store32(&pData[pos], uint32_t(6*sizeof(int32_t) + Name.size())); // total header size
4258          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4259          store32(&pData[pos], Compression);          store32(&pData[pos], Compression);
4260          pos += sizeof(int32_t);          pos += sizeof(int32_t);
# Line 4185  namespace { Line 4266  namespace {
4266          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4267          store32(&pData[pos], crc);          store32(&pData[pos], crc);
4268          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4269          store32(&pData[pos], Name.size());          store32(&pData[pos], (uint32_t) Name.size());
4270          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4271          for (int i = 0; i < Name.size(); ++i, ++pos)          for (int i = 0; i < Name.size(); ++i, ++pos)
4272              pData[pos] = Name[i];              pData[pos] = Name[i];
# Line 4200  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;
# Line 4251  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 4262  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 4353  namespace { Line 4443  namespace {
4443          EffectSend = 0;          EffectSend = 0;
4444          Attenuation = 0;          Attenuation = 0;
4445          FineTune = 0;          FineTune = 0;
4446          PitchbendRange = 0;          PitchbendRange = 2;
4447          PianoReleaseMode = false;          PianoReleaseMode = false;
4448          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
4449          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
# Line 4472  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 4527  namespace { Line 4618  namespace {
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 slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4622             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4623             const int slotSize  = 2 * sizeof(uint32_t);             const int slotSize  = 2 * sizeof(uint32_t);
4624             const int totalChunkSize = headerSize + slotCount * slotSize;             const int totalChunkSize = headerSize + slotCount * slotSize;
# Line 4563  namespace { Line 4654  namespace {
4654         if (pScriptRefs && pScriptRefs->size() > 0) {         if (pScriptRefs && pScriptRefs->size() > 0) {
4655             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4656             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4657             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4658             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4659             ckSCSL->SetPos(headerSize);             ckSCSL->SetPos(headerSize);
4660             for (int i = 0; i < slotCount; ++i) {             for (int i = 0; i < slotCount; ++i) {
4661                 uint32_t fileOffset =                 uint32_t fileOffset = uint32_t(
4662                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4663                      (*pScriptRefs)[i].script->pChunk->GetPos() -                      (*pScriptRefs)[i].script->pChunk->GetPos() -
4664                      CHUNK_HEADER_SIZE;                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
4665                   );
4666                 ckSCSL->WriteUint32(&fileOffset);                 ckSCSL->WriteUint32(&fileOffset);
4667                 // jump over flags entry (containing the bypass flag)                 // jump over flags entry (containing the bypass flag)
4668                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
# Line 4630  namespace { Line 4722  namespace {
4722          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
4723          Region* pNewRegion = new Region(this, rgn);          Region* pNewRegion = new Region(this, rgn);
4724          pRegions->push_back(pNewRegion);          pRegions->push_back(pNewRegion);
4725          Regions = pRegions->size();          Regions = (uint32_t) pRegions->size();
4726          // update Region key table for fast lookup          // update Region key table for fast lookup
4727          UpdateRegionKeyTable();          UpdateRegionKeyTable();
4728          // done          // done
# Line 4645  namespace { Line 4737  namespace {
4737      }      }
4738    
4739      /**      /**
4740         * Move this instrument at the position before @arg dst.
4741         *
4742         * This method can be used to reorder the sequence of instruments in a
4743         * .gig file. This might be helpful especially on large .gig files which
4744         * contain a large number of instruments within the same .gig file. So
4745         * grouping such instruments to similar ones, can help to keep track of them
4746         * when working with such complex .gig files.
4747         *
4748         * When calling this method, this instrument will be removed from in its
4749         * current position in the instruments list and moved to the requested
4750         * target position provided by @param dst. You may also pass NULL as
4751         * argument to this method, in that case this intrument will be moved to the
4752         * very end of the .gig file's instrument list.
4753         *
4754         * You have to call Save() to make the order change persistent to the .gig
4755         * file.
4756         *
4757         * Currently this method is limited to moving the instrument within the same
4758         * .gig file. Trying to move it to another .gig file by calling this method
4759         * will throw an exception.
4760         *
4761         * @param dst - destination instrument at which this instrument will be
4762         *              moved to, or pass NULL for moving to end of list
4763         * @throw gig::Exception if this instrument and target instrument are not
4764         *                       part of the same file
4765         */
4766        void Instrument::MoveTo(Instrument* dst) {
4767            if (dst && GetParent() != dst->GetParent())
4768                throw Exception(
4769                    "gig::Instrument::MoveTo() can only be used for moving within "
4770                    "the same gig file."
4771                );
4772    
4773            File* pFile = (File*) GetParent();
4774    
4775            // move this instrument within the instrument list
4776            {
4777                File::InstrumentList& list = *pFile->pInstruments;
4778    
4779                File::InstrumentList::iterator itFrom =
4780                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
4781    
4782                File::InstrumentList::iterator itTo =
4783                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
4784    
4785                list.splice(itTo, list, itFrom);
4786            }
4787    
4788            // move the instrument's actual list RIFF chunk appropriately
4789            RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS);
4790            lstCkInstruments->MoveSubChunk(
4791                this->pCkInstrument,
4792                (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
4793            );
4794        }
4795    
4796        /**
4797       * Returns a MIDI rule of the instrument.       * Returns a MIDI rule of the instrument.
4798       *       *
4799       * 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 4719  namespace { Line 4868  namespace {
4868                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
4869                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
4870                      if (script->pChunk) {                      if (script->pChunk) {
4871                          uint32_t offset = script->pChunk->GetFilePos() -                          uint32_t offset = uint32_t(
4872                                            script->pChunk->GetPos() -                              script->pChunk->GetFilePos() -
4873                                            CHUNK_HEADER_SIZE;                              script->pChunk->GetPos() -
4874                                CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
4875                            );
4876                          if (offset == soughtOffset)                          if (offset == soughtOffset)
4877                          {                          {
4878                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
# Line 4846  namespace { Line 4997  namespace {
4997       */       */
4998      void Instrument::RemoveScript(Script* pScript) {      void Instrument::RemoveScript(Script* pScript) {
4999          LoadScripts();          LoadScripts();
5000          for (int i = pScriptRefs->size() - 1; i >= 0; --i) {          for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5001              if ((*pScriptRefs)[i].script == pScript) {              if ((*pScriptRefs)[i].script == pScript) {
5002                  pScriptRefs->erase( pScriptRefs->begin() + i );                  pScriptRefs->erase( pScriptRefs->begin() + i );
5003              }              }
# Line 4868  namespace { Line 5019  namespace {
5019       * gigedit.       * gigedit.
5020       */       */
5021      uint Instrument::ScriptSlotCount() const {      uint Instrument::ScriptSlotCount() const {
5022          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5023      }      }
5024    
5025      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5004  namespace { Line 5155  namespace {
5155       *       *
5156       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5157       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5158         *
5159         * @param pProgress - callback function for progress notification
5160       */       */
5161      void Group::UpdateChunks() {      void Group::UpdateChunks(progress_t* pProgress) {
5162          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
5163          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5164          if (!_3gri) {          if (!_3gri) {
# Line 5282  namespace { Line 5435  namespace {
5435          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5436    
5437          // check if samples should be loaded from extension files          // check if samples should be loaded from extension files
5438            // (only for old gig files < 2 GB)
5439          int lastFileNo = 0;          int lastFileNo = 0;
5440          for (int i = 0 ; i < WavePoolCount ; i++) {          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {
5441              if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];              for (int i = 0 ; i < WavePoolCount ; i++) {
5442                    if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
5443                }
5444          }          }
5445          String name(pRIFF->GetFileName());          String name(pRIFF->GetFileName());
5446          int nameLen = name.length();          int nameLen = (int) name.length();
5447          char suffix[6];          char suffix[6];
5448          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
5449    
5450          for (int fileNo = 0 ; ; ) {          for (int fileNo = 0 ; ; ) {
5451              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5452              if (wvpl) {              if (wvpl) {
5453                  unsigned long wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos();
5454                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
5455                  while (wave) {                  while (wave) {
5456                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
# Line 5302  namespace { Line 5458  namespace {
5458                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5459                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5460    
5461                          unsigned long waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5462                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5463    
5464                          iSampleIndex++;                          iSampleIndex++;
5465                      }                      }
# Line 5541  namespace { Line 5697  namespace {
5697          if (!_3crc) return;          if (!_3crc) return;
5698    
5699          // get the index of the sample          // get the index of the sample
5700          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;  
             }  
         }  
5701          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");
5702    
5703          // write the CRC-32 checksum to disk          // write the CRC-32 checksum to disk
5704          _3crc->SetPos(iWaveIndex * 8);          _3crc->SetPos(iWaveIndex * 8);
5705          uint32_t tmp = 1;          uint32_t one = 1;
5706          _3crc->WriteUint32(&tmp); // unknown, always 1?          _3crc->WriteUint32(&one); // always 1
5707          _3crc->WriteUint32(&crc);          _3crc->WriteUint32(&crc);
5708      }      }
5709    
5710        uint32_t File::GetSampleChecksum(Sample* pSample) {
5711            // get the index of the sample
5712            int iWaveIndex = GetWaveTableIndexOf(pSample);
5713            if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
5714    
5715            return GetSampleChecksumByIndex(iWaveIndex);
5716        }
5717    
5718        uint32_t File::GetSampleChecksumByIndex(int index) {
5719            if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
5720    
5721            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5722            if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5723            uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
5724            if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5725    
5726            // read the CRC-32 checksum directly from disk
5727            size_t pos = index * 8;
5728            if (pos + 8 > _3crc->GetNewSize())
5729                throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
5730    
5731            uint32_t one = load32(&pData[pos]); // always 1
5732            if (one != 1)
5733                throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
5734    
5735            return load32(&pData[pos+4]);
5736        }
5737    
5738        int File::GetWaveTableIndexOf(gig::Sample* pSample) {
5739            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5740            File::SampleList::iterator iter = pSamples->begin();
5741            File::SampleList::iterator end  = pSamples->end();
5742            for (int index = 0; iter != end; ++iter, ++index)
5743                if (*iter == pSample)
5744                    return index;
5745            return -1;
5746        }
5747    
5748        /**
5749         * Checks whether the file's "3CRC" chunk was damaged. This chunk contains
5750         * the CRC32 check sums of all samples' raw wave data.
5751         *
5752         * @return true if 3CRC chunk is OK, or false if 3CRC chunk is damaged
5753         */
5754        bool File::VerifySampleChecksumTable() {
5755            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5756            if (!_3crc) return false;
5757            if (_3crc->GetNewSize() <= 0) return false;
5758            if (_3crc->GetNewSize() % 8) return false;
5759            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5760            if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
5761    
5762            const file_offset_t n = _3crc->GetNewSize() / 8;
5763    
5764            uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
5765            if (!pData) return false;
5766    
5767            for (file_offset_t i = 0; i < n; ++i) {
5768                uint32_t one = pData[i*2];
5769                if (one != 1) return false;
5770            }
5771    
5772            return true;
5773        }
5774    
5775        /**
5776         * Recalculates CRC32 checksums for all samples and rebuilds this gig
5777         * file's checksum table with those new checksums. This might usually
5778         * just be necessary if the checksum table was damaged.
5779         *
5780         * @e IMPORTANT: The current implementation of this method only works
5781         * with files that have not been modified since it was loaded, because
5782         * it expects that no externally caused file structure changes are
5783         * required!
5784         *
5785         * Due to the expectation above, this method is currently protected
5786         * and actually only used by the command line tool "gigdump" yet.
5787         *
5788         * @returns true if Save() is required to be called after this call,
5789         *          false if no further action is required
5790         */
5791        bool File::RebuildSampleChecksumTable() {
5792            // make sure sample chunks were scanned
5793            if (!pSamples) GetFirstSample();
5794    
5795            bool bRequiresSave = false;
5796    
5797            // make sure "3CRC" chunk exists with required size
5798            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5799            if (!_3crc) {
5800                _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
5801                // the order of einf and 3crc is not the same in v2 and v3
5802                RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
5803                if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
5804                bRequiresSave = true;
5805            } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
5806                _3crc->Resize(pSamples->size() * 8);
5807                bRequiresSave = true;
5808            }
5809    
5810            if (bRequiresSave) { // refill CRC table for all samples in RAM ...
5811                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
5812                {
5813                    File::SampleList::iterator iter = pSamples->begin();
5814                    File::SampleList::iterator end  = pSamples->end();
5815                    for (; iter != end; ++iter) {
5816                        gig::Sample* pSample = (gig::Sample*) *iter;
5817                        int index = GetWaveTableIndexOf(pSample);
5818                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
5819                        pData[index*2]   = 1; // always 1
5820                        pData[index*2+1] = pSample->CalculateWaveDataChecksum();
5821                    }
5822                }
5823            } else { // no file structure changes necessary, so directly write to disk and we are done ...
5824                // make sure file is in write mode
5825                pRIFF->SetMode(RIFF::stream_mode_read_write);
5826                {
5827                    File::SampleList::iterator iter = pSamples->begin();
5828                    File::SampleList::iterator end  = pSamples->end();
5829                    for (; iter != end; ++iter) {
5830                        gig::Sample* pSample = (gig::Sample*) *iter;
5831                        int index = GetWaveTableIndexOf(pSample);
5832                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
5833                        pSample->crc  = pSample->CalculateWaveDataChecksum();
5834                        SetSampleChecksum(pSample, pSample->crc);
5835                    }
5836                }
5837            }
5838    
5839            return bRequiresSave;
5840        }
5841    
5842      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
5843          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
5844          // there must always be at least one group          // there must always be at least one group
# Line 5781  namespace { Line 6061  namespace {
6061       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
6062       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
6063       *       *
6064         * @param pProgress - callback function for progress notification
6065       * @throws Exception - on errors       * @throws Exception - on errors
6066       */       */
6067      void File::UpdateChunks() {      void File::UpdateChunks(progress_t* pProgress) {
6068          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
6069    
         b64BitWavePoolOffsets = pVersion && pVersion->major == 3;  
   
6070          // update own gig format extension chunks          // update own gig format extension chunks
6071          // (not part of the GigaStudio 4 format)          // (not part of the GigaStudio 4 format)
6072          //          RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
6073            if (!lst3LS) {
6074                lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
6075            }
6076            // Make sure <3LS > chunk is placed before <ptbl> chunk. The precise
6077            // location of <3LS > is irrelevant, however it should be located
6078            // before  the actual wave data
6079            RIFF::Chunk* ckPTBL = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
6080            pRIFF->MoveSubChunk(lst3LS, ckPTBL);
6081    
6082          // This must be performed before writing the chunks for instruments,          // This must be performed before writing the chunks for instruments,
6083          // because the instruments' script slots will write the file offsets          // because the instruments' script slots will write the file offsets
6084          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
6085          if (pScriptGroups) {          if (pScriptGroups) {
6086              RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);              // Update instrument script (group) chunks.
6087              if (pScriptGroups->empty()) {              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
6088                  if (lst3LS) pRIFF->DeleteSubChunk(lst3LS);                   it != pScriptGroups->end(); ++it)
6089              } else {              {
6090                  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();  
                 }  
6091              }              }
6092          }          }
6093    
6094            // in case no libgig custom format data was added, then remove the
6095            // custom "3LS " chunk again
6096            if (!lst3LS->CountSubChunks()) {
6097                pRIFF->DeleteSubChunk(lst3LS);
6098                lst3LS = NULL;
6099            }
6100    
6101          // first update base class's chunks          // first update base class's chunks
6102          DLS::File::UpdateChunks();          DLS::File::UpdateChunks(pProgress);
6103    
6104          if (newFile) {          if (newFile) {
6105              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
# Line 5849  namespace { Line 6136  namespace {
6136              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
6137              std::list<Group*>::iterator end  = pGroups->end();              std::list<Group*>::iterator end  = pGroups->end();
6138              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
6139                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
6140              }              }
6141          }          }
6142    
# Line 5869  namespace { Line 6156  namespace {
6156          // Note that there are several fields with unknown use. These          // Note that there are several fields with unknown use. These
6157          // are set to zero.          // are set to zero.
6158    
6159          int sublen = pSamples->size() / 8 + 49;          int sublen = int(pSamples->size() / 8 + 49);
6160          int einfSize = (Instruments + 1) * sublen;          int einfSize = (Instruments + 1) * sublen;
6161    
6162          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
# Line 5942  namespace { Line 6229  namespace {
6229                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6230                  // next 8 bytes unknown                  // next 8 bytes unknown
6231                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6232                  store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());                  store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6233                  // next 4 bytes unknown                  // next 4 bytes unknown
6234    
6235                  totnbregions += instrument->Regions;                  totnbregions += instrument->Regions;
# Line 5960  namespace { Line 6247  namespace {
6247              store32(&pData[24], totnbloops);              store32(&pData[24], totnbloops);
6248              // next 8 bytes unknown              // next 8 bytes unknown
6249              // next 4 bytes unknown, not always 0              // next 4 bytes unknown, not always 0
6250              store32(&pData[40], pSamples->size());              store32(&pData[40], (uint32_t) pSamples->size());
6251              // next 4 bytes unknown              // next 4 bytes unknown
6252          }          }
6253    
6254          // update 3crc chunk          // update 3crc chunk
6255    
6256          // The 3crc chunk contains CRC-32 checksums for the          // The 3crc chunk contains CRC-32 checksums for the
6257          // samples. The actual checksum values will be filled in          // samples. When saving a gig file to disk, we first update the 3CRC
6258          // later, by Sample::Write.          // chunk here (in RAM) with the old crc values which we read from the
6259            // 3CRC chunk when we opened the file (available with gig::Sample::crc
6260            // member variable). This step is required, because samples might have
6261            // been deleted by the user since the file was opened, which in turn
6262            // changes the order of the (i.e. old) checksums within the 3crc chunk.
6263            // If a sample was conciously modified by the user (that is if
6264            // Sample::Write() was called later on) then Sample::Write() will just
6265            // update the respective individual checksum(s) directly on disk and
6266            // leaves all other sample checksums untouched.
6267    
6268          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6269          if (_3crc) {          if (_3crc) {
6270              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
6271          } else if (newFile) {          } else /*if (newFile)*/ {
6272              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
             _3crc->LoadChunkData();  
   
6273              // 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
6274              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6275          }          }
6276            { // must be performed in RAM here ...
6277                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6278                if (pData) {
6279                    File::SampleList::iterator iter = pSamples->begin();
6280                    File::SampleList::iterator end  = pSamples->end();
6281                    for (int index = 0; iter != end; ++iter, ++index) {
6282                        gig::Sample* pSample = (gig::Sample*) *iter;
6283                        pData[index*2]   = 1; // always 1
6284                        pData[index*2+1] = pSample->crc;
6285                    }
6286                }
6287            }
6288      }      }
6289            
6290      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
Legend:
Removed from v.2667  
changed lines
  Added in v.3112
  ViewVC Help
Powered by ViewVC