/[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 2639 by schoenebeck, Mon Jun 16 13:22:50 2014 UTC revision 2913 by schoenebeck, Tue May 17 15:19:33 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 367  namespace { Line 339  namespace {
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       */       */
342      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) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
343          static const DLS::Info::string_length_t fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
344              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
345              { 0, 0 }              { 0, 0 }
# Line 509  namespace { Line 481  namespace {
481          const int iReadAtOnce = 32*1024;          const int iReadAtOnce = 32*1024;
482          char* buf = new char[iReadAtOnce * orig->FrameSize];          char* buf = new char[iReadAtOnce * orig->FrameSize];
483          Sample* pOrig = (Sample*) orig; //HACK: remove constness for now          Sample* pOrig = (Sample*) orig; //HACK: remove constness for now
484          unsigned long restorePos = pOrig->GetPos();          file_offset_t restorePos = pOrig->GetPos();
485          pOrig->SetPos(0);          pOrig->SetPos(0);
486          SetPos(0);          SetPos(0);
487          for (unsigned long n = pOrig->Read(buf, iReadAtOnce); n;          for (file_offset_t n = pOrig->Read(buf, iReadAtOnce); n;
488                             n = pOrig->Read(buf, iReadAtOnce))                             n = pOrig->Read(buf, iReadAtOnce))
489          {          {
490              Write(buf, n);              Write(buf, n);
# Line 528  namespace { Line 500  namespace {
500       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
501       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
502       *       *
503         * @param pProgress - callback function for progress notification
504       * @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
505       *                        was provided yet       *                        was provided yet
506       * @throws gig::Exception if there is any invalid sample setting       * @throws gig::Exception if there is any invalid sample setting
507       */       */
508      void Sample::UpdateChunks() {      void Sample::UpdateChunks(progress_t* pProgress) {
509          // first update base class's chunks          // first update base class's chunks
510          DLS::Sample::UpdateChunks();          DLS::Sample::UpdateChunks(pProgress);
511    
512          // make sure 'smpl' chunk exists          // make sure 'smpl' chunk exists
513          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
# Line 596  namespace { Line 569  namespace {
569      void Sample::ScanCompressedSample() {      void Sample::ScanCompressedSample() {
570          //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)
571          this->SamplesTotal = 0;          this->SamplesTotal = 0;
572          std::list<unsigned long> frameOffsets;          std::list<file_offset_t> frameOffsets;
573    
574          SamplesPerFrame = BitDepth == 24 ? 256 : 2048;          SamplesPerFrame = BitDepth == 24 ? 256 : 2048;
575          WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag          WorstCaseFrameSize = SamplesPerFrame * FrameSize + Channels; // +Channels for compression flag
# Line 612  namespace { Line 585  namespace {
585                  const int mode_l = pCkData->ReadUint8();                  const int mode_l = pCkData->ReadUint8();
586                  const int mode_r = pCkData->ReadUint8();                  const int mode_r = pCkData->ReadUint8();
587                  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");
588                  const unsigned long frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];                  const file_offset_t frameSize = bytesPerFrame[mode_l] + bytesPerFrame[mode_r];
589    
590                  if (pCkData->RemainingBytes() <= frameSize) {                  if (pCkData->RemainingBytes() <= frameSize) {
591                      SamplesInLastFrame =                      SamplesInLastFrame =
# Line 631  namespace { Line 604  namespace {
604    
605                  const int mode = pCkData->ReadUint8();                  const int mode = pCkData->ReadUint8();
606                  if (mode > 5) throw gig::Exception("Unknown compression mode");                  if (mode > 5) throw gig::Exception("Unknown compression mode");
607                  const unsigned long frameSize = bytesPerFrame[mode];                  const file_offset_t frameSize = bytesPerFrame[mode];
608    
609                  if (pCkData->RemainingBytes() <= frameSize) {                  if (pCkData->RemainingBytes() <= frameSize) {
610                      SamplesInLastFrame =                      SamplesInLastFrame =
# Line 647  namespace { Line 620  namespace {
620    
621          // 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)
622          if (FrameTable) delete[] FrameTable;          if (FrameTable) delete[] FrameTable;
623          FrameTable = new unsigned long[frameOffsets.size()];          FrameTable = new file_offset_t[frameOffsets.size()];
624          std::list<unsigned long>::iterator end  = frameOffsets.end();          std::list<file_offset_t>::iterator end  = frameOffsets.end();
625          std::list<unsigned long>::iterator iter = frameOffsets.begin();          std::list<file_offset_t>::iterator iter = frameOffsets.begin();
626          for (int i = 0; iter != end; i++, iter++) {          for (int i = 0; iter != end; i++, iter++) {
627              FrameTable[i] = *iter;              FrameTable[i] = *iter;
628          }          }
# Line 690  namespace { Line 663  namespace {
663       *                      the cached sample data in bytes       *                      the cached sample data in bytes
664       * @see                 ReleaseSampleData(), Read(), SetPos()       * @see                 ReleaseSampleData(), Read(), SetPos()
665       */       */
666      buffer_t Sample::LoadSampleData(unsigned long SampleCount) {      buffer_t Sample::LoadSampleData(file_offset_t SampleCount) {
667          return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples          return LoadSampleDataWithNullSamplesExtension(SampleCount, 0); // 0 amount of NullSamples
668      }      }
669    
# Line 749  namespace { Line 722  namespace {
722       *                           size of the cached sample data in bytes       *                           size of the cached sample data in bytes
723       * @see                      ReleaseSampleData(), Read(), SetPos()       * @see                      ReleaseSampleData(), Read(), SetPos()
724       */       */
725      buffer_t Sample::LoadSampleDataWithNullSamplesExtension(unsigned long SampleCount, uint NullSamplesCount) {      buffer_t Sample::LoadSampleDataWithNullSamplesExtension(file_offset_t SampleCount, uint NullSamplesCount) {
726          if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;          if (SampleCount > this->SamplesTotal) SampleCount = this->SamplesTotal;
727          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;          if (RAMCache.pStart) delete[] (int8_t*) RAMCache.pStart;
728          unsigned long allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;          file_offset_t allocationsize = (SampleCount + NullSamplesCount) * this->FrameSize;
729          SetPos(0); // reset read position to begin of sample          SetPos(0); // reset read position to begin of sample
730          RAMCache.pStart            = new int8_t[allocationsize];          RAMCache.pStart            = new int8_t[allocationsize];
731          RAMCache.Size              = Read(RAMCache.pStart, SampleCount) * this->FrameSize;          RAMCache.Size              = Read(RAMCache.pStart, SampleCount) * this->FrameSize;
# Line 850  namespace { Line 823  namespace {
823       * @returns            the new sample position       * @returns            the new sample position
824       * @see                Read()       * @see                Read()
825       */       */
826      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) {
827          if (Compressed) {          if (Compressed) {
828              switch (Whence) {              switch (Whence) {
829                  case RIFF::stream_curpos:                  case RIFF::stream_curpos:
# Line 868  namespace { Line 841  namespace {
841              }              }
842              if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;              if (this->SamplePos > this->SamplesTotal) this->SamplePos = this->SamplesTotal;
843    
844              unsigned long frame = this->SamplePos / 2048; // to which frame to jump              file_offset_t frame = this->SamplePos / 2048; // to which frame to jump
845              this->FrameOffset   = this->SamplePos % 2048; // offset (in sample points) within that frame              this->FrameOffset   = this->SamplePos % 2048; // offset (in sample points) within that frame
846              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
847              return this->SamplePos;              return this->SamplePos;
848          }          }
849          else { // not compressed          else { // not compressed
850              unsigned long orderedBytes = SampleCount * this->FrameSize;              file_offset_t orderedBytes = SampleCount * this->FrameSize;
851              unsigned long result = pCkData->SetPos(orderedBytes, Whence);              file_offset_t result = pCkData->SetPos(orderedBytes, Whence);
852              return (result == orderedBytes) ? SampleCount              return (result == orderedBytes) ? SampleCount
853                                              : result / this->FrameSize;                                              : result / this->FrameSize;
854          }          }
# Line 884  namespace { Line 857  namespace {
857      /**      /**
858       * Returns the current position in the sample (in sample points).       * Returns the current position in the sample (in sample points).
859       */       */
860      unsigned long Sample::GetPos() const {      file_offset_t Sample::GetPos() const {
861          if (Compressed) return SamplePos;          if (Compressed) return SamplePos;
862          else            return pCkData->GetPos() / FrameSize;          else            return pCkData->GetPos() / FrameSize;
863      }      }
# Line 923  namespace { Line 896  namespace {
896       * @returns                number of successfully read sample points       * @returns                number of successfully read sample points
897       * @see                    CreateDecompressionBuffer()       * @see                    CreateDecompressionBuffer()
898       */       */
899      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,
900                                        DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {                                        DimensionRegion* pDimRgn, buffer_t* pExternalDecompressionBuffer) {
901          unsigned long samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;          file_offset_t samplestoread = SampleCount, totalreadsamples = 0, readsamples, samplestoloopend;
902          uint8_t* pDst = (uint8_t*) pBuffer;          uint8_t* pDst = (uint8_t*) pBuffer;
903    
904          SetPos(pPlaybackState->position); // recover position from the last time          SetPos(pPlaybackState->position); // recover position from the last time
# Line 963  namespace { Line 936  namespace {
936                                  // reading, swap all sample frames so it reflects                                  // reading, swap all sample frames so it reflects
937                                  // backward playback                                  // backward playback
938    
939                                  unsigned long swapareastart       = totalreadsamples;                                  file_offset_t swapareastart       = totalreadsamples;
940                                  unsigned long loopoffset          = GetPos() - loop.LoopStart;                                  file_offset_t loopoffset          = GetPos() - loop.LoopStart;
941                                  unsigned long samplestoreadinloop = Min(samplestoread, loopoffset);                                  file_offset_t samplestoreadinloop = Min(samplestoread, loopoffset);
942                                  unsigned long reverseplaybackend  = GetPos() - samplestoreadinloop;                                  file_offset_t reverseplaybackend  = GetPos() - samplestoreadinloop;
943    
944                                  SetPos(reverseplaybackend);                                  SetPos(reverseplaybackend);
945    
# Line 1014  namespace { Line 987  namespace {
987                          // reading, swap all sample frames so it reflects                          // reading, swap all sample frames so it reflects
988                          // backward playback                          // backward playback
989    
990                          unsigned long swapareastart       = totalreadsamples;                          file_offset_t swapareastart       = totalreadsamples;
991                          unsigned long loopoffset          = GetPos() - loop.LoopStart;                          file_offset_t loopoffset          = GetPos() - loop.LoopStart;
992                          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)
993                                                                                    : samplestoread;                                                                                    : samplestoread;
994                          unsigned long reverseplaybackend  = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);                          file_offset_t reverseplaybackend  = loop.LoopStart + Abs((loopoffset - samplestoreadinloop) % loop.LoopLength);
995    
996                          SetPos(reverseplaybackend);                          SetPos(reverseplaybackend);
997    
# Line 1098  namespace { Line 1071  namespace {
1071       * @returns            number of successfully read sample points       * @returns            number of successfully read sample points
1072       * @see                SetPos(), CreateDecompressionBuffer()       * @see                SetPos(), CreateDecompressionBuffer()
1073       */       */
1074      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) {
1075          if (SampleCount == 0) return 0;          if (SampleCount == 0) return 0;
1076          if (!Compressed) {          if (!Compressed) {
1077              if (BitDepth == 24) {              if (BitDepth == 24) {
# Line 1113  namespace { Line 1086  namespace {
1086          else {          else {
1087              if (this->SamplePos >= this->SamplesTotal) return 0;              if (this->SamplePos >= this->SamplesTotal) return 0;
1088              //TODO: efficiency: maybe we should test for an average compression rate              //TODO: efficiency: maybe we should test for an average compression rate
1089              unsigned long assumedsize      = GuessSize(SampleCount),              file_offset_t assumedsize      = GuessSize(SampleCount),
1090                            remainingbytes   = 0,           // remaining bytes in the local buffer                            remainingbytes   = 0,           // remaining bytes in the local buffer
1091                            remainingsamples = SampleCount,                            remainingsamples = SampleCount,
1092                            copysamples, skipsamples,                            copysamples, skipsamples,
# Line 1136  namespace { Line 1109  namespace {
1109              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);              remainingbytes = pCkData->Read(pSrc, assumedsize, 1);
1110    
1111              while (remainingsamples && remainingbytes) {              while (remainingsamples && remainingbytes) {
1112                  unsigned long framesamples = SamplesPerFrame;                  file_offset_t framesamples = SamplesPerFrame;
1113                  unsigned long framebytes, rightChannelOffset = 0, nextFrameOffset;                  file_offset_t framebytes, rightChannelOffset = 0, nextFrameOffset;
1114    
1115                  int mode_l = *pSrc++, mode_r = 0;                  int mode_l = *pSrc++, mode_r = 0;
1116    
# Line 1287  namespace { Line 1260  namespace {
1260       * @throws gig::Exception if sample is compressed       * @throws gig::Exception if sample is compressed
1261       * @see DLS::LoadSampleData()       * @see DLS::LoadSampleData()
1262       */       */
1263      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {      file_offset_t Sample::Write(void* pBuffer, file_offset_t SampleCount) {
1264          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)");
1265    
1266          // 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 1269  namespace {
1269              __resetCRC(crc);              __resetCRC(crc);
1270          }          }
1271          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");
1272          unsigned long res;          file_offset_t res;
1273          if (BitDepth == 24) {          if (BitDepth == 24) {
1274              res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;              res = pCkData->Write(pBuffer, SampleCount * FrameSize, 1) / FrameSize;
1275          } else { // 16 bit          } else { // 16 bit
# Line 1330  namespace { Line 1303  namespace {
1303       * @returns allocated decompression buffer       * @returns allocated decompression buffer
1304       * @see DestroyDecompressionBuffer()       * @see DestroyDecompressionBuffer()
1305       */       */
1306      buffer_t Sample::CreateDecompressionBuffer(unsigned long MaxReadSize) {      buffer_t Sample::CreateDecompressionBuffer(file_offset_t MaxReadSize) {
1307          buffer_t result;          buffer_t result;
1308          const double worstCaseHeaderOverhead =          const double worstCaseHeaderOverhead =
1309                  (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;
1310          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);
1311          result.pStart            = new int8_t[result.Size];          result.pStart            = new int8_t[result.Size];
1312          result.NullExtensionSize = 0;          result.NullExtensionSize = 0;
1313          return result;          return result;
# Line 1752  namespace { Line 1725  namespace {
1725       *       *
1726       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
1727       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
1728         *
1729         * @param pProgress - callback function for progress notification
1730       */       */
1731      void DimensionRegion::UpdateChunks() {      void DimensionRegion::UpdateChunks(progress_t* pProgress) {
1732          // first update base class's chunk          // first update base class's chunk
1733          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks(pProgress);
1734    
1735          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);          RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1736          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
# Line 3026  namespace { Line 3001  namespace {
3001       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
3002       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
3003       *       *
3004         * @param pProgress - callback function for progress notification
3005       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
3006       */       */
3007      void Region::UpdateChunks() {      void Region::UpdateChunks(progress_t* pProgress) {
3008          // 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
3009          // 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
3010          // 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 3012  namespace {
3012          pSample = pDimensionRegions[0]->pSample;          pSample = pDimensionRegions[0]->pSample;
3013    
3014          // first update base class's chunks          // first update base class's chunks
3015          DLS::Region::UpdateChunks();          DLS::Region::UpdateChunks(pProgress);
3016    
3017          // update dimension region's chunks          // update dimension region's chunks
3018          for (int i = 0; i < DimensionRegions; i++) {          for (int i = 0; i < DimensionRegions; i++) {
3019              pDimensionRegions[i]->UpdateChunks();              pDimensionRegions[i]->UpdateChunks(pProgress);
3020          }          }
3021    
3022          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
# Line 3673  namespace { Line 3649  namespace {
3649              throw gig::Exception("No dimension with provided old dimension type exists on this region");              throw gig::Exception("No dimension with provided old dimension type exists on this region");
3650          if (newType == dimension_samplechannel && def->zones != 2)          if (newType == dimension_samplechannel && def->zones != 2)
3651              throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");              throw gig::Exception("Cannot change to dimension type 'sample channel', because existing dimension does not have 2 zones");
3652            if (GetDimensionDefinition(newType))
3653                throw gig::Exception("There is already a dimension with requested new dimension type on this region");
3654            def->dimension  = newType;
3655          def->split_type = __resolveSplitType(newType);          def->split_type = __resolveSplitType(newType);
3656      }      }
3657    
# Line 3871  namespace { Line 3850  namespace {
3850          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
3851          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3852          if (!file->pWavePoolTable) return NULL;          if (!file->pWavePoolTable) return NULL;
3853          unsigned long soughtoffset = file->pWavePoolTable[WavePoolTableIndex];          // for new files or files >= 2 GB use 64 bit wave pool offsets
3854          unsigned long soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
3855          Sample* sample = file->GetFirstSample(pProgress);              // use 64 bit wave pool offsets (treating this as large file)
3856          while (sample) {              uint64_t soughtoffset =
3857              if (sample->ulWavePoolOffset == soughtoffset &&                  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
3858                  sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);                  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
3859              sample = file->GetNextSample();              Sample* sample = file->GetFirstSample(pProgress);
3860                while (sample) {
3861                    if (sample->ullWavePoolOffset == soughtoffset)
3862                        return static_cast<gig::Sample*>(sample);
3863                    sample = file->GetNextSample();
3864                }
3865            } else {
3866                // use extension files and 32 bit wave pool offsets
3867                file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
3868                file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
3869                Sample* sample = file->GetFirstSample(pProgress);
3870                while (sample) {
3871                    if (sample->ullWavePoolOffset == soughtoffset &&
3872                        sample->FileNo == soughtfileno) return static_cast<gig::Sample*>(sample);
3873                    sample = file->GetNextSample();
3874                }
3875          }          }
3876          return NULL;          return NULL;
3877      }      }
# Line 4158  namespace { Line 4152  namespace {
4152          memcpy(&data[0], &text[0], text.size());          memcpy(&data[0], &text[0], text.size());
4153      }      }
4154    
4155      void Script::UpdateChunks() {      /**
4156         * Apply this script to the respective RIFF chunks. You have to call
4157         * File::Save() to make changes persistent.
4158         *
4159         * Usually there is absolutely no need to call this method explicitly.
4160         * It will be called automatically when File::Save() was called.
4161         *
4162         * @param pProgress - callback function for progress notification
4163         */
4164        void Script::UpdateChunks(progress_t* pProgress) {
4165          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4166          __resetCRC(crc);          __resetCRC(crc);
4167          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
# Line 4197  namespace { Line 4200  namespace {
4200       * @param pGroup - script's new group       * @param pGroup - script's new group
4201       */       */
4202      void Script::SetGroup(ScriptGroup* pGroup) {      void Script::SetGroup(ScriptGroup* pGroup) {
4203          if (this->pGroup = pGroup) return;          if (this->pGroup == pGroup) return;
4204          if (pChunk)          if (pChunk)
4205              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);              pChunk->GetParent()->MoveSubChunk(pChunk, pGroup->pList);
4206          this->pGroup = pGroup;          this->pGroup = pGroup;
# Line 4248  namespace { Line 4251  namespace {
4251          }          }
4252      }      }
4253    
4254      void ScriptGroup::UpdateChunks() {      /**
4255         * Apply this script group to the respective RIFF chunks. You have to call
4256         * File::Save() to make changes persistent.
4257         *
4258         * Usually there is absolutely no need to call this method explicitly.
4259         * It will be called automatically when File::Save() was called.
4260         *
4261         * @param pProgress - callback function for progress notification
4262         */
4263        void ScriptGroup::UpdateChunks(progress_t* pProgress) {
4264          if (pScripts) {          if (pScripts) {
4265              if (!pList)              if (!pList)
4266                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);                  pList = pFile->pRIFF->GetSubList(LIST_TYPE_3LS)->AddSubList(LIST_TYPE_RTIS);
# Line 4259  namespace { Line 4271  namespace {
4271              for (std::list<Script*>::iterator it = pScripts->begin();              for (std::list<Script*>::iterator it = pScripts->begin();
4272                   it != pScripts->end(); ++it)                   it != pScripts->end(); ++it)
4273              {              {
4274                  (*it)->UpdateChunks();                  (*it)->UpdateChunks(pProgress);
4275              }              }
4276          }          }
4277      }      }
# Line 4469  namespace { Line 4481  namespace {
4481       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
4482       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
4483       *       *
4484         * @param pProgress - callback function for progress notification
4485       * @throws gig::Exception if samples cannot be dereferenced       * @throws gig::Exception if samples cannot be dereferenced
4486       */       */
4487      void Instrument::UpdateChunks() {      void Instrument::UpdateChunks(progress_t* pProgress) {
4488          // first update base classes' chunks          // first update base classes' chunks
4489          DLS::Instrument::UpdateChunks();          DLS::Instrument::UpdateChunks(pProgress);
4490    
4491          // update Regions' chunks          // update Regions' chunks
4492          {          {
4493              RegionList::iterator iter = pRegions->begin();              RegionList::iterator iter = pRegions->begin();
4494              RegionList::iterator end  = pRegions->end();              RegionList::iterator end  = pRegions->end();
4495              for (; iter != end; ++iter)              for (; iter != end; ++iter)
4496                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
4497          }          }
4498    
4499          // make sure 'lart' RIFF list chunk exists          // make sure 'lart' RIFF list chunk exists
# Line 4517  namespace { Line 4530  namespace {
4530          }          }
4531    
4532          // own gig format extensions          // own gig format extensions
4533         if (pScriptRefs) {         if (ScriptSlotCount()) {
4534               // make sure we have converted the original loaded script file
4535               // offsets into valid Script object pointers
4536               LoadScripts();
4537    
4538             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4539             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4540             const int slotCount = pScriptRefs->size();             const int slotCount = pScriptRefs->size();
# Line 4544  namespace { Line 4561  namespace {
4561                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);                 store32(&pData[pos], (*pScriptRefs)[i].bypass ? 1 : 0);
4562                 pos += sizeof(uint32_t);                 pos += sizeof(uint32_t);
4563             }             }
4564           } else {
4565               // no script slots, so get rid of any LS custom RIFF chunks (if any)
4566               RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4567               if (lst3LS) pCkInstrument->DeleteSubChunk(lst3LS);
4568         }         }
4569      }      }
4570    
4571      void Instrument::UpdateScriptFileOffsets() {      void Instrument::UpdateScriptFileOffsets() {
4572         // own gig format extensions         // own gig format extensions
4573         if (pScriptRefs) {         if (pScriptRefs && pScriptRefs->size() > 0) {
4574             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4575             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4576             const int slotCount = pScriptRefs->size();             const int slotCount = pScriptRefs->size();
# Line 4559  namespace { Line 4580  namespace {
4580                 uint32_t fileOffset =                 uint32_t fileOffset =
4581                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4582                      (*pScriptRefs)[i].script->pChunk->GetPos() -                      (*pScriptRefs)[i].script->pChunk->GetPos() -
4583                      CHUNK_HEADER_SIZE;                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());
4584                 ckSCSL->WriteUint32(&fileOffset);                 ckSCSL->WriteUint32(&fileOffset);
4585                 // jump over flags entry (containing the bypass flag)                 // jump over flags entry (containing the bypass flag)
4586                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
# Line 4634  namespace { Line 4655  namespace {
4655      }      }
4656    
4657      /**      /**
4658         * Move this instrument at the position before @arg dst.
4659         *
4660         * This method can be used to reorder the sequence of instruments in a
4661         * .gig file. This might be helpful especially on large .gig files which
4662         * contain a large number of instruments within the same .gig file. So
4663         * grouping such instruments to similar ones, can help to keep track of them
4664         * when working with such complex .gig files.
4665         *
4666         * When calling this method, this instrument will be removed from in its
4667         * current position in the instruments list and moved to the requested
4668         * target position provided by @param dst. You may also pass NULL as
4669         * argument to this method, in that case this intrument will be moved to the
4670         * very end of the .gig file's instrument list.
4671         *
4672         * You have to call Save() to make the order change persistent to the .gig
4673         * file.
4674         *
4675         * Currently this method is limited to moving the instrument within the same
4676         * .gig file. Trying to move it to another .gig file by calling this method
4677         * will throw an exception.
4678         *
4679         * @param dst - destination instrument at which this instrument will be
4680         *              moved to, or pass NULL for moving to end of list
4681         * @throw gig::Exception if this instrument and target instrument are not
4682         *                       part of the same file
4683         */
4684        void Instrument::MoveTo(Instrument* dst) {
4685            if (dst && GetParent() != dst->GetParent())
4686                throw Exception(
4687                    "gig::Instrument::MoveTo() can only be used for moving within "
4688                    "the same gig file."
4689                );
4690    
4691            File* pFile = (File*) GetParent();
4692    
4693            // move this instrument within the instrument list
4694            {
4695                File::InstrumentList& list = *pFile->pInstruments;
4696    
4697                File::InstrumentList::iterator itFrom =
4698                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(this));
4699    
4700                File::InstrumentList::iterator itTo =
4701                    std::find(list.begin(), list.end(), static_cast<DLS::Instrument*>(dst));
4702    
4703                list.splice(itTo, list, itFrom);
4704            }
4705    
4706            // move the instrument's actual list RIFF chunk appropriately
4707            RIFF::List* lstCkInstruments = pFile->pRIFF->GetSubList(LIST_TYPE_LINS);
4708            lstCkInstruments->MoveSubChunk(
4709                this->pCkInstrument,
4710                (RIFF::Chunk*) ((dst) ? dst->pCkInstrument : NULL)
4711            );
4712        }
4713    
4714        /**
4715       * Returns a MIDI rule of the instrument.       * Returns a MIDI rule of the instrument.
4716       *       *
4717       * 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 4710  namespace { Line 4788  namespace {
4788                      if (script->pChunk) {                      if (script->pChunk) {
4789                          uint32_t offset = script->pChunk->GetFilePos() -                          uint32_t offset = script->pChunk->GetFilePos() -
4790                                            script->pChunk->GetPos() -                                            script->pChunk->GetPos() -
4791                                            CHUNK_HEADER_SIZE;                                            CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());
4792                          if (offset == soughtOffset)                          if (offset == soughtOffset)
4793                          {                          {
4794                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
# Line 4993  namespace { Line 5071  namespace {
5071       *       *
5072       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5073       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5074         *
5075         * @param pProgress - callback function for progress notification
5076       */       */
5077      void Group::UpdateChunks() {      void Group::UpdateChunks(progress_t* pProgress) {
5078          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
5079          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
5080          if (!_3gri) {          if (!_3gri) {
# Line 5271  namespace { Line 5351  namespace {
5351          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5352    
5353          // check if samples should be loaded from extension files          // check if samples should be loaded from extension files
5354            // (only for old gig files < 2 GB)
5355          int lastFileNo = 0;          int lastFileNo = 0;
5356          for (int i = 0 ; i < WavePoolCount ; i++) {          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {
5357              if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];              for (int i = 0 ; i < WavePoolCount ; i++) {
5358                    if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
5359                }
5360          }          }
5361          String name(pRIFF->GetFileName());          String name(pRIFF->GetFileName());
5362          int nameLen = name.length();          int nameLen = name.length();
# Line 5283  namespace { Line 5366  namespace {
5366          for (int fileNo = 0 ; ; ) {          for (int fileNo = 0 ; ; ) {
5367              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5368              if (wvpl) {              if (wvpl) {
5369                  unsigned long wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos();
5370                  RIFF::List* wave = wvpl->GetFirstSubList();                  RIFF::List* wave = wvpl->GetFirstSubList();
5371                  while (wave) {                  while (wave) {
5372                      if (wave->GetListType() == LIST_TYPE_WAVE) {                      if (wave->GetListType() == LIST_TYPE_WAVE) {
# Line 5291  namespace { Line 5374  namespace {
5374                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;                          const float subprogress = (float) iSampleIndex / (float) iTotalSamples;
5375                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5376    
5377                          unsigned long waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5378                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));
5379    
5380                          iSampleIndex++;                          iSampleIndex++;
# Line 5770  namespace { Line 5853  namespace {
5853       * Usually there is absolutely no need to call this method explicitly.       * Usually there is absolutely no need to call this method explicitly.
5854       * It will be called automatically when File::Save() was called.       * It will be called automatically when File::Save() was called.
5855       *       *
5856         * @param pProgress - callback function for progress notification
5857       * @throws Exception - on errors       * @throws Exception - on errors
5858       */       */
5859      void File::UpdateChunks() {      void File::UpdateChunks(progress_t* pProgress) {
5860          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
5861    
         b64BitWavePoolOffsets = pVersion && pVersion->major == 3;  
   
5862          // update own gig format extension chunks          // update own gig format extension chunks
5863          // (not part of the GigaStudio 4 format)          // (not part of the GigaStudio 4 format)
5864          //          RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
5865            if (!lst3LS) {
5866                lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
5867            }
5868            // Make sure <3LS > chunk is placed before <ptbl> chunk. The precise
5869            // location of <3LS > is irrelevant, however it should be located
5870            // before  the actual wave data
5871            RIFF::Chunk* ckPTBL = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
5872            pRIFF->MoveSubChunk(lst3LS, ckPTBL);
5873    
5874          // This must be performed before writing the chunks for instruments,          // This must be performed before writing the chunks for instruments,
5875          // because the instruments' script slots will write the file offsets          // because the instruments' script slots will write the file offsets
5876          // of the respective instrument script chunk as reference.          // of the respective instrument script chunk as reference.
5877          if (pScriptGroups) {          if (pScriptGroups) {
5878              RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);              // Update instrument script (group) chunks.
5879              if (pScriptGroups->empty()) {              for (std::list<ScriptGroup*>::iterator it = pScriptGroups->begin();
5880                  if (lst3LS) pRIFF->DeleteSubChunk(lst3LS);                   it != pScriptGroups->end(); ++it)
5881              } else {              {
5882                  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();  
                 }  
5883              }              }
5884          }          }
5885    
5886            // in case no libgig custom format data was added, then remove the
5887            // custom "3LS " chunk again
5888            if (!lst3LS->CountSubChunks()) {
5889                pRIFF->DeleteSubChunk(lst3LS);
5890                lst3LS = NULL;
5891            }
5892    
5893          // first update base class's chunks          // first update base class's chunks
5894          DLS::File::UpdateChunks();          DLS::File::UpdateChunks(pProgress);
5895    
5896          if (newFile) {          if (newFile) {
5897              // INFO was added by Resource::UpdateChunks - make sure it              // INFO was added by Resource::UpdateChunks - make sure it
# Line 5838  namespace { Line 5928  namespace {
5928              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
5929              std::list<Group*>::iterator end  = pGroups->end();              std::list<Group*>::iterator end  = pGroups->end();
5930              for (; iter != end; ++iter) {              for (; iter != end; ++iter) {
5931                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks(pProgress);
5932              }              }
5933          }          }
5934    
Legend:
Removed from v.2639  
changed lines
  Added in v.2913
  ViewVC Help
Powered by ViewVC