/[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 3115 by schoenebeck, Sat Apr 15 20:17:05 2017 UTC revision 3440 by schoenebeck, Sun Dec 9 20:14:46 2018 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-2018 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 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 421  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 1685  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 1790  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 1823  namespace { Line 1975  namespace {
1975          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1976          if (!_3ewa) {          if (!_3ewa) {
1977              File* pFile = (File*) GetParent()->GetParent()->GetParent();              File* pFile = (File*) GetParent()->GetParent()->GetParent();
1978              bool version3 = pFile->pVersion && pFile->pVersion->major == 3;              bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
1979              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);              _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, versiongt2 ? 148 : 140);
1980          }          }
1981          pData = (uint8_t*) _3ewa->LoadChunkData();          pData = (uint8_t*) _3ewa->LoadChunkData();
1982    
# Line 2090  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 2129  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 2504  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 2998  namespace { Line 3208  namespace {
3208          }          }
3209          Layers = 1;          Layers = 1;
3210          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3211          int dimensionBits = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          int dimensionBits = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3212    
3213          // Actual Loading          // Actual Loading
3214    
# Line 3042  namespace { Line 3252  namespace {
3252              UpdateVelocityTable();              UpdateVelocityTable();
3253    
3254              // jump to start of the wave pool indices (if not already there)              // jump to start of the wave pool indices (if not already there)
3255              if (file->pVersion && file->pVersion->major == 3)              if (file->pVersion && file->pVersion->major > 2)
3256                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure                  _3lnk->SetPos(68); // version 3 has a different 3lnk structure
3257              else              else
3258                  _3lnk->SetPos(44);                  _3lnk->SetPos(44);
# Line 3051  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 3100  namespace { Line 3311  namespace {
3311          }          }
3312    
3313          File* pFile = (File*) GetParent()->GetParent();          File* pFile = (File*) GetParent()->GetParent();
3314          bool version3 = pFile->pVersion && pFile->pVersion->major == 3;          bool versiongt2 = pFile->pVersion && pFile->pVersion->major > 2;
3315          const int iMaxDimensions =  version3 ? 8 : 5;          const int iMaxDimensions =  versiongt2 ? 8 : 5;
3316          const int iMaxDimensionRegions = version3 ? 256 : 32;          const int iMaxDimensionRegions = versiongt2 ? 256 : 32;
3317    
3318          // make sure '3lnk' chunk exists          // make sure '3lnk' chunk exists
3319          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
3320          if (!_3lnk) {          if (!_3lnk) {
3321              const int _3lnkChunkSize = version3 ? 1092 : 172;              const int _3lnkChunkSize = versiongt2 ? 1092 : 172;
3322              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
3323              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);              memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
3324    
# Line 3131  namespace { Line 3342  namespace {
3342          }          }
3343    
3344          // update wave pool table in '3lnk' chunk          // update wave pool table in '3lnk' chunk
3345          const int iWavePoolOffset = version3 ? 68 : 44;          const int iWavePoolOffset = versiongt2 ? 68 : 44;
3346          for (uint i = 0; i < iMaxDimensionRegions; i++) {          for (uint i = 0; i < iMaxDimensionRegions; i++) {
3347              int iWaveIndex = -1;              int iWaveIndex = -1;
3348              if (i < DimensionRegions) {              if (i < DimensionRegions) {
# Line 3274  namespace { Line 3485  namespace {
3485    
3486          // check if max. amount of dimensions reached          // check if max. amount of dimensions reached
3487          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3488          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensions = (file->pVersion && file->pVersion->major > 2) ? 8 : 5;
3489          if (Dimensions >= iMaxDimensions)          if (Dimensions >= iMaxDimensions)
3490              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");
3491          // check if max. amount of dimension bits reached          // check if max. amount of dimension bits reached
# Line 3932  namespace { Line 4143  namespace {
4143          if ((int32_t)WavePoolTableIndex == -1) return NULL;          if ((int32_t)WavePoolTableIndex == -1) return NULL;
4144          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
4145          if (!file->pWavePoolTable) return NULL;          if (!file->pWavePoolTable) return NULL;
4146            if (WavePoolTableIndex + 1 > file->WavePoolCount) return NULL;
4147          // 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
4148          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {          if (file->pRIFF->IsNew() || (file->pRIFF->GetCurrentFileSize() >> 31)) {
4149              // use 64 bit wave pool offsets (treating this as large file)              // use 64 bit wave pool offsets (treating this as large file)
# Line 4298  namespace { Line 4510  namespace {
4510          return pGroup;          return pGroup;
4511      }      }
4512    
4513        /**
4514         * Make a (semi) deep copy of the Script object given by @a orig
4515         * and assign it to this object. Note: the ScriptGroup this Script
4516         * object belongs to remains untouched by this call.
4517         *
4518         * @param orig - original Script object to be copied from
4519         */
4520        void Script::CopyAssign(const Script* orig) {
4521            Name        = orig->Name;
4522            Compression = orig->Compression;
4523            Encoding    = orig->Encoding;
4524            Language    = orig->Language;
4525            Bypass      = orig->Bypass;
4526            data        = orig->data;
4527        }
4528    
4529      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4530          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4531          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4542  namespace { Line 4770  namespace {
4770          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
4771          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
4772              gig::Region* pRegion = static_cast<gig::Region*>(*iter);              gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4773              for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {              const int low  = std::max(int(pRegion->KeyRange.low), 0);
4774                const int high = std::min(int(pRegion->KeyRange.high), 127);
4775                for (int iKey = low; iKey <= high; iKey++) {
4776                  RegionKeyTable[iKey] = pRegion;                  RegionKeyTable[iKey] = pRegion;
4777              }              }
4778          }          }
# Line 4587  namespace { Line 4817  namespace {
4817              File* pFile = (File*) GetParent();              File* pFile = (File*) GetParent();
4818    
4819              // 3ewg is bigger in gig3, as it includes the iMIDI rules              // 3ewg is bigger in gig3, as it includes the iMIDI rules
4820              int size = (pFile->pVersion && pFile->pVersion->major == 3) ? 16416 : 12;              int size = (pFile->pVersion && pFile->pVersion->major > 2) ? 16416 : 12;
4821              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);              _3ewg = lart->AddSubChunk(CHUNK_ID_3EWG, size);
4822              memset(_3ewg->LoadChunkData(), 0, size);              memset(_3ewg->LoadChunkData(), 0, size);
4823          }          }
# Line 5169  namespace { Line 5399  namespace {
5399          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
5400          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
5401    
5402          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major == 3) {          if (!pNameChunk && pFile->pVersion && pFile->pVersion->major > 2) {
5403              // v3 has a fixed list of 128 strings, find a free one              // v3 has a fixed list of 128 strings, find a free one
5404              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {              for (RIFF::Chunk* ck = _3gnl->GetFirstSubChunk() ; ck ; ck = _3gnl->GetNextSubChunk()) {
5405                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {                  if (strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) {
# Line 5264  namespace { Line 5494  namespace {
5494          0, 3, 20030331 & 0xffff, 20030331 >> 16          0, 3, 20030331 & 0xffff, 20030331 >> 16
5495      };      };
5496    
5497        /// Reflects Gigasampler file format version 4.0 (2007-10-12).
5498        const DLS::version_t File::VERSION_4 = {
5499            0, 4, 20071012 & 0xffff, 20071012 >> 16
5500        };
5501    
5502      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
5503          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
5504          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
# Line 5360  namespace { Line 5595  namespace {
5595          return static_cast<gig::Sample*>( *it );          return static_cast<gig::Sample*>( *it );
5596      }      }
5597    
5598        /**
5599         * Returns the total amount of samples of this gig file.
5600         *
5601         * Note that this method might block for a long time in case it is required
5602         * to load the sample info for the first time.
5603         *
5604         * @returns total amount of samples
5605         */
5606        size_t File::CountSamples() {
5607            if (!pSamples) LoadSamples();
5608            if (!pSamples) return 0;
5609            return pSamples->size();
5610        }
5611    
5612      /** @brief Add a new sample.      /** @brief Add a new sample.
5613       *       *
5614       * 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 5495  namespace { Line 5744  namespace {
5744      }      }
5745    
5746      /**      /**
5747         * Returns the total amount of instruments of this gig file.
5748         *
5749         * Note that this method might block for a long time in case it is required
5750         * to load the instruments info for the first time.
5751         *
5752         * @returns total amount of instruments
5753         */
5754        size_t File::CountInstruments() {
5755            if (!pInstruments) LoadInstruments();
5756            if (!pInstruments) return 0;
5757            return pInstruments->size();
5758        }
5759    
5760        /**
5761       * Returns the instrument with the given index.       * Returns the instrument with the given index.
5762       *       *
5763       * @param index     - number of the sought instrument (0..n)       * @param index     - number of the sought instrument (0..n)
# Line 5613  namespace { Line 5876  namespace {
5876              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5877              mSamples[pFile->GetSample(i)] = s;              mSamples[pFile->GetSample(i)] = s;
5878          }          }
5879            
5880            // clone script groups and their scripts
5881            for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5882                ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5883                ScriptGroup* dg = AddScriptGroup();
5884                dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5885                for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5886                    Script* ss = sg->GetScript(iScript);
5887                    Script* ds = dg->AddScript();
5888                    ds->CopyAssign(ss);
5889                }
5890            }
5891    
5892          //BUG: For some reason this method only works with this additional          //BUG: For some reason this method only works with this additional
5893          //     Save() call in between here.          //     Save() call in between here.
5894          //          //
# Line 5801  namespace { Line 6076  namespace {
6076              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6077              // 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
6078              RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);              RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
6079              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6080              bRequiresSave = true;              bRequiresSave = true;
6081          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {          } else if (_3crc->GetNewSize() != pSamples->size() * 8) {
6082              _3crc->Resize(pSamples->size() * 8);              _3crc->Resize(pSamples->size() * 8);
# Line 5950  namespace { Line 6225  namespace {
6225                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();                  RIFF::Chunk* ck = lst3gnl->GetFirstSubChunk();
6226                  while (ck) {                  while (ck) {
6227                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {                      if (ck->GetChunkID() == CHUNK_ID_3GNM) {
6228                          if (pVersion && pVersion->major == 3 &&                          if (pVersion && pVersion->major > 2 &&
6229                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;                              strcmp(static_cast<char*>(ck->LoadChunkData()), "") == 0) break;
6230    
6231                          pGroups->push_back(new Group(this, ck));                          pGroups->push_back(new Group(this, ck));
# Line 6126  namespace { Line 6401  namespace {
6401    
6402              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
6403              // (before updating the Group chunks)              // (before updating the Group chunks)
6404              if (pVersion && pVersion->major == 3) {              if (pVersion && pVersion->major > 2) {
6405                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
6406                  for (int i = 0 ; i < 128 ; i++) {                  for (int i = 0 ; i < 128 ; i++) {
6407                      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 6272  namespace { Line 6547  namespace {
6547          } else /*if (newFile)*/ {          } else /*if (newFile)*/ {
6548              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);              _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
6549              // 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
6550              if (einf && pVersion && pVersion->major == 3) pRIFF->MoveSubChunk(_3crc, einf);              if (einf && pVersion && pVersion->major > 2) pRIFF->MoveSubChunk(_3crc, einf);
6551          }          }
6552          { // must be performed in RAM here ...          { // must be performed in RAM here ...
6553              uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();              uint32_t* pData = (uint32_t*) _3crc->LoadChunkData();
# Line 6330  namespace { Line 6605  namespace {
6605  // *************** Exception ***************  // *************** Exception ***************
6606  // *  // *
6607    
6608      Exception::Exception(String Message) : DLS::Exception(Message) {      Exception::Exception() : DLS::Exception() {
6609        }
6610    
6611        Exception::Exception(String format, ...) : DLS::Exception() {
6612            va_list arg;
6613            va_start(arg, format);
6614            Message = assemble(format, arg);
6615            va_end(arg);
6616        }
6617    
6618        Exception::Exception(String format, va_list arg) : DLS::Exception() {
6619            Message = assemble(format, arg);
6620      }      }
6621    
6622      void Exception::PrintMessage() {      void Exception::PrintMessage() {
Legend:
Removed from v.3115  
changed lines
  Added in v.3440
  ViewVC Help
Powered by ViewVC