/[svn]/linuxsampler/trunk/src/engines/gig/InstrumentResourceManager.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/gig/InstrumentResourceManager.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1876 by schoenebeck, Fri Mar 27 12:16:12 2009 UTC revision 2012 by iliev, Fri Oct 23 17:53:17 2009 UTC
# Line 24  Line 24 
24  #include <sstream>  #include <sstream>
25    
26  #include "InstrumentResourceManager.h"  #include "InstrumentResourceManager.h"
27    #include "EngineChannel.h"
28    #include "Engine.h"
29    
30  #include "../../common/global_private.h"  #include "../../common/global_private.h"
31  #include "../../plugins/InstrumentEditorFactory.h"  #include "../../plugins/InstrumentEditorFactory.h"
# Line 92  namespace LinuxSampler { namespace gig { Line 94  namespace LinuxSampler { namespace gig {
94          return Entries();          return Entries();
95      }      }
96    
     InstrumentManager::mode_t InstrumentResourceManager::GetMode(const instrument_id_t& ID) {  
         return static_cast<InstrumentManager::mode_t>(AvailabilityMode(ID));  
     }  
   
     void InstrumentResourceManager::SetMode(const instrument_id_t& ID, InstrumentManager::mode_t Mode) {  
         dmsg(2,("gig::InstrumentResourceManager: setting mode for %s (Index=%d) to %d\n",ID.FileName.c_str(),ID.Index,Mode));  
         SetAvailabilityMode(ID, static_cast<ResourceManager<InstrumentManager::instrument_id_t, ::gig::Instrument>::mode_t>(Mode));  
     }  
   
97      String InstrumentResourceManager::GetInstrumentName(instrument_id_t ID) {      String InstrumentResourceManager::GetInstrumentName(instrument_id_t ID) {
98          Lock();          Lock();
99          ::gig::Instrument* pInstrument = Resource(ID, false);          ::gig::Instrument* pInstrument = Resource(ID, false);
# Line 271  namespace LinuxSampler { namespace gig { Line 264  namespace LinuxSampler { namespace gig {
264          }          }
265          // NOTE: for now connect the virtual MIDI keyboard of the instrument editor (if any) with all engine channels that have the same instrument as the editor was opened for ( other ideas ? )          // NOTE: for now connect the virtual MIDI keyboard of the instrument editor (if any) with all engine channels that have the same instrument as the editor was opened for ( other ideas ? )
266          Lock();          Lock();
267          std::set<gig::EngineChannel*> engineChannels =          std::set<EngineChannel*> engineChannels =
268              GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);              GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
269          std::set<gig::EngineChannel*>::iterator iter = engineChannels.begin();          std::set<EngineChannel*>::iterator iter = engineChannels.begin();
270          std::set<gig::EngineChannel*>::iterator end  = engineChannels.end();          std::set<EngineChannel*>::iterator end  = engineChannels.end();
271          for (; iter != end; ++iter) (*iter)->Connect(pVirtualMidiDevice);          for (; iter != end; ++iter) (static_cast<AbstractEngineChannel*>(*iter))->Connect(pVirtualMidiDevice);
272          Unlock();          Unlock();
273    
274          return pEditor;          return pEditor;
# Line 322  namespace LinuxSampler { namespace gig { Line 315  namespace LinuxSampler { namespace gig {
315          if (pVirtualMidiDevice) {          if (pVirtualMidiDevice) {
316              Lock();              Lock();
317              // NOTE: see note in LaunchInstrumentEditor()              // NOTE: see note in LaunchInstrumentEditor()
318              std::set<gig::EngineChannel*> engineChannels =              std::set<EngineChannel*> engineChannels =
319                  GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);                  GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
320              std::set<gig::EngineChannel*>::iterator iter = engineChannels.begin();              std::set<EngineChannel*>::iterator iter = engineChannels.begin();
321              std::set<gig::EngineChannel*>::iterator end  = engineChannels.end();              std::set<EngineChannel*>::iterator end  = engineChannels.end();
322              for (; iter != end; ++iter) (*iter)->Disconnect(pVirtualMidiDevice);              for (; iter != end; ++iter) (*iter)->Disconnect(pVirtualMidiDevice);
323              Unlock();              Unlock();
324          } else {          } else {
# Line 432  namespace LinuxSampler { namespace gig { Line 425  namespace LinuxSampler { namespace gig {
425              ::gig::Instrument* pInstrument =              ::gig::Instrument* pInstrument =
426                  (::gig::Instrument*) pRegion->GetParent();                  (::gig::Instrument*) pRegion->GetParent();
427              Lock();              Lock();
428              std::set<gig::Engine*> engines =              std::set<Engine*> engines =
429                  GetEnginesUsing(pInstrument, false/*don't lock again*/);                  GetEnginesUsing(pInstrument, false/*don't lock again*/);
430              std::set<gig::Engine*>::iterator iter = engines.begin();              std::set<Engine*>::iterator iter = engines.begin();
431              std::set<gig::Engine*>::iterator end  = engines.end();              std::set<Engine*>::iterator end  = engines.end();
432              for (; iter != end; ++iter) (*iter)->Suspend(pRegion);              for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
433              Unlock();              Unlock();
434          } else if (sStructType == "gig::DimensionRegion") {          } else if (sStructType == "gig::DimensionRegion") {
# Line 449  namespace LinuxSampler { namespace gig { Line 442  namespace LinuxSampler { namespace gig {
442              ::gig::Instrument* pInstrument =              ::gig::Instrument* pInstrument =
443                  (::gig::Instrument*) pRegion->GetParent();                  (::gig::Instrument*) pRegion->GetParent();
444              Lock();              Lock();
445              std::set<gig::Engine*> engines =              std::set<Engine*> engines =
446                  GetEnginesUsing(pInstrument, false/*don't lock again*/);                  GetEnginesUsing(pInstrument, false/*don't lock again*/);
447              std::set<gig::Engine*>::iterator iter = engines.begin();              std::set<Engine*>::iterator iter = engines.begin();
448              std::set<gig::Engine*>::iterator end  = engines.end();              std::set<Engine*>::iterator end  = engines.end();
449              for (; iter != end; ++iter) (*iter)->Suspend(pRegion);              for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
450              Unlock();              Unlock();
451          } else {          } else {
# Line 485  namespace LinuxSampler { namespace gig { Line 478  namespace LinuxSampler { namespace gig {
478                  GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);                  GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
479              for (int i = 0; i < instruments.size(); i++) {              for (int i = 0; i < instruments.size(); i++) {
480                  if (SampleReferencedByInstrument(pSample, instruments[i])) {                  if (SampleReferencedByInstrument(pSample, instruments[i])) {
481                      std::set<gig::EngineChannel*> engineChannels =                      std::set<EngineChannel*> engineChannels =
482                          GetEngineChannelsUsing(instruments[i], false/*don't lock again*/);                          GetEngineChannelsUsing(instruments[i], false/*don't lock again*/);
483                      std::set<gig::EngineChannel*>::iterator iter = engineChannels.begin();                      std::set<EngineChannel*>::iterator iter = engineChannels.begin();
484                      std::set<gig::EngineChannel*>::iterator end  = engineChannels.end();                      std::set<EngineChannel*>::iterator end  = engineChannels.end();
485                      for (; iter != end; ++iter)                      for (; iter != end; ++iter)
486                          CacheInitialSamples(pSample, *iter);                          CacheInitialSamples(pSample, *iter);
487                  }                  }
# Line 501  namespace LinuxSampler { namespace gig { Line 494  namespace LinuxSampler { namespace gig {
494              ::gig::Instrument* pInstrument =              ::gig::Instrument* pInstrument =
495                  (::gig::Instrument*) pRegion->GetParent();                  (::gig::Instrument*) pRegion->GetParent();
496              Lock();              Lock();
497              std::set<gig::Engine*> engines =              std::set<Engine*> engines =
498                  GetEnginesUsing(pInstrument, false/*don't lock again*/);                  GetEnginesUsing(pInstrument, false/*don't lock again*/);
499              std::set<gig::Engine*>::iterator iter = engines.begin();              std::set<Engine*>::iterator iter = engines.begin();
500              std::set<gig::Engine*>::iterator end  = engines.end();              std::set<Engine*>::iterator end  = engines.end();
501              for (; iter != end; ++iter) (*iter)->Resume(pRegion);              for (; iter != end; ++iter) (*iter)->Resume(pRegion);
502              Unlock();              Unlock();
503          } else if (sStructType == "gig::DimensionRegion") {          } else if (sStructType == "gig::DimensionRegion") {
# Line 516  namespace LinuxSampler { namespace gig { Line 509  namespace LinuxSampler { namespace gig {
509              ::gig::Instrument* pInstrument =              ::gig::Instrument* pInstrument =
510                  (::gig::Instrument*) pRegion->GetParent();                  (::gig::Instrument*) pRegion->GetParent();
511              Lock();              Lock();
512              std::set<gig::Engine*> engines =              std::set<Engine*> engines =
513                  GetEnginesUsing(pInstrument, false/*don't lock again*/);                  GetEnginesUsing(pInstrument, false/*don't lock again*/);
514              std::set<gig::Engine*>::iterator iter = engines.begin();              std::set<Engine*>::iterator iter = engines.begin();
515              std::set<gig::Engine*>::iterator end  = engines.end();              std::set<Engine*>::iterator end  = engines.end();
516              for (; iter != end; ++iter) (*iter)->Resume(pRegion);              for (; iter != end; ++iter) (*iter)->Resume(pRegion);
517              Unlock();              Unlock();
518          } else {          } else {
# Line 555  namespace LinuxSampler { namespace gig { Line 548  namespace LinuxSampler { namespace gig {
548              ::gig::Sample* pSample = (::gig::Sample*) pNewSample;              ::gig::Sample* pSample = (::gig::Sample*) pNewSample;
549              ::gig::File* pFile = (::gig::File*) pSample->GetParent();              ::gig::File* pFile = (::gig::File*) pSample->GetParent();
550              // get all engines that use that same gig::File              // get all engines that use that same gig::File
551              std::set<gig::Engine*> engines = GetEnginesUsing(pFile, false/*don't lock again*/);              std::set<Engine*> engines = GetEnginesUsing(pFile, false/*don't lock again*/);
552              std::set<gig::Engine*>::iterator iter = engines.begin();              std::set<Engine*>::iterator iter = engines.begin();
553              std::set<gig::Engine*>::iterator end  = engines.end();              std::set<Engine*>::iterator end  = engines.end();
554              for (; iter != end; ++iter)              for (; iter != end; ++iter)
555                  CacheInitialSamples(pSample, *iter);                  CacheInitialSamples(pSample, *iter);
556              Unlock();              Unlock();
# Line 598  namespace LinuxSampler { namespace gig { Line 591  namespace LinuxSampler { namespace gig {
591    
592              if (pRgn->GetSample() && !pRgn->GetSample()->GetCache().Size) {              if (pRgn->GetSample() && !pRgn->GetSample()->GetCache().Size) {
593                  dmsg(2,("C"));                  dmsg(2,("C"));
594                  CacheInitialSamples(pRgn->GetSample(), (gig::EngineChannel*) pConsumer);                  CacheInitialSamples(pRgn->GetSample(), (EngineChannel*) pConsumer);
595              }              }
596              for (uint i = 0; i < pRgn->DimensionRegions; i++) {              for (uint i = 0; i < pRgn->DimensionRegions; i++) {
597                  CacheInitialSamples(pRgn->pDimensionRegions[i]->pSample, (gig::EngineChannel*) pConsumer);                  CacheInitialSamples(pRgn->pDimensionRegions[i]->pSample, (EngineChannel*) pConsumer);
598              }              }
599    
600              pRgn = pInstrument->GetNextRegion();              pRgn = pInstrument->GetNextRegion();
# Line 616  namespace LinuxSampler { namespace gig { Line 609  namespace LinuxSampler { namespace gig {
609          pEntry->ID.Index      = Key.Index;          pEntry->ID.Index      = Key.Index;
610          pEntry->pGig          = pGig;          pEntry->pGig          = pGig;
611    
612          gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(pConsumer);          EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(pConsumer);
613          // and we save this to check if we need to reallocate for a engine with higher value of 'MaxSamplesPerSecond'          // and we save this to check if we need to reallocate for a engine with higher value of 'MaxSamplesPerSecond'
614          pEntry->MaxSamplesPerCycle =          pEntry->MaxSamplesPerCycle =
615              (!pEngineChannel) ? 0 /* don't care for instrument editors */ :              (!pEngineChannel) ? 0 /* don't care for instrument editors */ :
616                  (pEngineChannel->GetEngine()) ?                  (pEngineChannel->GetEngine()) ?
617                      dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()                      dynamic_cast<Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()
618                      : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;                      : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;
619          pArg = pEntry;          pArg = pEntry;
620    
# Line 637  namespace LinuxSampler { namespace gig { Line 630  namespace LinuxSampler { namespace gig {
630    
631      void InstrumentResourceManager::OnBorrow(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, void*& pArg) {      void InstrumentResourceManager::OnBorrow(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, void*& pArg) {
632          instr_entry_t* pEntry = (instr_entry_t*) pArg;          instr_entry_t* pEntry = (instr_entry_t*) pArg;
633          gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(pConsumer);          EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(pConsumer);
634          uint maxSamplesPerCycle =          uint maxSamplesPerCycle =
635              (pEngineChannel && pEngineChannel->GetEngine()) ? dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()              (pEngineChannel && pEngineChannel->GetEngine()) ? dynamic_cast<Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()
636                                            : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;                                            : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;
637          if (pEntry->MaxSamplesPerCycle < maxSamplesPerCycle) {          if (pEntry->MaxSamplesPerCycle < maxSamplesPerCycle) {
638              Update(pResource, pConsumer);              Update(pResource, pConsumer);
639          }          }
640      }      }
641    
642      /**      void InstrumentResourceManager::DeleteRegionIfNotUsed(::gig::DimensionRegion* pRegion, region_info_t* pRegInfo) {
643       * Give back an instrument. This should be used instead of          // TODO: we could delete Region and Instrument here if they have become unused
      * HandBack if there are some dimension regions that are still in  
      * use. (When an instrument is changed, the voices currently  
      * playing are allowed to keep playing with the old instrument  
      * until note off arrives. New notes will use the new instrument.)  
      */  
     void InstrumentResourceManager::HandBackInstrument(::gig::Instrument* pResource, InstrumentConsumer* pConsumer,  
                                                        RTList< ::gig::DimensionRegion*>* pDimRegionsInUse) {  
         DimRegInfoMutex.Lock();  
         for (RTList< ::gig::DimensionRegion*>::Iterator i = pDimRegionsInUse->first() ; i != pDimRegionsInUse->end() ; i++) {  
             DimRegInfo[*i].refCount++;  
             SampleRefCount[(*i)->pSample]++;  
         }  
         HandBack(pResource, pConsumer, true);  
         DimRegInfoMutex.Unlock();  
644      }      }
645        void InstrumentResourceManager::DeleteSampleIfNotUsed(::gig::Sample* pSample, region_info_t* pRegInfo) {
646      /**          ::gig::File* gig = pRegInfo->file;
647       * Give back a dimension region that belongs to an instrument that          ::RIFF::File* riff = static_cast< ::RIFF::File*>(pRegInfo->pArg);
648       * was previously handed back.          if (gig) {
649       */              gig->DeleteSample(pSample);
650      void InstrumentResourceManager::HandBackDimReg(::gig::DimensionRegion* pDimReg) {              if (!gig->GetFirstSample()) {
651          DimRegInfoMutex.Lock();                  dmsg(2,("No more samples in use - freeing gig\n"));
652          dimreg_info_t& dimRegInfo = DimRegInfo[pDimReg];                  delete gig;
653          int dimRegRefCount = --dimRegInfo.refCount;                  delete riff;
         int sampleRefCount = --SampleRefCount[pDimReg->pSample];  
         if (dimRegRefCount == 0) {  
             ::gig::File* gig = dimRegInfo.file;  
             ::RIFF::File* riff = dimRegInfo.riff;  
             DimRegInfo.erase(pDimReg);  
             // TODO: we could delete Region and Instrument here if  
             // they have become unused  
   
             if (sampleRefCount == 0) {  
                 SampleRefCount.erase(pDimReg->pSample);  
   
                 if (gig) {  
                     gig->DeleteSample(pDimReg->pSample);  
                     if (!gig->GetFirstSample()) {  
                         dmsg(2,("No more samples in use - freeing gig\n"));  
                         delete gig;  
                         delete riff;  
                     }  
                 }  
654              }              }
655          }          }
         DimRegInfoMutex.Unlock();  
656      }      }
657    
658      /**      /**
# Line 704  namespace LinuxSampler { namespace gig { Line 663  namespace LinuxSampler { namespace gig {
663       *                   (may be NULL, in this case default amount of samples       *                   (may be NULL, in this case default amount of samples
664       *                   will be cached)       *                   will be cached)
665       */       */
666      void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, gig::EngineChannel* pEngineChannel) {      void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, EngineChannel* pEngineChannel) {
667          gig::Engine* pEngine =          Engine* pEngine =
668              (pEngineChannel && pEngineChannel->GetEngine()) ?              (pEngineChannel && pEngineChannel->GetEngine()) ?
669                  dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine()) : NULL;                  dynamic_cast<Engine*>(pEngineChannel->GetEngine()) : NULL;
670          CacheInitialSamples(pSample, pEngine);          CacheInitialSamples(pSample, pEngine);
671      }      }
672    
# Line 722  namespace LinuxSampler { namespace gig { Line 681  namespace LinuxSampler { namespace gig {
681       *                   (may be NULL, in this case default amount of samples       *                   (may be NULL, in this case default amount of samples
682       *                   will be cached)       *                   will be cached)
683       */       */
684      void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, gig::Engine* pEngine) {      void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, AbstractEngine* pEngine) {
685          if (!pSample) {          if (!pSample) {
686              dmsg(4,("gig::InstrumentResourceManager: Skipping sample (pSample == NULL)\n"));              dmsg(4,("gig::InstrumentResourceManager: Skipping sample (pSample == NULL)\n"));
687              return;              return;
# Line 787  namespace LinuxSampler { namespace gig { Line 746  namespace LinuxSampler { namespace gig {
746       * @param bLock - whether we should lock (mutex) the instrument manager       * @param bLock - whether we should lock (mutex) the instrument manager
747       *                during this call and unlock at the end of this call       *                during this call and unlock at the end of this call
748       */       */
749      std::set<gig::EngineChannel*> InstrumentResourceManager::GetEngineChannelsUsing(::gig::Instrument* pInstrument, bool bLock) {      std::set<EngineChannel*> InstrumentResourceManager::GetEngineChannelsUsing(::gig::Instrument* pInstrument, bool bLock) {
750          if (bLock) Lock();          if (bLock) Lock();
751          std::set<gig::EngineChannel*> result;          std::set<EngineChannel*> result;
752          std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);          std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);
753          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
754          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();
755          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
756              gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(*iter);              EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
757              if (!pEngineChannel) continue;              if (!pEngineChannel) continue;
758              result.insert(pEngineChannel);              result.insert(pEngineChannel);
759          }          }
# Line 810  namespace LinuxSampler { namespace gig { Line 769  namespace LinuxSampler { namespace gig {
769       * @param bLock - whether we should lock (mutex) the instrument manager       * @param bLock - whether we should lock (mutex) the instrument manager
770       *                during this call and unlock at the end of this call       *                during this call and unlock at the end of this call
771       */       */
772      std::set<gig::Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::Instrument* pInstrument, bool bLock) {      std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::Instrument* pInstrument, bool bLock) {
773          if (bLock) Lock();          if (bLock) Lock();
774          std::set<gig::Engine*> result;          std::set<Engine*> result;
775          std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);          std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);
776          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
777          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();          std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();
778          for (; iter != end; ++iter) {          for (; iter != end; ++iter) {
779              gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(*iter);              EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
780              if (!pEngineChannel) continue;              if (!pEngineChannel) continue;
781              gig::Engine* pEngine = dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine());              Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
782              if (!pEngine) continue;              if (!pEngine) continue;
783              result.insert(pEngine);              result.insert(pEngine);
784          }          }
# Line 835  namespace LinuxSampler { namespace gig { Line 794  namespace LinuxSampler { namespace gig {
794       * @param bLock - whether we should lock (mutex) the instrument manager       * @param bLock - whether we should lock (mutex) the instrument manager
795       *                during this call and unlock at the end of this call       *                during this call and unlock at the end of this call
796       */       */
797      std::set<gig::Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::File* pFile, bool bLock) {      std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::File* pFile, bool bLock) {
798          if (bLock) Lock();          if (bLock) Lock();
799          // get all instruments (currently in usage) that use that same gig::File          // get all instruments (currently in usage) that use that same gig::File
800          std::vector< ::gig::Instrument*> instrumentsOfInterest =          std::vector< ::gig::Instrument*> instrumentsOfInterest =
801              GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);              GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
802    
803          // get all engines that use that same gig::File          // get all engines that use that same gig::File
804          std::set<gig::Engine*> result;          std::set<Engine*> result;
805          {          {
806              for (int i = 0; i < instrumentsOfInterest.size(); i++) {              for (int i = 0; i < instrumentsOfInterest.size(); i++) {
807                  std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(instrumentsOfInterest[i]);                  std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(instrumentsOfInterest[i]);
808                  std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();                  std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
809                  std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();                  std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end  = consumers.end();
810                  for (; iter != end; ++iter) {                  for (; iter != end; ++iter) {
811                      gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(*iter);                      EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
812                      if (!pEngineChannel) continue;                      if (!pEngineChannel) continue;
813                      gig::Engine* pEngine = dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine());                      Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
814                      if (!pEngine) continue;                      if (!pEngine) continue;
815                      // the unique, sorted container std::set makes                      // the unique, sorted container std::set makes
816                      // sure we won't have duplicates                      // sure we won't have duplicates
# Line 905  namespace LinuxSampler { namespace gig { Line 864  namespace LinuxSampler { namespace gig {
864          // get all engines that use that same gig::Instrument          // get all engines that use that same gig::Instrument
865          suspendedEngines = GetEnginesUsing(pInstrument, true/*lock*/);          suspendedEngines = GetEnginesUsing(pInstrument, true/*lock*/);
866          // finally, completely suspend all engines that use that same gig::Instrument          // finally, completely suspend all engines that use that same gig::Instrument
867          std::set<gig::Engine*>::iterator iter = suspendedEngines.begin();          std::set<Engine*>::iterator iter = suspendedEngines.begin();
868          std::set<gig::Engine*>::iterator end  = suspendedEngines.end();          std::set<Engine*>::iterator end  = suspendedEngines.end();
869          for (; iter != end; ++iter) (*iter)->SuspendAll();          for (; iter != end; ++iter) (*iter)->SuspendAll();
870      }      }
871    
# Line 929  namespace LinuxSampler { namespace gig { Line 888  namespace LinuxSampler { namespace gig {
888          // get all engines that use that same gig::File          // get all engines that use that same gig::File
889          suspendedEngines = GetEnginesUsing(pFile, true/*lock*/);          suspendedEngines = GetEnginesUsing(pFile, true/*lock*/);
890          // finally, completely suspend all engines that use that same gig::File          // finally, completely suspend all engines that use that same gig::File
891          std::set<gig::Engine*>::iterator iter = suspendedEngines.begin();          std::set<Engine*>::iterator iter = suspendedEngines.begin();
892          std::set<gig::Engine*>::iterator end  = suspendedEngines.end();          std::set<Engine*>::iterator end  = suspendedEngines.end();
893          for (; iter != end; ++iter) (*iter)->SuspendAll();          for (; iter != end; ++iter) (*iter)->SuspendAll();
894      }      }
895    
# Line 986  namespace LinuxSampler { namespace gig { Line 945  namespace LinuxSampler { namespace gig {
945                  for (int i = 0 ; i < region->DimensionRegions ; i++)                  for (int i = 0 ; i < region->DimensionRegions ; i++)
946                  {                  {
947                      ::gig::DimensionRegion *d = region->pDimensionRegions[i];                      ::gig::DimensionRegion *d = region->pDimensionRegions[i];
948                      std::map< ::gig::DimensionRegion*, dimreg_info_t>::iterator iter = parent->DimRegInfo.find(d);                      std::map< ::gig::DimensionRegion*, region_info_t>::iterator iter = parent->RegionInfo.find(d);
949                      if (iter != parent->DimRegInfo.end()) {                      if (iter != parent->RegionInfo.end()) {
950                          dimreg_info_t& dimRegInfo = (*iter).second;                          region_info_t& dimRegInfo = (*iter).second;
951                          dimRegInfo.file = pResource;                          dimRegInfo.file = pResource;
952                          dimRegInfo.riff = (::RIFF::File*)pArg;                          dimRegInfo.pArg = (::RIFF::File*)pArg;
953                          deleteFile = deleteInstrument = deleteRegion = false;                          deleteFile = deleteInstrument = deleteRegion = false;
954                      }                      }
955                  }                  }
Legend:
Removed from v.1876  
changed lines
  Added in v.2012
  ViewVC Help
Powered by ViewVC