/[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 2985 by schoenebeck, Tue Sep 20 22:13:37 2016 UTC revision 3138 by schoenebeck, Wed May 3 14:41:58 2017 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2016 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2017 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 55  Line 55 
55  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)
56  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)
57    
58    #define SRLZ(member) \
59        archive->serializeMember(*this, member, #member);
60    
61  namespace gig {  namespace gig {
62    
63  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
# Line 269  namespace { Line 272  namespace {
272       * steps.       * steps.
273       *       *
274       * Once the whole data was processed by __calculateCRC(), one should       * Once the whole data was processed by __calculateCRC(), one should
275       * call __encodeCRC() to get the final CRC result.       * call __finalizeCRC() to get the final CRC result.
276       *       *
277       * @param buf     - pointer to data the CRC shall be calculated of       * @param buf     - pointer to data the CRC shall be calculated of
278       * @param bufSize - size of the data to be processed       * @param bufSize - size of the data to be processed
279       * @param crc     - variable the CRC sum shall be stored to       * @param crc     - variable the CRC sum shall be stored to
280       */       */
281      static void __calculateCRC(unsigned char* buf, int bufSize, uint32_t& crc) {      static void __calculateCRC(unsigned char* buf, size_t bufSize, uint32_t& crc) {
282          for (int i = 0 ; i < bufSize ; i++) {          for (size_t i = 0 ; i < bufSize ; i++) {
283              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
284          }          }
285      }      }
# Line 286  namespace { Line 289  namespace {
289       *       *
290       * @param crc - variable previously passed to __calculateCRC()       * @param crc - variable previously passed to __calculateCRC()
291       */       */
292      inline static uint32_t __encodeCRC(const uint32_t& crc) {      inline static void __finalizeCRC(uint32_t& crc) {
293          return crc ^ 0xffffffff;          crc ^= 0xffffffff;
294      }      }
295    
296    
# Line 315  namespace { Line 318  namespace {
318    
319    
320    
321    // *************** leverage_ctrl_t ***************
322    // *
323    
324        void leverage_ctrl_t::serialize(Serialization::Archive* archive) {
325            SRLZ(type);
326            SRLZ(controller_number);
327        }
328    
329    
330    
331    // *************** crossfade_t ***************
332    // *
333    
334        void crossfade_t::serialize(Serialization::Archive* archive) {
335            SRLZ(in_start);
336            SRLZ(in_end);
337            SRLZ(out_start);
338            SRLZ(out_end);
339        }
340    
341    
342    
343  // *************** Sample ***************  // *************** Sample ***************
344  // *  // *
345    
# Line 338  namespace { Line 363  namespace {
363       *                         ('wvpl') list chunk       *                         ('wvpl') list chunk
364       * @param fileNo         - number of an extension file where this sample       * @param fileNo         - number of an extension file where this sample
365       *                         is located, 0 otherwise       *                         is located, 0 otherwise
366         * @param index          - wave pool index of sample (may be -1 on new sample)
367       */       */
368      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)
369            : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset)
370        {
371          static const DLS::Info::string_length_t fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
372              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
373              { 0, 0 }              { 0, 0 }
# Line 349  namespace { Line 377  namespace {
377          FileNo = fileNo;          FileNo = fileNo;
378    
379          __resetCRC(crc);          __resetCRC(crc);
380            // if this is not a new sample, try to get the sample's already existing
381            // CRC32 checksum from disk, this checksum will reflect the sample's CRC32
382            // checksum of the time when the sample was consciously modified by the
383            // user for the last time (by calling Sample::Write() that is).
384            if (index >= 0) { // not a new file ...
385                try {
386                    uint32_t crc = pFile->GetSampleChecksumByIndex(index);
387                    this->crc = crc;
388                } catch (...) {}
389            }
390    
391          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
392          if (pCk3gix) {          if (pCk3gix) {
# Line 1281  namespace { Line 1319  namespace {
1319          // if this is the last write, update the checksum chunk in the          // if this is the last write, update the checksum chunk in the
1320          // file          // file
1321          if (pCkData->GetPos() == pCkData->GetSize()) {          if (pCkData->GetPos() == pCkData->GetSize()) {
1322                __finalizeCRC(crc);
1323              File* pFile = static_cast<File*>(GetParent());              File* pFile = static_cast<File*>(GetParent());
1324              pFile->SetSampleChecksum(this, __encodeCRC(crc));              pFile->SetSampleChecksum(this, crc);
1325          }          }
1326          return res;          return res;
1327      }      }
# Line 1342  namespace { Line 1381  namespace {
1381      }      }
1382    
1383      /**      /**
1384         * Returns the CRC-32 checksum of the sample's raw wave form data at the
1385         * time when this sample's wave form data was modified for the last time
1386         * by calling Write(). This checksum only covers the raw wave form data,
1387         * not any meta informations like i.e. bit depth or loop points. Since
1388         * this method just returns the checksum stored for this sample i.e. when
1389         * the gig file was loaded, this method returns immediately. So it does no
1390         * recalcuation of the checksum with the currently available sample wave
1391         * form data.
1392         *
1393         * @see VerifyWaveData()
1394         */
1395        uint32_t Sample::GetWaveDataCRC32Checksum() {
1396            return crc;
1397        }
1398    
1399        /**
1400       * Checks the integrity of this sample's raw audio wave data. Whenever a       * Checks the integrity of this sample's raw audio wave data. Whenever a
1401       * Sample's raw wave data is intentionally modified (i.e. by calling       * Sample's raw wave data is intentionally modified (i.e. by calling
1402       * Write() and supplying the new raw audio wave form data) a CRC32 checksum       * Write() and supplying the new raw audio wave form data) a CRC32 checksum
# Line 1357  namespace { Line 1412  namespace {
1412       * default whenever a gig file is loaded. So this method must be called       * default whenever a gig file is loaded. So this method must be called
1413       * explicitly to fulfill this task.       * explicitly to fulfill this task.
1414       *       *
1415         * @param pActually - (optional) if provided, will be set to the actually
1416         *                    calculated checksum of the current raw wave form data,
1417         *                    you can get the expected checksum instead by calling
1418         *                    GetWaveDataCRC32Checksum()
1419       * @returns true if sample is OK or false if the sample is damaged       * @returns true if sample is OK or false if the sample is damaged
1420       * @throws Exception if no checksum had been stored to disk for this       * @throws Exception if no checksum had been stored to disk for this
1421       *         sample yet, or on I/O issues       *         sample yet, or on I/O issues
1422         * @see GetWaveDataCRC32Checksum()
1423       */       */
1424      bool Sample::VerifyWaveData() {      bool Sample::VerifyWaveData(uint32_t* pActually) {
1425          File* pFile = static_cast<File*>(GetParent());          //File* pFile = static_cast<File*>(GetParent());
         const uint32_t referenceCRC = pFile->GetSampleChecksum(this);  
1426          uint32_t crc = CalculateWaveDataChecksum();          uint32_t crc = CalculateWaveDataChecksum();
1427          return crc == referenceCRC;          if (pActually) *pActually = crc;
1428            return crc == this->crc;
1429      }      }
1430    
1431      uint32_t Sample::CalculateWaveDataChecksum() {      uint32_t Sample::CalculateWaveDataChecksum() {
# Line 1382  namespace { Line 1442  namespace {
1442              if (nRead <= 0) break;              if (nRead <= 0) break;
1443              __calculateCRC(&buffer[0], nRead * FrameSize, crc);              __calculateCRC(&buffer[0], nRead * FrameSize, crc);
1444          }          }
1445          __encodeCRC(crc);          __finalizeCRC(crc);
1446          return crc;          return crc;
1447      }      }
1448    
# Line 1596  namespace { Line 1656  namespace {
1656              EG2Attack                       = 0.0;              EG2Attack                       = 0.0;
1657              EG2Decay1                       = 0.005;              EG2Decay1                       = 0.005;
1658              EG2Sustain                      = 1000;              EG2Sustain                      = 1000;
1659              EG2Release                      = 0.3;              EG2Release                      = 60;
1660              LFO2ControlDepth                = 0;              LFO2ControlDepth                = 0;
1661              LFO2Frequency                   = 1.0;              LFO2Frequency                   = 1.0;
1662              LFO2InternalDepth               = 0;              LFO2InternalDepth               = 0;
# Line 1755  namespace { Line 1815  namespace {
1815          }          }
1816      }      }
1817    
1818        void DimensionRegion::serialize(Serialization::Archive* archive) {
1819            SRLZ(VelocityUpperLimit);
1820            SRLZ(EG1PreAttack);
1821            SRLZ(EG1Attack);
1822            SRLZ(EG1Decay1);
1823            SRLZ(EG1Decay2);
1824            SRLZ(EG1InfiniteSustain);
1825            SRLZ(EG1Sustain);
1826            SRLZ(EG1Release);
1827            SRLZ(EG1Hold);
1828            SRLZ(EG1Controller);
1829            SRLZ(EG1ControllerInvert);
1830            SRLZ(EG1ControllerAttackInfluence);
1831            SRLZ(EG1ControllerDecayInfluence);
1832            SRLZ(EG1ControllerReleaseInfluence);
1833            SRLZ(LFO1Frequency);
1834            SRLZ(LFO1InternalDepth);
1835            SRLZ(LFO1ControlDepth);
1836            SRLZ(LFO1Controller);
1837            SRLZ(LFO1FlipPhase);
1838            SRLZ(LFO1Sync);
1839            SRLZ(EG2PreAttack);
1840            SRLZ(EG2Attack);
1841            SRLZ(EG2Decay1);
1842            SRLZ(EG2Decay2);
1843            SRLZ(EG2InfiniteSustain);
1844            SRLZ(EG2Sustain);
1845            SRLZ(EG2Release);
1846            SRLZ(EG2Controller);
1847            SRLZ(EG2ControllerInvert);
1848            SRLZ(EG2ControllerAttackInfluence);
1849            SRLZ(EG2ControllerDecayInfluence);
1850            SRLZ(EG2ControllerReleaseInfluence);
1851            SRLZ(LFO2Frequency);
1852            SRLZ(LFO2InternalDepth);
1853            SRLZ(LFO2ControlDepth);
1854            SRLZ(LFO2Controller);
1855            SRLZ(LFO2FlipPhase);
1856            SRLZ(LFO2Sync);
1857            SRLZ(EG3Attack);
1858            SRLZ(EG3Depth);
1859            SRLZ(LFO3Frequency);
1860            SRLZ(LFO3InternalDepth);
1861            SRLZ(LFO3ControlDepth);
1862            SRLZ(LFO3Controller);
1863            SRLZ(LFO3Sync);
1864            SRLZ(VCFEnabled);
1865            SRLZ(VCFType);
1866            SRLZ(VCFCutoffController);
1867            SRLZ(VCFCutoffControllerInvert);
1868            SRLZ(VCFCutoff);
1869            SRLZ(VCFVelocityCurve);
1870            SRLZ(VCFVelocityScale);
1871            SRLZ(VCFVelocityDynamicRange);
1872            SRLZ(VCFResonance);
1873            SRLZ(VCFResonanceDynamic);
1874            SRLZ(VCFResonanceController);
1875            SRLZ(VCFKeyboardTracking);
1876            SRLZ(VCFKeyboardTrackingBreakpoint);
1877            SRLZ(VelocityResponseCurve);
1878            SRLZ(VelocityResponseDepth);
1879            SRLZ(VelocityResponseCurveScaling);
1880            SRLZ(ReleaseVelocityResponseCurve);
1881            SRLZ(ReleaseVelocityResponseDepth);
1882            SRLZ(ReleaseTriggerDecay);
1883            SRLZ(Crossfade);
1884            SRLZ(PitchTrack);
1885            SRLZ(DimensionBypass);
1886            SRLZ(Pan);
1887            SRLZ(SelfMask);
1888            SRLZ(AttenuationController);
1889            SRLZ(InvertAttenuationController);
1890            SRLZ(AttenuationControllerThreshold);
1891            SRLZ(ChannelOffset);
1892            SRLZ(SustainDefeat);
1893            SRLZ(MSDecode);
1894            //SRLZ(SampleStartOffset);
1895            SRLZ(SampleAttenuation);
1896    
1897            // derived attributes from DLS::Sampler
1898            SRLZ(FineTune);
1899            SRLZ(Gain);
1900        }
1901    
1902      /**      /**
1903       * Updates the respective member variable and updates @c SampleAttenuation       * Updates the respective member variable and updates @c SampleAttenuation
1904       * which depends on this value.       * which depends on this value.
# Line 1795  namespace { Line 1939  namespace {
1939    
1940          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1941    
1942          const uint32_t chunksize = _3ewa->GetNewSize();          const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
1943          store32(&pData[0], chunksize); // unknown, always chunk size?          store32(&pData[0], chunksize); // unknown, always chunk size?
1944    
1945          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
# Line 3763  namespace { Line 3907  namespace {
3907      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
3908          uint8_t bits;          uint8_t bits;
3909          int veldim = -1;          int veldim = -1;
3910          int velbitpos;          int velbitpos = 0;
3911          int bitpos = 0;          int bitpos = 0;
3912          int dimregidx = 0;          int dimregidx = 0;
3913          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3812  namespace { Line 3956  namespace {
3956      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
3957          uint8_t bits;          uint8_t bits;
3958          int veldim = -1;          int veldim = -1;
3959          int velbitpos;          int velbitpos = 0;
3960          int bitpos = 0;          int bitpos = 0;
3961          int dimregidx = 0;          int dimregidx = 0;
3962          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 4161  namespace { Line 4305  namespace {
4305              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4306              ckScri->SetPos(sizeof(int32_t) + headerSize);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4307              // read actual script data              // read actual script data
4308              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();              uint32_t scriptSize = uint32_t(ckScri->GetSize() - ckScri->GetPos());
4309              data.resize(scriptSize);              data.resize(scriptSize);
4310              for (int i = 0; i < scriptSize; ++i)              for (int i = 0; i < scriptSize; ++i)
4311                  data[i] = ckScri->ReadUint8();                  data[i] = ckScri->ReadUint8();
# Line 4212  namespace { Line 4356  namespace {
4356          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4357          __resetCRC(crc);          __resetCRC(crc);
4358          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
4359          __encodeCRC(crc);          __finalizeCRC(crc);
4360          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4361          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();
4362          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4363          else pChunk->Resize(chunkSize);          else pChunk->Resize(chunkSize);
4364          // fill the chunk data to be written to disk          // fill the chunk data to be written to disk
4365          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4366          int pos = 0;          int pos = 0;
4367          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
4368          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4369          store32(&pData[pos], Compression);          store32(&pData[pos], Compression);
4370          pos += sizeof(int32_t);          pos += sizeof(int32_t);
# Line 4232  namespace { Line 4376  namespace {
4376          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4377          store32(&pData[pos], crc);          store32(&pData[pos], crc);
4378          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4379          store32(&pData[pos], Name.size());          store32(&pData[pos], (uint32_t) Name.size());
4380          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4381          for (int i = 0; i < Name.size(); ++i, ++pos)          for (int i = 0; i < Name.size(); ++i, ++pos)
4382              pData[pos] = Name[i];              pData[pos] = Name[i];
# Line 4263  namespace { Line 4407  namespace {
4407          return pGroup;          return pGroup;
4408      }      }
4409    
4410        /**
4411         * Make a (semi) deep copy of the Script object given by @a orig
4412         * and assign it to this object. Note: the ScriptGroup this Script
4413         * object belongs to remains untouched by this call.
4414         *
4415         * @param orig - original Script object to be copied from
4416         */
4417        void Script::CopyAssign(const Script* orig) {
4418            Name        = orig->Name;
4419            Compression = orig->Compression;
4420            Encoding    = orig->Encoding;
4421            Language    = orig->Language;
4422            Bypass      = orig->Bypass;
4423            data        = orig->data;
4424        }
4425    
4426      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4427          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4428          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4409  namespace { Line 4569  namespace {
4569          EffectSend = 0;          EffectSend = 0;
4570          Attenuation = 0;          Attenuation = 0;
4571          FineTune = 0;          FineTune = 0;
4572          PitchbendRange = 0;          PitchbendRange = 2;
4573          PianoReleaseMode = false;          PianoReleaseMode = false;
4574          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
4575          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
# Line 4584  namespace { Line 4744  namespace {
4744    
4745             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4746             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4747             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4748             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4749             const int slotSize  = 2 * sizeof(uint32_t);             const int slotSize  = 2 * sizeof(uint32_t);
4750             const int totalChunkSize = headerSize + slotCount * slotSize;             const int totalChunkSize = headerSize + slotCount * slotSize;
# Line 4620  namespace { Line 4780  namespace {
4780         if (pScriptRefs && pScriptRefs->size() > 0) {         if (pScriptRefs && pScriptRefs->size() > 0) {
4781             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4782             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4783             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4784             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4785             ckSCSL->SetPos(headerSize);             ckSCSL->SetPos(headerSize);
4786             for (int i = 0; i < slotCount; ++i) {             for (int i = 0; i < slotCount; ++i) {
4787                 uint32_t fileOffset =                 uint32_t fileOffset = uint32_t(
4788                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4789                      (*pScriptRefs)[i].script->pChunk->GetPos() -                      (*pScriptRefs)[i].script->pChunk->GetPos() -
4790                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
4791                   );
4792                 ckSCSL->WriteUint32(&fileOffset);                 ckSCSL->WriteUint32(&fileOffset);
4793                 // jump over flags entry (containing the bypass flag)                 // jump over flags entry (containing the bypass flag)
4794                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
# Line 4687  namespace { Line 4848  namespace {
4848          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
4849          Region* pNewRegion = new Region(this, rgn);          Region* pNewRegion = new Region(this, rgn);
4850          pRegions->push_back(pNewRegion);          pRegions->push_back(pNewRegion);
4851          Regions = pRegions->size();          Regions = (uint32_t) pRegions->size();
4852          // update Region key table for fast lookup          // update Region key table for fast lookup
4853          UpdateRegionKeyTable();          UpdateRegionKeyTable();
4854          // done          // done
# Line 4833  namespace { Line 4994  namespace {
4994                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
4995                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
4996                      if (script->pChunk) {                      if (script->pChunk) {
4997                          uint32_t offset = script->pChunk->GetFilePos() -                          uint32_t offset = uint32_t(
4998                                            script->pChunk->GetPos() -                              script->pChunk->GetFilePos() -
4999                                            CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());                              script->pChunk->GetPos() -
5000                                CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
5001                            );
5002                          if (offset == soughtOffset)                          if (offset == soughtOffset)
5003                          {                          {
5004                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
# Line 4960  namespace { Line 5123  namespace {
5123       */       */
5124      void Instrument::RemoveScript(Script* pScript) {      void Instrument::RemoveScript(Script* pScript) {
5125          LoadScripts();          LoadScripts();
5126          for (int i = pScriptRefs->size() - 1; i >= 0; --i) {          for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5127              if ((*pScriptRefs)[i].script == pScript) {              if ((*pScriptRefs)[i].script == pScript) {
5128                  pScriptRefs->erase( pScriptRefs->begin() + i );                  pScriptRefs->erase( pScriptRefs->begin() + i );
5129              }              }
# Line 4982  namespace { Line 5145  namespace {
5145       * gigedit.       * gigedit.
5146       */       */
5147      uint Instrument::ScriptSlotCount() const {      uint Instrument::ScriptSlotCount() const {
5148          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5149      }      }
5150    
5151      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5406  namespace { Line 5569  namespace {
5569              }              }
5570          }          }
5571          String name(pRIFF->GetFileName());          String name(pRIFF->GetFileName());
5572          int nameLen = name.length();          int nameLen = (int) name.length();
5573          char suffix[6];          char suffix[6];
5574          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
5575    
# Line 5422  namespace { Line 5585  namespace {
5585                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5586    
5587                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5588                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5589    
5590                          iSampleIndex++;                          iSampleIndex++;
5591                      }                      }
# Line 5575  namespace { Line 5738  namespace {
5738              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5739              mSamples[pFile->GetSample(i)] = s;              mSamples[pFile->GetSample(i)] = s;
5740          }          }
5741            
5742            // clone script groups and their scripts
5743            for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5744                ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5745                ScriptGroup* dg = AddScriptGroup();
5746                dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5747                for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5748                    Script* ss = sg->GetScript(iScript);
5749                    Script* ds = dg->AddScript();
5750                    ds->CopyAssign(ss);
5751                }
5752            }
5753    
5754          //BUG: For some reason this method only works with this additional          //BUG: For some reason this method only works with this additional
5755          //     Save() call in between here.          //     Save() call in between here.
5756          //          //
# Line 5668  namespace { Line 5843  namespace {
5843          uint32_t one = 1;          uint32_t one = 1;
5844          _3crc->WriteUint32(&one); // always 1          _3crc->WriteUint32(&one); // always 1
5845          _3crc->WriteUint32(&crc);          _3crc->WriteUint32(&crc);
   
         // reload CRC table to RAM to keep it persistent over several subsequent save operations  
         _3crc->ReleaseChunkData();  
         _3crc->LoadChunkData();  
5846      }      }
5847    
5848      uint32_t File::GetSampleChecksum(Sample* pSample) {      uint32_t File::GetSampleChecksum(Sample* pSample) {
5849            // get the index of the sample
5850            int iWaveIndex = GetWaveTableIndexOf(pSample);
5851            if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
5852    
5853            return GetSampleChecksumByIndex(iWaveIndex);
5854        }
5855    
5856        uint32_t File::GetSampleChecksumByIndex(int index) {
5857            if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
5858    
5859          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5860          if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");          if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5861          uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();          uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
5862          if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");          if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5863    
         // 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");  
   
5864          // read the CRC-32 checksum directly from disk          // read the CRC-32 checksum directly from disk
5865          size_t pos = iWaveIndex * 8;          size_t pos = index * 8;
5866          if (pos + 8 > _3crc->GetNewSize())          if (pos + 8 > _3crc->GetNewSize())
5867              throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");              throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
5868    
5869          uint32_t one = load32(&pData[pos]); // always 1          uint32_t one = load32(&pData[pos]); // always 1
5870          if (one != 1)          if (one != 1)
5871              throw gig::Exception("Could not verify sample, because reference checksum table is damaged");              throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
5872    
5873          return load32(&pData[pos+4]);          return load32(&pData[pos+4]);
5874      }      }
5875        
5876      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
5877          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5878          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
# Line 5720  namespace { Line 5897  namespace {
5897          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5898          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
5899    
5900          const int n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
5901    
5902          uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();          uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
5903          if (!pData) return false;          if (!pData) return false;
5904    
5905          for (int i = 0; i < n; ++i) {          for (file_offset_t i = 0; i < n; ++i) {
5906              uint32_t one = pData[i*2];              uint32_t one = pData[i*2];
5907              if (one != 1) return false;              if (one != 1) return false;
5908          }          }
# Line 5759  namespace { Line 5936  namespace {
5936          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5937          if (!_3crc) {          if (!_3crc) {
5938              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
5939                // the order of einf and 3crc is not the same in v2 and v3
5940                RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
5941                if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
5942              bRequiresSave = true;              bRequiresSave = true;
5943          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
5944              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
# Line 5788  namespace { Line 5968  namespace {
5968                      gig::Sample* pSample = (gig::Sample*) *iter;                      gig::Sample* pSample = (gig::Sample*) *iter;
5969                      int index = GetWaveTableIndexOf(pSample);                      int index = GetWaveTableIndexOf(pSample);
5970                      if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");                      if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
5971                      uint32_t crc = pSample->CalculateWaveDataChecksum();                      pSample->crc  = pSample->CalculateWaveDataChecksum();
5972                      SetSampleChecksum(pSample, crc);                      SetSampleChecksum(pSample, pSample->crc);
5973                  }                  }
5974              }              }
5975          }          }
# Line 6056  namespace { Line 6236  namespace {
6236              lst3LS = NULL;              lst3LS = NULL;
6237          }          }
6238    
         // if there is a 3CRC chunk, make sure it is loaded into RAM, otherwise  
         // its data might get lost or damaged on file structure changes  
         RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);  
         if (_3crc) _3crc->LoadChunkData();  
   
6239          // first update base class's chunks          // first update base class's chunks
6240          DLS::File::UpdateChunks(pProgress);          DLS::File::UpdateChunks(pProgress);
6241    
# Line 6119  namespace { Line 6294  namespace {
6294          // Note that there are several fields with unknown use. These          // Note that there are several fields with unknown use. These
6295          // are set to zero.          // are set to zero.
6296    
6297          int sublen = pSamples->size() / 8 + 49;          int sublen = int(pSamples->size() / 8 + 49);
6298          int einfSize = (Instruments + 1) * sublen;          int einfSize = (Instruments + 1) * sublen;
6299    
6300          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
# Line 6192  namespace { Line 6367  namespace {
6367                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6368                  // next 8 bytes unknown                  // next 8 bytes unknown
6369                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6370                  store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());                  store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6371                  // next 4 bytes unknown                  // next 4 bytes unknown
6372    
6373                  totnbregions += instrument->Regions;                  totnbregions += instrument->Regions;
# Line 6210  namespace { Line 6385  namespace {
6385              store32(&pData[24], totnbloops);              store32(&pData[24], totnbloops);
6386              // next 8 bytes unknown              // next 8 bytes unknown
6387              // next 4 bytes unknown, not always 0              // next 4 bytes unknown, not always 0
6388              store32(&pData[40], pSamples->size());              store32(&pData[40], (uint32_t) pSamples->size());
6389              // next 4 bytes unknown              // next 4 bytes unknown
6390          }          }
6391    
6392          // update 3crc chunk          // update 3crc chunk
6393    
6394          // The 3crc chunk contains CRC-32 checksums for the          // The 3crc chunk contains CRC-32 checksums for the
6395          // samples. The actual checksum values will be filled in          // samples. When saving a gig file to disk, we first update the 3CRC
6396          // later, by Sample::Write.          // chunk here (in RAM) with the old crc values which we read from the
6397            // 3CRC chunk when we opened the file (available with gig::Sample::crc
6398            // member variable). This step is required, because samples might have
6399            // been deleted by the user since the file was opened, which in turn
6400            // changes the order of the (i.e. old) checksums within the 3crc chunk.
6401            // If a sample was conciously modified by the user (that is if
6402            // Sample::Write() was called later on) then Sample::Write() will just
6403            // update the respective individual checksum(s) directly on disk and
6404            // leaves all other sample checksums untouched.
6405    
6406            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6407          if (_3crc) {          if (_3crc) {
6408              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
6409          } else if (newFile) {          } else /*if (newFile)*/ {
6410              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
             _3crc->LoadChunkData();  
   
6411              // the order of einf and 3crc is not the same in v2 and v3              // the order of einf and 3crc is not the same in v2 and v3
6412              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6413          }          }
6414            { // must be performed in RAM here ...
6415                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6416                if (pData) {
6417                    File::SampleList::iterator iter = pSamples->begin();
6418                    File::SampleList::iterator end  = pSamples->end();
6419                    for (int index = 0; iter != end; ++iter, ++index) {
6420                        gig::Sample* pSample = (gig::Sample*) *iter;
6421                        pData[index*2]   = 1; // always 1
6422                        pData[index*2+1] = pSample->crc;
6423                    }
6424                }
6425            }
6426      }      }
6427            
6428      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
Legend:
Removed from v.2985  
changed lines
  Added in v.3138
  ViewVC Help
Powered by ViewVC