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

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

Parent Directory | Revision Log | View Patch Patch

-revision 2912 by schoenebeck,
Tue May 17 14:30:10 2016 UTC
+revision 3117 by schoenebeck,
Sun Apr 16 23:20:30 2017 UTC
 Line 2
   *                                                                         *
   *   libgig - C++ cross-platform Gigasampler format file access library    *
   *                                                                         *
-  *   Copyright (C) 2003-2016 by Christian Schoenebeck                      *
+  *   Copyright (C) 2003-2017 by Christian Schoenebeck                      *
   *                              <cuse@users.sourceforge.net>               *
   *                                                                         *
   *   This library is free software; you can redistribute it and/or modify  *
 Line 269 
 namespace {
       * steps.
       *
       * Once the whole data was processed by __calculateCRC(), one should
-      * call __encodeCRC() to get the final CRC result.
+      * call __finalizeCRC() to get the final CRC result.
       *
       * @param buf     - pointer to data the CRC shall be calculated of
       * @param bufSize - size of the data to be processed
       * @param crc     - variable the CRC sum shall be stored to
       */
-     static void __calculateCRC(unsigned char* buf, int bufSize, uint32_t& crc) {
+     static void __calculateCRC(unsigned char* buf, size_t bufSize, uint32_t& crc) {
-         for (int i = 0 ; i < bufSize ; i++) {
+         for (size_t i = 0 ; i < bufSize ; i++) {
              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
          }
      }
 Line 286 
 namespace {
       *
       * @param crc - variable previously passed to __calculateCRC()
       */
-     inline static uint32_t __encodeCRC(const uint32_t& crc) {
+     inline static void __finalizeCRC(uint32_t& crc) {
-         return crc ^ 0xffffffff;
+         crc ^= 0xffffffff;
      }
 Line 318 
 namespace {
  // *************** Sample ***************
  // *
-     unsigned int Sample::Instances = 0;
+     size_t       Sample::Instances = 0;
      buffer_t     Sample::InternalDecompressionBuffer;
      /** @brief Constructor.
 Line 338 
 namespace {
       *                         ('wvpl') list chunk
       * @param fileNo         - number of an extension file where this sample
       *                         is located, 0 otherwise
+      * @param index          - wave pool index of sample (may be -1 on new sample)
       */
-     Sample::Sample(File* pFile, RIFF::List* waveList, file_offset_t 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)
+         : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset)
+     {
          static const DLS::Info::string_length_t fixedStringLengths[] = {
              { CHUNK_ID_INAM, 64 },
              { 0, 0 }
-Line 349 
 namespace {
+Line 352 
 namespace {
          FileNo = fileNo;
          __resetCRC(crc);
+         // if this is not a new sample, try to get the sample's already existing
+         // CRC32 checksum from disk, this checksum will reflect the sample's CRC32
+         // checksum of the time when the sample was consciously modified by the
+         // user for the last time (by calling Sample::Write() that is).
+         if (index >= 0) { // not a new file ...
+             try {
+                 uint32_t crc = pFile->GetSampleChecksumByIndex(index);
+                 this->crc = crc;
+             } catch (...) {}
+         }
          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
          if (pCk3gix) {
-Line 789 
 namespace {
+Line 802 
 namespace {
       * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
       * other formats will fail!
       *
-      * @param iNewSize - new sample wave data size in sample points (must be
+      * @param NewSize - new sample wave data size in sample points (must be
-      *                   greater than zero)
+      *                  greater than zero)
       * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
-      *                         or if \a iNewSize is less than 1
+      * @throws DLS::Exception if \a NewSize is less than 1 or unrealistic large
       * @throws gig::Exception if existing sample is compressed
       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
       *      DLS::Sample::FormatTag, File::Save()
       */
-     void Sample::Resize(int iNewSize) {
+     void Sample::Resize(file_offset_t NewSize) {
          if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
-         DLS::Sample::Resize(iNewSize);
+         DLS::Sample::Resize(NewSize);
      }
      /**
-Line 1281 
 namespace {
+Line 1294 
 namespace {
          // if this is the last write, update the checksum chunk in the
          // file
          if (pCkData->GetPos() == pCkData->GetSize()) {
+             __finalizeCRC(crc);
              File* pFile = static_cast<File*>(GetParent());
-             pFile->SetSampleChecksum(this, __encodeCRC(crc));
+             pFile->SetSampleChecksum(this, crc);
          }
          return res;
      }
-Line 1341 
 namespace {
+Line 1355 
 namespace {
          return pGroup;
      }
+     /**
+      * Returns the CRC-32 checksum of the sample's raw wave form data at the
+      * time when this sample's wave form data was modified for the last time
+      * by calling Write(). This checksum only covers the raw wave form data,
+      * not any meta informations like i.e. bit depth or loop points. Since
+      * this method just returns the checksum stored for this sample i.e. when
+      * the gig file was loaded, this method returns immediately. So it does no
+      * recalcuation of the checksum with the currently available sample wave
+      * form data.
+      *
+      * @see VerifyWaveData()
+      */
+     uint32_t Sample::GetWaveDataCRC32Checksum() {
+         return crc;
+     }
+     /**
+      * Checks the integrity of this sample's raw audio wave data. Whenever a
+      * Sample's raw wave data is intentionally modified (i.e. by calling
+      * Write() and supplying the new raw audio wave form data) a CRC32 checksum
+      * is calculated and stored/updated for this sample, along to the sample's
+      * meta informations.
+      *
+      * Now by calling this method the current raw audio wave data is checked
+      * against the already stored CRC32 check sum in order to check whether the
+      * sample data had been damaged unintentionally for some reason. Since by
+      * calling this method always the entire raw audio wave data has to be
+      * read, verifying all samples this way may take a long time accordingly.
+      * And that's also the reason why the sample integrity is not checked by
+      * default whenever a gig file is loaded. So this method must be called
+      * explicitly to fulfill this task.
+      *
+      * @param pActually - (optional) if provided, will be set to the actually
+      *                    calculated checksum of the current raw wave form data,
+      *                    you can get the expected checksum instead by calling
+      *                    GetWaveDataCRC32Checksum()
+      * @returns true if sample is OK or false if the sample is damaged
+      * @throws Exception if no checksum had been stored to disk for this
+      *         sample yet, or on I/O issues
+      * @see GetWaveDataCRC32Checksum()
+      */
+     bool Sample::VerifyWaveData(uint32_t* pActually) {
+         //File* pFile = static_cast<File*>(GetParent());
+         uint32_t crc = CalculateWaveDataChecksum();
+         if (pActually) *pActually = crc;
+         return crc == this->crc;
+     }
+     uint32_t Sample::CalculateWaveDataChecksum() {
+         const size_t sz = 20*1024; // 20kB buffer size
+         std::vector<uint8_t> buffer(sz);
+         buffer.resize(sz);
+         const size_t n = sz / FrameSize;
+         SetPos(0);
+         uint32_t crc = 0;
+         __resetCRC(crc);
+         while (true) {
+             file_offset_t nRead = Read(&buffer[0], n);
+             if (nRead <= 0) break;
+             __calculateCRC(&buffer[0], nRead * FrameSize, crc);
+         }
+         __finalizeCRC(crc);
+         return crc;
+     }
      Sample::~Sample() {
          Instances--;
          if (!Instances && InternalDecompressionBuffer.Size) {
-Line 1357 
 namespace {
+Line 1437 
 namespace {
  // *************** DimensionRegion ***************
  // *
-     uint                               DimensionRegion::Instances       = 0;
+     size_t                             DimensionRegion::Instances       = 0;
      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
-Line 1551 
 namespace {
+Line 1631 
 namespace {
              EG2Attack                       = 0.0;
              EG2Decay1                       = 0.005;
              EG2Sustain                      = 1000;
-             EG2Release                      = 0.3;
+             EG2Release                      = 60;
              LFO2ControlDepth                = 0;
              LFO2Frequency                   = 1.0;
              LFO2InternalDepth               = 0;
-Line 1750 
 namespace {
+Line 1830 
 namespace {
          // update '3ewa' chunk with DimensionRegion's current settings
-         const uint32_t chunksize = _3ewa->GetNewSize();
+         const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
          store32(&pData[0], chunksize); // unknown, always chunk size?
          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
-Line 3106 
 namespace {
+Line 3186 
 namespace {
          int step = 1;
          for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
          int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
-         int end = step * pDimensionDefinitions[veldim].zones;
          // loop through all dimension regions for all dimensions except the velocity dimension
          int dim[8] = { 0 };
          for (int i = 0 ; i < DimensionRegions ; i++) {
+             const int end = i + step * pDimensionDefinitions[veldim].zones;
+             // create a velocity table for all cases where the velocity zone is zero
              if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
                  pDimensionRegions[i]->VelocityUpperLimit) {
                  // create the velocity table
-Line 3142 
 namespace {
+Line 3223 
 namespace {
                  }
              }
+             // jump to the next case where the velocity zone is zero
              int j;
              int shift = 0;
              for (j = 0 ; j < Dimensions ; j++) {
-Line 3716 
 namespace {
+Line 3798 
 namespace {
      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
          uint8_t bits;
          int veldim = -1;
-         int velbitpos;
+         int velbitpos = 0;
          int bitpos = 0;
          int dimregidx = 0;
          for (uint i = 0; i < Dimensions; i++) {
-Line 3765 
 namespace {
+Line 3847 
 namespace {
      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
          uint8_t bits;
          int veldim = -1;
-         int velbitpos;
+         int velbitpos = 0;
          int bitpos = 0;
          int dimregidx = 0;
          for (uint i = 0; i < Dimensions; i++) {
-Line 3850 
 namespace {
+Line 3932 
 namespace {
          if ((int32_t)WavePoolTableIndex == -1) return NULL;
          File* file = (File*) GetParent()->GetParent();
          if (!file->pWavePoolTable) return NULL;
-         if (file->HasMonolithicLargeFilePolicy()) {
+         // for new files or files >= 2 GB use 64 bit wave pool offsets
+         if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
+             // use 64 bit wave pool offsets (treating this as large file)
              uint64_t soughtoffset =
                  uint64_t(file->pWavePoolTable[WavePoolTableIndex]) |
                  uint64_t(file->pWavePoolTableHi[WavePoolTableIndex]) << 32;
-Line 3861 
 namespace {
+Line 3945 
 namespace {
                  sample = file->GetNextSample();
              }
          } else {
+             // use extension files and 32 bit wave pool offsets
              file_offset_t soughtoffset = file->pWavePoolTable[WavePoolTableIndex];
              file_offset_t soughtfileno = file->pWavePoolTableHi[WavePoolTableIndex];
              Sample* sample = file->GetFirstSample(pProgress);
-Line 4111 
 namespace {
+Line 4196 
 namespace {
              // to handle potential future extensions of the header
              ckScri->SetPos(sizeof(int32_t) + headerSize);
              // read actual script data
-             uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();
+             uint32_t scriptSize = uint32_t(ckScri->GetSize() - ckScri->GetPos());
              data.resize(scriptSize);
              for (int i = 0; i < scriptSize; ++i)
                  data[i] = ckScri->ReadUint8();
-Line 4162 
 namespace {
+Line 4247 
 namespace {
          // recalculate CRC32 check sum
          __resetCRC(crc);
          __calculateCRC(&data[0], data.size(), crc);
-         __encodeCRC(crc);
+         __finalizeCRC(crc);
          // make sure chunk exists and has the required size
-         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();
          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
          else pChunk->Resize(chunkSize);
          // fill the chunk data to be written to disk
          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
          int pos = 0;
-         store32(&pData[pos], 6*sizeof(int32_t) + Name.size()); // total header size
+         store32(&pData[pos], uint32_t(6*sizeof(int32_t) + Name.size())); // total header size
          pos += sizeof(int32_t);
          store32(&pData[pos], Compression);
          pos += sizeof(int32_t);
-Line 4182 
 namespace {
+Line 4267 
 namespace {
          pos += sizeof(int32_t);
          store32(&pData[pos], crc);
          pos += sizeof(int32_t);
-         store32(&pData[pos], Name.size());
+         store32(&pData[pos], (uint32_t) Name.size());
          pos += sizeof(int32_t);
          for (int i = 0; i < Name.size(); ++i, ++pos)
              pData[pos] = Name[i];
-Line 4213 
 namespace {
+Line 4298 
 namespace {
          return pGroup;
      }
+     /**
+      * Make a (semi) deep copy of the Script object given by @a orig
+      * and assign it to this object. Note: the ScriptGroup this Script
+      * object belongs to remains untouched by this call.
+      *
+      * @param orig - original Script object to be copied from
+      */
+     void Script::CopyAssign(const Script* orig) {
+         Name        = orig->Name;
+         Compression = orig->Compression;
+         Encoding    = orig->Encoding;
+         Language    = orig->Language;
+         Bypass      = orig->Bypass;
+         data        = orig->data;
+     }
      void Script::RemoveAllScriptReferences() {
          File* pFile = pGroup->pFile;
          for (int i = 0; pFile->GetInstrument(i); ++i) {
-Line 4359 
 namespace {
+Line 4460 
 namespace {
          EffectSend = 0;
          Attenuation = 0;
          FineTune = 0;
-         PitchbendRange = 0;
+         PitchbendRange = 2;
          PianoReleaseMode = false;
          DimensionKeyRange.low = 0;
          DimensionKeyRange.high = 0;
-Line 4534 
 namespace {
+Line 4635 
 namespace {
             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
-            const int slotCount = pScriptRefs->size();
+            const int slotCount = (int) pScriptRefs->size();
             const int headerSize = 3 * sizeof(uint32_t);
             const int slotSize  = 2 * sizeof(uint32_t);
             const int totalChunkSize = headerSize + slotCount * slotSize;
-Line 4570 
 namespace {
+Line 4671 
 namespace {
         if (pScriptRefs && pScriptRefs->size() > 0) {
             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
-            const int slotCount = pScriptRefs->size();
+            const int slotCount = (int) pScriptRefs->size();
             const int headerSize = 3 * sizeof(uint32_t);
             ckSCSL->SetPos(headerSize);
             for (int i = 0; i < slotCount; ++i) {
-                uint32_t fileOffset =
+                uint32_t fileOffset = uint32_t(
                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
                      (*pScriptRefs)[i].script->pChunk->GetPos() -
-                     CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());
+                     CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
+                );
                 ckSCSL->WriteUint32(&fileOffset);
                 // jump over flags entry (containing the bypass flag)
                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
-Line 4637 
 namespace {
+Line 4739 
 namespace {
          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
          Region* pNewRegion = new Region(this, rgn);
          pRegions->push_back(pNewRegion);
-         Regions = pRegions->size();
+         Regions = (uint32_t) pRegions->size();
          // update Region key table for fast lookup
          UpdateRegionKeyTable();
          // done
-Line 4783 
 namespace {
+Line 4885 
 namespace {
                  for (uint s = 0; group->GetScript(s); ++s) {
                      Script* script = group->GetScript(s);
                      if (script->pChunk) {
-                         uint32_t offset = script->pChunk->GetFilePos() -
+                         uint32_t offset = uint32_t(
-                                           script->pChunk->GetPos() -
+                             script->pChunk->GetFilePos() -
-                                           CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());
+                             script->pChunk->GetPos() -
+                             CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
+                         );
                          if (offset == soughtOffset)
                          {
                              _ScriptPooolRef ref;
-Line 4910 
 namespace {
+Line 5014 
 namespace {
       */
      void Instrument::RemoveScript(Script* pScript) {
          LoadScripts();
-         for (int i = pScriptRefs->size() - 1; i >= 0; --i) {
+         for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
              if ((*pScriptRefs)[i].script == pScript) {
                  pScriptRefs->erase( pScriptRefs->begin() + i );
              }
-Line 4932 
 namespace {
+Line 5036 
 namespace {
       * gigedit.
       */
      uint Instrument::ScriptSlotCount() const {
-         return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();
+         return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
      }
      /** @brief Whether script execution shall be skipped.
-Line 5348 
 namespace {
+Line 5452 
 namespace {
          int iTotalSamples = WavePoolCount;
          // check if samples should be loaded from extension files
+         // (only for old gig files < 2 GB)
          int lastFileNo = 0;
-         if (!HasMonolithicLargeFilePolicy()) {
+         if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {
              for (int i = 0 ; i < WavePoolCount ; i++) {
                  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];
              }
          }
          String name(pRIFF->GetFileName());
-         int nameLen = name.length();
+         int nameLen = (int) name.length();
          char suffix[6];
          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
-Line 5371 
 namespace {
+Line 5476 
 namespace {
                          __notify_progress(pProgress, subprogress);
                          file_offset_t waveFileOffset = wave->GetFilePos();
-                         pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));
+                         pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
                          iSampleIndex++;
                      }
-Line 5524 
 namespace {
+Line 5629 
 namespace {
              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
              mSamples[pFile->GetSample(i)] = s;
          }
+         // clone script groups and their scripts
+         for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
+             ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
+             ScriptGroup* dg = AddScriptGroup();
+             dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
+             for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
+                 Script* ss = sg->GetScript(iScript);
+                 Script* ds = dg->AddScript();
+                 ds->CopyAssign(ss);
+             }
+         }
          //BUG: For some reason this method only works with this additional
          //     Save() call in between here.
          //
-Line 5609 
 namespace {
+Line 5726 
 namespace {
          if (!_3crc) return;
          // get the index of the sample
-         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;
-             }
-         }
          if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
          // write the CRC-32 checksum to disk
          _3crc->SetPos(iWaveIndex * 8);
-         uint32_t tmp = 1;
+         uint32_t one = 1;
-         _3crc->WriteUint32(&tmp); // unknown, always 1?
+         _3crc->WriteUint32(&one); // always 1
          _3crc->WriteUint32(&crc);
      }
+     uint32_t File::GetSampleChecksum(Sample* pSample) {
+         // get the index of the sample
+         int iWaveIndex = GetWaveTableIndexOf(pSample);
+         if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
+         return GetSampleChecksumByIndex(iWaveIndex);
+     }
+     uint32_t File::GetSampleChecksumByIndex(int index) {
+         if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
+         RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
+         if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
+         uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
+         if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
+         // read the CRC-32 checksum directly from disk
+         size_t pos = index * 8;
+         if (pos + 8 > _3crc->GetNewSize())
+             throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
+         uint32_t one = load32(&pData[pos]); // always 1
+         if (one != 1)
+             throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
+         return load32(&pData[pos+4]);
+     }
+     int File::GetWaveTableIndexOf(gig::Sample* pSample) {
+         if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
+         File::SampleList::iterator iter = pSamples->begin();
+         File::SampleList::iterator end  = pSamples->end();
+         for (int index = 0; iter != end; ++iter, ++index)
+             if (*iter == pSample)
+                 return index;
+         return -1;
+     }
+     /**
+      * Checks whether the file's "3CRC" chunk was damaged. This chunk contains
+      * the CRC32 check sums of all samples' raw wave data.
+      *
+      * @return true if 3CRC chunk is OK, or false if 3CRC chunk is damaged
+      */
+     bool File::VerifySampleChecksumTable() {
+         RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
+         if (!_3crc) return false;
+         if (_3crc->GetNewSize() <= 0) return false;
+         if (_3crc->GetNewSize() % 8) return false;
+         if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
+         if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
+         const file_offset_t n = _3crc->GetNewSize() / 8;
+         uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
+         if (!pData) return false;
+         for (file_offset_t i = 0; i < n; ++i) {
+             uint32_t one = pData[i*2];
+             if (one != 1) return false;
+         }
+         return true;
+     }
+     /**
+      * Recalculates CRC32 checksums for all samples and rebuilds this gig
+      * file's checksum table with those new checksums. This might usually
+      * just be necessary if the checksum table was damaged.
+      *
+      * @e IMPORTANT: The current implementation of this method only works
+      * with files that have not been modified since it was loaded, because
+      * it expects that no externally caused file structure changes are
+      * required!
+      *
+      * Due to the expectation above, this method is currently protected
+      * and actually only used by the command line tool "gigdump" yet.
+      *
+      * @returns true if Save() is required to be called after this call,
+      *          false if no further action is required
+      */
+     bool File::RebuildSampleChecksumTable() {
+         // make sure sample chunks were scanned
+         if (!pSamples) GetFirstSample();
+         bool bRequiresSave = false;
+         // make sure "3CRC" chunk exists with required size
+         RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
+         if (!_3crc) {
+             _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
+             // the order of einf and 3crc is not the same in v2 and v3
+             RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
+             if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
+             bRequiresSave = true;
+         } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
+             _3crc->Resize(pSamples->size() * 8);
+             bRequiresSave = true;
+         }
+         if (bRequiresSave) { // refill CRC table for all samples in RAM ...
+             uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
+             {
+                 File::SampleList::iterator iter = pSamples->begin();
+                 File::SampleList::iterator end  = pSamples->end();
+                 for (; iter != end; ++iter) {
+                     gig::Sample* pSample = (gig::Sample*) *iter;
+                     int index = GetWaveTableIndexOf(pSample);
+                     if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
+                     pData[index*2]   = 1; // always 1
+                     pData[index*2+1] = pSample->CalculateWaveDataChecksum();
+                 }
+             }
+         } else { // no file structure changes necessary, so directly write to disk and we are done ...
+             // make sure file is in write mode
+             pRIFF->SetMode(RIFF::stream_mode_read_write);
+             {
+                 File::SampleList::iterator iter = pSamples->begin();
+                 File::SampleList::iterator end  = pSamples->end();
+                 for (; iter != end; ++iter) {
+                     gig::Sample* pSample = (gig::Sample*) *iter;
+                     int index = GetWaveTableIndexOf(pSample);
+                     if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
+                     pSample->crc  = pSample->CalculateWaveDataChecksum();
+                     SetSampleChecksum(pSample, pSample->crc);
+                 }
+             }
+         }
+         return bRequiresSave;
+     }
      Group* File::GetFirstGroup() {
          if (!pGroups) LoadGroups();
          // there must always be at least one group
-Line 5841 
 namespace {
+Line 6082 
 namespace {
          }
      }
-     /** @brief Returns the version number of libgig's Giga file format extension.
-      *
-      * libgig added several new features which were not available with the
-      * original GigaStudio software. For those purposes libgig's own custom RIFF
-      * chunks were added to the Giga file format.
-      *
-      * This method returns the version number of the Giga file format extension
-      * used in this Giga file. Currently there are 3 possible values that might
-      * be returned by this method:
-      *
-      * - @c 0: This gig file is not using any libgig specific file format
-      *         extension at all.
-      * - @c 1: This gig file uses the RT instrument script format extension.
-      * - @c 2: This gig file additionally provides support for monolithic
-      *         large gig files (larger than 2 GB).
-      *
-      * @note This method is currently protected and shall not be used as public
-      * API method, since its method signature might change in future.
-      */
-     uint File::GetFormatExtensionVersion() const {
-         RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
-         if (!lst3LS) return 0; // is not using custom Giga format extensions at all
-         RIFF::Chunk* ckFFmt = lst3LS->GetSubChunk(CHUNK_ID_FFMT);
-         if (!ckFFmt) return 1; // uses custom Giga format extension(s) but had no format version saved
-         uint8_t* pData = (uint8_t*) ckFFmt->LoadChunkData();
-         return load32(pData);
-     }
-     /** @brief Returns true in case this file is stored as one, single monolithic gig file.
-      *
-      * To avoid issues with operating systems which did not support large files
-      * (larger than 2 GB) the original Giga file format avoided to ever save gig
-      * files larger than 2 GB, instead such large Giga files were splitted into
-      * several files, each one not being larger than 2 GB. It used a predefined
-      * file name scheme for them like this:
-      * @code
-      * foo.gig
-      * foo.gx01
-      * foo.gx02
-      * foo.gx03
-      * ...
-      * @endcode
-      * So when like in this example foo.gig was loaded, all other files
-      * (foo.gx01, ...) were automatically loaded as well to make up the overall
-      * large gig file (provided they were located at the same directory). Such
-      * additional .gxYY files were called "extension files".
-      *
-      * Since nowadays all modern systems support large files, libgig always
-      * saves large gig files as one single monolithic gig file instead, that
-      * is libgig won't split such a large gig file into separate files like the
-      * original GigaStudio software did. It uses a custom Giga file format
-      * extension for this feature.
-      *
-      * For still being able though to load old splitted gig files and the new
-      * large monolithic ones, this method is used to determine which loading
-      * policy must be used for this gig file.
-      *
-      * @note This method is currently protected and shall not be used as public
-      * API method, since its method signature might change in future and since
-      * this method should not be directly relevant for applications based on
-      * libgig.
-      */
-     bool File::HasMonolithicLargeFilePolicy() const {
-         RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
-         if (!lst3LS) return false;
-         RIFF::Chunk* ckFFmt = lst3LS->GetSubChunk(CHUNK_ID_FFMT);
-         if (!ckFFmt) return false;
-         uint8_t* pData = (uint8_t*) ckFFmt->LoadChunkData();
-         uint32_t formatBitField = load32(&pData[4]);
-         return formatBitField & 1;
-     }
      /**
       * Apply all the gig file's current instruments, samples, groups and settings
       * to the respective RIFF chunks. You have to call Save() to make changes
-Line 5927 
 namespace {
+Line 6096 
 namespace {
      void File::UpdateChunks(progress_t* pProgress) {
          bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
-         b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
          // update own gig format extension chunks
          // (not part of the GigaStudio 4 format)
          RIFF::List* lst3LS = pRIFF->GetSubList(LIST_TYPE_3LS);
-Line 5936 
 namespace {
+Line 6103 
 namespace {
              lst3LS = pRIFF->AddSubList(LIST_TYPE_3LS);
          }
          // Make sure <3LS > chunk is placed before <ptbl> chunk. The precise
-         // location of <3LS > is irrelevant, however it MUST BE located BEFORE
+         // location of <3LS > is irrelevant, however it should be located
-         // the actual wave data, otherwise the <3LS > chunk becomes
+         // before  the actual wave data
-         // inaccessible on gig files larger than 4GB !
          RIFF::Chunk* ckPTBL = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
          pRIFF->MoveSubChunk(lst3LS, ckPTBL);
-         // Update <FFmt> chunk with informations about our file format
-         // extensions. Currently this <FFmt> chunk has the following
-         // layout:
-         //
-         // <uint32> -> (libgig's) File Format Extension version
-         // <uint32> -> Format bit field:
-         //             bit 0: If flag is not set use separate .gx01
-         //                    extension files if file is larger than 2 GB
-         //                    like with the original Giga format, if flag
-         //                    is set use 64 bit sample references and keep
-         //                    everything as one single monolithic gig file.
-         RIFF::Chunk* ckFFmt = lst3LS->GetSubChunk(CHUNK_ID_FFMT);
-         if (!ckFFmt) {
-             const int iChunkSize = 2 * sizeof(uint32_t);
-             ckFFmt = lst3LS->AddSubChunk(CHUNK_ID_FFMT, iChunkSize);
-         }
-         {
-             uint8_t* pData = (uint8_t*) ckFFmt->LoadChunkData();
-             store32(&pData[0], GIG_FILE_EXT_VERSION);
-             // for now we always save gig files larger than 2 GB as one
-             // single monolithic file (saving those with extension files is
-             // currently not supported and probably also not desired anymore
-             // nowadays).
-             uint32_t formatBitfield = 1;
-             store32(&pData[4], formatBitfield);
-         }
          // This must be performed before writing the chunks for instruments,
          // because the instruments' script slots will write the file offsets
          // of the respective instrument script chunk as reference.
-Line 5980 
 namespace {
+Line 6120 
 namespace {
              }
          }
+         // in case no libgig custom format data was added, then remove the
+         // custom "3LS " chunk again
+         if (!lst3LS->CountSubChunks()) {
+             pRIFF->DeleteSubChunk(lst3LS);
+             lst3LS = NULL;
+         }
          // first update base class's chunks
          DLS::File::UpdateChunks(pProgress);
-Line 6038 
 namespace {
+Line 6185 
 namespace {
          // Note that there are several fields with unknown use. These
          // are set to zero.
-         int sublen = pSamples->size() / 8 + 49;
+         int sublen = int(pSamples->size() / 8 + 49);
          int einfSize = (Instruments + 1) * sublen;
          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
-Line 6111 
 namespace {
+Line 6258 
 namespace {
                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
                  // next 8 bytes unknown
                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
-                 store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());
+                 store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
                  // next 4 bytes unknown
                  totnbregions += instrument->Regions;
-Line 6129 
 namespace {
+Line 6276 
 namespace {
              store32(&pData[24], totnbloops);
              // next 8 bytes unknown
              // next 4 bytes unknown, not always 0
-             store32(&pData[40], pSamples->size());
+             store32(&pData[40], (uint32_t) pSamples->size());
              // next 4 bytes unknown
          }
          // update 3crc chunk
          // The 3crc chunk contains CRC-32 checksums for the
-         // samples. The actual checksum values will be filled in
+         // samples. When saving a gig file to disk, we first update the 3CRC
-         // later, by Sample::Write.
+         // chunk here (in RAM) with the old crc values which we read from the
+         // 3CRC chunk when we opened the file (available with gig::Sample::crc
+         // member variable). This step is required, because samples might have
+         // been deleted by the user since the file was opened, which in turn
+         // changes the order of the (i.e. old) checksums within the 3crc chunk.
+         // If a sample was conciously modified by the user (that is if
+         // Sample::Write() was called later on) then Sample::Write() will just
+         // update the respective individual checksum(s) directly on disk and
+         // leaves all other sample checksums untouched.
          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
          if (_3crc) {
              _3crc->Resize(pSamples->size() * 8);
-         } else if (newFile) {
+         } else /*if (newFile)*/ {
              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
-             _3crc->LoadChunkData();
              // the order of einf and 3crc is not the same in v2 and v3
              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
          }
+         { // must be performed in RAM here ...
+             uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
+             if (pData) {
+                 File::SampleList::iterator iter = pSamples->begin();
+                 File::SampleList::iterator end  = pSamples->end();
+                 for (int index = 0; iter != end; ++iter, ++index) {
+                     gig::Sample* pSample = (gig::Sample*) *iter;
+                     pData[index*2]   = 1; // always 1
+                     pData[index*2+1] = pSample->crc;
+                 }
+             }
+         }
      }
      void File::UpdateFileOffsets() {

 Legend:



Removed from v.2912
 


changed lines


 
Added in v.3117
 Legend:



Removed from v.2912
 


changed lines


 
Added in v.3117
-Removed from v.2912
+Added in v.3117

	ViewVC Help
Powered by ViewVC