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

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

Parent Directory | Revision Log | View Patch Patch

-revision 3474 by schoenebeck,
Wed Feb 20 16:04:19 2019 UTC
+revision 3488 by schoenebeck,
Thu Feb 28 17:49:07 2019 UTC
 Line 122 
 namespace DLS {
              artl->GetChunkID() != CHUNK_ID_ARTL) {
                throw DLS::Exception("<artl-ck> or <art2-ck> chunk expected");
          }
+         artl->SetPos(0);
          HeaderSize  = artl->ReadUint32();
          Connections = artl->ReadUint32();
          artl->SetPos(HeaderSize);
-Line 164 
 namespace DLS {
+Line 167 
 namespace DLS {
          }
      }
+     /** @brief Remove all RIFF chunks associated with this Articulation object.
+      *
+      * At the moment Articulation::DeleteChunks() does nothing. It is
+      * recommended to call this method explicitly though from deriving classes's
+      * own overridden implementation of this method to avoid potential future
+      * compatiblity issues.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Articulation::DeleteChunks() {
+     }
  // *************** Articulator  ***************
-Line 232 
 namespace DLS {
+Line 247 
 namespace DLS {
              }
          }
      }
+     /** @brief Remove all RIFF chunks associated with this Articulator object.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Articulator::DeleteChunks() {
+         if (pArticulations) {
+             ArticulationList::iterator iter = pArticulations->begin();
+             ArticulationList::iterator end  = pArticulations->end();
+             for (; iter != end; ++iter) {
+                 (*iter)->DeleteChunks();
+             }
+         }
+     }
      /**
       * Not yet implemented in this version, since the .gig format does
       * not need to copy DLS articulators and so far nobody used pure
-Line 399 
 namespace DLS {
+Line 428 
 namespace DLS {
          SaveString(CHUNK_ID_ISRF, lstINFO, SourceForm, String(""));
          SaveString(CHUNK_ID_ITCH, lstINFO, Technician, String(""));
      }
+     /** @brief Remove all RIFF chunks associated with this Info object.
+      *
+      * At the moment Info::DeleteChunks() does nothing. It is
+      * recommended to call this method explicitly though from deriving classes's
+      * own overridden implementation of this method to avoid potential future
+      * compatiblity issues.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Info::DeleteChunks() {
+     }
      /**
       * Make a deep copy of the Info object given by @a orig and assign it to
       * this object.
-Line 450 
 namespace DLS {
+Line 491 
 namespace DLS {
          RIFF::Chunk* ckDLSID = lstResource->GetSubChunk(CHUNK_ID_DLID);
          if (ckDLSID) {
+             ckDLSID->SetPos(0);
              pDLSID = new dlsid_t;
              ckDLSID->Read(&pDLSID->ulData1, 1, 4);
              ckDLSID->Read(&pDLSID->usData2, 1, 2);
-Line 464 
 namespace DLS {
+Line 507 
 namespace DLS {
          if (pInfo)  delete pInfo;
      }
+     /** @brief Remove all RIFF chunks associated with this Resource object.
+      *
+      * At the moment Resource::DeleteChunks() does nothing. It is recommended
+      * to call this method explicitly though from deriving classes's own
+      * overridden implementation of this method to avoid potential future
+      * compatiblity issues.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Resource::DeleteChunks() {
+     }
      /** @brief Update chunks with current Resource data.
       *
       * Apply Resource data persistently below the previously given resource
-Line 555 
 namespace DLS {
+Line 610 
 namespace DLS {
          pParentList       = ParentList;
          RIFF::Chunk* wsmp = ParentList->GetSubChunk(CHUNK_ID_WSMP);
          if (wsmp) {
+             wsmp->SetPos(0);
              uiHeaderSize   = wsmp->ReadUint32();
              UnityNote      = wsmp->ReadUint16();
              FineTune       = wsmp->ReadInt16();
-Line 629 
 namespace DLS {
+Line 686 
 namespace DLS {
          }
      }
+     /** @brief Remove all RIFF chunks associated with this Sampler object.
+      *
+      * At the moment Sampler::DeleteChunks() does nothing. It is
+      * recommended to call this method explicitly though from deriving classes's
+      * own overridden implementation of this method to avoid potential future
+      * compatiblity issues.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Sampler::DeleteChunks() {
+     }
      /**
       * Adds a new sample loop with the provided loop definition.
       *
-Line 721 
 namespace DLS {
+Line 790 
 namespace DLS {
          pCkFormat = waveList->GetSubChunk(CHUNK_ID_FMT);
          pCkData   = waveList->GetSubChunk(CHUNK_ID_DATA);
          if (pCkFormat) {
+             pCkFormat->SetPos(0);
              // common fields
              FormatTag              = pCkFormat->ReadUint16();
              Channels               = pCkFormat->ReadUint16();
-Line 751 
 namespace DLS {
+Line 822 
 namespace DLS {
      /** @brief Destructor.
       *
-      * Removes RIFF chunks associated with this Sample and frees all
+      * Frees all memory occupied by this sample.
-      * memory occupied by this sample.
       */
      Sample::~Sample() {
-         RIFF::List* pParent = pWaveList->GetParent();
+         if (pCkData)
-         pParent->DeleteSubChunk(pWaveList);
+             pCkData->ReleaseChunkData();
+         if (pCkFormat)
+             pCkFormat->ReleaseChunkData();
      }
+     /** @brief Remove all RIFF chunks associated with this Sample object.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Sample::DeleteChunks() {
+         // handle base class
+         Resource::DeleteChunks();
+         // handle own RIFF chunks
+         if (pWaveList) {
+             RIFF::List* pParent = pWaveList->GetParent();
+             pParent->DeleteSubChunk(pWaveList);
+             pWaveList = NULL;
+         }
+     }
      /**
       * Make a deep copy of the Sample object given by @a orig (without the
       * actual sample waveform data however) and assign it to this object.
-Line 1003 
 namespace DLS {
+Line 1091 
 namespace DLS {
          // articulation information
          RIFF::Chunk* rgnh = rgnList->GetSubChunk(CHUNK_ID_RGNH);
          if (rgnh) {
+             rgnh->SetPos(0);
              rgnh->Read(&KeyRange, 2, 2);
              rgnh->Read(&VelocityRange, 2, 2);
              FormatOptionFlags = rgnh->ReadUint16();
-Line 1025 
 namespace DLS {
+Line 1115 
 namespace DLS {
          // sample information
          RIFF::Chunk* wlnk = rgnList->GetSubChunk(CHUNK_ID_WLNK);
          if (wlnk) {
+             wlnk->SetPos(0);
              WaveLinkOptionFlags = wlnk->ReadUint16();
              PhaseGroup          = wlnk->ReadUint16();
              Channel             = wlnk->ReadUint32();
-Line 1043 
 namespace DLS {
+Line 1135 
 namespace DLS {
      /** @brief Destructor.
       *
-      * Removes RIFF chunks associated with this Region.
+      * Intended to free up all memory occupied by this Region object. ATM this
+      * destructor implementation does nothing though.
       */
      Region::~Region() {
-         RIFF::List* pParent = pCkRegion->GetParent();
+     }
-         pParent->DeleteSubChunk(pCkRegion);
+     /** @brief Remove all RIFF chunks associated with this Region object.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Region::DeleteChunks() {
+         // handle base classes
+         Resource::DeleteChunks();
+         Articulator::DeleteChunks();
+         Sampler::DeleteChunks();
+         // handle own RIFF chunks
+         if (pCkRegion) {
+             RIFF::List* pParent = pCkRegion->GetParent();
+             pParent->DeleteSubChunk(pCkRegion);
+             pCkRegion = NULL;
+         }
      }
      Sample* Region::GetSample() {
-Line 1229 
 namespace DLS {
+Line 1338 
 namespace DLS {
          midi_locale_t locale;
          RIFF::Chunk* insh = pCkInstrument->GetSubChunk(CHUNK_ID_INSH);
          if (insh) {
+             insh->SetPos(0);
              Regions = insh->ReadUint32();
              insh->Read(&locale, 2, 4);
          } else { // 'insh' chunk missing
-Line 1300 
 namespace DLS {
+Line 1411 
 namespace DLS {
          if (iter == pRegions->end()) return;
          pRegions->erase(iter);
          Regions = (uint32_t) pRegions->size();
+         pRegion->DeleteChunks();
          delete pRegion;
      }
-Line 1333 
 namespace DLS {
+Line 1445 
 namespace DLS {
          RegionList::iterator iter = pRegions->begin();
          RegionList::iterator end  = pRegions->end();
          for (int i = 0; iter != end; ++iter, ++i) {
-             // divide local progress into subprogress
+             if (pProgress) {
-             progress_t subprogress;
+                 // divide local progress into subprogress
-             __divide_progress(pProgress, &subprogress, pRegions->size(), i);
+                 progress_t subprogress;
-             // do the actual work
+                 __divide_progress(pProgress, &subprogress, pRegions->size(), i);
-             (*iter)->UpdateChunks(&subprogress);
+                 // do the actual work
+                 (*iter)->UpdateChunks(&subprogress);
+             } else
+                 (*iter)->UpdateChunks(NULL);
          }
-         __notify_progress(pProgress, 1.0); // notify done
+         if (pProgress)
+             __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Destructor.
       *
-      * Removes RIFF chunks associated with this Instrument and frees all
+      * Frees all memory occupied by this instrument.
-      * memory occupied by this instrument.
       */
      Instrument::~Instrument() {
          if (pRegions) {
-Line 1357 
 namespace DLS {
+Line 1472 
 namespace DLS {
              }
              delete pRegions;
          }
-         // remove instrument's chunks
-         RIFF::List* pParent = pCkInstrument->GetParent();
-         pParent->DeleteSubChunk(pCkInstrument);
      }
+     /** @brief Remove all RIFF chunks associated with this Instrument object.
+      *
+      * See Storage::DeleteChunks() for details.
+      */
+     void Instrument::DeleteChunks() {
+         // handle base classes
+         Resource::DeleteChunks();
+         Articulator::DeleteChunks();
+         // handle RIFF chunks of members
+         if (pRegions) {
+             RegionList::iterator it  = pRegions->begin();
+             RegionList::iterator end = pRegions->end();
+             for (; it != end; ++it)
+                 (*it)->DeleteChunks();
+         }
+         // handle own RIFF chunks
+         if (pCkInstrument) {
+             RIFF::List* pParent = pCkInstrument->GetParent();
+             pParent->DeleteSubChunk(pCkInstrument);
+             pCkInstrument = NULL;
+         }
+     }
      void Instrument::CopyAssignCore(const Instrument* orig) {
          // handle base classes
          Resource::CopyAssign(orig);
-Line 1445 
 namespace DLS {
+Line 1582 
 namespace DLS {
          bOwningRiff = false;
          RIFF::Chunk* ckVersion = pRIFF->GetSubChunk(CHUNK_ID_VERS);
          if (ckVersion) {
+             ckVersion->SetPos(0);
              pVersion = new version_t;
              ckVersion->Read(pVersion, 4, 2);
          }
-Line 1452 
 namespace DLS {
+Line 1591 
 namespace DLS {
          RIFF::Chunk* colh = pRIFF->GetSubChunk(CHUNK_ID_COLH);
          if (!colh) throw DLS::Exception("Mandatory chunks in RIFF list chunk not found.");
+         colh->SetPos(0);
          Instruments = colh->ReadUint32();
          RIFF::Chunk* ptbl = pRIFF->GetSubChunk(CHUNK_ID_PTBL);
-Line 1462 
 namespace DLS {
+Line 1602 
 namespace DLS {
              WavePoolHeaderSize = 8;
              b64BitWavePoolOffsets = false;
          } else {
+             ptbl->SetPos(0);
              WavePoolHeaderSize = ptbl->ReadUint32();
              WavePoolCount  = ptbl->ReadUint32();
              pWavePoolTable = new uint32_t[WavePoolCount];
-Line 1535 
 namespace DLS {
+Line 1677 
 namespace DLS {
          if (!pSamples) pSamples = new SampleList;
          RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
          if (wvpl) {
-             file_offset_t wvplFileOffset = wvpl->GetFilePos();
+             file_offset_t wvplFileOffset = wvpl->GetFilePos() -
+                                            wvpl->GetPos(); // should be zero, but just to be sure
              RIFF::List* wave = wvpl->GetFirstSubList();
              while (wave) {
                  if (wave->GetListType() == LIST_TYPE_WAVE) {
-                     file_offset_t waveFileOffset = wave->GetFilePos();
+                     file_offset_t waveFileOffset = wave->GetFilePos() -
+                                                    wave->GetPos(); // should be zero, but just to be sure
                      pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset));
                  }
                  wave = wvpl->GetNextSubList();
-Line 1548 
 namespace DLS {
+Line 1692 
 namespace DLS {
          else { // Seen a dwpl list chunk instead of a wvpl list chunk in some file (officially not DLS compliant)
              RIFF::List* dwpl = pRIFF->GetSubList(LIST_TYPE_DWPL);
              if (dwpl) {
-                 file_offset_t dwplFileOffset = dwpl->GetFilePos();
+                 file_offset_t dwplFileOffset = dwpl->GetFilePos() -
+                                                dwpl->GetPos(); // should be zero, but just to be sure
                  RIFF::List* wave = dwpl->GetFirstSubList();
                  while (wave) {
                      if (wave->GetListType() == LIST_TYPE_WAVE) {
-                         file_offset_t waveFileOffset = wave->GetFilePos();
+                         file_offset_t waveFileOffset = wave->GetFilePos() -
+                                                        wave->GetPos(); // should be zero, but just to be sure
                          pSamples->push_back(new Sample(this, wave, waveFileOffset - dwplFileOffset));
                      }
                      wave = dwpl->GetNextSubList();
-Line 1591 
 namespace DLS {
+Line 1737 
 namespace DLS {
          SampleList::iterator iter = find(pSamples->begin(), pSamples->end(), pSample);
          if (iter == pSamples->end()) return;
          pSamples->erase(iter);
+         pSample->DeleteChunks();
          delete pSample;
      }
-Line 1650 
 namespace DLS {
+Line 1797 
 namespace DLS {
          InstrumentList::iterator iter = find(pInstruments->begin(), pInstruments->end(), pInstrument);
          if (iter == pInstruments->end()) return;
          pInstruments->erase(iter);
+         pInstrument->DeleteChunks();
          delete pInstrument;
      }
      /**
+      * Returns the underlying RIFF::File used for persistency of this DLS::File
+      * object.
+      */
+     RIFF::File* File::GetRiffFile() {
+         return pRIFF;
+     }
+     /**
       * Returns extension file of given index. Extension files are used
       * sometimes to circumvent the 2 GB file size limit of the RIFF format and
       * of certain operating systems in general. In this case, instead of just
-Line 1726 
 namespace DLS {
+Line 1882 
 namespace DLS {
          // update instrument's chunks
          if (pInstruments) {
-             // divide local progress into subprogress
+             if (pProgress) {
-             progress_t subprogress;
+                 // divide local progress into subprogress
-             __divide_progress(pProgress, &subprogress, 20.f, 0.f); // arbitrarily subdivided into 5% of total progress
+                 progress_t subprogress;
+                 __divide_progress(pProgress, &subprogress, 20.f, 0.f); // arbitrarily subdivided into 5% of total progress
-             // do the actual work
-             InstrumentList::iterator iter = pInstruments->begin();
-             InstrumentList::iterator end  = pInstruments->end();
-             for (int i = 0; iter != end; ++iter, ++i) {
-                 // divide subprogress into sub-subprogress
-                 progress_t subsubprogress;
-                 __divide_progress(&subprogress, &subsubprogress, pInstruments->size(), i);
                  // do the actual work
-                 (*iter)->UpdateChunks(&subsubprogress);
+                 InstrumentList::iterator iter = pInstruments->begin();
-             }
+                 InstrumentList::iterator end  = pInstruments->end();
+                 for (int i = 0; iter != end; ++iter, ++i) {
+                     // divide subprogress into sub-subprogress
+                     progress_t subsubprogress;
+                     __divide_progress(&subprogress, &subsubprogress, pInstruments->size(), i);
+                     // do the actual work
+                     (*iter)->UpdateChunks(&subsubprogress);
+                 }
-             __notify_progress(&subprogress, 1.0); // notify subprogress done
+                 __notify_progress(&subprogress, 1.0); // notify subprogress done
+             } else {
+                 InstrumentList::iterator iter = pInstruments->begin();
+                 InstrumentList::iterator end  = pInstruments->end();
+                 for (int i = 0; iter != end; ++iter, ++i) {
+                     (*iter)->UpdateChunks(NULL);
+                 }
+             }
          }
          // update 'ptbl' chunk
-Line 1759 
 namespace DLS {
+Line 1923 
 namespace DLS {
          // update sample's chunks
          if (pSamples) {
-             // divide local progress into subprogress
+             if (pProgress) {
-             progress_t subprogress;
+                 // divide local progress into subprogress
-             __divide_progress(pProgress, &subprogress, 20.f, 1.f); // arbitrarily subdivided into 95% of total progress
+                 progress_t subprogress;
+                 __divide_progress(pProgress, &subprogress, 20.f, 1.f); // arbitrarily subdivided into 95% of total progress
-             // do the actual work
-             SampleList::iterator iter = pSamples->begin();
-             SampleList::iterator end  = pSamples->end();
-             for (int i = 0; iter != end; ++iter, ++i) {
-                 // divide subprogress into sub-subprogress
-                 progress_t subsubprogress;
-                 __divide_progress(&subprogress, &subsubprogress, pSamples->size(), i);
                  // do the actual work
-                 (*iter)->UpdateChunks(&subsubprogress);
+                 SampleList::iterator iter = pSamples->begin();
-             }
+                 SampleList::iterator end  = pSamples->end();
+                 for (int i = 0; iter != end; ++iter, ++i) {
+                     // divide subprogress into sub-subprogress
+                     progress_t subsubprogress;
+                     __divide_progress(&subprogress, &subsubprogress, pSamples->size(), i);
+                     // do the actual work
+                     (*iter)->UpdateChunks(&subsubprogress);
+                 }
-             __notify_progress(&subprogress, 1.0); // notify subprogress done
+                 __notify_progress(&subprogress, 1.0); // notify subprogress done
+             } else {
+                 SampleList::iterator iter = pSamples->begin();
+                 SampleList::iterator end  = pSamples->end();
+                 for (int i = 0; iter != end; ++iter, ++i) {
+                     (*iter)->UpdateChunks(NULL);
+                 }
+             }
          }
          // if there are any extension files, gather which ones are regular
-Line 1910 
 namespace DLS {
+Line 2082 
 namespace DLS {
              ptbl->Resize(iPtblSize);
          }
-         __notify_progress(pProgress, 1.0); // notify done
+         if (pProgress)
+             __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Save changes to another file.
-Line 1935 
 namespace DLS {
+Line 2108 
 namespace DLS {
          // save extension files (if required)
          if (!ExtensionFiles.empty()) {
              // for assembling path of extension files to be saved to
-             const std::string folder = parentPath(Path);
              const std::string baseName = pathWithoutExtension(Path);
              // save the individual extension files
              std::list<RIFF::File*>::iterator it = ExtensionFiles.begin();
              for (int i = 0; it != ExtensionFiles.end(); ++i, ++it) {
-                 // divide local progress into subprogress
-                 progress_t subprogress;
-                 __divide_progress(pProgress, &subprogress, tasks, 0.f + i); // subdivided into amount of extension files
                  //FIXME: the .gx99 file is always used by GSt for convolution
                  // data (GigaPulse); so we should better detect by subchunk
                  // whether the extension file is intended for convolution
-Line 1950 
 namespace DLS {
+Line 2119 
 namespace DLS {
                  // not work for saving new gigs created from scratch
                  const std::string oldName = (*it)->GetFileName();
                  const bool isGigaPulseFile = (extensionOfPath(oldName) == "gx99");
-                 std::string ext = (isGigaPulseFile) ? ".gx99" : strPrint(".gx02d", i+1);
+                 std::string ext = (isGigaPulseFile) ? ".gx99" : strPrint(".gx%02d", i+1);
-                 std::string newPath = concatPath(folder, baseName) + ext;
+                 std::string newPath = baseName + ext;
                  // save extension file to its new location
-                 (*it)->Save(newPath, &subprogress);
+                 if (pProgress) {
+                      // divide local progress into subprogress
+                     progress_t subprogress;
+                     __divide_progress(pProgress, &subprogress, tasks, 0.f + i); // subdivided into amount of extension files
+                     // do the actual work
+                     (*it)->Save(newPath, &subprogress);
+                 } else
+                     (*it)->Save(newPath);
              }
          }
-         {
+         if (pProgress) {
              // divide local progress into subprogress
              progress_t subprogress;
              __divide_progress(pProgress, &subprogress, tasks, 1.f + nExtFiles); // arbitrarily subdivided into 50% (minus extension files progress)
              // do the actual work
              UpdateChunks(&subprogress);
-         }
+         } else
-         {
+             UpdateChunks(NULL);
+         if (pProgress) {
              // divide local progress into subprogress
              progress_t subprogress;
              __divide_progress(pProgress, &subprogress, tasks, 2.f + nExtFiles); // arbitrarily subdivided into 50% (minus extension files progress)
              // do the actual work
              pRIFF->Save(Path, &subprogress);
-         }
+         } else
+             pRIFF->Save(Path);
          UpdateFileOffsets();
-         __notify_progress(pProgress, 1.0); // notify done
+         if (pProgress)
+             __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Save changes to same file.
-Line 1994 
 namespace DLS {
+Line 2176 
 namespace DLS {
          if (!ExtensionFiles.empty()) {
              std::list<RIFF::File*>::iterator it = ExtensionFiles.begin();
              for (int i = 0; it != ExtensionFiles.end(); ++i, ++it) {
-                 // divide local progress into subprogress
-                 progress_t subprogress;
-                 __divide_progress(pProgress, &subprogress, tasks, 0.f + i); // subdivided into amount of extension files
                  // save extension file
-                 (*it)->Save(&subprogress);
+                 if (pProgress) {
+                     // divide local progress into subprogress
+                     progress_t subprogress;
+                     __divide_progress(pProgress, &subprogress, tasks, 0.f + i); // subdivided into amount of extension files
+                     // do the actual work
+                     (*it)->Save(&subprogress);
+                 } else
+                     (*it)->Save();
              }
          }
-         {
+         if (pProgress) {
              // divide local progress into subprogress
              progress_t subprogress;
              __divide_progress(pProgress, &subprogress, tasks, 1.f + nExtFiles); // arbitrarily subdivided into 50% (minus extension files progress)
              // do the actual work
              UpdateChunks(&subprogress);
-         }
+         } else
-         {
+             UpdateChunks(NULL);
+         if (pProgress) {
              // divide local progress into subprogress
              progress_t subprogress;
              __divide_progress(pProgress, &subprogress, tasks, 2.f + nExtFiles); // arbitrarily subdivided into 50% (minus extension files progress)
              // do the actual work
              pRIFF->Save(&subprogress);
-         }
+         } else
+             pRIFF->Save();
          UpdateFileOffsets();
-         __notify_progress(pProgress, 1.0); // notify done
+         if (pProgress)
+             __notify_progress(pProgress, 1.0); // notify done
      }
      /** @brief Updates all file offsets stored all over the file.
-Line 2113 
 namespace DLS {
+Line 2305 
 namespace DLS {
          if (!pSamples) return;
          // update offsets in wave pool table
          RIFF::List* wvpl = pRIFF->GetSubList(LIST_TYPE_WVPL);
-         uint64_t wvplFileOffset = wvpl->GetFilePos();
+         uint64_t wvplFileOffset = wvpl->GetFilePos() -
+                                   wvpl->GetPos(); // mandatory, since position might have changed
          if (!b64BitWavePoolOffsets) { // conventional 32 bit offsets (and no extension files) ...
              SampleList::iterator iter = pSamples->begin();
              SampleList::iterator end  = pSamples->end();
              for (int i = 0 ; iter != end ; ++iter, i++) {
-                 uint64_t _64BitOffset = (*iter)->pWaveList->GetFilePos() - wvplFileOffset - LIST_HEADER_SIZE(pRIFF->GetFileOffsetSize());
+                 uint64_t _64BitOffset =
+                     (*iter)->pWaveList->GetFilePos() -
+                     (*iter)->pWaveList->GetPos() - // should be zero, but just to be sure
+                     wvplFileOffset -
+                     LIST_HEADER_SIZE(pRIFF->GetFileOffsetSize());
                  (*iter)->ullWavePoolOffset = _64BitOffset;
                  pWavePoolTable[i] = (uint32_t) _64BitOffset;
              }
-Line 2127 
 namespace DLS {
+Line 2324 
 namespace DLS {
                  SampleList::iterator iter = pSamples->begin();
                  SampleList::iterator end  = pSamples->end();
                  for (int i = 0 ; iter != end ; ++iter, i++) {
-                     uint64_t _64BitOffset = (*iter)->pWaveList->GetFilePos() - wvplFileOffset - LIST_HEADER_SIZE(pRIFF->GetFileOffsetSize());
+                     uint64_t _64BitOffset =
+                         (*iter)->pWaveList->GetFilePos() -
+                         (*iter)->pWaveList->GetPos() - // should be zero, but just to be sure
+                         wvplFileOffset -
+                         LIST_HEADER_SIZE(pRIFF->GetFileOffsetSize());
                      (*iter)->ullWavePoolOffset = _64BitOffset;
                      pWavePoolTableHi[i] = (uint32_t) (_64BitOffset >> 32);
                      pWavePoolTable[i]   = (uint32_t) _64BitOffset;
-Line 2160 
 namespace DLS {
+Line 2361 
 namespace DLS {
                          RIFF::List* extWvpl = pCurPoolFile->GetSubList(LIST_TYPE_WVPL);
                          if (!extWvpl)
                              throw DLS::Exception("Fatal error, pool file has no 'wvpl' list chunk");
-                         waveOffset = extWvpl->GetFilePos() + LIST_HEADER_SIZE(pCurPoolFile->GetFileOffsetSize());
+                         waveOffset =
+                             extWvpl->GetFilePos() -
+                             extWvpl->GetPos() + // mandatory, since position might have changed
+                             LIST_HEADER_SIZE(pCurPoolFile->GetFileOffsetSize());
                      }
-                     uint64_t _64BitOffset = (*iter)->pWaveList->GetFilePos() - waveOffset;
+                     uint64_t _64BitOffset =
+                         (*iter)->pWaveList->GetFilePos() -
+                         (*iter)->pWaveList->GetPos() - // should be zero, but just to be sure
+                         waveOffset;
                      // pWavePoolTableHi stores file number when extension files are in use
                      pWavePoolTableHi[i] = (uint32_t) fileNo;
                      pWavePoolTable[i]   = (uint32_t) _64BitOffset;

 Legend:



Removed from v.3474
 


changed lines


 
Added in v.3488
 Legend:



Removed from v.3474
 


changed lines


 
Added in v.3488
-Removed from v.3474
+Added in v.3488

	ViewVC Help
Powered by ViewVC