/[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 3475 by schoenebeck, Wed Feb 20 17:06:11 2019 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-2019 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    
# 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 408  namespace { Line 468  namespace {
468          TruncatedBits     = 0;          TruncatedBits     = 0;
469          if (Compressed) {          if (Compressed) {
470              uint32_t version = ewav->ReadInt32();              uint32_t version = ewav->ReadInt32();
471              if (version == 3 && BitDepth == 24) {              if (version > 2 && BitDepth == 24) {
472                  Dithered = ewav->ReadInt32();                  Dithered = ewav->ReadInt32();
473                  ewav->SetPos(Channels == 2 ? 84 : 64);                  ewav->SetPos(Channels == 2 ? 84 : 64);
474                  TruncatedBits = ewav->ReadInt32();                  TruncatedBits = ewav->ReadInt32();
# 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 1342  namespace { Line 1403  namespace {
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       * 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       * 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       * Write() and supplying the new raw audio wave form data) a CRC32 checksum
# Line 1357  namespace { Line 1434  namespace {
1434       * 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
1435       * explicitly to fulfill this task.       * 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       * @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       * @throws Exception if no checksum had been stored to disk for this
1443       *         sample yet, or on I/O issues       *         sample yet, or on I/O issues
1444         * @see GetWaveDataCRC32Checksum()
1445       */       */
1446      bool Sample::VerifyWaveData() {      bool Sample::VerifyWaveData(uint32_t* pActually) {
1447          File* pFile = static_cast<File*>(GetParent());          //File* pFile = static_cast<File*>(GetParent());
         const uint32_t referenceCRC = pFile->GetSampleChecksum(this);  
1448          uint32_t crc = CalculateWaveDataChecksum();          uint32_t crc = CalculateWaveDataChecksum();
1449          return crc == referenceCRC;          if (pActually) *pActually = crc;
1450            return crc == this->crc;
1451      }      }
1452    
1453      uint32_t Sample::CalculateWaveDataChecksum() {      uint32_t Sample::CalculateWaveDataChecksum() {
# Line 1382  namespace { Line 1464  namespace {
1464              if (nRead <= 0) break;              if (nRead <= 0) break;
1465              __calculateCRC(&buffer[0], nRead * FrameSize, crc);              __calculateCRC(&buffer[0], nRead * FrameSize, crc);
1466          }          }
1467          __encodeCRC(crc);          __finalizeCRC(crc);
1468          return crc;          return crc;
1469      }      }
1470    
# Line 1596  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 1650  namespace { Line 1732  namespace {
1732              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1733              memset(DimensionUpperLimits, 127, 8);              memset(DimensionUpperLimits, 127, 8);
1734          }          }
1735            // chunk for own format extensions, these will *NOT* work with Gigasampler/GigaStudio !
1736            RIFF::Chunk* lsde = _3ewl->GetSubChunk(CHUNK_ID_LSDE);
1737            if (lsde) { // format extension for EG behavior options
1738                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
1739                for (int i = 0; i < 2; ++i) { // NOTE: we reserved a 3rd byte for a potential future EG3 option
1740                    unsigned char byte = lsde->ReadUint8();
1741                    pEGOpts[i]->AttackCancel     = byte & 1;
1742                    pEGOpts[i]->AttackHoldCancel = byte & (1 << 1);
1743                    pEGOpts[i]->Decay1Cancel     = byte & (1 << 2);
1744                    pEGOpts[i]->Decay2Cancel     = byte & (1 << 3);
1745                    pEGOpts[i]->ReleaseCancel    = byte & (1 << 4);
1746                }
1747            }
1748            // format extension for sustain pedal up effect on release trigger samples
1749            if (lsde && lsde->GetSize() > 3) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
1750                lsde->SetPos(3);
1751                uint8_t byte = lsde->ReadUint8();
1752                SustainReleaseTrigger   = static_cast<sust_rel_trg_t>(byte & 0x03);
1753                NoNoteOffReleaseTrigger = byte >> 7;
1754            } else {
1755                SustainReleaseTrigger   = sust_rel_trg_none;
1756                NoNoteOffReleaseTrigger = false;
1757            }
1758    
1759          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
1760                                                       VelocityResponseDepth,                                                       VelocityResponseDepth,
# Line 1755  namespace { Line 1860  namespace {
1860          }          }
1861      }      }
1862    
1863        void DimensionRegion::serialize(Serialization::Archive* archive) {
1864            // in case this class will become backward incompatible one day,
1865            // then set a version and minimum version for this class like:
1866            //archive->setVersion(*this, 2);
1867            //archive->setMinVersion(*this, 1);
1868    
1869            SRLZ(VelocityUpperLimit);
1870            SRLZ(EG1PreAttack);
1871            SRLZ(EG1Attack);
1872            SRLZ(EG1Decay1);
1873            SRLZ(EG1Decay2);
1874            SRLZ(EG1InfiniteSustain);
1875            SRLZ(EG1Sustain);
1876            SRLZ(EG1Release);
1877            SRLZ(EG1Hold);
1878            SRLZ(EG1Controller);
1879            SRLZ(EG1ControllerInvert);
1880            SRLZ(EG1ControllerAttackInfluence);
1881            SRLZ(EG1ControllerDecayInfluence);
1882            SRLZ(EG1ControllerReleaseInfluence);
1883            SRLZ(LFO1Frequency);
1884            SRLZ(LFO1InternalDepth);
1885            SRLZ(LFO1ControlDepth);
1886            SRLZ(LFO1Controller);
1887            SRLZ(LFO1FlipPhase);
1888            SRLZ(LFO1Sync);
1889            SRLZ(EG2PreAttack);
1890            SRLZ(EG2Attack);
1891            SRLZ(EG2Decay1);
1892            SRLZ(EG2Decay2);
1893            SRLZ(EG2InfiniteSustain);
1894            SRLZ(EG2Sustain);
1895            SRLZ(EG2Release);
1896            SRLZ(EG2Controller);
1897            SRLZ(EG2ControllerInvert);
1898            SRLZ(EG2ControllerAttackInfluence);
1899            SRLZ(EG2ControllerDecayInfluence);
1900            SRLZ(EG2ControllerReleaseInfluence);
1901            SRLZ(LFO2Frequency);
1902            SRLZ(LFO2InternalDepth);
1903            SRLZ(LFO2ControlDepth);
1904            SRLZ(LFO2Controller);
1905            SRLZ(LFO2FlipPhase);
1906            SRLZ(LFO2Sync);
1907            SRLZ(EG3Attack);
1908            SRLZ(EG3Depth);
1909            SRLZ(LFO3Frequency);
1910            SRLZ(LFO3InternalDepth);
1911            SRLZ(LFO3ControlDepth);
1912            SRLZ(LFO3Controller);
1913            SRLZ(LFO3Sync);
1914            SRLZ(VCFEnabled);
1915            SRLZ(VCFType);
1916            SRLZ(VCFCutoffController);
1917            SRLZ(VCFCutoffControllerInvert);
1918            SRLZ(VCFCutoff);
1919            SRLZ(VCFVelocityCurve);
1920            SRLZ(VCFVelocityScale);
1921            SRLZ(VCFVelocityDynamicRange);
1922            SRLZ(VCFResonance);
1923            SRLZ(VCFResonanceDynamic);
1924            SRLZ(VCFResonanceController);
1925            SRLZ(VCFKeyboardTracking);
1926            SRLZ(VCFKeyboardTrackingBreakpoint);
1927            SRLZ(VelocityResponseCurve);
1928            SRLZ(VelocityResponseDepth);
1929            SRLZ(VelocityResponseCurveScaling);
1930            SRLZ(ReleaseVelocityResponseCurve);
1931            SRLZ(ReleaseVelocityResponseDepth);
1932            SRLZ(ReleaseTriggerDecay);
1933            SRLZ(Crossfade);
1934            SRLZ(PitchTrack);
1935            SRLZ(DimensionBypass);
1936            SRLZ(Pan);
1937            SRLZ(SelfMask);
1938            SRLZ(AttenuationController);
1939            SRLZ(InvertAttenuationController);
1940            SRLZ(AttenuationControllerThreshold);
1941            SRLZ(ChannelOffset);
1942            SRLZ(SustainDefeat);
1943            SRLZ(MSDecode);
1944            //SRLZ(SampleStartOffset);
1945            SRLZ(SampleAttenuation);
1946            SRLZ(EG1Options);
1947            SRLZ(EG2Options);
1948            SRLZ(SustainReleaseTrigger);
1949            SRLZ(NoNoteOffReleaseTrigger);
1950    
1951            // derived attributes from DLS::Sampler
1952            SRLZ(FineTune);
1953            SRLZ(Gain);
1954        }
1955    
1956      /**      /**
1957       * Updates the respective member variable and updates @c SampleAttenuation       * Updates the respective member variable and updates @c SampleAttenuation
1958       * which depends on this value.       * which depends on this value.
# Line 1788  namespace { Line 1986  namespace {
1986          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1987          if (!_3ewa) {          if (!_3ewa) {
1988              File* pFile = (File*) GetParent()->GetParent()->GetParent();              File* pFile = (File*) GetParent()->GetParent()->GetParent();
1989              bool version3 = pFile->pVersion && pFile->pVersion->major == 3;              bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
1990              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, versiongt2 ? 148 : 140);
1991          }          }
1992          pData = (uint8_t*) _3ewa->LoadChunkData();          pData = (uint8_t*) _3ewa->LoadChunkData();
1993    
1994          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1995    
1996          const uint32_t chunksize = _3ewa->GetNewSize();          const uint32_t chunksize = (uint32_t) _3ewa->GetNewSize();
1997          store32(&pData[0], chunksize); // unknown, always chunk size?          store32(&pData[0], chunksize); // unknown, always chunk size?
1998    
1999          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
# Line 2055  namespace { Line 2253  namespace {
2253          if (chunksize >= 148) {          if (chunksize >= 148) {
2254              memcpy(&pData[140], DimensionUpperLimits, 8);              memcpy(&pData[140], DimensionUpperLimits, 8);
2255          }          }
2256    
2257            // chunk for own format extensions, these will *NOT* work with
2258            // Gigasampler/GigaStudio !
2259            RIFF::Chunk* lsde = pParentList->GetSubChunk(CHUNK_ID_LSDE);
2260            const int lsdeSize = 4; // NOTE: we reserved the 3rd byte for a potential future EG3 option
2261            if (!lsde) {
2262                // only add this "LSDE" chunk if either EG options or release
2263                // trigger options deviate from their default behaviour
2264                eg_opt_t defaultOpt;
2265                if (memcmp(&EG1Options, &defaultOpt, sizeof(eg_opt_t)) ||
2266                    memcmp(&EG2Options, &defaultOpt, sizeof(eg_opt_t)) ||
2267                    SustainReleaseTrigger || NoNoteOffReleaseTrigger)
2268                {
2269                    lsde = pParentList->AddSubChunk(CHUNK_ID_LSDE, lsdeSize);
2270                    // move LSDE chunk to the end of parent list
2271                    pParentList->MoveSubChunk(lsde, (RIFF::Chunk*)NULL);
2272                }
2273            }
2274            if (lsde) {
2275                if (lsde->GetNewSize() < lsdeSize)
2276                    lsde->Resize(lsdeSize);
2277                // format extension for EG behavior options
2278                unsigned char* pData = (unsigned char*) lsde->LoadChunkData();
2279                eg_opt_t* pEGOpts[2] = { &EG1Options, &EG2Options };
2280                for (int i = 0; i < 2; ++i) { // NOTE: we reserved the 3rd byte for a potential future EG3 option
2281                    pData[i] =
2282                        (pEGOpts[i]->AttackCancel     ? 1 : 0) |
2283                        (pEGOpts[i]->AttackHoldCancel ? (1<<1) : 0) |
2284                        (pEGOpts[i]->Decay1Cancel     ? (1<<2) : 0) |
2285                        (pEGOpts[i]->Decay2Cancel     ? (1<<3) : 0) |
2286                        (pEGOpts[i]->ReleaseCancel    ? (1<<4) : 0);
2287                }
2288                // format extension for release trigger options
2289                pData[3] = static_cast<uint8_t>(SustainReleaseTrigger) | (NoNoteOffReleaseTrigger ? (1<<7) : 0);
2290            }
2291      }      }
2292    
2293      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {      double* DimensionRegion::GetReleaseVelocityTable(curve_type_t releaseVelocityResponseCurve, uint8_t releaseVelocityResponseDepth) {
# Line 2094  namespace { Line 2327  namespace {
2327      // 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
2328      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)
2329      {      {
2330            // sanity check input parameters
2331            // (fallback to some default parameters on ill input)
2332            switch (curveType) {
2333                case curve_type_nonlinear:
2334                case curve_type_linear:
2335                    if (depth > 4) {
2336                        printf("Warning: Invalid depth (0x%x) for velocity curve type (0x%x).\n", depth, curveType);
2337                        depth   = 0;
2338                        scaling = 0;
2339                    }
2340                    break;
2341                case curve_type_special:
2342                    if (depth > 5) {
2343                        printf("Warning: Invalid depth (0x%x) for velocity curve type 'special'.\n", depth);
2344                        depth   = 0;
2345                        scaling = 0;
2346                    }
2347                    break;
2348                case curve_type_unknown:
2349                default:
2350                    printf("Warning: Unknown velocity curve type (0x%x).\n", curveType);
2351                    curveType = curve_type_linear;
2352                    depth     = 0;
2353                    scaling   = 0;
2354                    break;
2355            }
2356    
2357          double* table;          double* table;
2358          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;          uint32_t tableKey = (curveType<<16) | (depth<<8) | scaling;
2359          if (pVelocityTables->count(tableKey)) { // if key exists          if (pVelocityTables->count(tableKey)) { // if key exists
# Line 2469  namespace { Line 2729  namespace {
2729    
2730              // unknown controller type              // unknown controller type
2731              default:              default:
2732                  throw gig::Exception("Unknown leverage controller type.");                  decodedcontroller.type = leverage_ctrl_t::type_none;
2733                    decodedcontroller.controller_number = 0;
2734                    printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2735                    break;
2736          }          }
2737          return decodedcontroller;          return decodedcontroller;
2738      }      }
# Line 2963  namespace { Line 3226  namespace {
3226          }          }
3227          Layers = 1;          Layers = 1;
3228          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3229          int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          int dimensionBits = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3230    
3231          // Actual Loading          // Actual Loading
3232    
# Line 3007  namespace { Line 3270  namespace {
3270              UpdateVelocityTable();              UpdateVelocityTable();
3271    
3272              // jump to start of the wave pool indices (if not already there)              // jump to start of the wave pool indices (if not already there)
3273              if (file->pVersion && file->pVersion->major == 3)              if (file->pVersion && file->pVersion->major > 2)
3274                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure
3275              else              else
3276                  _3lnk->SetPos(44);                  _3lnk->SetPos(44);
# Line 3016  namespace { Line 3279  namespace {
3279              if (file->GetAutoLoad()) {              if (file->GetAutoLoad()) {
3280                  for (uint i = 0; i < DimensionRegions; i++) {                  for (uint i = 0; i < DimensionRegions; i++) {
3281                      uint32_t wavepoolindex = _3lnk->ReadUint32();                      uint32_t wavepoolindex = _3lnk->ReadUint32();
3282                      if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      if (file->pWavePoolTable && pDimensionRegions[i])
3283                            pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3284                  }                  }
3285                  GetSample(); // load global region sample reference                  GetSample(); // load global region sample reference
3286              }              }
# Line 3065  namespace { Line 3329  namespace {
3329          }          }
3330    
3331          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
3332          bool version3 = pFile->pVersion && pFile->pVersion->major == 3;          bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3333          const int iMaxDimensions =  version3 ? 8 : 5;          const int iMaxDimensions =  versiongt2 ? 8 : 5;
3334          const int iMaxDimensionRegions = version3 ? 256 : 32;          const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3335    
3336          // make sure '3lnk' chunk exists          // make sure '3lnk' chunk exists
3337          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
3338          if (!_3lnk) {          if (!_3lnk) {
3339              const int _3lnkChunkSize = version3 ? 1092 : 172;              const int _3lnkChunkSize = versiongt2 ? 1092 : 172;
3340              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
3341              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
3342    
# Line 3096  namespace { Line 3360  namespace {
3360          }          }
3361    
3362          // update wave pool table in '3lnk' chunk          // update wave pool table in '3lnk' chunk
3363          const int iWavePoolOffset = version3 ? 68 : 44;          const int iWavePoolOffset = versiongt2 ? 68 : 44;
3364          for (uint i = 0; i < iMaxDimensionRegions; i++) {          for (uint i = 0; i < iMaxDimensionRegions; i++) {
3365              int iWaveIndex = -1;              int iWaveIndex = -1;
3366              if (i < DimensionRegions) {              if (i < DimensionRegions) {
# Line 3239  namespace { Line 3503  namespace {
3503    
3504          // check if max. amount of dimensions reached          // check if max. amount of dimensions reached
3505          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3506          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensions = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3507          if (Dimensions >= iMaxDimensions)          if (Dimensions >= iMaxDimensions)
3508              throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");              throw gig::Exception("Could not add new dimension, max. amount of " + ToString(iMaxDimensions) + " dimensions already reached");
3509          // check if max. amount of dimension bits reached          // check if max. amount of dimension bits reached
# Line 3763  namespace { Line 4027  namespace {
4027      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {      DimensionRegion* Region::GetDimensionRegionByValue(const uint DimValues[8]) {
4028          uint8_t bits;          uint8_t bits;
4029          int veldim = -1;          int veldim = -1;
4030          int velbitpos;          int velbitpos = 0;
4031          int bitpos = 0;          int bitpos = 0;
4032          int dimregidx = 0;          int dimregidx = 0;
4033          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3812  namespace { Line 4076  namespace {
4076      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {      int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
4077          uint8_t bits;          uint8_t bits;
4078          int veldim = -1;          int veldim = -1;
4079          int velbitpos;          int velbitpos = 0;
4080          int bitpos = 0;          int bitpos = 0;
4081          int dimregidx = 0;          int dimregidx = 0;
4082          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
# Line 3897  namespace { Line 4161  namespace {
4161          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
4162          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
4163          if (!file->pWavePoolTable) return NULL;          if (!file->pWavePoolTable) return NULL;
4164            if (WavePoolTableIndex + 1 > file->WavePoolCount) return NULL;
4165          // for new files or files >= 2 GB use 64 bit wave pool offsets          // for new files or files >= 2 GB use 64 bit wave pool offsets
4166          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
4167              // use 64 bit wave pool offsets (treating this as large file)              // use 64 bit wave pool offsets (treating this as large file)
# Line 4161  namespace { Line 4426  namespace {
4426              // to handle potential future extensions of the header              // to handle potential future extensions of the header
4427              ckScri->SetPos(sizeof(int32_t) + headerSize);              ckScri->SetPos(sizeof(int32_t) + headerSize);
4428              // read actual script data              // read actual script data
4429              uint32_t scriptSize = ckScri->GetSize() - ckScri->GetPos();              uint32_t scriptSize = uint32_t(ckScri->GetSize() - ckScri->GetPos());
4430              data.resize(scriptSize);              data.resize(scriptSize);
4431              for (int i = 0; i < scriptSize; ++i)              for (int i = 0; i < scriptSize; ++i)
4432                  data[i] = ckScri->ReadUint8();                  data[i] = ckScri->ReadUint8();
# Line 4212  namespace { Line 4477  namespace {
4477          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4478          __resetCRC(crc);          __resetCRC(crc);
4479          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
4480          __encodeCRC(crc);          __finalizeCRC(crc);
4481          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4482          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();
4483          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
4484          else pChunk->Resize(chunkSize);          else pChunk->Resize(chunkSize);
4485          // fill the chunk data to be written to disk          // fill the chunk data to be written to disk
4486          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();          uint8_t* pData = (uint8_t*) pChunk->LoadChunkData();
4487          int pos = 0;          int pos = 0;
4488          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
4489          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4490          store32(&pData[pos], Compression);          store32(&pData[pos], Compression);
4491          pos += sizeof(int32_t);          pos += sizeof(int32_t);
# Line 4232  namespace { Line 4497  namespace {
4497          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4498          store32(&pData[pos], crc);          store32(&pData[pos], crc);
4499          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4500          store32(&pData[pos], Name.size());          store32(&pData[pos], (uint32_t) Name.size());
4501          pos += sizeof(int32_t);          pos += sizeof(int32_t);
4502          for (int i = 0; i < Name.size(); ++i, ++pos)          for (int i = 0; i < Name.size(); ++i, ++pos)
4503              pData[pos] = Name[i];              pData[pos] = Name[i];
# Line 4263  namespace { Line 4528  namespace {
4528          return pGroup;          return pGroup;
4529      }      }
4530    
4531        /**
4532         * Make a (semi) deep copy of the Script object given by @a orig
4533         * and assign it to this object. Note: the ScriptGroup this Script
4534         * object belongs to remains untouched by this call.
4535         *
4536         * @param orig - original Script object to be copied from
4537         */
4538        void Script::CopyAssign(const Script* orig) {
4539            Name        = orig->Name;
4540            Compression = orig->Compression;
4541            Encoding    = orig->Encoding;
4542            Language    = orig->Language;
4543            Bypass      = orig->Bypass;
4544            data        = orig->data;
4545        }
4546    
4547      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4548          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4549          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4409  namespace { Line 4690  namespace {
4690          EffectSend = 0;          EffectSend = 0;
4691          Attenuation = 0;          Attenuation = 0;
4692          FineTune = 0;          FineTune = 0;
4693          PitchbendRange = 0;          PitchbendRange = 2;
4694          PianoReleaseMode = false;          PianoReleaseMode = false;
4695          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
4696          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
# Line 4507  namespace { Line 4788  namespace {
4788          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
4789          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
4790              gig::Region* pRegion = static_cast<gig::Region*>(*iter);              gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4791              for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {              const int low  = std::max(int(pRegion->KeyRange.low), 0);
4792                const int high = std::min(int(pRegion->KeyRange.high), 127);
4793                for (int iKey = low; iKey <= high; iKey++) {
4794                  RegionKeyTable[iKey] = pRegion;                  RegionKeyTable[iKey] = pRegion;
4795              }              }
4796          }          }
# Line 4552  namespace { Line 4835  namespace {
4835              File* pFile = (File*) GetParent();              File* pFile = (File*) GetParent();
4836    
4837              // 3ewg is bigger in gig3, as it includes the iMIDI rules              // 3ewg is bigger in gig3, as it includes the iMIDI rules
4838              int size = (pFile->pVersion && pFile->pVersion->major == 3) ? 16416 : 12;              int size = (pFile->pVersion && pFile->pVersion->major > 2) ? 16416 : 12;
4839              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);
4840              memset(_3ewg->LoadChunkData(), 0, size);              memset(_3ewg->LoadChunkData(), 0, size);
4841          }          }
# Line 4584  namespace { Line 4867  namespace {
4867    
4868             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4869             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);             if (!lst3LS) lst3LS = pCkInstrument->AddSubList(LIST_TYPE_3LS);
4870             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4871             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4872             const int slotSize  = 2 * sizeof(uint32_t);             const int slotSize  = 2 * sizeof(uint32_t);
4873             const int totalChunkSize = headerSize + slotCount * slotSize;             const int totalChunkSize = headerSize + slotCount * slotSize;
# Line 4620  namespace { Line 4903  namespace {
4903         if (pScriptRefs && pScriptRefs->size() > 0) {         if (pScriptRefs && pScriptRefs->size() > 0) {
4904             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);             RIFF::List* lst3LS = pCkInstrument->GetSubList(LIST_TYPE_3LS);
4905             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);             RIFF::Chunk* ckSCSL = lst3LS->GetSubChunk(CHUNK_ID_SCSL);
4906             const int slotCount = pScriptRefs->size();             const int slotCount = (int) pScriptRefs->size();
4907             const int headerSize = 3 * sizeof(uint32_t);             const int headerSize = 3 * sizeof(uint32_t);
4908             ckSCSL->SetPos(headerSize);             ckSCSL->SetPos(headerSize);
4909             for (int i = 0; i < slotCount; ++i) {             for (int i = 0; i < slotCount; ++i) {
4910                 uint32_t fileOffset =                 uint32_t fileOffset = uint32_t(
4911                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -                      (*pScriptRefs)[i].script->pChunk->GetFilePos() -
4912                      (*pScriptRefs)[i].script->pChunk->GetPos() -                      (*pScriptRefs)[i].script->pChunk->GetPos() -
4913                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize());                      CHUNK_HEADER_SIZE(ckSCSL->GetFile()->GetFileOffsetSize())
4914                   );
4915                 ckSCSL->WriteUint32(&fileOffset);                 ckSCSL->WriteUint32(&fileOffset);
4916                 // jump over flags entry (containing the bypass flag)                 // jump over flags entry (containing the bypass flag)
4917                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);                 ckSCSL->SetPos(sizeof(uint32_t), RIFF::stream_curpos);
# Line 4687  namespace { Line 4971  namespace {
4971          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);          RIFF::List* rgn = lrgn->AddSubList(LIST_TYPE_RGN);
4972          Region* pNewRegion = new Region(this, rgn);          Region* pNewRegion = new Region(this, rgn);
4973          pRegions->push_back(pNewRegion);          pRegions->push_back(pNewRegion);
4974          Regions = pRegions->size();          Regions = (uint32_t) pRegions->size();
4975          // update Region key table for fast lookup          // update Region key table for fast lookup
4976          UpdateRegionKeyTable();          UpdateRegionKeyTable();
4977          // done          // done
# Line 4833  namespace { Line 5117  namespace {
5117                  for (uint s = 0; group->GetScript(s); ++s) {                  for (uint s = 0; group->GetScript(s); ++s) {
5118                      Script* script = group->GetScript(s);                      Script* script = group->GetScript(s);
5119                      if (script->pChunk) {                      if (script->pChunk) {
5120                          uint32_t offset = script->pChunk->GetFilePos() -                          uint32_t offset = uint32_t(
5121                                            script->pChunk->GetPos() -                              script->pChunk->GetFilePos() -
5122                                            CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize());                              script->pChunk->GetPos() -
5123                                CHUNK_HEADER_SIZE(script->pChunk->GetFile()->GetFileOffsetSize())
5124                            );
5125                          if (offset == soughtOffset)                          if (offset == soughtOffset)
5126                          {                          {
5127                              _ScriptPooolRef ref;                              _ScriptPooolRef ref;
# Line 4960  namespace { Line 5246  namespace {
5246       */       */
5247      void Instrument::RemoveScript(Script* pScript) {      void Instrument::RemoveScript(Script* pScript) {
5248          LoadScripts();          LoadScripts();
5249          for (int i = pScriptRefs->size() - 1; i >= 0; --i) {          for (ssize_t i = pScriptRefs->size() - 1; i >= 0; --i) {
5250              if ((*pScriptRefs)[i].script == pScript) {              if ((*pScriptRefs)[i].script == pScript) {
5251                  pScriptRefs->erase( pScriptRefs->begin() + i );                  pScriptRefs->erase( pScriptRefs->begin() + i );
5252              }              }
# Line 4982  namespace { Line 5268  namespace {
5268       * gigedit.       * gigedit.
5269       */       */
5270      uint Instrument::ScriptSlotCount() const {      uint Instrument::ScriptSlotCount() const {
5271          return pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size();          return uint(pScriptRefs ? pScriptRefs->size() : scriptPoolFileOffsets.size());
5272      }      }
5273    
5274      /** @brief Whether script execution shall be skipped.      /** @brief Whether script execution shall be skipped.
# Line 5131  namespace { Line 5417  namespace {
5417          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
5418          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
5419    
5420          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major == 3) {          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
5421              // v3 has a fixed list of 128 strings, find a free one              // v3 has a fixed list of 128 strings, find a free one
5422              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {
5423                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
# Line 5226  namespace { Line 5512  namespace {
5512          0, 3, 20030331 & 0xffff, 20030331 >> 16          0, 3, 20030331 & 0xffff, 20030331 >> 16
5513      };      };
5514    
5515        /// Reflects Gigasampler file format version 4.0 (2007-10-12).
5516        const DLS::version_t File::VERSION_4 = {
5517            0, 4, 20071012 & 0xffff, 20071012 >> 16
5518        };
5519    
5520      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
5521          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
5522          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
# Line 5322  namespace { Line 5613  namespace {
5613          return static_cast<gig::Sample*>( *it );          return static_cast<gig::Sample*>( *it );
5614      }      }
5615    
5616        /**
5617         * Returns the total amount of samples of this gig file.
5618         *
5619         * Note that this method might block for a long time in case it is required
5620         * to load the sample info for the first time.
5621         *
5622         * @returns total amount of samples
5623         */
5624        size_t File::CountSamples() {
5625            if (!pSamples) LoadSamples();
5626            if (!pSamples) return 0;
5627            return pSamples->size();
5628        }
5629    
5630      /** @brief Add a new sample.      /** @brief Add a new sample.
5631       *       *
5632       * This will create a new Sample object for the gig file. You have to       * This will create a new Sample object for the gig file. You have to
# Line 5397  namespace { Line 5702  namespace {
5702          int iSampleIndex  = 0;          int iSampleIndex  = 0;
5703          int iTotalSamples = WavePoolCount;          int iTotalSamples = WavePoolCount;
5704    
5705          // check if samples should be loaded from extension files          // just for assembling path of optional extension files to be read
5706          // (only for old gig files < 2 GB)          const std::string folder = parentPath(pRIFF->GetFileName());
5707          int lastFileNo = 0;          const std::string baseName = pathWithoutExtension(pRIFF->GetFileName());
5708          if (!file->IsNew() && !(file->GetCurrentFileSize() >> 31)) {  
5709              for (int i = 0 ; i < WavePoolCount ; i++) {          // the main gig file and the extension files (.gx01, ... , .gx98) may
5710                  if (pWavePoolTableHi[i] > lastFileNo) lastFileNo = pWavePoolTableHi[i];          // contain wave data (wave pool)
5711              }          std::vector<RIFF::File*> poolFiles;
5712          }          poolFiles.push_back(pRIFF);
5713          String name(pRIFF->GetFileName());  
5714          int nameLen = name.length();          // get info about all extension files
5715          char suffix[6];          RIFF::Chunk* ckXfil = pRIFF->GetSubChunk(CHUNK_ID_XFIL);
5716          if (nameLen > 4 && name.substr(nameLen - 4) == ".gig") nameLen -= 4;          if (ckXfil) { // there are extension files (.gx01, ... , .gx98) ...
5717                const uint32_t n = ckXfil->ReadInt32();
5718          for (int fileNo = 0 ; ; ) {              for (int i = 0; i < n; i++) {
5719                    // read the filename and load the extension file
5720                    std::string name;
5721                    ckXfil->ReadString(name, 128);
5722                    std::string path = concatPath(folder, name);
5723                    RIFF::File* pExtFile = new RIFF::File(path);
5724                    // check that the dlsids match
5725                    RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5726                    if (ckDLSID) {
5727                        ::DLS::dlsid_t idExpected;
5728                        idExpected.ulData1 = ckXfil->ReadInt32();
5729                        idExpected.usData2 = ckXfil->ReadInt16();
5730                        idExpected.usData3 = ckXfil->ReadInt16();
5731                        ckXfil->Read(idExpected.abData, 8, 1);
5732                        ::DLS::dlsid_t idFound;
5733                        ckDLSID->Read(&idFound.ulData1, 1, 4);
5734                        ckDLSID->Read(&idFound.usData2, 1, 2);
5735                        ckDLSID->Read(&idFound.usData3, 1, 2);
5736                        ckDLSID->Read(idFound.abData, 8, 1);
5737                        if (memcmp(&idExpected, &idFound, 16) != 0)
5738                            throw gig::Exception("dlsid mismatch for extension file: %s", path.c_str());
5739                    }
5740                    poolFiles.push_back(pExtFile);
5741                    ExtensionFiles.push_back(pExtFile);
5742                }
5743            }
5744    
5745            // check if a .gx99 (GigaPulse) file exists
5746            RIFF::Chunk* ckDoxf = pRIFF->GetSubChunk(CHUNK_ID_DOXF);
5747            if (ckDoxf) { // there is a .gx99 (GigaPulse) file ...
5748                std::string path = baseName + ".gx99";
5749                RIFF::File* pExtFile = new RIFF::File(path);
5750    
5751                // skip unused int and filename
5752                ckDoxf->SetPos(132, RIFF::stream_curpos);
5753    
5754                // check that the dlsids match
5755                RIFF::Chunk* ckDLSID = pExtFile->GetSubChunk(CHUNK_ID_DLID);
5756                if (ckDLSID) {
5757                    ::DLS::dlsid_t idExpected;
5758                    idExpected.ulData1 = ckDoxf->ReadInt32();
5759                    idExpected.usData2 = ckDoxf->ReadInt16();
5760                    idExpected.usData3 = ckDoxf->ReadInt16();
5761                    ckDoxf->Read(idExpected.abData, 8, 1);
5762                    ::DLS::dlsid_t idFound;
5763                    ckDLSID->Read(&idFound.ulData1, 1, 4);
5764                    ckDLSID->Read(&idFound.usData2, 1, 2);
5765                    ckDLSID->Read(&idFound.usData3, 1, 2);
5766                    ckDLSID->Read(idFound.abData, 8, 1);
5767                    if (memcmp(&idExpected, &idFound, 16) != 0)
5768                        throw gig::Exception("dlsid mismatch for GigaPulse file: %s", path.c_str());
5769                }
5770                poolFiles.push_back(pExtFile);
5771                ExtensionFiles.push_back(pExtFile);
5772            }
5773    
5774            // load samples from extension files (if required)
5775            for (int i = 0; i < poolFiles.size(); i++) {
5776                RIFF::File* file = poolFiles[i];
5777              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);              RIFF::List* wvpl = file->GetSubList(LIST_TYPE_WVPL);
5778              if (wvpl) {              if (wvpl) {
5779                  file_offset_t wvplFileOffset = wvpl->GetFilePos();                  file_offset_t wvplFileOffset = wvpl->GetFilePos();
# Line 5422  namespace { Line 5785  namespace {
5785                          __notify_progress(pProgress, subprogress);                          __notify_progress(pProgress, subprogress);
5786    
5787                          file_offset_t waveFileOffset = wave->GetFilePos();                          file_offset_t waveFileOffset = wave->GetFilePos();
5788                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, fileNo));                          pSamples->push_back(new Sample(this, wave, waveFileOffset - wvplFileOffset, i, iSampleIndex));
5789    
5790                          iSampleIndex++;                          iSampleIndex++;
5791                      }                      }
5792                      wave = wvpl->GetNextSubList();                      wave = wvpl->GetNextSubList();
5793                  }                  }
5794                }
                 if (fileNo == lastFileNo) break;  
   
                 // open extension file (*.gx01, *.gx02, ...)  
                 fileNo++;  
                 sprintf(suffix, ".gx%02d", fileNo);  
                 name.replace(nameLen, 5, suffix);  
                 file = new RIFF::File(name);  
                 ExtensionFiles.push_back(file);  
             } else break;  
5795          }          }
5796    
5797          __notify_progress(pProgress, 1.0); // notify done          __notify_progress(pProgress, 1.0); // notify done
# Line 5457  namespace { Line 5811  namespace {
5811      }      }
5812    
5813      /**      /**
5814         * Returns the total amount of instruments of this gig file.
5815         *
5816         * Note that this method might block for a long time in case it is required
5817         * to load the instruments info for the first time.
5818         *
5819         * @returns total amount of instruments
5820         */
5821        size_t File::CountInstruments() {
5822            if (!pInstruments) LoadInstruments();
5823            if (!pInstruments) return 0;
5824            return pInstruments->size();
5825        }
5826    
5827        /**
5828       * Returns the instrument with the given index.       * Returns the instrument with the given index.
5829       *       *
5830       * @param index     - number of the sought instrument (0..n)       * @param index     - number of the sought instrument (0..n)
# Line 5575  namespace { Line 5943  namespace {
5943              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5944              mSamples[pFile->GetSample(i)] = s;              mSamples[pFile->GetSample(i)] = s;
5945          }          }
5946            
5947            // clone script groups and their scripts
5948            for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5949                ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5950                ScriptGroup* dg = AddScriptGroup();
5951                dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5952                for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5953                    Script* ss = sg->GetScript(iScript);
5954                    Script* ds = dg->AddScript();
5955                    ds->CopyAssign(ss);
5956                }
5957            }
5958    
5959          //BUG: For some reason this method only works with this additional          //BUG: For some reason this method only works with this additional
5960          //     Save() call in between here.          //     Save() call in between here.
5961          //          //
# Line 5668  namespace { Line 6048  namespace {
6048          uint32_t one = 1;          uint32_t one = 1;
6049          _3crc->WriteUint32(&one); // always 1          _3crc->WriteUint32(&one); // always 1
6050          _3crc->WriteUint32(&crc);          _3crc->WriteUint32(&crc);
   
         // reload CRC table to RAM to keep it persistent over several subsequent save operations  
         _3crc->ReleaseChunkData();  
         _3crc->LoadChunkData();  
6051      }      }
6052    
6053      uint32_t File::GetSampleChecksum(Sample* pSample) {      uint32_t File::GetSampleChecksum(Sample* pSample) {
6054            // get the index of the sample
6055            int iWaveIndex = GetWaveTableIndexOf(pSample);
6056            if (iWaveIndex < 0) throw gig::Exception("Could not retrieve reference crc of sample, could not resolve sample's wave table index");
6057    
6058            return GetSampleChecksumByIndex(iWaveIndex);
6059        }
6060    
6061        uint32_t File::GetSampleChecksumByIndex(int index) {
6062            if (index < 0) throw gig::Exception("Could not retrieve reference crc of sample, invalid wave pool index of sample");
6063    
6064          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6065          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");
6066          uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();          uint8_t* pData = (uint8_t*) _3crc->LoadChunkData();
6067          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");
6068    
         // 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");  
   
6069          // read the CRC-32 checksum directly from disk          // read the CRC-32 checksum directly from disk
6070          size_t pos = iWaveIndex * 8;          size_t pos = index * 8;
6071          if (pos + 8 > _3crc->GetNewSize())          if (pos + 8 > _3crc->GetNewSize())
6072              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");
6073    
6074          uint32_t one = load32(&pData[pos]); // always 1          uint32_t one = load32(&pData[pos]); // always 1
6075          if (one != 1)          if (one != 1)
6076              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");
6077    
6078          return load32(&pData[pos+4]);          return load32(&pData[pos+4]);
6079      }      }
6080        
6081      int File::GetWaveTableIndexOf(gig::Sample* pSample) {      int File::GetWaveTableIndexOf(gig::Sample* pSample) {
6082          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
6083          File::SampleList::iterator iter = pSamples->begin();          File::SampleList::iterator iter = pSamples->begin();
# Line 5720  namespace { Line 6102  namespace {
6102          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned          if (!pSamples) GetFirstSample(); // make sure sample chunks were scanned
6103          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;          if (_3crc->GetNewSize() != pSamples->size() * 8) return false;
6104    
6105          const int n = _3crc->GetNewSize() / 8;          const file_offset_t n = _3crc->GetNewSize() / 8;
6106    
6107          uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();          uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6108          if (!pData) return false;          if (!pData) return false;
6109    
6110          for (int i = 0; i < n; ++i) {          for (file_offset_t i = 0; i < n; ++i) {
6111              uint32_t one = pData[i*2];              uint32_t one = pData[i*2];
6112              if (one != 1) return false;              if (one != 1) return false;
6113          }          }
# Line 5759  namespace { Line 6141  namespace {
6141          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);          RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6142          if (!_3crc) {          if (!_3crc) {
6143              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6144                // the order of einf and 3crc is not the same in v2 and v3
6145                RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6146                if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6147              bRequiresSave = true;              bRequiresSave = true;
6148          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
6149              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
# Line 5788  namespace { Line 6173  namespace {
6173                      gig::Sample* pSample = (gig::Sample*) *iter;                      gig::Sample* pSample = (gig::Sample*) *iter;
6174                      int index = GetWaveTableIndexOf(pSample);                      int index = GetWaveTableIndexOf(pSample);
6175                      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");
6176                      uint32_t crc = pSample->CalculateWaveDataChecksum();                      pSample->crc  = pSample->CalculateWaveDataChecksum();
6177                      SetSampleChecksum(pSample, crc);                      SetSampleChecksum(pSample, pSample->crc);
6178                  }                  }
6179              }              }
6180          }          }
# Line 5907  namespace { Line 6292  namespace {
6292                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
6293                  while (ck) {                  while (ck) {
6294                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
6295                          if (pVersion && pVersion->major == 3 &&                          if (pVersion && pVersion->major > 2 &&
6296                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
6297    
6298                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
# Line 6056  namespace { Line 6441  namespace {
6441              lst3LS = NULL;              lst3LS = NULL;
6442          }          }
6443    
         // 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();  
   
6444          // first update base class's chunks          // first update base class's chunks
6445          DLS::File::UpdateChunks(pProgress);          DLS::File::UpdateChunks(pProgress);
6446    
# Line 6088  namespace { Line 6468  namespace {
6468    
6469              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
6470              // (before updating the Group chunks)              // (before updating the Group chunks)
6471              if (pVersion && pVersion->major == 3) {              if (pVersion && pVersion->major > 2) {
6472                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
6473                  for (int i = 0 ; i < 128 ; i++) {                  for (int i = 0 ; i < 128 ; i++) {
6474                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
# Line 6119  namespace { Line 6499  namespace {
6499          // Note that there are several fields with unknown use. These          // Note that there are several fields with unknown use. These
6500          // are set to zero.          // are set to zero.
6501    
6502          int sublen = pSamples->size() / 8 + 49;          int sublen = int(pSamples->size() / 8 + 49);
6503          int einfSize = (Instruments + 1) * sublen;          int einfSize = (Instruments + 1) * sublen;
6504    
6505          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);          RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
# Line 6192  namespace { Line 6572  namespace {
6572                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);                  store32(&pData[(instrumentIdx + 1) * sublen + 24], nbloops);
6573                  // next 8 bytes unknown                  // next 8 bytes unknown
6574                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);                  store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
6575                  store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());                  store32(&pData[(instrumentIdx + 1) * sublen + 40], (uint32_t) pSamples->size());
6576                  // next 4 bytes unknown                  // next 4 bytes unknown
6577    
6578                  totnbregions += instrument->Regions;                  totnbregions += instrument->Regions;
# Line 6210  namespace { Line 6590  namespace {
6590              store32(&pData[24], totnbloops);              store32(&pData[24], totnbloops);
6591              // next 8 bytes unknown              // next 8 bytes unknown
6592              // next 4 bytes unknown, not always 0              // next 4 bytes unknown, not always 0
6593              store32(&pData[40], pSamples->size());              store32(&pData[40], (uint32_t) pSamples->size());
6594              // next 4 bytes unknown              // next 4 bytes unknown
6595          }          }
6596    
6597          // update 3crc chunk          // update 3crc chunk
6598    
6599          // The 3crc chunk contains CRC-32 checksums for the          // The 3crc chunk contains CRC-32 checksums for the
6600          // samples. The actual checksum values will be filled in          // samples. When saving a gig file to disk, we first update the 3CRC
6601          // later, by Sample::Write.          // chunk here (in RAM) with the old crc values which we read from the
6602            // 3CRC chunk when we opened the file (available with gig::Sample::crc
6603            // member variable). This step is required, because samples might have
6604            // been deleted by the user since the file was opened, which in turn
6605            // changes the order of the (i.e. old) checksums within the 3crc chunk.
6606            // If a sample was conciously modified by the user (that is if
6607            // Sample::Write() was called later on) then Sample::Write() will just
6608            // update the respective individual checksum(s) directly on disk and
6609            // leaves all other sample checksums untouched.
6610    
6611            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
6612          if (_3crc) {          if (_3crc) {
6613              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
6614          } else if (newFile) {          } else /*if (newFile)*/ {
6615              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
             _3crc->LoadChunkData();  
   
6616              // 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
6617              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6618            }
6619            { // must be performed in RAM here ...
6620                uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
6621                if (pData) {
6622                    File::SampleList::iterator iter = pSamples->begin();
6623                    File::SampleList::iterator end  = pSamples->end();
6624                    for (int index = 0; iter != end; ++iter, ++index) {
6625                        gig::Sample* pSample = (gig::Sample*) *iter;
6626                        pData[index*2]   = 1; // always 1
6627                        pData[index*2+1] = pSample->crc;
6628                    }
6629                }
6630          }          }
6631      }      }
6632            
# Line 6273  namespace { Line 6672  namespace {
6672  // *************** Exception ***************  // *************** Exception ***************
6673  // *  // *
6674    
6675      Exception::Exception(String Message) : DLS::Exception(Message) {      Exception::Exception() : DLS::Exception() {
6676        }
6677    
6678        Exception::Exception(String format, ...) : DLS::Exception() {
6679            va_list arg;
6680            va_start(arg, format);
6681            Message = assemble(format, arg);
6682            va_end(arg);
6683        }
6684    
6685        Exception::Exception(String format, va_list arg) : DLS::Exception() {
6686            Message = assemble(format, arg);
6687      }      }
6688    
6689      void Exception::PrintMessage() {      void Exception::PrintMessage() {
Legend:
Removed from v.2985  
changed lines
  Added in v.3475
  ViewVC Help
Powered by ViewVC