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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1455 - (show annotations) (download)
Sun Oct 21 11:59:59 2007 UTC (13 years, 3 months ago) by persson
File size: 36782 byte(s)
* bugfix: the thread used by an editor plugin didn't die when the
  editor closed

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 #include <sstream>
25
26 #include "InstrumentResourceManager.h"
27
28 #include "../../common/global_private.h"
29 #include "../../plugins/InstrumentEditorFactory.h"
30
31 // We need to know the maximum number of sample points which are going to
32 // be processed for each render cycle of the audio output driver, to know
33 // how much initial sample points we need to cache into RAM. If the given
34 // sampler channel does not have an audio output device assigned yet
35 // though, we simply use this default value.
36 #define GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE 128
37
38 namespace LinuxSampler { namespace gig {
39
40 // data stored as long as an instrument resource exists
41 struct instr_entry_t {
42 InstrumentManager::instrument_id_t ID;
43 ::gig::File* pGig;
44 uint MaxSamplesPerCycle; ///< if some engine requests an already allocated instrument with a higher value, we have to reallocate the instrument
45 };
46
47 // some data needed for the libgig callback function
48 struct progress_callback_arg_t {
49 InstrumentResourceManager* pManager;
50 InstrumentManager::instrument_id_t* pInstrumentKey;
51 };
52
53 // we use this to react on events concerning an instrument on behalf of an instrument editor
54 class InstrumentEditorProxy : public InstrumentConsumer {
55 public:
56 virtual void ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg) {
57 //TODO: inform the instrument editor about the pending update
58 }
59
60 virtual void ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg) {
61 //TODO:: inform the instrument editor about finished update
62 }
63
64 virtual void OnResourceProgress(float fProgress) {
65 //TODO: inform the instrument editor about the progress of an update
66 }
67
68 // the instrument we borrowed on behalf of the editor
69 ::gig::Instrument* pInstrument;
70 };
71
72 /**
73 * Callback function which will be called by libgig during loading of
74 * instruments to inform about the current progress. Or to be more
75 * specific; it will be called during the GetInstrument() call.
76 *
77 * @param pProgress - contains current progress value, pointer to the
78 * InstrumentResourceManager instance and
79 * instrument ID
80 */
81 void InstrumentResourceManager::OnInstrumentLoadingProgress(::gig::progress_t* pProgress) {
82 dmsg(7,("gig::InstrumentResourceManager: progress %f%", pProgress->factor));
83 progress_callback_arg_t* pArg = static_cast<progress_callback_arg_t*>(pProgress->custom);
84 // we randomly schedule 90% for the .gig file loading and the remaining 10% later for sample caching
85 const float localProgress = 0.9f * pProgress->factor;
86 pArg->pManager->DispatchResourceProgressEvent(*pArg->pInstrumentKey, localProgress);
87 }
88
89 std::vector<InstrumentResourceManager::instrument_id_t> InstrumentResourceManager::Instruments() {
90 return Entries();
91 }
92
93 InstrumentManager::mode_t InstrumentResourceManager::GetMode(const instrument_id_t& ID) {
94 return static_cast<InstrumentManager::mode_t>(AvailabilityMode(ID));
95 }
96
97 void InstrumentResourceManager::SetMode(const instrument_id_t& ID, InstrumentManager::mode_t Mode) {
98 dmsg(2,("gig::InstrumentResourceManager: setting mode for %s (Index=%d) to %d\n",ID.FileName.c_str(),ID.Index,Mode));
99 SetAvailabilityMode(ID, static_cast<ResourceManager<InstrumentManager::instrument_id_t, ::gig::Instrument>::mode_t>(Mode));
100 }
101
102 String InstrumentResourceManager::GetInstrumentName(instrument_id_t ID) {
103 Lock();
104 ::gig::Instrument* pInstrument = Resource(ID, false);
105 String res = (pInstrument) ? pInstrument->pInfo->Name : "";
106 Unlock();
107 return res;
108 }
109
110 String InstrumentResourceManager::GetInstrumentDataStructureName(instrument_id_t ID) {
111 return ::gig::libraryName();
112 }
113
114 String InstrumentResourceManager::GetInstrumentDataStructureVersion(instrument_id_t ID) {
115 return ::gig::libraryVersion();
116 }
117
118 void InstrumentResourceManager::LaunchInstrumentEditor(instrument_id_t ID) throw (InstrumentManagerException) {
119 const String sDataType = GetInstrumentDataStructureName(ID);
120 const String sDataVersion = GetInstrumentDataStructureVersion(ID);
121 // find instrument editors capable to handle given instrument
122 std::vector<String> vEditors =
123 InstrumentEditorFactory::MatchingEditors(sDataType, sDataVersion);
124 if (!vEditors.size())
125 throw InstrumentManagerException(
126 "There is no instrument editor capable to handle this instrument"
127 );
128 // simply use the first editor in the result set
129 dmsg(1,("Found matching editor '%s' for instrument ('%s', %d) having data structure ('%s','%s')\n",
130 vEditors[0].c_str(), ID.FileName.c_str(), ID.Index, sDataType.c_str(), sDataVersion.c_str()));
131 InstrumentEditor* pEditor = InstrumentEditorFactory::Create(vEditors[0]);
132 // register for receiving notifications from the instrument editor
133 pEditor->AddListener(this);
134 // create a proxy that reacts on notification on behalf of the editor
135 InstrumentEditorProxy* pProxy = new InstrumentEditorProxy;
136 // borrow the instrument on behalf of the instrument editor
137 ::gig::Instrument* pInstrument = Borrow(ID, pProxy);
138 // remember the proxy and instrument for this instrument editor
139 pProxy->pInstrument = pInstrument;
140 InstrumentEditorProxiesMutex.Lock();
141 InstrumentEditorProxies[pEditor] = pProxy;
142 InstrumentEditorProxiesMutex.Unlock();
143 // launch the instrument editor for the given instrument
144 pEditor->Launch(pInstrument, sDataType, sDataVersion);
145 }
146
147 /**
148 * Will be called by the respective instrument editor once it left its
149 * Main() loop. That way we can handle cleanup before its thread finally
150 * dies.
151 *
152 * @param pSender - instrument editor that stops execution
153 */
154 void InstrumentResourceManager::OnInstrumentEditorQuit(InstrumentEditor* pSender) {
155 dmsg(1,("InstrumentResourceManager: instrument editor quit, doing cleanup\n"));
156 // hand back instrument and free proxy
157 InstrumentEditorProxiesMutex.Lock();
158 if (InstrumentEditorProxies.count(pSender)) {
159 InstrumentEditorProxy* pProxy =
160 dynamic_cast<InstrumentEditorProxy*>(
161 InstrumentEditorProxies[pSender]
162 );
163 InstrumentEditorProxies.erase(pSender);
164 InstrumentEditorProxiesMutex.Unlock();
165 HandBack(pProxy->pInstrument, pProxy);
166 if (pProxy) delete pProxy;
167 } else {
168 InstrumentEditorProxiesMutex.Unlock();
169 std::cerr << "Eeeek, could not find instrument editor proxy, this is a bug!\n" << std::flush;
170 }
171
172 // Note that we don't need to free the editor here. As it
173 // derives from Thread, it will delete itself when the thread
174 // dies.
175 }
176
177 void InstrumentResourceManager::OnSamplesToBeRemoved(std::set<void*> Samples, InstrumentEditor* pSender) {
178 if (Samples.empty()) {
179 std::cerr << "gig::InstrumentResourceManager: WARNING, "
180 "OnSamplesToBeRemoved() called with empty list, this "
181 "is a bug!\n" << std::flush;
182 return;
183 }
184 // TODO: ATM we assume here that all samples are from the same file
185 ::gig::Sample* pFirstSample = (::gig::Sample*) *Samples.begin();
186 ::gig::File* pCriticalFile = dynamic_cast< ::gig::File*>(pFirstSample->GetParent());
187 // completely suspend all engines that use that same file
188 SuspendEnginesUsing(pCriticalFile);
189 }
190
191 void InstrumentResourceManager::OnSamplesRemoved(InstrumentEditor* pSender) {
192 // resume all previously, completely suspended engines
193 // (we don't have to un-cache the removed samples here, since that is
194 // automatically done by the gig::Sample destructor)
195 ResumeAllEngines();
196 }
197
198 void InstrumentResourceManager::OnDataStructureToBeChanged(void* pStruct, String sStructType, InstrumentEditor* pSender) {
199 //TODO: remove code duplication
200 if (sStructType == "gig::File") {
201 // completely suspend all engines that use that file
202 ::gig::File* pFile = (::gig::File*) pStruct;
203 SuspendEnginesUsing(pFile);
204 } else if (sStructType == "gig::Instrument") {
205 // completely suspend all engines that use that instrument
206 ::gig::Instrument* pInstrument = (::gig::Instrument*) pStruct;
207 SuspendEnginesUsing(pInstrument);
208 } else if (sStructType == "gig::Region") {
209 // only advice the engines to suspend the given region, so they'll
210 // only ignore that region (and probably already other suspended
211 // ones), but beside that continue normal playback
212 ::gig::Region* pRegion = (::gig::Region*) pStruct;
213 ::gig::Instrument* pInstrument =
214 (::gig::Instrument*) pRegion->GetParent();
215 Lock();
216 std::set<gig::Engine*> engines =
217 GetEnginesUsing(pInstrument, false/*don't lock again*/);
218 std::set<gig::Engine*>::iterator iter = engines.begin();
219 std::set<gig::Engine*>::iterator end = engines.end();
220 for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
221 Unlock();
222 } else if (sStructType == "gig::DimensionRegion") {
223 // only advice the engines to suspend the given DimensionRegions's
224 // parent region, so they'll only ignore that region (and probably
225 // already other suspended ones), but beside that continue normal
226 // playback
227 ::gig::DimensionRegion* pDimReg =
228 (::gig::DimensionRegion*) pStruct;
229 ::gig::Region* pRegion = pDimReg->GetParent();
230 ::gig::Instrument* pInstrument =
231 (::gig::Instrument*) pRegion->GetParent();
232 Lock();
233 std::set<gig::Engine*> engines =
234 GetEnginesUsing(pInstrument, false/*don't lock again*/);
235 std::set<gig::Engine*>::iterator iter = engines.begin();
236 std::set<gig::Engine*>::iterator end = engines.end();
237 for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
238 Unlock();
239 } else {
240 std::cerr << "gig::InstrumentResourceManager: ERROR, unknown data "
241 "structure '" << sStructType << "' requested to be "
242 "suspended by instrument editor. This is a bug!\n"
243 << std::flush;
244 //TODO: we should inform the instrument editor that something seriously went wrong
245 }
246 }
247
248 void InstrumentResourceManager::OnDataStructureChanged(void* pStruct, String sStructType, InstrumentEditor* pSender) {
249 //TODO: remove code duplication
250 if (sStructType == "gig::File") {
251 // resume all previously suspended engines
252 ResumeAllEngines();
253 } else if (sStructType == "gig::Instrument") {
254 // resume all previously suspended engines
255 ResumeAllEngines();
256 } else if (sStructType == "gig::Region") {
257 // advice the engines to resume the given region, that is to
258 // using it for playback again
259 ::gig::Region* pRegion = (::gig::Region*) pStruct;
260 ::gig::Instrument* pInstrument =
261 (::gig::Instrument*) pRegion->GetParent();
262 Lock();
263 std::set<gig::Engine*> engines =
264 GetEnginesUsing(pInstrument, false/*don't lock again*/);
265 std::set<gig::Engine*>::iterator iter = engines.begin();
266 std::set<gig::Engine*>::iterator end = engines.end();
267 for (; iter != end; ++iter) (*iter)->Resume(pRegion);
268 Unlock();
269 } else if (sStructType == "gig::DimensionRegion") {
270 // advice the engines to resume the given DimensionRegion's parent
271 // region, that is to using it for playback again
272 ::gig::DimensionRegion* pDimReg =
273 (::gig::DimensionRegion*) pStruct;
274 ::gig::Region* pRegion = pDimReg->GetParent();
275 ::gig::Instrument* pInstrument =
276 (::gig::Instrument*) pRegion->GetParent();
277 Lock();
278 std::set<gig::Engine*> engines =
279 GetEnginesUsing(pInstrument, false/*don't lock again*/);
280 std::set<gig::Engine*>::iterator iter = engines.begin();
281 std::set<gig::Engine*>::iterator end = engines.end();
282 for (; iter != end; ++iter) (*iter)->Resume(pRegion);
283 Unlock();
284 } else {
285 std::cerr << "gig::InstrumentResourceManager: ERROR, unknown data "
286 "structure '" << sStructType << "' requested to be "
287 "resumed by instrument editor. This is a bug!\n"
288 << std::flush;
289 //TODO: we should inform the instrument editor that something seriously went wrong
290 }
291 }
292
293 void InstrumentResourceManager::OnSampleReferenceChanged(void* pOldSample, void* pNewSample, InstrumentEditor* pSender) {
294 // uncache old sample in case it's not used by anybody anymore
295 if (pOldSample) {
296 Lock();
297 ::gig::Sample* pSample = (::gig::Sample*) pOldSample;
298 ::gig::File* pFile = (::gig::File*) pSample->GetParent();
299 std::vector< ::gig::Instrument*> instruments =
300 GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
301 for (int i = 0; i < instruments.size(); i++)
302 if (!SampleReferencedByInstrument(pSample, instruments[i]))
303 UncacheInitialSamples(pSample);
304 Unlock();
305 }
306 // make sure new sample reference is cached
307 if (pNewSample) {
308 Lock();
309 ::gig::Sample* pSample = (::gig::Sample*) pNewSample;
310 ::gig::File* pFile = (::gig::File*) pSample->GetParent();
311 // get all engines that use that same gig::File
312 std::set<gig::Engine*> engines = GetEnginesUsing(pFile, false/*don't lock again*/);
313 std::set<gig::Engine*>::iterator iter = engines.begin();
314 std::set<gig::Engine*>::iterator end = engines.end();
315 for (; iter != end; ++iter)
316 CacheInitialSamples(pSample, *iter);
317 Unlock();
318 }
319 }
320
321 ::gig::Instrument* InstrumentResourceManager::Create(instrument_id_t Key, InstrumentConsumer* pConsumer, void*& pArg) {
322 // get gig file from internal gig file manager
323 ::gig::File* pGig = Gigs.Borrow(Key.FileName, (GigConsumer*) Key.Index); // conversion kinda hackish :/
324
325 // we pass this to the progress callback mechanism of libgig
326 progress_callback_arg_t callbackArg;
327 callbackArg.pManager = this;
328 callbackArg.pInstrumentKey = &Key;
329
330 ::gig::progress_t progress;
331 progress.callback = OnInstrumentLoadingProgress;
332 progress.custom = &callbackArg;
333
334 dmsg(1,("Loading gig instrument ('%s',%d)...",Key.FileName.c_str(),Key.Index));
335 ::gig::Instrument* pInstrument = pGig->GetInstrument(Key.Index, &progress);
336 if (!pInstrument) {
337 std::stringstream msg;
338 msg << "There's no instrument with index " << Key.Index << ".";
339 throw InstrumentManagerException(msg.str());
340 }
341 pGig->GetFirstSample(); // just to force complete instrument loading
342 dmsg(1,("OK\n"));
343
344 // cache initial samples points (for actually needed samples)
345 dmsg(1,("Caching initial samples..."));
346 uint iRegion = 0; // just for progress calculation
347 ::gig::Region* pRgn = pInstrument->GetFirstRegion();
348 while (pRgn) {
349 // we randomly schedule 90% for the .gig file loading and the remaining 10% now for sample caching
350 const float localProgress = 0.9f + 0.1f * (float) iRegion / (float) pInstrument->Regions;
351 DispatchResourceProgressEvent(Key, localProgress);
352
353 if (pRgn->GetSample() && !pRgn->GetSample()->GetCache().Size) {
354 dmsg(2,("C"));
355 CacheInitialSamples(pRgn->GetSample(), (gig::EngineChannel*) pConsumer);
356 }
357 for (uint i = 0; i < pRgn->DimensionRegions; i++) {
358 CacheInitialSamples(pRgn->pDimensionRegions[i]->pSample, (gig::EngineChannel*) pConsumer);
359 }
360
361 pRgn = pInstrument->GetNextRegion();
362 iRegion++;
363 }
364 dmsg(1,("OK\n"));
365 DispatchResourceProgressEvent(Key, 1.0f); // done; notify all consumers about progress 100%
366
367 // we need the following for destruction later
368 instr_entry_t* pEntry = new instr_entry_t;
369 pEntry->ID.FileName = Key.FileName;
370 pEntry->ID.Index = Key.Index;
371 pEntry->pGig = pGig;
372
373 gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(pConsumer);
374 // and we save this to check if we need to reallocate for a engine with higher value of 'MaxSamplesPerSecond'
375 pEntry->MaxSamplesPerCycle =
376 (!pEngineChannel) ? 0 /* don't care for instrument editors */ :
377 (pEngineChannel->GetEngine()) ?
378 dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()
379 : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;
380 pArg = pEntry;
381
382 return pInstrument;
383 }
384
385 void InstrumentResourceManager::Destroy( ::gig::Instrument* pResource, void* pArg) {
386 instr_entry_t* pEntry = (instr_entry_t*) pArg;
387 // we don't need the .gig file here anymore
388 Gigs.HandBack(pEntry->pGig, (GigConsumer*) pEntry->ID.Index); // conversion kinda hackish :/
389 delete pEntry;
390 }
391
392 void InstrumentResourceManager::OnBorrow(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, void*& pArg) {
393 instr_entry_t* pEntry = (instr_entry_t*) pArg;
394 gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(pConsumer);
395 uint maxSamplesPerCycle =
396 (pEngineChannel && pEngineChannel->GetEngine()) ? dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine())->pAudioOutputDevice->MaxSamplesPerCycle()
397 : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;
398 if (pEntry->MaxSamplesPerCycle < maxSamplesPerCycle) {
399 Update(pResource, pConsumer);
400 }
401 }
402
403 /**
404 * Give back an instrument. This should be used instead of
405 * HandBack if there are some dimension regions that are still in
406 * use. (When an instrument is changed, the voices currently
407 * playing is allowed to keep playing with the old instrument
408 * until note off arrives. New notes will use the new instrument.)
409 */
410 void InstrumentResourceManager::HandBackInstrument(::gig::Instrument* pResource, InstrumentConsumer* pConsumer,
411 ::gig::DimensionRegion** dimRegionsInUse) {
412 DimRegInfoMutex.Lock();
413 for (int i = 0 ; dimRegionsInUse[i] ; i++) {
414 DimRegInfo[dimRegionsInUse[i]].refCount++;
415 SampleRefCount[dimRegionsInUse[i]->pSample]++;
416 }
417 HandBack(pResource, pConsumer, true);
418 DimRegInfoMutex.Unlock();
419 }
420
421 /**
422 * Give back a dimension region that belongs to an instrument that
423 * was previously handed back.
424 */
425 void InstrumentResourceManager::HandBackDimReg(::gig::DimensionRegion* pDimReg) {
426 DimRegInfoMutex.Lock();
427 dimreg_info_t& dimRegInfo = DimRegInfo[pDimReg];
428 int dimRegRefCount = --dimRegInfo.refCount;
429 int sampleRefCount = --SampleRefCount[pDimReg->pSample];
430 if (dimRegRefCount == 0) {
431 ::gig::File* gig = dimRegInfo.file;
432 ::RIFF::File* riff = dimRegInfo.riff;
433 DimRegInfo.erase(pDimReg);
434 // TODO: we could delete Region and Instrument here if
435 // they have become unused
436
437 if (sampleRefCount == 0) {
438 SampleRefCount.erase(pDimReg->pSample);
439
440 if (gig) {
441 gig->DeleteSample(pDimReg->pSample);
442 if (!gig->GetFirstSample()) {
443 dmsg(2,("No more samples in use - freeing gig\n"));
444 delete gig;
445 delete riff;
446 }
447 }
448 }
449 }
450 DimRegInfoMutex.Unlock();
451 }
452
453 /**
454 * Just a wrapper around the other @c CacheInitialSamples() method.
455 *
456 * @param pSample - points to the sample to be cached
457 * @param pEngine - pointer to Gig Engine Channel which caused this call
458 * (may be NULL, in this case default amount of samples
459 * will be cached)
460 */
461 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, gig::EngineChannel* pEngineChannel) {
462 gig::Engine* pEngine =
463 (pEngineChannel && pEngineChannel->GetEngine()) ?
464 dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine()) : NULL;
465 CacheInitialSamples(pSample, pEngine);
466 }
467
468 /**
469 * Caches a certain size at the beginning of the given sample in RAM. If the
470 * sample is very short, the whole sample will be loaded into RAM and thus
471 * no disk streaming is needed for this sample. Caching an initial part of
472 * samples is needed to compensate disk reading latency.
473 *
474 * @param pSample - points to the sample to be cached
475 * @param pEngine - pointer to Gig Engine which caused this call
476 * (may be NULL, in this case default amount of samples
477 * will be cached)
478 */
479 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, gig::Engine* pEngine) {
480 if (!pSample) {
481 dmsg(4,("gig::InstrumentResourceManager: Skipping sample (pSample == NULL)\n"));
482 return;
483 }
484 if (!pSample->SamplesTotal) return; // skip zero size samples
485
486 if (pSample->SamplesTotal <= CONFIG_PRELOAD_SAMPLES) {
487 // Sample is too short for disk streaming, so we load the whole
488 // sample into RAM and place 'pAudioIO->FragmentSize << CONFIG_MAX_PITCH'
489 // number of '0' samples (silence samples) behind the official buffer
490 // border, to allow the interpolator do it's work even at the end of
491 // the sample.
492 const uint maxSamplesPerCycle =
493 (pEngine) ? pEngine->pAudioOutputDevice->MaxSamplesPerCycle()
494 : GIG_RESOURCE_MANAGER_DEFAULT_MAX_SAMPLES_PER_CYCLE;
495 const uint neededSilenceSamples = (maxSamplesPerCycle << CONFIG_MAX_PITCH) + 3;
496 const uint currentlyCachedSilenceSamples = pSample->GetCache().NullExtensionSize / pSample->FrameSize;
497 if (currentlyCachedSilenceSamples < neededSilenceSamples) {
498 dmsg(3,("Caching whole sample (sample name: \"%s\", sample size: %d)\n", pSample->pInfo->Name.c_str(), pSample->SamplesTotal));
499 ::gig::buffer_t buf = pSample->LoadSampleDataWithNullSamplesExtension(neededSilenceSamples);
500 dmsg(4,("Cached %d Bytes, %d silence bytes.\n", buf.Size, buf.NullExtensionSize));
501 }
502 }
503 else { // we only cache CONFIG_PRELOAD_SAMPLES and stream the other sample points from disk
504 if (!pSample->GetCache().Size) pSample->LoadSampleData(CONFIG_PRELOAD_SAMPLES);
505 }
506
507 if (!pSample->GetCache().Size) std::cerr << "Unable to cache sample - maybe memory full!" << std::endl << std::flush;
508 }
509
510 void InstrumentResourceManager::UncacheInitialSamples(::gig::Sample* pSample) {
511 dmsg(1,("Uncaching sample %x\n",pSample));
512 if (pSample->GetCache().Size) pSample->ReleaseSampleData();
513 }
514
515 /**
516 * Returns a list with all instruments currently in use, that are part of
517 * the given file.
518 *
519 * @param pFile - search criteria
520 * @param bLock - whether we should lock (mutex) the instrument manager
521 * during this call and unlock at the end of this call
522 */
523 std::vector< ::gig::Instrument*> InstrumentResourceManager::GetInstrumentsCurrentlyUsedOf(::gig::File* pFile, bool bLock) {
524 if (bLock) Lock();
525 std::vector< ::gig::Instrument*> result;
526 std::vector< ::gig::Instrument*> allInstruments = Resources(false/*don't lock again*/);
527 for (int i = 0; i < allInstruments.size(); i++)
528 if (
529 (::gig::File*) allInstruments[i]->GetParent()
530 == pFile
531 ) result.push_back(allInstruments[i]);
532 if (bLock) Unlock();
533 return result;
534 }
535
536 /**
537 * Returns a list with all gig Engines that are currently using the given
538 * instrument.
539 *
540 * @param pInstrument - search criteria
541 * @param bLock - whether we should lock (mutex) the instrument manager
542 * during this call and unlock at the end of this call
543 */
544 std::set<gig::Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::Instrument* pInstrument, bool bLock) {
545 if (bLock) Lock();
546 std::set<gig::Engine*> result;
547 std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);
548 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
549 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end = consumers.end();
550 for (; iter != end; ++iter) {
551 gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(*iter);
552 if (!pEngineChannel) continue;
553 gig::Engine* pEngine = dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine());
554 if (!pEngine) continue;
555 result.insert(pEngine);
556 }
557 if (bLock) Unlock();
558 return result;
559 }
560
561 /**
562 * Returns a list with all gig Engines that are currently using an
563 * instrument that is part of the given instrument file.
564 *
565 * @param pFile - search criteria
566 * @param bLock - whether we should lock (mutex) the instrument manager
567 * during this call and unlock at the end of this call
568 */
569 std::set<gig::Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::File* pFile, bool bLock) {
570 if (bLock) Lock();
571 // get all instruments (currently in usage) that use that same gig::File
572 std::vector< ::gig::Instrument*> instrumentsOfInterest =
573 GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
574
575 // get all engines that use that same gig::File
576 std::set<gig::Engine*> result;
577 {
578 for (int i = 0; i < instrumentsOfInterest.size(); i++) {
579 std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(instrumentsOfInterest[i]);
580 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
581 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end = consumers.end();
582 for (; iter != end; ++iter) {
583 gig::EngineChannel* pEngineChannel = dynamic_cast<gig::EngineChannel*>(*iter);
584 if (!pEngineChannel) continue;
585 gig::Engine* pEngine = dynamic_cast<gig::Engine*>(pEngineChannel->GetEngine());
586 if (!pEngine) continue;
587 // the unique, sorted container std::set makes
588 // sure we won't have duplicates
589 result.insert(pEngine);
590 }
591 }
592 }
593 if (bLock) Unlock();
594 return result;
595 }
596
597 /**
598 * Returns @c true in case the given sample is referenced somewhere by the
599 * given instrument, @c false otherwise.
600 *
601 * @param pSample - sample reference
602 * @param pInstrument - instrument that might use that sample
603 */
604 bool InstrumentResourceManager::SampleReferencedByInstrument(::gig::Sample* pSample, ::gig::Instrument* pInstrument) {
605 for (
606 ::gig::Region* pRegion = pInstrument->GetFirstRegion();
607 pRegion; pRegion = pInstrument->GetNextRegion()
608 ) {
609 for (
610 int i = 0; i < pRegion->DimensionRegions &&
611 pRegion->pDimensionRegions[i]; i++
612 ) {
613 if (pRegion->pDimensionRegions[i]->pSample == pSample)
614 return true;
615 }
616 }
617 return false;
618 }
619
620 /**
621 * Suspend all gig engines that use the given instrument. This means
622 * completely stopping playback on those engines and killing all their
623 * voices and disk streams. This method will block until all voices AND
624 * their disk streams are finally deleted and the engine turned into a
625 * complete idle loop.
626 *
627 * All @c SuspendEnginesUsing() methods only serve one thread by one and
628 * block all other threads until the current active thread called
629 * @c ResumeAllEngines() .
630 *
631 * @param pInstrument - search criteria
632 */
633 void InstrumentResourceManager::SuspendEnginesUsing(::gig::Instrument* pInstrument) {
634 // make sure no other thread suspends whole engines at the same time
635 suspendedEnginesMutex.Lock();
636 // get all engines that use that same gig::Instrument
637 suspendedEngines = GetEnginesUsing(pInstrument, true/*lock*/);
638 // finally, completely suspend all engines that use that same gig::Instrument
639 std::set<gig::Engine*>::iterator iter = suspendedEngines.begin();
640 std::set<gig::Engine*>::iterator end = suspendedEngines.end();
641 for (; iter != end; ++iter) (*iter)->SuspendAll();
642 }
643
644 /**
645 * Suspend all gig engines that use the given instrument file. This means
646 * completely stopping playback on those engines and killing all their
647 * voices and disk streams. This method will block until all voices AND
648 * their disk streams are finally deleted and the engine turned into a
649 * complete idle loop.
650 *
651 * All @c SuspendEnginesUsing() methods only serve one thread by one and
652 * block all other threads until the current active thread called
653 * @c ResumeAllEngines() .
654 *
655 * @param pFile - search criteria
656 */
657 void InstrumentResourceManager::SuspendEnginesUsing(::gig::File* pFile) {
658 // make sure no other thread suspends whole engines at the same time
659 suspendedEnginesMutex.Lock();
660 // get all engines that use that same gig::File
661 suspendedEngines = GetEnginesUsing(pFile, true/*lock*/);
662 // finally, completely suspend all engines that use that same gig::File
663 std::set<gig::Engine*>::iterator iter = suspendedEngines.begin();
664 std::set<gig::Engine*>::iterator end = suspendedEngines.end();
665 for (; iter != end; ++iter) (*iter)->SuspendAll();
666 }
667
668 /**
669 * MUST be called after one called one of the @c SuspendEnginesUsing()
670 * methods, to resume normal playback on all previously suspended engines.
671 * As it's only possible for one thread to suspend whole engines at the
672 * same time, this method doesn't take any arguments.
673 */
674 void InstrumentResourceManager::ResumeAllEngines() {
675 // resume all previously completely suspended engines
676 std::set<Engine*>::iterator iter = suspendedEngines.begin();
677 std::set<Engine*>::iterator end = suspendedEngines.end();
678 for (; iter != end; ++iter) (*iter)->ResumeAll();
679 // no more suspended engines ...
680 suspendedEngines.clear();
681 // allow another thread to suspend whole engines
682 suspendedEnginesMutex.Unlock();
683 }
684
685
686
687 // internal gig file manager
688
689 ::gig::File* InstrumentResourceManager::GigResourceManager::Create(String Key, GigConsumer* pConsumer, void*& pArg) {
690 dmsg(1,("Loading gig file \'%s\'...", Key.c_str()));
691 ::RIFF::File* pRIFF = new ::RIFF::File(Key);
692 ::gig::File* pGig = new ::gig::File(pRIFF);
693 pArg = pRIFF;
694 dmsg(1,("OK\n"));
695 return pGig;
696 }
697
698 void InstrumentResourceManager::GigResourceManager::Destroy(::gig::File* pResource, void* pArg) {
699 dmsg(1,("Freeing gig file from memory..."));
700
701 // Delete as much as possible of the gig file. Some of the
702 // dimension regions and samples may still be in use - these
703 // will be deleted later by the HandBackDimReg function.
704 bool deleteFile = true;
705 ::gig::Instrument* nextInstrument;
706 for (::gig::Instrument* instrument = pResource->GetFirstInstrument() ;
707 instrument ;
708 instrument = nextInstrument) {
709 nextInstrument = pResource->GetNextInstrument();
710 bool deleteInstrument = true;
711 ::gig::Region* nextRegion;
712 for (::gig::Region *region = instrument->GetFirstRegion() ;
713 region ;
714 region = nextRegion) {
715 nextRegion = instrument->GetNextRegion();
716 bool deleteRegion = true;
717 for (int i = 0 ; i < region->DimensionRegions ; i++)
718 {
719 ::gig::DimensionRegion *d = region->pDimensionRegions[i];
720 std::map< ::gig::DimensionRegion*, dimreg_info_t>::iterator iter = parent->DimRegInfo.find(d);
721 if (iter != parent->DimRegInfo.end()) {
722 dimreg_info_t& dimRegInfo = (*iter).second;
723 dimRegInfo.file = pResource;
724 dimRegInfo.riff = (::RIFF::File*)pArg;
725 deleteFile = deleteInstrument = deleteRegion = false;
726 }
727 }
728 if (deleteRegion) instrument->DeleteRegion(region);
729 }
730 if (deleteInstrument) pResource->DeleteInstrument(instrument);
731 }
732 if (deleteFile) {
733 delete pResource;
734 delete (::RIFF::File*) pArg;
735 } else {
736 dmsg(2,("keeping some samples that are in use..."));
737 ::gig::Sample* nextSample;
738 for (::gig::Sample* sample = pResource->GetFirstSample() ;
739 sample ;
740 sample = nextSample) {
741 nextSample = pResource->GetNextSample();
742 if (parent->SampleRefCount.find(sample) == parent->SampleRefCount.end()) {
743 pResource->DeleteSample(sample);
744 }
745 }
746 }
747 dmsg(1,("OK\n"));
748 }
749
750 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC