/[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 2913 by schoenebeck, Tue May 17 15:19:33 2016 UTC revision 3349 by schoenebeck, Tue Oct 3 17:12:07 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 24  Line 24 
24  #include "gig.h"  #include "gig.h"
25    
26  #include "helper.h"  #include "helper.h"
27    #include "Serialization.h"
28    
29  #include <algorithm>  #include <algorithm>
30  #include <math.h>  #include <math.h>
# Line 55  Line 56 
56  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)
57  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)
58    
59    #define SRLZ(member) \
60        archive->serializeMember(*this, member, #member);
61    
62  namespace gig {  namespace gig {
63    
64  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
# Line 269  namespace { Line 273  namespace {
273       * steps.       * steps.
274       *       *
275       * Once the whole data was processed by __calculateCRC(), one should       * Once the whole data was processed by __calculateCRC(), one should
276       * call __encodeCRC() to get the final CRC result.       * call __finalizeCRC() to get the final CRC result.
277       *       *
278       * @param buf     - pointer to data the CRC shall be calculated of       * @param buf     - pointer to data the CRC shall be calculated of
279       * @param bufSize - size of the data to be processed       * @param bufSize - size of the data to be processed
280       * @param crc     - variable the CRC sum shall be stored to       * @param crc     - variable the CRC sum shall be stored to
281       */       */
282      static void __calculateCRC(unsigned char* buf, int bufSize, uint32_t& crc) {      static void __calculateCRC(unsigned char* buf, size_t bufSize, uint32_t& crc) {
283          for (int i = 0 ; i < bufSize ; i++) {          for (size_t i = 0 ; i < bufSize ; i++) {
284              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);              crc = __CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
285          }          }
286      }      }
# Line 286  namespace { Line 290  namespace {
290       *       *
291       * @param crc - variable previously passed to __calculateCRC()       * @param crc - variable previously passed to __calculateCRC()
292       */       */
293      inline static uint32_t __encodeCRC(const uint32_t& crc) {      inline static void __finalizeCRC(uint32_t& crc) {
294          return crc ^ 0xffffffff;          crc ^= 0xffffffff;
295      }      }
296    
297    
# Line 315  namespace { Line 319  namespace {
319    
320    
321    
322    // *************** leverage_ctrl_t ***************
323    // *
324    
325        void leverage_ctrl_t::serialize(Serialization::Archive* archive) {
326            SRLZ(type);
327            SRLZ(controller_number);
328        }
329    
330    
331    
332    // *************** crossfade_t ***************
333    // *
334    
335        void crossfade_t::serialize(Serialization::Archive* archive) {
336            SRLZ(in_start);
337            SRLZ(in_end);
338            SRLZ(out_start);
339            SRLZ(out_end);
340        }
341    
342    
343    
344    // *************** eg_opt_t ***************
345    // *
346    
347        eg_opt_t::eg_opt_t() {
348            AttackCancel     = true;
349            AttackHoldCancel = true;
350            Decay1Cancel     = true;
351            Decay2Cancel     = true;
352            ReleaseCancel    = true;
353        }
354    
355        void eg_opt_t::serialize(Serialization::Archive* archive) {
356            SRLZ(AttackCancel);
357            SRLZ(AttackHoldCancel);
358            SRLZ(Decay1Cancel);
359            SRLZ(Decay2Cancel);
360            SRLZ(ReleaseCancel);
361        }
362    
363    
364    
365  // *************** Sample ***************  // *************** Sample ***************
366  // *  // *
367    
368      unsigned int Sample::Instances = 0;      size_t       Sample::Instances = 0;
369      buffer_t     Sample::InternalDecompressionBuffer;      buffer_t     Sample::InternalDecompressionBuffer;
370    
371      /** @brief Constructor.      /** @brief Constructor.
# Line 338  namespace { Line 385  namespace {
385       *                         ('wvpl') list chunk       *                         ('wvpl') list chunk
386       * @param fileNo         - number of an extension file where this sample       * @param fileNo         - number of an extension file where this sample
387       *                         is located, 0 otherwise       *                         is located, 0 otherwise
388         * @param index          - wave pool index of sample (may be -1 on new sample)
389       */       */
390      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)
391            : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset)
392        {
393          static const DLS::Info::string_length_t fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
394              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
395              { 0, 0 }              { 0, 0 }
# Line 349  namespace { Line 399  namespace {
399          FileNo = fileNo;          FileNo = fileNo;
400    
401          __resetCRC(crc);          __resetCRC(crc);
402            // if this is not a new sample, try to get the sample's already existing
403            // CRC32 checksum from disk, this checksum will reflect the sample's CRC32
404            // checksum of the time when the sample was consciously modified by the
405            // user for the last time (by calling Sample::Write() that is).
406            if (index >= 0) { // not a new file ...
407                try {
408                    uint32_t crc = pFile->GetSampleChecksumByIndex(index);
409                    this->crc = crc;
410                } catch (...) {}
411            }
412    
413          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);          pCk3gix = waveList->GetSubChunk(CHUNK_ID_3GIX);
414          if (pCk3gix) {          if (pCk3gix) {
# Line 789  namespace { Line 849  namespace {
849       * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with       * FormatTag must be DLS_WAVE_FORMAT_PCM. Trying to resize samples with
850       * other formats will fail!       * other formats will fail!
851       *       *
852       * @param iNewSize - new sample wave data size in sample points (must be       * @param NewSize - new sample wave data size in sample points (must be
853       *                   greater than zero)       *                  greater than zero)
854       * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM       * @throws DLS::Excecption if FormatTag != DLS_WAVE_FORMAT_PCM
855       *                         or if \a iNewSize is less than 1       * @throws DLS::Exception if \a NewSize is less than 1 or unrealistic large
856       * @throws gig::Exception if existing sample is compressed       * @throws gig::Exception if existing sample is compressed
857       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,       * @see DLS::Sample::GetSize(), DLS::Sample::FrameSize,
858       *      DLS::Sample::FormatTag, File::Save()       *      DLS::Sample::FormatTag, File::Save()
859       */       */
860      void Sample::Resize(int iNewSize) {      void Sample::Resize(file_offset_t NewSize) {
861          if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");          if (Compressed) throw gig::Exception("There is no support for modifying compressed samples (yet)");
862          DLS::Sample::Resize(iNewSize);          DLS::Sample::Resize(NewSize);
863      }      }
864    
865      /**      /**
# Line 1281  namespace { Line 1341  namespace {
1341          // if this is the last write, update the checksum chunk in the          // if this is the last write, update the checksum chunk in the
1342          // file          // file
1343          if (pCkData->GetPos() == pCkData->GetSize()) {          if (pCkData->GetPos() == pCkData->GetSize()) {
1344                __finalizeCRC(crc);
1345              File* pFile = static_cast<File*>(GetParent());              File* pFile = static_cast<File*>(GetParent());
1346              pFile->SetSampleChecksum(this, __encodeCRC(crc));              pFile->SetSampleChecksum(this, crc);
1347          }          }
1348          return res;          return res;
1349      }      }
# Line 1341  namespace { Line 1402  namespace {
1402          return pGroup;          return pGroup;
1403      }      }
1404    
1405        /**
1406         * Returns the CRC-32 checksum of the sample's raw wave form data at the
1407         * time when this sample's wave form data was modified for the last time
1408         * by calling Write(). This checksum only covers the raw wave form data,
1409         * not any meta informations like i.e. bit depth or loop points. Since
1410         * this method just returns the checksum stored for this sample i.e. when
1411         * the gig file was loaded, this method returns immediately. So it does no
1412         * recalcuation of the checksum with the currently available sample wave
1413         * form data.
1414         *
1415         * @see VerifyWaveData()
1416         */
1417        uint32_t Sample::GetWaveDataCRC32Checksum() {
1418            return crc;
1419        }
1420    
1421        /**
1422         * Checks the integrity of this sample's raw audio wave data. Whenever a
1423         * Sample's raw wave data is intentionally modified (i.e. by calling
1424         * Write() and supplying the new raw audio wave form data) a CRC32 checksum
1425         * is calculated and stored/updated for this sample, along to the sample's
1426         * meta informations.
1427         *
1428         * Now by calling this method the current raw audio wave data is checked
1429         * against the already stored CRC32 check sum in order to check whether the
1430         * sample data had been damaged unintentionally for some reason. Since by
1431         * calling this method always the entire raw audio wave data has to be
1432         * read, verifying all samples this way may take a long time accordingly.
1433         * And that's also the reason why the sample integrity is not checked by
1434         * default whenever a gig file is loaded. So this method must be called
1435         * explicitly to fulfill this task.
1436         *
1437         * @param pActually - (optional) if provided, will be set to the actually
1438         *                    calculated checksum of the current raw wave form data,
1439         *                    you can get the expected checksum instead by calling
1440         *                    GetWaveDataCRC32Checksum()
1441         * @returns true if sample is OK or false if the sample is damaged
1442         * @throws Exception if no checksum had been stored to disk for this
1443         *         sample yet, or on I/O issues
1444         * @see GetWaveDataCRC32Checksum()
1445         */
1446        bool Sample::VerifyWaveData(uint32_t* pActually) {
1447            //File* pFile = static_cast<File*>(GetParent());
1448            uint32_t crc = CalculateWaveDataChecksum();
1449            if (pActually) *pActually = crc;
1450            return crc == this->crc;
1451        }
1452    
1453        uint32_t Sample::CalculateWaveDataChecksum() {
1454            const size_t sz = 20*1024; // 20kB buffer size
1455            std::vector<uint8_t> buffer(sz);
1456            buffer.resize(sz);
1457    
1458            const size_t n = sz / FrameSize;
1459            SetPos(0);
1460            uint32_t crc = 0;
1461            __resetCRC(crc);
1462            while (true) {
1463                file_offset_t nRead = Read(&buffer[0], n);
1464                if (nRead <= 0) break;
1465                __calculateCRC(&buffer[0], nRead * FrameSize, crc);
1466            }
1467            __finalizeCRC(crc);
1468            return crc;
1469        }
1470    
1471      Sample::~Sample() {      Sample::~Sample() {
1472          Instances--;          Instances--;
1473          if (!Instances && InternalDecompressionBuffer.Size) {          if (!Instances && InternalDecompressionBuffer.Size) {
# Line 1357  namespace { Line 1484  namespace {
1484  // *************** DimensionRegion ***************  // *************** DimensionRegion ***************
1485  // *  // *
1486    
1487      uint                               DimensionRegion::Instances       = 0;      size_t                             DimensionRegion::Instances       = 0;
1488      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;      DimensionRegion::VelocityTableMap* DimensionRegion::pVelocityTables = NULL;
1489    
1490      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {      DimensionRegion::DimensionRegion(Region* pParent, RIFF::List* _3ewl) : DLS::Sampler(_3ewl) {
# Line 1551  namespace { Line 1678  namespace {
1678              EG2Attack                       = 0.0;              EG2Attack                       = 0.0;
1679              EG2Decay1                       = 0.005;              EG2Decay1                       = 0.005;
1680              EG2Sustain                      = 1000;              EG2Sustain                      = 1000;
1681              EG2Release                      = 0.3;              EG2Release                      = 60;
1682              LFO2ControlDepth                = 0;              LFO2ControlDepth                = 0;
1683              LFO2Frequency                   = 1.0;              LFO2Frequency                   = 1.0;
1684              LFO2InternalDepth               = 0;              LFO2InternalDepth               = 0;
# Line 1605  namespace { Line 1732  namespace {
1732              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1733              memset(DimensionUpperLimits, 127, 8);              memset(DimensionUpperLimits, 127, 8);
1734          }          }
1735            // format extension for EG behavior options, these will *NOT* work with
1736            // Gigasampler/GigaStudio !
1737            RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1738            if (lsde) {
1739                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1740                for (int i = 0; i < 2; ++i) {
1741                    unsigned char byte = lsde->ReadUint8();
1742                    pEGOpts[i]->AttackCancel     = byte & 1;
1743                    pEGOpts[i]->AttackHoldCancel = byte & (1 << 1);
1744                    pEGOpts[i]->Decay1Cancel     = byte & (1 << 2);
1745                    pEGOpts[i]->Decay2Cancel     = byte & (1 << 3);
1746                    pEGOpts[i]->ReleaseCancel    = byte & (1 << 4);
1747                }
1748            }
1749    
1750          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1751                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
# Line 1710  namespace { Line 1851  namespace {
1851          }          }
1852      }      }
1853    
1854        void DimensionRegion::serialize(Serialization::Archive* archive) {
1855            // in case this class will become backward incompatible one day,
1856            // then set a version and minimum version for this class like:
1857            //archive->setVersion(*this, 2);
1858            //archive->setMinVersion(*this, 1);
1859    
1860            SRLZ(VelocityUpperLimit);
1861            SRLZ(EG1PreAttack);
1862            SRLZ(EG1Attack);
1863            SRLZ(EG1Decay1);
1864            SRLZ(EG1Decay2);
1865            SRLZ(EG1InfiniteSustain);
1866            SRLZ(EG1Sustain);
1867            SRLZ(EG1Release);
1868            SRLZ(EG1Hold);
1869            SRLZ(EG1Controller);
1870            SRLZ(EG1ControllerInvert);
1871            SRLZ(EG1ControllerAttackInfluence);
1872            SRLZ(EG1ControllerDecayInfluence);
1873            SRLZ(EG1ControllerReleaseInfluence);
1874            SRLZ(LFO1Frequency);
1875            SRLZ(LFO1InternalDepth);
1876            SRLZ(LFO1ControlDepth);
1877            SRLZ(LFO1Controller);
1878            SRLZ(LFO1FlipPhase);
1879            SRLZ(LFO1Sync);
1880            SRLZ(EG2PreAttack);
1881            SRLZ(EG2Attack);
1882            SRLZ(EG2Decay1);
1883            SRLZ(EG2Decay2);
1884            SRLZ(EG2InfiniteSustain);
1885            SRLZ(EG2Sustain);
1886            SRLZ(EG2Release);
1887            SRLZ(EG2Controller);
1888            SRLZ(EG2ControllerInvert);
1889            SRLZ(EG2ControllerAttackInfluence);
1890            SRLZ(EG2ControllerDecayInfluence);
1891            SRLZ(EG2ControllerReleaseInfluence);
1892            SRLZ(LFO2Frequency);
1893            SRLZ(LFO2InternalDepth);
1894            SRLZ(LFO2ControlDepth);
1895            SRLZ(LFO2Controller);
1896            SRLZ(LFO2FlipPhase);
1897            SRLZ(LFO2Sync);
1898            SRLZ(EG3Attack);
1899            SRLZ(EG3Depth);
1900            SRLZ(LFO3Frequency);
1901            SRLZ(LFO3InternalDepth);
1902            SRLZ(LFO3ControlDepth);
1903            SRLZ(LFO3Controller);
1904            SRLZ(LFO3Sync);
1905            SRLZ(VCFEnabled);
1906            SRLZ(VCFType);
1907            SRLZ(VCFCutoffController);
1908            SRLZ(VCFCutoffControllerInvert);
1909            SRLZ(VCFCutoff);
1910            SRLZ(VCFVelocityCurve);
1911            SRLZ(VCFVelocityScale);
1912            SRLZ(VCFVelocityDynamicRange);
1913            SRLZ(VCFResonance);
1914            SRLZ(VCFResonanceDynamic);
1915            SRLZ(VCFResonanceController);
1916            SRLZ(VCFKeyboardTracking);
1917            SRLZ(VCFKeyboardTrackingBreakpoint);
1918            SRLZ(VelocityResponseCurve);
1919            SRLZ(VelocityResponseDepth);
1920            SRLZ(VelocityResponseCurveScaling);
1921            SRLZ(ReleaseVelocityResponseCurve);
1922            SRLZ(ReleaseVelocityResponseDepth);
1923            SRLZ(ReleaseTriggerDecay);
1924            SRLZ(Crossfade);
1925            SRLZ(PitchTrack);
1926            SRLZ(DimensionBypass);
1927            SRLZ(Pan);
1928            SRLZ(SelfMask);
1929            SRLZ(AttenuationController);
1930            SRLZ(InvertAttenuationController);
1931            SRLZ(AttenuationControllerThreshold);
1932            SRLZ(ChannelOffset);
1933            SRLZ(SustainDefeat);
1934            SRLZ(MSDecode);
1935            //SRLZ(SampleStartOffset);
1936            SRLZ(SampleAttenuation);
1937            SRLZ(EG1Options);
1938            SRLZ(EG2Options);
1939    
1940            // derived attributes from DLS::Sampler
1941            SRLZ(FineTune);
1942            SRLZ(Gain);
1943        }
1944    
1945      /**      /**
1946       * Updates the respective member variable and updates @c SampleAttenuation       * Updates the respective member variable and updates @c SampleAttenuation
1947       * which depends on this value.       * which depends on this value.
# Line 1750  namespace { Line 1982  namespace {
1982    
1983          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1984    
1985          const uint32_t chunksize = _3ewa->GetNewSize();          const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
1986          store32(&pData[0], chunksize); // unknown, always chunk size?          store32(&pData[0], chunksize); // unknown, always chunk size?
1987    
1988          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
# Line 2010  namespace { Line 2242  namespace {
2242          if (chunksize >= 148) {          if (chunksize >= 148) {
2243              memcpy(&pData[140], DimensionUpperLimits, 8);              memcpy(&pData[140], DimensionUpperLimits, 8);
2244          }          }
2245    
2246            // format extension for EG behavior options, these will *NOT* work with
2247            // Gigasampler/GigaStudio !
2248            RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2249            if (!lsde) {
2250                // only add this "LSDE" chunk if the EG options do not match the
2251                // default EG behavior
2252                eg_opt_t defaultOpt;
2253                if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2254                    memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)))
2255                {
2256                    lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, 2);
2257                    // move LSDE chunk to the end of parent list
2258                    pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
2259                }
2260            }
2261            if (lsde) {
2262                unsigned char* pData = (unsigned char*) lsde->LoadChunkData();
2263                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
2264                for (int i = 0; i < 2; ++i) {
2265                    pData[i] =
2266                        (pEGOpts[i]->AttackCancel     ? 1 : 0) |
2267                        (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) |
2268                        (pEGOpts[i]->Decay1Cancel     ? (1<<2) : 0) |
2269                        (pEGOpts[i]->Decay2Cancel     ? (1<<3) : 0) |
2270                        (pEGOpts[i]->ReleaseCancel    ? (1<<4) : 0);
2271                }
2272            }
2273      }      }
2274    
2275      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
# Line 2049  namespace { Line 2309  namespace {
2309      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet      // get the corresponding velocity table from the table map or create & calculate that table if it doesn't exist yet
2310      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)      double* DimensionRegion::GetVelocityTable(curve_type_t curveType, uint8_t depth, uint8_t scaling)
2311      {      {
2312            // sanity check input parameters
2313            // (fallback to some default parameters on ill input)
2314            switch (curveType) {
2315                case curve_type_nonlinear:
2316                case curve_type_linear:
2317                    if (depth > 4) {
2318                        printf("Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2319                        depth   = 0;
2320                        scaling = 0;
2321                    }
2322                    break;
2323                case curve_type_special:
2324                    if (depth > 5) {
2325                        printf("Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2326                        depth   = 0;
2327                        scaling = 0;
2328                    }
2329                    break;
2330                case curve_type_unknown:
2331                default:
2332                    printf("Warning: Unknown velocity curve type (0x%x).\n", curveType);
2333                    curveType = curve_type_linear;
2334                    depth     = 0;
2335                    scaling   = 0;
2336                    break;
2337            }
2338    
2339          double* table;          double* table;
2340          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2341          if (pVelocityTables->count(tableKey)) { // if key exists          if (pVelocityTables->count(tableKey)) { // if key exists
# Line 2424  namespace { Line 2711  namespace {
2711    
2712              // unknown controller type              // unknown controller type
2713              default:              default:
2714                  throw gig::Exception("Unknown leverage controller type.");                  decodedcontroller.type = leverage_ctrl_t::type_none;
2715                    decodedcontroller.controller_number = 0;
2716                    printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2717                    break;
2718          }          }
2719          return decodedcontroller;          return decodedcontroller;
2720      }      }
# Line 2971  namespace { Line 3261  namespace {
3261              if (file->GetAutoLoad()) {              if (file->GetAutoLoad()) {
3262                  for (uint i = 0; i < DimensionRegions; i++) {                  for (uint i = 0; i < DimensionRegions; i++) {
3263                      uint32_t wavepoolindex = _3lnk->ReadUint32();                      uint32_t wavepoolindex = _3lnk->ReadUint32();
3264                      if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      if (file->pWavePoolTable && pDimensionRegions[i])
3265                            pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3266                  }                  }
3267                  GetSample(); // load global region sample reference                  GetSample(); // load global region sample reference
3268              }              }
# Line 3106  namespace { Line 3397  namespace {
3397          int step = 1;          int step = 1;
3398          for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;          for (int i = 0 ; i < veldim ; i++) step <<= pDimensionDefinitions[i].bits;
3399          int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;          int skipveldim = (step << pDimensionDefinitions[veldim].bits) - step;
         int end = step * pDimensionDefinitions[veldim].zones;  
3400    
3401          // loop through all dimension regions for all dimensions except the velocity dimension          // loop through all dimension regions for all dimensions except the velocity dimension
3402          int dim[8] = { 0 };          int dim[8] = { 0 };
3403          for (int i = 0 ; i < DimensionRegions ; i++) {          for (int i = 0 ; i < DimensionRegions ; i++) {
3404                const int end = i + step * pDimensionDefinitions[veldim].zones;
3405    
3406                // create a velocity table for all cases where the velocity zone is zero
3407              if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||              if (pDimensionRegions[i]->DimensionUpperLimits[veldim] ||
3408                  pDimensionRegions[i]->VelocityUpperLimit) {                  pDimensionRegions[i]->VelocityUpperLimit) {
3409                  // create the velocity table                  // create the velocity table
# Line 3142  namespace { Line 3434  namespace {
3434                  }                  }
3435              }              }
3436    
3437                // jump to the next case where the velocity zone is zero
3438              int j;              int j;
3439              int shift = 0;              int shift = 0;
3440              for (j = 0 ; j < Dimensions ; j++) {              for (j = 0 ; j < Dimensions ; j++) {
# Line 3716  namespace { Line 4009  namespace {
4009      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
4010          uint8_t bits;          uint8_t bits;
4011          int veldim = -1;          int veldim = -1;
4012          int velbitpos;          int velbitpos = 0;
4013          int bitpos = 0;          int bitpos = 0;
4014          int dimregidx = 0;          int dimregidx = 0;
4015          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3765  namespace { Line 4058  namespace {
4058      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
4059          uint8_t bits;          uint8_t bits;
4060          int veldim = -1;          int veldim = -1;
4061          int velbitpos;          int velbitpos = 0;
4062          int bitpos = 0;          int bitpos = 0;
4063          int dimregidx = 0;          int dimregidx = 0;
4064          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 4114  namespace { Line 4407  namespace {
4407              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4408              ckScri->SetPos(sizeof(int32_t) + headerSize);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4409              // read actual script data              // read actual script data
4410              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();              uint32_t scriptSize = uint32_t(ckScri->GetSize() - ckScri->GetPos());
4411              data.resize(scriptSize);              data.resize(scriptSize);
4412              for (int i = 0; i < scriptSize; ++i)              for (int i = 0; i < scriptSize; ++i)
4413                  data[i] = ckScri->ReadUint8();                  data[i] = ckScri->ReadUint8();
# Line 4165  namespace { Line 4458  namespace {
4458          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4459          __resetCRC(crc);          __resetCRC(crc);
4460          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
4461          __encodeCRC(crc);          __finalizeCRC(crc);
4462          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4463          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();
4464          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4465          else pChunk->Resize(chunkSize);          else pChunk->Resize(chunkSize);
4466          // fill the chunk data to be written to disk          // fill the chunk data to be written to disk
4467          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4468          int pos = 0;          int pos = 0;
4469          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
4470          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4471          store32(&pData[pos], Compression);          store32(&pData[pos], Compression);
4472          pos += sizeof(int32_t);          pos += sizeof(int32_t);
# Line 4185  namespace { Line 4478  namespace {
4478          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4479          store32(&pData[pos], crc);          store32(&pData[pos], crc);
4480          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4481          store32(&pData[pos], Name.size());          store32(&pData[pos], (uint32_t) Name.size());
4482          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4483          for (int i = 0; i < Name.size(); ++i, ++pos)          for (int i = 0; i < Name.size(); ++i, ++pos)
4484              pData[pos] = Name[i];              pData[pos] = Name[i];
# Line 4216  namespace { Line 4509  namespace {
4509          return pGroup;          return pGroup;
4510      }      }
4511    
4512        /**
4513         * Make a (semi) deep copy of the Script object given by @a orig
4514         * and assign it to this object. Note: the ScriptGroup this Script
4515         * object belongs to remains untouched by this call.
4516         *
4517         * @param orig - original Script object to be copied from
4518         */
4519        void Script::CopyAssign(const Script* orig) {
4520            Name        = orig->Name;
4521            Compression = orig->Compression;
4522            Encoding    = orig->Encoding;
4523            Language    = orig->Language;
4524            Bypass      = orig->Bypass;
4525            data        = orig->data;
4526        }
4527    
4528      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4529          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4530          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4362  namespace { Line 4671  namespace {
4671          EffectSend = 0;          EffectSend = 0;
4672          Attenuation = 0;          Attenuation = 0;
4673          FineTune = 0;          FineTune = 0;
4674          PitchbendRange = 0;          PitchbendRange = 2;
4675          PianoReleaseMode = false;          PianoReleaseMode = false;
4676          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
4677          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
# Line 4460  namespace { Line 4769  namespace {
4769          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
4770          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
4771              gig::Region* pRegion = static_cast<gig::Region*>(*iter);              gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4772              for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {              const int low  = std::max(int(pRegion->KeyRange.low), 0);
4773                const int high = std::min(int(pRegion->KeyRange.high), 127);
4774                for (int iKey = low; iKey <= high; iKey++) {
4775                  RegionKeyTable[iKey] = pRegion;                  RegionKeyTable[iKey] = pRegion;
4776              }              }
4777          }          }
# Line 4537  namespace { Line 4848  namespace {
4848    
4849             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4850             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4851             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4852             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4853             const int slotSize  = 2 * sizeof(uint32_t);             const int slotSize  = 2 * sizeof(uint32_t);
4854             const int totalChunkSize = headerSize + slotCount * slotSize;             const int totalChunkSize = headerSize + slotCount * slotSize;
# Line 4573  namespace { Line 4884  namespace {
4884         if (pScriptRefs && pScriptRefs->size() > 0) {         if (pScriptRefs && pScriptRefs->size() > 0) {
4885             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4886             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4887             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4888             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4889             ckSCSL->SetPos(headerSize);             ckSCSL->SetPos(headerSize);
4890             for (int i = 0; i < slotCount; ++i) {             for (int i = 0; i < slotCount; ++i) {
4891                 uint32_t fileOffset =                 uint32_t fileOffset = uint32_t(
4892                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4893                      (*pScriptRefs)[i].script->pChunk->GetPos() -                      (*pScriptRefs)[i].script->pChunk->GetPos() -
4894                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
4895                   );
4896                 ckSCSL->WriteUint32(&fileOffset);                 ckSCSL->WriteUint32(&fileOffset);
4897                 // jump over flags entry (containing the bypass flag)                 // jump over flags entry (containing the bypass flag)
4898                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
# Line 4640  namespace { Line 4952  namespace {
4952          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
4953          Region* pNewRegion = new Region(this, rgn);          Region* pNewRegion = new Region(this, rgn);
4954          pRegions->push_back(pNewRegion);          pRegions->push_back(pNewRegion);
4955          Regions = pRegions->size();          Regions = (uint32_t) pRegions->size();
4956          // update Region key table for fast lookup          // update Region key table for fast lookup
4957          UpdateRegionKeyTable();          UpdateRegionKeyTable();
4958          // done          // done
# Line 4786  namespace { Line 5098  namespace {
5098                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
5099                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
5100                      if (script->pChunk) {                      if (script->pChunk) {
5101                          uint32_t offset = script->pChunk->GetFilePos() -                          uint32_t offset = uint32_t(
5102                                            script->pChunk->GetPos() -                              script->pChunk->GetFilePos() -
5103                                            CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());                              script->pChunk->GetPos() -
5104                                CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
5105                            );
5106                          if (offset == soughtOffset)                          if (offset == soughtOffset)
5107                          {                          {
5108                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
# Line 4913  namespace { Line 5227  namespace {
5227       */       */
5228      void Instrument::RemoveScript(Script* pScript) {      void Instrument::RemoveScript(Script* pScript) {
5229          LoadScripts();          LoadScripts();
5230          for (int i = pScriptRefs->size() - 1; i >= 0; --i) {          for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5231              if ((*pScriptRefs)[i].script == pScript) {              if ((*pScriptRefs)[i].script == pScript) {
5232                  pScriptRefs->erase( pScriptRefs->begin() + i );                  pScriptRefs->erase( pScriptRefs->begin() + i );
5233              }              }
# Line 4935  namespace { Line 5249  namespace {
5249       * gigedit.       * gigedit.
5250       */       */
5251      uint Instrument::ScriptSlotCount() const {      uint Instrument::ScriptSlotCount() const {
5252          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5253      }      }
5254    
5255      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5359  namespace { Line 5673  namespace {
5673              }              }
5674          }          }
5675          String name(pRIFF->GetFileName());          String name(pRIFF->GetFileName());
5676          int nameLen = name.length();          int nameLen = (int) name.length();
5677          char suffix[6];          char suffix[6];
5678          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;
5679    
# Line 5375  namespace { Line 5689  namespace {
5689                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5690    
5691                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5692                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo, iSampleIndex));
5693    
5694                          iSampleIndex++;                          iSampleIndex++;
5695                      }                      }
# Line 5528  namespace { Line 5842  namespace {
5842              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5843              mSamples[pFile->GetSample(i)] = s;              mSamples[pFile->GetSample(i)] = s;
5844          }          }
5845            
5846            // clone script groups and their scripts
5847            for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5848                ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5849                ScriptGroup* dg = AddScriptGroup();
5850                dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5851                for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5852                    Script* ss = sg->GetScript(iScript);
5853                    Script* ds = dg->AddScript();
5854                    ds->CopyAssign(ss);
5855                }
5856            }
5857    
5858          //BUG: For some reason this method only works with this additional          //BUG: For some reason this method only works with this additional
5859          //     Save() call in between here.          //     Save() call in between here.
5860          //          //
# Line 5613  namespace { Line 5939  namespace {
5939          if (!_3crc) return;          if (!_3crc) return;
5940    
5941          // get the index of the sample          // get the index of the sample
5942          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;  
             }  
         }  
5943          if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");          if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
5944    
5945          // write the CRC-32 checksum to disk          // write the CRC-32 checksum to disk
5946          _3crc->SetPos(iWaveIndex * 8);          _3crc->SetPos(iWaveIndex * 8);
5947          uint32_t tmp = 1;          uint32_t one = 1;
5948          _3crc->WriteUint32(&tmp); // unknown, always 1?          _3crc->WriteUint32(&one); // always 1
5949          _3crc->WriteUint32(&crc);          _3crc->WriteUint32(&crc);
5950      }      }
5951    
5952        uint32_t File::GetSampleChecksum(Sample* pSample) {
5953            // get the index of the sample
5954            int iWaveIndex = GetWaveTableIndexOf(pSample);
5955            if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
5956    
5957            return GetSampleChecksumByIndex(iWaveIndex);
5958        }
5959    
5960        uint32_t File::GetSampleChecksumByIndex(int index) {
5961            if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
5962    
5963            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5964            if (!_3crc) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5965            uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
5966            if (!pData) throw gig::Exception("Could not retrieve reference crc of sample, no checksums stored for this file yet");
5967    
5968            // read the CRC-32 checksum directly from disk
5969            size_t pos = index * 8;
5970            if (pos + 8 > _3crc->GetNewSize())
5971                throw gig::Exception("Could not retrieve reference crc of sample, could not seek to required position in crc chunk");
5972    
5973            uint32_t one = load32(&pData[pos]); // always 1
5974            if (one != 1)
5975                throw gig::Exception("Could not retrieve reference crc of sample, because reference checksum table is damaged");
5976    
5977            return load32(&pData[pos+4]);
5978        }
5979    
5980        int File::GetWaveTableIndexOf(gig::Sample* pSample) {
5981            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
5982            File::SampleList::iterator iter = pSamples->begin();
5983            File::SampleList::iterator end  = pSamples->end();
5984            for (int index = 0; iter != end; ++iter, ++index)
5985                if (*iter == pSample)
5986                    return index;
5987            return -1;
5988        }
5989    
5990        /**
5991         * Checks whether the file's "3CRC" chunk was damaged. This chunk contains
5992         * the CRC32 check sums of all samples' raw wave data.
5993         *
5994         * @return true if 3CRC chunk is OK, or false if 3CRC chunk is damaged
5995         */
5996        bool File::VerifySampleChecksumTable() {
5997            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
5998            if (!_3crc) return false;
5999            if (_3crc->GetNewSize() <= 0) return false;
6000            if (_3crc->GetNewSize() % 8) return false;
6001            if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
6002            if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6003    
6004            const file_offset_t n = _3crc->GetNewSize() / 8;
6005    
6006            uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6007            if (!pData) return false;
6008    
6009            for (file_offset_t i = 0; i < n; ++i) {
6010                uint32_t one = pData[i*2];
6011                if (one != 1) return false;
6012            }
6013    
6014            return true;
6015        }
6016    
6017        /**
6018         * Recalculates CRC32 checksums for all samples and rebuilds this gig
6019         * file's checksum table with those new checksums. This might usually
6020         * just be necessary if the checksum table was damaged.
6021         *
6022         * @e IMPORTANT: The current implementation of this method only works
6023         * with files that have not been modified since it was loaded, because
6024         * it expects that no externally caused file structure changes are
6025         * required!
6026         *
6027         * Due to the expectation above, this method is currently protected
6028         * and actually only used by the command line tool "gigdump" yet.
6029         *
6030         * @returns true if Save() is required to be called after this call,
6031         *          false if no further action is required
6032         */
6033        bool File::RebuildSampleChecksumTable() {
6034            // make sure sample chunks were scanned
6035            if (!pSamples) GetFirstSample();
6036    
6037            bool bRequiresSave = false;
6038    
6039            // make sure "3CRC" chunk exists with required size
6040            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6041            if (!_3crc) {
6042                _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6043                // the order of einf and 3crc is not the same in v2 and v3
6044                RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6045                if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6046                bRequiresSave = true;
6047            } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
6048                _3crc->Resize(pSamples->size() * 8);
6049                bRequiresSave = true;
6050            }
6051    
6052            if (bRequiresSave) { // refill CRC table for all samples in RAM ...
6053                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6054                {
6055                    File::SampleList::iterator iter = pSamples->begin();
6056                    File::SampleList::iterator end  = pSamples->end();
6057                    for (; iter != end; ++iter) {
6058                        gig::Sample* pSample = (gig::Sample*) *iter;
6059                        int index = GetWaveTableIndexOf(pSample);
6060                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6061                        pData[index*2]   = 1; // always 1
6062                        pData[index*2+1] = pSample->CalculateWaveDataChecksum();
6063                    }
6064                }
6065            } else { // no file structure changes necessary, so directly write to disk and we are done ...
6066                // make sure file is in write mode
6067                pRIFF->SetMode(RIFF::stream_mode_read_write);
6068                {
6069                    File::SampleList::iterator iter = pSamples->begin();
6070                    File::SampleList::iterator end  = pSamples->end();
6071                    for (; iter != end; ++iter) {
6072                        gig::Sample* pSample = (gig::Sample*) *iter;
6073                        int index = GetWaveTableIndexOf(pSample);
6074                        if (index < 0) throw gig::Exception("Could not rebuild crc table for samples, wave table index of a sample could not be resolved");
6075                        pSample->crc  = pSample->CalculateWaveDataChecksum();
6076                        SetSampleChecksum(pSample, pSample->crc);
6077                    }
6078                }
6079            }
6080    
6081            return bRequiresSave;
6082        }
6083    
6084      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
6085          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
6086          // there must always be at least one group          // there must always be at least one group
# Line 5948  namespace { Line 6398  namespace {
6398          // Note that there are several fields with unknown use. These          // Note that there are several fields with unknown use. These
6399          // are set to zero.          // are set to zero.
6400    
6401          int sublen = pSamples->size() / 8 + 49;          int sublen = int(pSamples->size() / 8 + 49);
6402          int einfSize = (Instruments + 1) * sublen;          int einfSize = (Instruments + 1) * sublen;
6403    
6404          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
# Line 6021  namespace { Line 6471  namespace {
6471                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6472                  // next 8 bytes unknown                  // next 8 bytes unknown
6473                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6474                  store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());                  store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6475                  // next 4 bytes unknown                  // next 4 bytes unknown
6476    
6477                  totnbregions += instrument->Regions;                  totnbregions += instrument->Regions;
# Line 6039  namespace { Line 6489  namespace {
6489              store32(&pData[24], totnbloops);              store32(&pData[24], totnbloops);
6490              // next 8 bytes unknown              // next 8 bytes unknown
6491              // next 4 bytes unknown, not always 0              // next 4 bytes unknown, not always 0
6492              store32(&pData[40], pSamples->size());              store32(&pData[40], (uint32_t) pSamples->size());
6493              // next 4 bytes unknown              // next 4 bytes unknown
6494          }          }
6495    
6496          // update 3crc chunk          // update 3crc chunk
6497    
6498          // The 3crc chunk contains CRC-32 checksums for the          // The 3crc chunk contains CRC-32 checksums for the
6499          // samples. The actual checksum values will be filled in          // samples. When saving a gig file to disk, we first update the 3CRC
6500          // later, by Sample::Write.          // chunk here (in RAM) with the old crc values which we read from the
6501            // 3CRC chunk when we opened the file (available with gig::Sample::crc
6502            // member variable). This step is required, because samples might have
6503            // been deleted by the user since the file was opened, which in turn
6504            // changes the order of the (i.e. old) checksums within the 3crc chunk.
6505            // If a sample was conciously modified by the user (that is if
6506            // Sample::Write() was called later on) then Sample::Write() will just
6507            // update the respective individual checksum(s) directly on disk and
6508            // leaves all other sample checksums untouched.
6509    
6510          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6511          if (_3crc) {          if (_3crc) {
6512              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
6513          } else if (newFile) {          } else /*if (newFile)*/ {
6514              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
             _3crc->LoadChunkData();  
   
6515              // 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
6516              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);
6517          }          }
6518            { // must be performed in RAM here ...
6519                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6520                if (pData) {
6521                    File::SampleList::iterator iter = pSamples->begin();
6522                    File::SampleList::iterator end  = pSamples->end();
6523                    for (int index = 0; iter != end; ++iter, ++index) {
6524                        gig::Sample* pSample = (gig::Sample*) *iter;
6525                        pData[index*2]   = 1; // always 1
6526                        pData[index*2+1] = pSample->crc;
6527                    }
6528                }
6529            }
6530      }      }
6531            
6532      void File::UpdateFileOffsets() {      void File::UpdateFileOffsets() {
# Line 6103  namespace { Line 6571  namespace {
6571  // *************** Exception ***************  // *************** Exception ***************
6572  // *  // *
6573    
6574      Exception::Exception(String Message) : DLS::Exception(Message) {      Exception::Exception() : DLS::Exception() {
6575        }
6576    
6577        Exception::Exception(String format, ...) : DLS::Exception() {
6578            va_list arg;
6579            va_start(arg, format);
6580            Message = assemble(format, arg);
6581            va_end(arg);
6582        }
6583    
6584        Exception::Exception(String format, va_list arg) : DLS::Exception() {
6585            Message = assemble(format, arg);
6586      }      }
6587    
6588      void Exception::PrintMessage() {      void Exception::PrintMessage() {
Legend:
Removed from v.2913  
changed lines
  Added in v.3349
  ViewVC Help
Powered by ViewVC