/[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 3112 by schoenebeck, Wed Feb 15 13:21:31 2017 UTC revision 3348 by schoenebeck, Tue Oct 3 15:05:45 2017 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2016 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2017 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 24  Line 24 
24  #include "gig.h"  #include "gig.h"
25    
26  #include "helper.h"  #include "helper.h"
27    #include "Serialization.h"
28    
29  #include <algorithm>  #include <algorithm>
30  #include <math.h>  #include <math.h>
# Line 55  Line 56 
56  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)  #define GIG_EG_CTR_DECAY_INFLUENCE_ENCODE(x)    ((x & 0x03) << 3)
57  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)  #define GIG_EG_CTR_RELEASE_INFLUENCE_ENCODE(x)  ((x & 0x03) << 5)
58    
59    #define SRLZ(member) \
60        archive->serializeMember(*this, member, #member);
61    
62  namespace gig {  namespace gig {
63    
64  // *************** Internal functions for sample decompression ***************  // *************** Internal functions for sample decompression ***************
# Line 269  namespace { Line 273  namespace {
273       * steps.       * steps.
274       *       *
275       * Once the whole data was processed by __calculateCRC(), one should       * Once the whole data was processed by __calculateCRC(), one should
276       * call __encodeCRC() to get the final CRC result.       * call __finalizeCRC() to get the final CRC result.
277       *       *
278       * @param buf     - pointer to data the CRC shall be calculated of       * @param buf     - pointer to data the CRC shall be calculated of
279       * @param bufSize - size of the data to be processed       * @param bufSize - size of the data to be processed
# 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 1294  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 1416  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 1684  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 1789  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 2089  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 2503  namespace { Line 2684  namespace {
2684    
2685              // unknown controller type              // unknown controller type
2686              default:              default:
2687                  throw gig::Exception("Unknown leverage controller type.");                  decodedcontroller.type = leverage_ctrl_t::type_none;
2688                    decodedcontroller.controller_number = 0;
2689                    printf("Warning: Unknown leverage controller type (0x%x).\n", EncodedController);
2690                    break;
2691          }          }
2692          return decodedcontroller;          return decodedcontroller;
2693      }      }
# Line 3050  namespace { Line 3234  namespace {
3234              if (file->GetAutoLoad()) {              if (file->GetAutoLoad()) {
3235                  for (uint i = 0; i < DimensionRegions; i++) {                  for (uint i = 0; i < DimensionRegions; i++) {
3236                      uint32_t wavepoolindex = _3lnk->ReadUint32();                      uint32_t wavepoolindex = _3lnk->ReadUint32();
3237                      if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      if (file->pWavePoolTable && pDimensionRegions[i])
3238                            pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
3239                  }                  }
3240                  GetSample(); // load global region sample reference                  GetSample(); // load global region sample reference
3241              }              }
# Line 4246  namespace { Line 4431  namespace {
4431          // recalculate CRC32 check sum          // recalculate CRC32 check sum
4432          __resetCRC(crc);          __resetCRC(crc);
4433          __calculateCRC(&data[0], data.size(), crc);          __calculateCRC(&data[0], data.size(), crc);
4434          __encodeCRC(crc);          __finalizeCRC(crc);
4435          // make sure chunk exists and has the required size          // make sure chunk exists and has the required size
4436          const file_offset_t chunkSize = (file_offset_t) 7*sizeof(int32_t) + Name.size() + data.size();          const file_offset_t chunkSize = (file_offset_t) 7*sizeof(int32_t) + Name.size() + data.size();
4437          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);          if (!pChunk) pChunk = pGroup->pList->AddSubChunk(CHUNK_ID_SCRI, chunkSize);
# Line 4297  namespace { Line 4482  namespace {
4482          return pGroup;          return pGroup;
4483      }      }
4484    
4485        /**
4486         * Make a (semi) deep copy of the Script object given by @a orig
4487         * and assign it to this object. Note: the ScriptGroup this Script
4488         * object belongs to remains untouched by this call.
4489         *
4490         * @param orig - original Script object to be copied from
4491         */
4492        void Script::CopyAssign(const Script* orig) {
4493            Name        = orig->Name;
4494            Compression = orig->Compression;
4495            Encoding    = orig->Encoding;
4496            Language    = orig->Language;
4497            Bypass      = orig->Bypass;
4498            data        = orig->data;
4499        }
4500    
4501      void Script::RemoveAllScriptReferences() {      void Script::RemoveAllScriptReferences() {
4502          File* pFile = pGroup->pFile;          File* pFile = pGroup->pFile;
4503          for (int i = 0; pFile->GetInstrument(i); ++i) {          for (int i = 0; pFile->GetInstrument(i); ++i) {
# Line 4541  namespace { Line 4742  namespace {
4742          RegionList::iterator end  = pRegions->end();          RegionList::iterator end  = pRegions->end();
4743          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
4744              gig::Region* pRegion = static_cast<gig::Region*>(*iter);              gig::Region* pRegion = static_cast<gig::Region*>(*iter);
4745              for (int iKey = pRegion->KeyRange.low; iKey <= pRegion->KeyRange.high; iKey++) {              const int low  = std::max(int(pRegion->KeyRange.low), 0);
4746                const int high = std::min(int(pRegion->KeyRange.high), 127);
4747                for (int iKey = low; iKey <= high; iKey++) {
4748                  RegionKeyTable[iKey] = pRegion;                  RegionKeyTable[iKey] = pRegion;
4749              }              }
4750          }          }
# Line 5612  namespace { Line 5815  namespace {
5815              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);              mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
5816              mSamples[pFile->GetSample(i)] = s;              mSamples[pFile->GetSample(i)] = s;
5817          }          }
5818            
5819            // clone script groups and their scripts
5820            for (int iGroup = 0; pFile->GetScriptGroup(iGroup); ++iGroup) {
5821                ScriptGroup* sg = pFile->GetScriptGroup(iGroup);
5822                ScriptGroup* dg = AddScriptGroup();
5823                dg->Name = "COPY" + ToString(iCallCount) + "_" + sg->Name;
5824                for (int iScript = 0; sg->GetScript(iScript); ++iScript) {
5825                    Script* ss = sg->GetScript(iScript);
5826                    Script* ds = dg->AddScript();
5827                    ds->CopyAssign(ss);
5828                }
5829            }
5830    
5831          //BUG: For some reason this method only works with this additional          //BUG: For some reason this method only works with this additional
5832          //     Save() call in between here.          //     Save() call in between here.
5833          //          //
# Line 6329  namespace { Line 6544  namespace {
6544  // *************** Exception ***************  // *************** Exception ***************
6545  // *  // *
6546    
6547      Exception::Exception(String Message) : DLS::Exception(Message) {      Exception::Exception() : DLS::Exception() {
6548        }
6549    
6550        Exception::Exception(String format, ...) : DLS::Exception() {
6551            va_list arg;
6552            va_start(arg, format);
6553            Message = assemble(format, arg);
6554            va_end(arg);
6555        }
6556    
6557        Exception::Exception(String format, va_list arg) : DLS::Exception() {
6558            Message = assemble(format, arg);
6559      }      }
6560    
6561      void Exception::PrintMessage() {      void Exception::PrintMessage() {
Legend:
Removed from v.3112  
changed lines
  Added in v.3348
  ViewVC Help
Powered by ViewVC