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

Contents of /linuxsampler/trunk/src/engines/gig/InstrumentResourceManager.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1375 - (show annotations) (download) (as text)
Wed Oct 3 18:41:09 2007 UTC (16 years, 5 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 8200 byte(s)
* code refactoring, moved the following files from
  src/engines/ -> src/plugins/ :

  InstrumentEditor.h ,
  InstrumentEditor.cpp ,
  InstrumentEditorFactory.h ,
  InstrumentEditorFactory.cpp

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2007 Christian Schoenebeck *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LS_GIG_INSTRUMENTRESOURCEMANAGER_H__
25 #define __LS_GIG_INSTRUMENTRESOURCEMANAGER_H__
26
27 #include "../../common/global.h"
28
29 #include <gig.h>
30
31 #include "../../common/global.h"
32 #include "../../common/ResourceManager.h"
33 #include "../../drivers/audio/AudioOutputDevice.h"
34 #include "../InstrumentManager.h"
35
36 //namespace libgig = gig;
37
38 namespace LinuxSampler { namespace gig {
39
40 typedef ResourceConsumer< ::gig::Instrument> InstrumentConsumer;
41
42 }} // namespace LinuxSampler::gig
43
44 #include "EngineChannel.h"
45 #include "Engine.h"
46 #include "../../plugins/InstrumentEditor.h"
47
48 namespace LinuxSampler { namespace gig {
49
50 // just symbol prototyping
51 class EngineChannel;
52 class Engine;
53
54 /** @brief Gig instrument manager
55 *
56 * Manager to share gig instruments between multiple Gigasampler
57 * engine channels. The engine channels Borrow() instruments when they
58 * need them and HandBack() when they don't need them anymore. The
59 * InstrumentResourceManager loads the corresponding gig file and gig
60 * instrument if needed, if it's already in use by another engine
61 * channel, then it just returns the same resource, if an gig
62 * instrument / file is not needed anymore, then it will be freed from
63 * memory.
64 */
65 class InstrumentResourceManager : public InstrumentManager, public ResourceManager<InstrumentManager::instrument_id_t, ::gig::Instrument>, public InstrumentEditorListener {
66 public:
67 InstrumentResourceManager() : Gigs(this) {}
68 virtual ~InstrumentResourceManager() {}
69 static void OnInstrumentLoadingProgress(::gig::progress_t* pProgress);
70
71 // implementation of derived abstract methods from 'InstrumentManager'
72 virtual std::vector<instrument_id_t> Instruments();
73 virtual InstrumentManager::mode_t GetMode(const instrument_id_t& ID);
74 virtual void SetMode(const instrument_id_t& ID, InstrumentManager::mode_t Mode);
75 virtual String GetInstrumentName(instrument_id_t ID);
76 virtual String GetInstrumentDataStructureName(instrument_id_t ID);
77 virtual String GetInstrumentDataStructureVersion(instrument_id_t ID);
78 virtual void LaunchInstrumentEditor(instrument_id_t ID) throw (InstrumentManagerException);
79
80 // implementation of derived abstract methods from 'InstrumentEditorListener'
81 virtual void OnInstrumentEditorQuit(InstrumentEditor* pSender);
82 virtual void OnSamplesToBeRemoved(std::set<void*> Samples, InstrumentEditor* pSender);
83 virtual void OnSamplesRemoved(InstrumentEditor* pSender);
84 virtual void OnDataStructureToBeChanged(void* pStruct, String sStructType, InstrumentEditor* pSender);
85 virtual void OnDataStructureChanged(void* pStruct, String sStructType, InstrumentEditor* pSender);
86 virtual void OnSampleReferenceChanged(void* pOldSample, void* pNewSample, InstrumentEditor* pSender);
87
88 void HandBackInstrument(::gig::Instrument* pResource, InstrumentConsumer* pConsumer,
89 ::gig::DimensionRegion** dimRegionsInUse);
90 void HandBackDimReg(::gig::DimensionRegion* pDimReg);
91
92 protected:
93 // implementation of derived abstract methods from 'ResourceManager'
94 virtual ::gig::Instrument* Create(instrument_id_t Key, InstrumentConsumer* pConsumer, void*& pArg);
95 virtual void Destroy(::gig::Instrument* pResource, void* pArg);
96 virtual void OnBorrow(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, void*& pArg);
97 private:
98 typedef ResourceConsumer< ::gig::File> GigConsumer;
99
100 class GigResourceManager : public ResourceManager<String, ::gig::File> {
101 protected:
102 // implementation of derived abstract methods from 'ResourceManager'
103 virtual ::gig::File* Create(String Key, GigConsumer* pConsumer, void*& pArg);
104 virtual void Destroy(::gig::File* pResource, void* pArg);
105 virtual void OnBorrow(::gig::File* pResource, GigConsumer* pConsumer, void*& pArg) {} // ignore
106 public:
107 GigResourceManager(InstrumentResourceManager* parent) : parent(parent) {}
108 virtual ~GigResourceManager() {}
109 private:
110 InstrumentResourceManager* parent;
111 } Gigs;
112
113 void CacheInitialSamples(::gig::Sample* pSample, gig::EngineChannel* pEngineChannel);
114 void CacheInitialSamples(::gig::Sample* pSample, gig::Engine* pEngine);
115 void UncacheInitialSamples(::gig::Sample* pSample);
116 std::vector< ::gig::Instrument*> GetInstrumentsCurrentlyUsedOf(::gig::File* pFile, bool bLock);
117 std::set<gig::Engine*> GetEnginesUsing(::gig::Instrument* pFile, bool bLock);
118 std::set<gig::Engine*> GetEnginesUsing(::gig::File* pFile, bool bLock);
119 bool SampleReferencedByInstrument(::gig::Sample* pSample, ::gig::Instrument* pInstrument);
120 void SuspendEnginesUsing(::gig::Instrument* pInstrument);
121 void SuspendEnginesUsing(::gig::File* pFile);
122 void ResumeAllEngines();
123
124 struct dimreg_info_t {
125 int refCount;
126 ::gig::File* file;
127 ::RIFF::File* riff;
128 };
129 Mutex DimRegInfoMutex; ///< protects the DimRegInfo and SampleRefCount maps from concurrent access by the instrument loader and disk threads
130 std::map< ::gig::DimensionRegion*, dimreg_info_t> DimRegInfo; ///< contains dimension regions that are still in use but belong to released instrument
131 std::map< ::gig::Sample*, int> SampleRefCount; ///< contains samples that are still in use but belong to a released instrument
132
133 Mutex InstrumentEditorProxiesMutex; ///< protects the 'InstrumentEditorProxies' map
134 std::map<InstrumentEditor*, InstrumentConsumer*> InstrumentEditorProxies; ///< here we store the objects that react on instrument specific notifications on behalf of the respective instrument editor
135 std::set<Engine*> suspendedEngines; ///< all engines currently completely suspended
136 Mutex suspendedEnginesMutex; ///< protects 'suspendedEngines' set
137 };
138
139 }} // namespace LinuxSampler::gig
140
141 #endif // __LS_GIG_INSTRUMENTRESOURCEMANAGER_H__

  ViewVC Help
Powered by ViewVC