/[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 1381 by schoenebeck, Thu Oct 4 18:57:10 2007 UTC revision 1713 by persson, Thu Mar 6 20:42:22 2008 UTC
# Line 25  Line 25 
25    
26  #include "helper.h"  #include "helper.h"
27    
28    #include <algorithm>
29  #include <math.h>  #include <math.h>
30  #include <iostream>  #include <iostream>
31    
# Line 366  namespace { Line 367  namespace {
367       *                         is located, 0 otherwise       *                         is located, 0 otherwise
368       */       */
369      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {      Sample::Sample(File* pFile, RIFF::List* waveList, unsigned long WavePoolOffset, unsigned long fileNo) : DLS::Sample((DLS::File*) pFile, waveList, WavePoolOffset) {
370          static const DLS::Info::FixedStringLength fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
371              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
372              { 0, 0 }              { 0, 0 }
373          };          };
374          pInfo->FixedStringLengths = fixedStringLengths;          pInfo->SetFixedStringLengths(fixedStringLengths);
375          Instances++;          Instances++;
376          FileNo = fileNo;          FileNo = fileNo;
377    
# Line 2372  namespace { Line 2373  namespace {
2373    
2374          // Actual Loading          // Actual Loading
2375    
2376            if (!file->GetAutoLoad()) return;
2377    
2378          LoadDimensionRegions(rgnList);          LoadDimensionRegions(rgnList);
2379    
2380          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = rgnList->GetSubChunk(CHUNK_ID_3LNK);
# Line 2415  namespace { Line 2418  namespace {
2418              else              else
2419                  _3lnk->SetPos(44);                  _3lnk->SetPos(44);
2420    
2421              // load sample references              // load sample references (if auto loading is enabled)
2422              for (uint i = 0; i < DimensionRegions; i++) {              if (file->GetAutoLoad()) {
2423                  uint32_t wavepoolindex = _3lnk->ReadUint32();                  for (uint i = 0; i < DimensionRegions; i++) {
2424                  if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);                      uint32_t wavepoolindex = _3lnk->ReadUint32();
2425                        if (file->pWavePoolTable) pDimensionRegions[i]->pSample = GetSampleFromWavePool(wavepoolindex);
2426                    }
2427                    GetSample(); // load global region sample reference
2428              }              }
             GetSample(); // load global region sample reference  
2429          } else {          } else {
2430              DimensionRegions = 0;              DimensionRegions = 0;
2431              for (int i = 0 ; i < 8 ; i++) {              for (int i = 0 ; i < 8 ; i++) {
# Line 2919  namespace { Line 2924  namespace {
2924      }      }
2925    
2926    
2927    // *************** MidiRule ***************
2928    // *
2929    
2930    MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {
2931        _3ewg->SetPos(36);
2932        Triggers = _3ewg->ReadUint8();
2933        _3ewg->SetPos(40);
2934        ControllerNumber = _3ewg->ReadUint8();
2935        _3ewg->SetPos(46);
2936        for (int i = 0 ; i < Triggers ; i++) {
2937            pTriggers[i].TriggerPoint = _3ewg->ReadUint8();
2938            pTriggers[i].Descending = _3ewg->ReadUint8();
2939            pTriggers[i].VelSensitivity = _3ewg->ReadUint8();
2940            pTriggers[i].Key = _3ewg->ReadUint8();
2941            pTriggers[i].NoteOff = _3ewg->ReadUint8();
2942            pTriggers[i].Velocity = _3ewg->ReadUint8();
2943            pTriggers[i].OverridePedal = _3ewg->ReadUint8();
2944            _3ewg->ReadUint8();
2945        }
2946    }
2947    
2948    
2949  // *************** Instrument ***************  // *************** Instrument ***************
2950  // *  // *
2951    
2952      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {      Instrument::Instrument(File* pFile, RIFF::List* insList, progress_t* pProgress) : DLS::Instrument((DLS::File*)pFile, insList) {
2953          static const DLS::Info::FixedStringLength fixedStringLengths[] = {          static const DLS::Info::string_length_t fixedStringLengths[] = {
2954              { CHUNK_ID_INAM, 64 },              { CHUNK_ID_INAM, 64 },
2955              { CHUNK_ID_ISFT, 12 },              { CHUNK_ID_ISFT, 12 },
2956              { 0, 0 }              { 0, 0 }
2957          };          };
2958          pInfo->FixedStringLengths = fixedStringLengths;          pInfo->SetFixedStringLengths(fixedStringLengths);
2959    
2960          // Initialization          // Initialization
2961          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
# Line 2940  namespace { Line 2966  namespace {
2966          PianoReleaseMode = false;          PianoReleaseMode = false;
2967          DimensionKeyRange.low = 0;          DimensionKeyRange.low = 0;
2968          DimensionKeyRange.high = 0;          DimensionKeyRange.high = 0;
2969            pMidiRules = new MidiRule*[3];
2970            pMidiRules[0] = NULL;
2971    
2972          // Loading          // Loading
2973          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
# Line 2954  namespace { Line 2982  namespace {
2982                  PianoReleaseMode       = dimkeystart & 0x01;                  PianoReleaseMode       = dimkeystart & 0x01;
2983                  DimensionKeyRange.low  = dimkeystart >> 1;                  DimensionKeyRange.low  = dimkeystart >> 1;
2984                  DimensionKeyRange.high = _3ewg->ReadUint8();                  DimensionKeyRange.high = _3ewg->ReadUint8();
2985    
2986                    if (_3ewg->GetSize() > 32) {
2987                        // read MIDI rules
2988                        int i = 0;
2989                        _3ewg->SetPos(32);
2990                        uint8_t id1 = _3ewg->ReadUint8();
2991                        uint8_t id2 = _3ewg->ReadUint8();
2992    
2993                        if (id1 == 4 && id2 == 16) {
2994                            pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
2995                        }
2996                        //TODO: all the other types of rules
2997    
2998                        pMidiRules[i] = NULL;
2999                    }
3000              }              }
3001          }          }
3002    
3003          if (!pRegions) pRegions = new RegionList;          if (pFile->GetAutoLoad()) {
3004          RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);              if (!pRegions) pRegions = new RegionList;
3005          if (lrgn) {              RIFF::List* lrgn = insList->GetSubList(LIST_TYPE_LRGN);
3006              RIFF::List* rgn = lrgn->GetFirstSubList();              if (lrgn) {
3007              while (rgn) {                  RIFF::List* rgn = lrgn->GetFirstSubList();
3008                  if (rgn->GetListType() == LIST_TYPE_RGN) {                  while (rgn) {
3009                      __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);                      if (rgn->GetListType() == LIST_TYPE_RGN) {
3010                      pRegions->push_back(new Region(this, rgn));                          __notify_progress(pProgress, (float) pRegions->size() / (float) Regions);
3011                            pRegions->push_back(new Region(this, rgn));
3012                        }
3013                        rgn = lrgn->GetNextSubList();
3014                  }                  }
3015                  rgn = lrgn->GetNextSubList();                  // Creating Region Key Table for fast lookup
3016                    UpdateRegionKeyTable();
3017              }              }
             // Creating Region Key Table for fast lookup  
             UpdateRegionKeyTable();  
3018          }          }
3019    
3020          __notify_progress(pProgress, 1.0f); // notify done          __notify_progress(pProgress, 1.0f); // notify done
# Line 2988  namespace { Line 3033  namespace {
3033      }      }
3034    
3035      Instrument::~Instrument() {      Instrument::~Instrument() {
3036            delete[] pMidiRules;
3037      }      }
3038    
3039      /**      /**
# Line 3102  namespace { Line 3148  namespace {
3148          UpdateRegionKeyTable();          UpdateRegionKeyTable();
3149      }      }
3150    
3151        /**
3152         * Returns a MIDI rule of the instrument.
3153         *
3154         * The list of MIDI rules, at least in gig v3, always contains at
3155         * most two rules. The second rule can only be the DEF filter
3156         * (which currently isn't supported by libgig).
3157         *
3158         * @param i - MIDI rule number
3159         * @returns   pointer address to MIDI rule number i or NULL if there is none
3160         */
3161        MidiRule* Instrument::GetMidiRule(int i) {
3162            return pMidiRules[i];
3163        }
3164    
3165    
3166  // *************** Group ***************  // *************** Group ***************
# Line 3227  namespace { Line 3286  namespace {
3286  // *************** File ***************  // *************** File ***************
3287  // *  // *
3288    
3289      // File version 2.0, 1998-06-28      /// Reflects Gigasampler file format version 2.0 (1998-06-28).
3290      const DLS::version_t File::VERSION_2 = {      const DLS::version_t File::VERSION_2 = {
3291          0, 2, 19980628 & 0xffff, 19980628 >> 16          0, 2, 19980628 & 0xffff, 19980628 >> 16
3292      };      };
3293    
3294      // File version 3.0, 2003-03-31      /// Reflects Gigasampler file format version 3.0 (2003-03-31).
3295      const DLS::version_t File::VERSION_3 = {      const DLS::version_t File::VERSION_3 = {
3296          0, 3, 20030331 & 0xffff, 20030331 >> 16          0, 3, 20030331 & 0xffff, 20030331 >> 16
3297      };      };
3298    
3299      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {      static const DLS::Info::string_length_t _FileFixedStringLengths[] = {
3300          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
3301          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
3302          { CHUNK_ID_ICMS, 128 },          { CHUNK_ID_ICMS, 128 },
# Line 3259  namespace { Line 3318  namespace {
3318      };      };
3319    
3320      File::File() : DLS::File() {      File::File() : DLS::File() {
3321            bAutoLoad = true;
3322          *pVersion = VERSION_3;          *pVersion = VERSION_3;
3323          pGroups = NULL;          pGroups = NULL;
3324          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
3325          pInfo->ArchivalLocation = String(256, ' ');          pInfo->ArchivalLocation = String(256, ' ');
3326    
3327          // add some mandatory chunks to get the file chunks in right          // add some mandatory chunks to get the file chunks in right
# Line 3274  namespace { Line 3334  namespace {
3334      }      }
3335    
3336      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
3337            bAutoLoad = true;
3338          pGroups = NULL;          pGroups = NULL;
3339          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->SetFixedStringLengths(_FileFixedStringLengths);
3340      }      }
3341    
3342      File::~File() {      File::~File() {
# Line 3343  namespace { Line 3404  namespace {
3404          pSamples->erase(iter);          pSamples->erase(iter);
3405          delete pSample;          delete pSample;
3406    
3407            SampleList::iterator tmp = SamplesIterator;
3408          // remove all references to the sample          // remove all references to the sample
3409          for (Instrument* instrument = GetFirstInstrument() ; instrument ;          for (Instrument* instrument = GetFirstInstrument() ; instrument ;
3410               instrument = GetNextInstrument()) {               instrument = GetNextInstrument()) {
# Line 3357  namespace { Line 3419  namespace {
3419                  }                  }
3420              }              }
3421          }          }
3422            SamplesIterator = tmp; // restore iterator
3423      }      }
3424    
3425      void File::LoadSamples() {      void File::LoadSamples() {
# Line 3447  namespace { Line 3510  namespace {
3510              progress_t subprogress;              progress_t subprogress;
3511              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask              __divide_progress(pProgress, &subprogress, 3.0f, 0.0f); // randomly schedule 33% for this subtask
3512              __notify_progress(&subprogress, 0.0f);              __notify_progress(&subprogress, 0.0f);
3513              GetFirstSample(&subprogress); // now force all samples to be loaded              if (GetAutoLoad())
3514                    GetFirstSample(&subprogress); // now force all samples to be loaded
3515              __notify_progress(&subprogress, 1.0f);              __notify_progress(&subprogress, 1.0f);
3516    
3517              // instrument loading subtask              // instrument loading subtask
# Line 3854  namespace { Line 3918  namespace {
3918          }          }
3919      }      }
3920    
3921        /**
3922         * Enable / disable automatic loading. By default this properyt is
3923         * enabled and all informations are loaded automatically. However
3924         * loading all Regions, DimensionRegions and especially samples might
3925         * take a long time for large .gig files, and sometimes one might only
3926         * be interested in retrieving very superficial informations like the
3927         * amount of instruments and their names. In this case one might disable
3928         * automatic loading to avoid very slow response times.
3929         *
3930         * @e CAUTION: by disabling this property many pointers (i.e. sample
3931         * references) and informations will have invalid or even undefined
3932         * data! This feature is currently only intended for retrieving very
3933         * superficial informations in a very fast way. Don't use it to retrieve
3934         * details like synthesis informations or even to modify .gig files!
3935         */
3936        void File::SetAutoLoad(bool b) {
3937            bAutoLoad = b;
3938        }
3939    
3940        /**
3941         * Returns whether automatic loading is enabled.
3942         * @see SetAutoLoad()
3943         */
3944        bool File::GetAutoLoad() {
3945            return bAutoLoad;
3946        }
3947    
3948    
3949    
3950  // *************** Exception ***************  // *************** Exception ***************
Legend:
Removed from v.1381  
changed lines
  Added in v.1713
  ViewVC Help
Powered by ViewVC