/[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 2326 - (show annotations) (download)
Thu Mar 8 19:40:14 2012 UTC (9 years, 4 months ago) by persson
File size: 45328 byte(s)
* bugfix: instrument loading crashed for sfz and sf2 in Ardour (#176)
* more thread safety fixes for the instrument loading thread

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2012 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 #include "EngineChannel.h"
28 #include "Engine.h"
29
30 #include "../../common/global_private.h"
31 #include "../../plugins/InstrumentEditorFactory.h"
32
33 namespace LinuxSampler { namespace gig {
34
35 // some data needed for the libgig callback function
36 struct progress_callback_arg_t {
37 InstrumentResourceManager* pManager;
38 InstrumentManager::instrument_id_t* pInstrumentKey;
39 };
40
41 // we use this to react on events concerning an instrument on behalf of an instrument editor
42 class InstrumentEditorProxy : public InstrumentConsumer {
43 public:
44 virtual void ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg) {
45 //TODO: inform the instrument editor about the pending update
46 }
47
48 virtual void ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg) {
49 //TODO:: inform the instrument editor about finished update
50 }
51
52 virtual void OnResourceProgress(float fProgress) {
53 //TODO: inform the instrument editor about the progress of an update
54 }
55
56 // the instrument we borrowed on behalf of the editor
57 ::gig::Instrument* pInstrument;
58 // the instrument editor we work on behalf
59 InstrumentEditor* pEditor;
60 };
61
62 /**
63 * Callback function which will be called by libgig during loading of
64 * instruments to inform about the current progress. Or to be more
65 * specific; it will be called during the GetInstrument() call.
66 *
67 * @param pProgress - contains current progress value, pointer to the
68 * InstrumentResourceManager instance and
69 * instrument ID
70 */
71 void InstrumentResourceManager::OnInstrumentLoadingProgress(::gig::progress_t* pProgress) {
72 dmsg(7,("gig::InstrumentResourceManager: progress %f%", pProgress->factor));
73 progress_callback_arg_t* pArg = static_cast<progress_callback_arg_t*>(pProgress->custom);
74 // we randomly schedule 90% for the .gig file loading and the remaining 10% later for sample caching
75 const float localProgress = 0.9f * pProgress->factor;
76 pArg->pManager->DispatchResourceProgressEvent(*pArg->pInstrumentKey, localProgress);
77 }
78
79 String InstrumentResourceManager::GetInstrumentName(instrument_id_t ID) {
80 Lock();
81 ::gig::Instrument* pInstrument = Resource(ID, false);
82 String res = (pInstrument) ? pInstrument->pInfo->Name : "";
83 Unlock();
84 return res;
85 }
86
87 String InstrumentResourceManager::GetInstrumentDataStructureName(instrument_id_t ID) {
88 return ::gig::libraryName();
89 }
90
91 String InstrumentResourceManager::GetInstrumentDataStructureVersion(instrument_id_t ID) {
92 return ::gig::libraryVersion();
93 }
94
95 std::vector<InstrumentResourceManager::instrument_id_t> InstrumentResourceManager::GetInstrumentFileContent(String File) throw (InstrumentManagerException) {
96 ::RIFF::File* riff = NULL;
97 ::gig::File* gig = NULL;
98 try {
99 std::vector<instrument_id_t> result;
100 riff = new ::RIFF::File(File);
101 gig = new ::gig::File(riff);
102 gig->SetAutoLoad(false); // avoid time consuming samples scanning
103 for (int i = 0; gig->GetInstrument(i); i++) {
104 instrument_id_t id;
105 id.FileName = File;
106 id.Index = i;
107 result.push_back(id);
108 }
109 if (gig) delete gig;
110 if (riff) delete riff;
111 return result;
112 } catch (::RIFF::Exception e) {
113 if (gig) delete gig;
114 if (riff) delete riff;
115 throw InstrumentManagerException(e.Message);
116 } catch (...) {
117 if (gig) delete gig;
118 if (riff) delete riff;
119 throw InstrumentManagerException("Unknown exception while trying to parse '" + File + "'");
120 }
121 }
122
123 InstrumentResourceManager::instrument_info_t InstrumentResourceManager::GetInstrumentInfo(instrument_id_t ID) throw (InstrumentManagerException) {
124 Lock();
125 ::gig::Instrument* pInstrument = Resource(ID, false);
126 bool loaded = (pInstrument != NULL);
127 if (!loaded) Unlock();
128
129 ::RIFF::File* riff = NULL;
130 ::gig::File* gig = NULL;
131 try {
132 if (!loaded) {
133 riff = new ::RIFF::File(ID.FileName);
134 gig = new ::gig::File(riff);
135 gig->SetAutoLoad(false); // avoid time consuming samples scanning
136 pInstrument = gig->GetInstrument(ID.Index);
137 }
138
139 if (!pInstrument) throw InstrumentManagerException("There is no instrument " + ToString(ID.Index) + " in " + ID.FileName);
140
141 instrument_info_t info;
142 for (int i = 0; i < 128; i++) { info.KeyBindings[i] = info.KeySwitchBindings[i] = 0; }
143
144 ::gig::File* pFile = (::gig::File*) pInstrument->GetParent();
145
146 if (pFile->pVersion) {
147 info.FormatVersion = ToString(pFile->pVersion->major);
148 info.Product = pFile->pInfo->Product;
149 info.Artists = pFile->pInfo->Artists;
150 }
151
152 info.InstrumentName = pInstrument->pInfo->Name;
153
154 ::gig::Region* pRegion = pInstrument->GetFirstRegion();
155 while (pRegion) {
156 int low = pRegion->KeyRange.low;
157 int high = pRegion->KeyRange.high;
158 if (low < 0 || low > 127 || high < 0 || high > 127 || low > high) {
159 std::cerr << "Invalid key range: " << low << " - " << high << std::endl;
160 } else {
161 for (int i = low; i <= high; i++) info.KeyBindings[i] = 1;
162 }
163
164 pRegion = pInstrument->GetNextRegion();
165 }
166
167 if (loaded) { // retrieve keyswitching only if the instrument is fully loaded.
168
169 // only return keyswitch range if keyswitching is used
170 bool hasKeyswitches = false;
171 for (::gig::Region* pRegion = pInstrument->GetFirstRegion() ;
172 pRegion && !hasKeyswitches ;
173 pRegion = pInstrument->GetNextRegion()) {
174 for (int i = 0 ; i < pRegion->Dimensions ; i++) {
175 if (pRegion->pDimensionDefinitions[i].dimension == ::gig::dimension_keyboard) {
176 hasKeyswitches = true;
177 break;
178 }
179 }
180 }
181
182 if (hasKeyswitches) {
183 int low = pInstrument->DimensionKeyRange.low;
184 int high = pInstrument->DimensionKeyRange.high;
185 if (low < 0 || low > 127 || high < 0 || high > 127 || low > high) {
186 std::cerr << "Invalid keyswitch range: " << low << " - " << high << std::endl;
187 } else {
188 for (int i = low; i <= high; i++) info.KeySwitchBindings[i] = 1;
189 }
190 }
191 }
192
193 if (loaded) Unlock();
194
195 if (gig) delete gig;
196 if (riff) delete riff;
197 return info;
198 } catch (::RIFF::Exception e) {
199 if (loaded) Unlock();
200 if (gig) delete gig;
201 if (riff) delete riff;
202 throw InstrumentManagerException(e.Message);
203 } catch (...) {
204 if (loaded) Unlock();
205 if (gig) delete gig;
206 if (riff) delete riff;
207 throw InstrumentManagerException("Unknown exception while trying to parse '" + ID.FileName + "'");
208 }
209 }
210
211 InstrumentEditor* InstrumentResourceManager::LaunchInstrumentEditor(instrument_id_t ID, void* pUserData) throw (InstrumentManagerException) {
212 const String sDataType = GetInstrumentDataStructureName(ID);
213 const String sDataVersion = GetInstrumentDataStructureVersion(ID);
214 // find instrument editors capable to handle given instrument
215 std::vector<String> vEditors =
216 InstrumentEditorFactory::MatchingEditors(sDataType, sDataVersion);
217 if (!vEditors.size())
218 throw InstrumentManagerException(
219 "There is no instrument editor capable to handle this instrument"
220 );
221 // simply use the first editor in the result set
222 dmsg(1,("Found matching editor '%s' for instrument ('%s', %d) having data structure ('%s','%s')\n",
223 vEditors[0].c_str(), ID.FileName.c_str(), ID.Index, sDataType.c_str(), sDataVersion.c_str()));
224 InstrumentEditor* pEditor = InstrumentEditorFactory::Create(vEditors[0]);
225 // register for receiving notifications from the instrument editor
226 pEditor->AddListener(this);
227 // create a proxy that reacts on notification on behalf of the editor
228 InstrumentEditorProxy* pProxy = new InstrumentEditorProxy;
229 // borrow the instrument on behalf of the instrument editor
230 ::gig::Instrument* pInstrument = Borrow(ID, pProxy);
231 // remember the proxy and instrument for this instrument editor
232 pProxy->pInstrument = pInstrument;
233 pProxy->pEditor = pEditor;
234 InstrumentEditorProxiesMutex.Lock();
235 InstrumentEditorProxies.add(pProxy);
236 InstrumentEditorProxiesMutex.Unlock();
237 // launch the instrument editor for the given instrument
238 pEditor->Launch(pInstrument, sDataType, sDataVersion, pUserData);
239
240 // register the instrument editor as virtual MIDI device as well ...
241 VirtualMidiDevice* pVirtualMidiDevice =
242 dynamic_cast<VirtualMidiDevice*>(pEditor);
243 if (!pVirtualMidiDevice) {
244 std::cerr << "Instrument editor not a virtual MIDI device\n" << std::flush;
245 return pEditor;
246 }
247 // 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 ? )
248 Lock();
249 std::set<EngineChannel*> engineChannels =
250 GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
251 std::set<EngineChannel*>::iterator iter = engineChannels.begin();
252 std::set<EngineChannel*>::iterator end = engineChannels.end();
253 for (; iter != end; ++iter) (static_cast<AbstractEngineChannel*>(*iter))->Connect(pVirtualMidiDevice);
254 Unlock();
255
256 return pEditor;
257 }
258
259 /**
260 * Will be called by the respective instrument editor once it left its
261 * Main() loop. That way we can handle cleanup before its thread finally
262 * dies.
263 *
264 * @param pSender - instrument editor that stops execution
265 */
266 void InstrumentResourceManager::OnInstrumentEditorQuit(InstrumentEditor* pSender) {
267 dmsg(1,("InstrumentResourceManager: instrument editor quit, doing cleanup\n"));
268
269 ::gig::Instrument* pInstrument = NULL;
270 InstrumentEditorProxy* pProxy = NULL;
271 int iProxyIndex = -1;
272
273 // first find the editor proxy entry for this editor
274 InstrumentEditorProxiesMutex.Lock();
275 for (int i = 0; i < InstrumentEditorProxies.size(); i++) {
276 InstrumentEditorProxy* pCurProxy =
277 dynamic_cast<InstrumentEditorProxy*>(
278 InstrumentEditorProxies[i]
279 );
280 if (pCurProxy->pEditor == pSender) {
281 pProxy = pCurProxy;
282 iProxyIndex = i;
283 pInstrument = pCurProxy->pInstrument;
284 }
285 }
286 InstrumentEditorProxiesMutex.Unlock();
287
288 if (!pProxy) {
289 std::cerr << "Eeeek, could not find instrument editor proxy, "
290 "this is a bug!\n" << std::flush;
291 return;
292 }
293
294 // now unregister editor as not being available as a virtual MIDI device anymore
295 VirtualMidiDevice* pVirtualMidiDevice =
296 dynamic_cast<VirtualMidiDevice*>(pSender);
297 if (pVirtualMidiDevice) {
298 Lock();
299 // NOTE: see note in LaunchInstrumentEditor()
300 std::set<EngineChannel*> engineChannels =
301 GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
302 std::set<EngineChannel*>::iterator iter = engineChannels.begin();
303 std::set<EngineChannel*>::iterator end = engineChannels.end();
304 for (; iter != end; ++iter) (*iter)->Disconnect(pVirtualMidiDevice);
305 Unlock();
306 } else {
307 std::cerr << "Could not unregister editor as not longer acting as "
308 "virtual MIDI device. Wasn't it registered?\n"
309 << std::flush;
310 }
311
312 // finally delete proxy entry and hand back instrument
313 if (pInstrument) {
314 InstrumentEditorProxiesMutex.Lock();
315 InstrumentEditorProxies.remove(iProxyIndex);
316 InstrumentEditorProxiesMutex.Unlock();
317
318 HandBack(pInstrument, pProxy);
319 delete pProxy;
320 }
321
322 // Note that we don't need to free the editor here. As it
323 // derives from Thread, it will delete itself when the thread
324 // dies.
325 }
326
327 #if 0 // currently unused :
328 /**
329 * Try to inform the respective instrument editor(s), that a note on
330 * event just occured. This method is called by the MIDI thread. If any
331 * obstacles are in the way (e.g. if a wait for an unlock would be
332 * required) we give up immediately, since the RT safeness of the MIDI
333 * thread has absolute priority.
334 */
335 void InstrumentResourceManager::TrySendNoteOnToEditors(uint8_t Key, uint8_t Velocity, ::gig::Instrument* pInstrument) {
336 const bool bGotLock = InstrumentEditorProxiesMutex.Trylock(); // naively assumes RT safe implementation
337 if (!bGotLock) return; // hell, forget it, not worth the hassle
338 for (int i = 0; i < InstrumentEditorProxies.size(); i++) {
339 InstrumentEditorProxy* pProxy =
340 dynamic_cast<InstrumentEditorProxy*>(
341 InstrumentEditorProxies[i]
342 );
343 if (pProxy->pInstrument == pInstrument)
344 pProxy->pEditor->SendNoteOnToDevice(Key, Velocity);
345 }
346 InstrumentEditorProxiesMutex.Unlock(); // naively assumes RT safe implementation
347 }
348
349 /**
350 * Try to inform the respective instrument editor(s), that a note off
351 * event just occured. This method is called by the MIDI thread. If any
352 * obstacles are in the way (e.g. if a wait for an unlock would be
353 * required) we give up immediately, since the RT safeness of the MIDI
354 * thread has absolute priority.
355 */
356 void InstrumentResourceManager::TrySendNoteOffToEditors(uint8_t Key, uint8_t Velocity, ::gig::Instrument* pInstrument) {
357 const bool bGotLock = InstrumentEditorProxiesMutex.Trylock(); // naively assumes RT safe implementation
358 if (!bGotLock) return; // hell, forget it, not worth the hassle
359 for (int i = 0; i < InstrumentEditorProxies.size(); i++) {
360 InstrumentEditorProxy* pProxy =
361 dynamic_cast<InstrumentEditorProxy*>(
362 InstrumentEditorProxies[i]
363 );
364 if (pProxy->pInstrument == pInstrument)
365 pProxy->pEditor->SendNoteOffToDevice(Key, Velocity);
366 }
367 InstrumentEditorProxiesMutex.Unlock(); // naively assumes RT safe implementation
368 }
369 #endif // unused
370
371 void InstrumentResourceManager::OnSamplesToBeRemoved(std::set<void*> Samples, InstrumentEditor* pSender) {
372 if (Samples.empty()) {
373 std::cerr << "gig::InstrumentResourceManager: WARNING, "
374 "OnSamplesToBeRemoved() called with empty list, this "
375 "is a bug!\n" << std::flush;
376 return;
377 }
378 // TODO: ATM we assume here that all samples are from the same file
379 ::gig::Sample* pFirstSample = (::gig::Sample*) *Samples.begin();
380 ::gig::File* pCriticalFile = dynamic_cast< ::gig::File*>(pFirstSample->GetParent());
381 // completely suspend all engines that use that same file
382 SuspendEnginesUsing(pCriticalFile);
383 }
384
385 void InstrumentResourceManager::OnSamplesRemoved(InstrumentEditor* pSender) {
386 // resume all previously, completely suspended engines
387 // (we don't have to un-cache the removed samples here, since that is
388 // automatically done by the gig::Sample destructor)
389 ResumeAllEngines();
390 }
391
392 void InstrumentResourceManager::OnDataStructureToBeChanged(void* pStruct, String sStructType, InstrumentEditor* pSender) {
393 //TODO: remove code duplication
394 if (sStructType == "gig::File") {
395 // completely suspend all engines that use that file
396 ::gig::File* pFile = (::gig::File*) pStruct;
397 SuspendEnginesUsing(pFile);
398 } else if (sStructType == "gig::Instrument") {
399 // completely suspend all engines that use that instrument
400 ::gig::Instrument* pInstrument = (::gig::Instrument*) pStruct;
401 SuspendEnginesUsing(pInstrument);
402 } else if (sStructType == "gig::Region") {
403 // only advice the engines to suspend the given region, so they'll
404 // only ignore that region (and probably already other suspended
405 // ones), but beside that continue normal playback
406 ::gig::Region* pRegion = (::gig::Region*) pStruct;
407 ::gig::Instrument* pInstrument =
408 (::gig::Instrument*) pRegion->GetParent();
409 Lock();
410 std::set<Engine*> engines =
411 GetEnginesUsing(pInstrument, false/*don't lock again*/);
412 std::set<Engine*>::iterator iter = engines.begin();
413 std::set<Engine*>::iterator end = engines.end();
414 for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
415 Unlock();
416 } else if (sStructType == "gig::DimensionRegion") {
417 // only advice the engines to suspend the given DimensionRegions's
418 // parent region, so they'll only ignore that region (and probably
419 // already other suspended ones), but beside that continue normal
420 // playback
421 ::gig::DimensionRegion* pDimReg =
422 (::gig::DimensionRegion*) pStruct;
423 ::gig::Region* pRegion = pDimReg->GetParent();
424 ::gig::Instrument* pInstrument =
425 (::gig::Instrument*) pRegion->GetParent();
426 Lock();
427 std::set<Engine*> engines =
428 GetEnginesUsing(pInstrument, false/*don't lock again*/);
429 std::set<Engine*>::iterator iter = engines.begin();
430 std::set<Engine*>::iterator end = engines.end();
431 for (; iter != end; ++iter) (*iter)->Suspend(pRegion);
432 Unlock();
433 } else {
434 std::cerr << "gig::InstrumentResourceManager: ERROR, unknown data "
435 "structure '" << sStructType << "' requested to be "
436 "suspended by instrument editor. This is a bug!\n"
437 << std::flush;
438 //TODO: we should inform the instrument editor that something seriously went wrong
439 }
440 }
441
442 void InstrumentResourceManager::OnDataStructureChanged(void* pStruct, String sStructType, InstrumentEditor* pSender) {
443 //TODO: remove code duplication
444 if (sStructType == "gig::File") {
445 // resume all previously suspended engines
446 ResumeAllEngines();
447 } else if (sStructType == "gig::Instrument") {
448 // resume all previously suspended engines
449 ResumeAllEngines();
450 } else if (sStructType == "gig::Sample") {
451 // we're assuming here, that OnDataStructureToBeChanged() with
452 // "gig::File" was called previously, so we won't resume anything
453 // here, but just re-cache the given sample
454 Lock();
455 ::gig::Sample* pSample = (::gig::Sample*) pStruct;
456 ::gig::File* pFile = (::gig::File*) pSample->GetParent();
457 UncacheInitialSamples(pSample);
458 // now re-cache ...
459 std::vector< ::gig::Instrument*> instruments =
460 GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
461 for (int i = 0; i < instruments.size(); i++) {
462 if (SampleReferencedByInstrument(pSample, instruments[i])) {
463 std::set<EngineChannel*> engineChannels =
464 GetEngineChannelsUsing(instruments[i], false/*don't lock again*/);
465 std::set<EngineChannel*>::iterator iter = engineChannels.begin();
466 std::set<EngineChannel*>::iterator end = engineChannels.end();
467 for (; iter != end; ++iter)
468 CacheInitialSamples(pSample, *iter);
469 }
470 }
471 Unlock();
472 } else if (sStructType == "gig::Region") {
473 // advice the engines to resume the given region, that is to
474 // using it for playback again
475 ::gig::Region* pRegion = (::gig::Region*) pStruct;
476 ::gig::Instrument* pInstrument =
477 (::gig::Instrument*) pRegion->GetParent();
478 Lock();
479 std::set<Engine*> engines =
480 GetEnginesUsing(pInstrument, false/*don't lock again*/);
481 std::set<Engine*>::iterator iter = engines.begin();
482 std::set<Engine*>::iterator end = engines.end();
483 for (; iter != end; ++iter) (*iter)->Resume(pRegion);
484 Unlock();
485 } else if (sStructType == "gig::DimensionRegion") {
486 // advice the engines to resume the given DimensionRegion's parent
487 // region, that is to using it for playback again
488 ::gig::DimensionRegion* pDimReg =
489 (::gig::DimensionRegion*) pStruct;
490 ::gig::Region* pRegion = pDimReg->GetParent();
491 ::gig::Instrument* pInstrument =
492 (::gig::Instrument*) pRegion->GetParent();
493 Lock();
494 std::set<Engine*> engines =
495 GetEnginesUsing(pInstrument, false/*don't lock again*/);
496 std::set<Engine*>::iterator iter = engines.begin();
497 std::set<Engine*>::iterator end = engines.end();
498 for (; iter != end; ++iter) (*iter)->Resume(pRegion);
499 Unlock();
500 } else {
501 std::cerr << "gig::InstrumentResourceManager: ERROR, unknown data "
502 "structure '" << sStructType << "' requested to be "
503 "resumed by instrument editor. This is a bug!\n"
504 << std::flush;
505 //TODO: we should inform the instrument editor that something seriously went wrong
506 }
507 }
508
509 void InstrumentResourceManager::OnSampleReferenceChanged(void* pOldSample, void* pNewSample, InstrumentEditor* pSender) {
510 // uncache old sample in case it's not used by anybody anymore
511 if (pOldSample) {
512 Lock();
513 ::gig::Sample* pSample = (::gig::Sample*) pOldSample;
514 ::gig::File* pFile = (::gig::File*) pSample->GetParent();
515 bool bSampleStillInUse = false;
516 std::vector< ::gig::Instrument*> instruments =
517 GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
518 for (int i = 0; i < instruments.size(); i++) {
519 if (SampleReferencedByInstrument(pSample, instruments[i])) {
520 bSampleStillInUse = true;
521 break;
522 }
523 }
524 if (!bSampleStillInUse) UncacheInitialSamples(pSample);
525 Unlock();
526 }
527 // make sure new sample reference is cached
528 if (pNewSample) {
529 Lock();
530 ::gig::Sample* pSample = (::gig::Sample*) pNewSample;
531 ::gig::File* pFile = (::gig::File*) pSample->GetParent();
532 // get all engines that use that same gig::File
533 std::set<Engine*> engines = GetEnginesUsing(pFile, false/*don't lock again*/);
534 std::set<Engine*>::iterator iter = engines.begin();
535 std::set<Engine*>::iterator end = engines.end();
536 for (; iter != end; ++iter)
537 CacheInitialSamples(pSample, *iter);
538 Unlock();
539 }
540 }
541
542 ::gig::Instrument* InstrumentResourceManager::Create(instrument_id_t Key, InstrumentConsumer* pConsumer, void*& pArg) {
543 // get gig file from internal gig file manager
544 ::gig::File* pGig = Gigs.Borrow(Key.FileName, reinterpret_cast<GigConsumer*>(Key.Index)); // conversion kinda hackish :/
545
546 // we pass this to the progress callback mechanism of libgig
547 progress_callback_arg_t callbackArg;
548 callbackArg.pManager = this;
549 callbackArg.pInstrumentKey = &Key;
550
551 ::gig::progress_t progress;
552 progress.callback = OnInstrumentLoadingProgress;
553 progress.custom = &callbackArg;
554
555 dmsg(1,("Loading gig instrument ('%s',%d)...",Key.FileName.c_str(),Key.Index));
556 ::gig::Instrument* pInstrument = pGig->GetInstrument(Key.Index, &progress);
557 if (!pInstrument) {
558 std::stringstream msg;
559 msg << "There's no instrument with index " << Key.Index << ".";
560 throw InstrumentManagerException(msg.str());
561 }
562 pGig->GetFirstSample(); // just to force complete instrument loading
563 dmsg(1,("OK\n"));
564
565 uint maxSamplesPerCycle = GetMaxSamplesPerCycle(pConsumer);
566
567 // cache initial samples points (for actually needed samples)
568 dmsg(1,("Caching initial samples..."));
569 uint iRegion = 0; // just for progress calculation
570 ::gig::Region* pRgn = pInstrument->GetFirstRegion();
571 while (pRgn) {
572 // we randomly schedule 90% for the .gig file loading and the remaining 10% now for sample caching
573 const float localProgress = 0.9f + 0.1f * (float) iRegion / (float) pInstrument->Regions;
574 DispatchResourceProgressEvent(Key, localProgress);
575
576 if (pRgn->GetSample() && !pRgn->GetSample()->GetCache().Size) {
577 dmsg(2,("C"));
578 CacheInitialSamples(pRgn->GetSample(), maxSamplesPerCycle);
579 }
580 for (uint i = 0; i < pRgn->DimensionRegions; i++) {
581 CacheInitialSamples(pRgn->pDimensionRegions[i]->pSample, maxSamplesPerCycle);
582 }
583
584 pRgn = pInstrument->GetNextRegion();
585 iRegion++;
586 }
587 dmsg(1,("OK\n"));
588 DispatchResourceProgressEvent(Key, 1.0f); // done; notify all consumers about progress 100%
589
590 // we need the following for destruction later
591 instr_entry_t* pEntry = new instr_entry_t;
592 pEntry->ID.FileName = Key.FileName;
593 pEntry->ID.Index = Key.Index;
594 pEntry->pFile = pGig;
595
596 // (try to resolve the audio device context)
597 // and we save this to check if we need to reallocate for an engine with higher value of 'MaxSamplesPerSecond'
598 pEntry->MaxSamplesPerCycle = maxSamplesPerCycle;
599
600 pArg = pEntry;
601
602 return pInstrument;
603 }
604
605 void InstrumentResourceManager::Destroy(::gig::Instrument* pResource, void* pArg) {
606 instr_entry_t* pEntry = (instr_entry_t*) pArg;
607 // we don't need the .gig file here anymore
608 Gigs.HandBack(pEntry->pFile, reinterpret_cast<GigConsumer*>(pEntry->ID.Index)); // conversion kinda hackish :/
609 delete pEntry;
610 }
611
612 void InstrumentResourceManager::DeleteRegionIfNotUsed(::gig::DimensionRegion* pRegion, region_info_t* pRegInfo) {
613 // TODO: we could delete Region and Instrument here if they have become unused
614 }
615
616 void InstrumentResourceManager::DeleteSampleIfNotUsed(::gig::Sample* pSample, region_info_t* pRegInfo) {
617 ::gig::File* gig = pRegInfo->file;
618 ::RIFF::File* riff = static_cast< ::RIFF::File*>(pRegInfo->pArg);
619 if (gig) {
620 gig->DeleteSample(pSample);
621 if (!gig->GetFirstSample()) {
622 dmsg(2,("No more samples in use - freeing gig\n"));
623 delete gig;
624 delete riff;
625 }
626 }
627 }
628
629 /**
630 * Just a wrapper around the other @c CacheInitialSamples() method.
631 *
632 * @param pSample - points to the sample to be cached
633 * @param pEngine - pointer to Gig Engine Channel which caused this call
634 * (may be NULL, in this case default amount of samples
635 * will be cached)
636 */
637 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, EngineChannel* pEngineChannel) {
638 Engine* pEngine =
639 (pEngineChannel && pEngineChannel->GetEngine()) ?
640 dynamic_cast<Engine*>(pEngineChannel->GetEngine()) : NULL;
641 CacheInitialSamples(pSample, pEngine);
642 }
643
644 /**
645 * Caches a certain size at the beginning of the given sample in RAM. If the
646 * sample is very short, the whole sample will be loaded into RAM and thus
647 * no disk streaming is needed for this sample. Caching an initial part of
648 * samples is needed to compensate disk reading latency.
649 *
650 * @param pSample - points to the sample to be cached
651 * @param pEngine - pointer to Gig Engine which caused this call
652 * (may be NULL, in this case default amount of samples
653 * will be cached)
654 */
655 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, AbstractEngine* pEngine) {
656 uint maxSamplesPerCycle =
657 (pEngine) ? pEngine->pAudioOutputDevice->MaxSamplesPerCycle() :
658 DefaultMaxSamplesPerCycle();
659 CacheInitialSamples(pSample, maxSamplesPerCycle);
660 }
661
662 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, uint maxSamplesPerCycle) {
663 if (!pSample) {
664 dmsg(4,("gig::InstrumentResourceManager: Skipping sample (pSample == NULL)\n"));
665 return;
666 }
667 if (!pSample->SamplesTotal) return; // skip zero size samples
668
669 if (pSample->SamplesTotal <= CONFIG_PRELOAD_SAMPLES) {
670 // Sample is too short for disk streaming, so we load the whole
671 // sample into RAM and place 'pAudioIO->FragmentSize << CONFIG_MAX_PITCH'
672 // number of '0' samples (silence samples) behind the official buffer
673 // border, to allow the interpolator do it's work even at the end of
674 // the sample.
675 const uint neededSilenceSamples = (maxSamplesPerCycle << CONFIG_MAX_PITCH) + 3;
676 const uint currentlyCachedSilenceSamples = pSample->GetCache().NullExtensionSize / pSample->FrameSize;
677 if (currentlyCachedSilenceSamples < neededSilenceSamples) {
678 dmsg(3,("Caching whole sample (sample name: \"%s\", sample size: %d)\n", pSample->pInfo->Name.c_str(), pSample->SamplesTotal));
679 ::gig::buffer_t buf = pSample->LoadSampleDataWithNullSamplesExtension(neededSilenceSamples);
680 dmsg(4,("Cached %d Bytes, %d silence bytes.\n", buf.Size, buf.NullExtensionSize));
681 }
682 }
683 else { // we only cache CONFIG_PRELOAD_SAMPLES and stream the other sample points from disk
684 if (!pSample->GetCache().Size) pSample->LoadSampleData(CONFIG_PRELOAD_SAMPLES);
685 }
686
687 if (!pSample->GetCache().Size) std::cerr << "Unable to cache sample - maybe memory full!" << std::endl << std::flush;
688 }
689
690 void InstrumentResourceManager::UncacheInitialSamples(::gig::Sample* pSample) {
691 dmsg(1,("Uncaching sample %x\n",pSample));
692 if (pSample->GetCache().Size) pSample->ReleaseSampleData();
693 }
694
695 /**
696 * Returns a list with all instruments currently in use, that are part of
697 * the given file.
698 *
699 * @param pFile - search criteria
700 * @param bLock - whether we should lock (mutex) the instrument manager
701 * during this call and unlock at the end of this call
702 */
703 std::vector< ::gig::Instrument*> InstrumentResourceManager::GetInstrumentsCurrentlyUsedOf(::gig::File* pFile, bool bLock) {
704 if (bLock) Lock();
705 std::vector< ::gig::Instrument*> result;
706 std::vector< ::gig::Instrument*> allInstruments = Resources(false/*don't lock again*/);
707 for (int i = 0; i < allInstruments.size(); i++)
708 if (
709 (::gig::File*) allInstruments[i]->GetParent()
710 == pFile
711 ) result.push_back(allInstruments[i]);
712 if (bLock) Unlock();
713 return result;
714 }
715
716 /**
717 * Returns a list with all gig engine channels that are currently using
718 * the given instrument.
719 *
720 * @param pInstrument - search criteria
721 * @param bLock - whether we should lock (mutex) the instrument manager
722 * during this call and unlock at the end of this call
723 */
724 std::set<EngineChannel*> InstrumentResourceManager::GetEngineChannelsUsing(::gig::Instrument* pInstrument, bool bLock) {
725 if (bLock) Lock();
726 std::set<EngineChannel*> result;
727 std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);
728 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
729 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end = consumers.end();
730 for (; iter != end; ++iter) {
731 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
732 if (!pEngineChannel) continue;
733 result.insert(pEngineChannel);
734 }
735 if (bLock) Unlock();
736 return result;
737 }
738
739 /**
740 * Returns a list with all gig Engines that are currently using the given
741 * instrument.
742 *
743 * @param pInstrument - search criteria
744 * @param bLock - whether we should lock (mutex) the instrument manager
745 * during this call and unlock at the end of this call
746 */
747 std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::Instrument* pInstrument, bool bLock) {
748 if (bLock) Lock();
749 std::set<Engine*> result;
750 std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(pInstrument);
751 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
752 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end = consumers.end();
753 for (; iter != end; ++iter) {
754 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
755 if (!pEngineChannel) continue;
756 Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
757 if (!pEngine) continue;
758 result.insert(pEngine);
759 }
760 if (bLock) Unlock();
761 return result;
762 }
763
764 /**
765 * Returns a list with all gig Engines that are currently using an
766 * instrument that is part of the given instrument file.
767 *
768 * @param pFile - search criteria
769 * @param bLock - whether we should lock (mutex) the instrument manager
770 * during this call and unlock at the end of this call
771 */
772 std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::File* pFile, bool bLock) {
773 if (bLock) Lock();
774 // get all instruments (currently in usage) that use that same gig::File
775 std::vector< ::gig::Instrument*> instrumentsOfInterest =
776 GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
777
778 // get all engines that use that same gig::File
779 std::set<Engine*> result;
780 {
781 for (int i = 0; i < instrumentsOfInterest.size(); i++) {
782 std::set<ResourceConsumer< ::gig::Instrument>*> consumers = ConsumersOf(instrumentsOfInterest[i]);
783 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator iter = consumers.begin();
784 std::set<ResourceConsumer< ::gig::Instrument>*>::iterator end = consumers.end();
785 for (; iter != end; ++iter) {
786 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
787 if (!pEngineChannel) continue;
788 Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
789 if (!pEngine) continue;
790 // the unique, sorted container std::set makes
791 // sure we won't have duplicates
792 result.insert(pEngine);
793 }
794 }
795 }
796 if (bLock) Unlock();
797 return result;
798 }
799
800 /**
801 * Returns @c true in case the given sample is referenced somewhere by the
802 * given instrument, @c false otherwise.
803 *
804 * @param pSample - sample reference
805 * @param pInstrument - instrument that might use that sample
806 */
807 bool InstrumentResourceManager::SampleReferencedByInstrument(::gig::Sample* pSample, ::gig::Instrument* pInstrument) {
808 for (
809 ::gig::Region* pRegion = pInstrument->GetFirstRegion();
810 pRegion; pRegion = pInstrument->GetNextRegion()
811 ) {
812 for (
813 int i = 0; i < pRegion->DimensionRegions &&
814 pRegion->pDimensionRegions[i]; i++
815 ) {
816 if (pRegion->pDimensionRegions[i]->pSample == pSample)
817 return true;
818 }
819 }
820 return false;
821 }
822
823 /**
824 * Suspend all gig engines that use the given instrument. This means
825 * completely stopping playback on those engines and killing all their
826 * voices and disk streams. This method will block until all voices AND
827 * their disk streams are finally deleted and the engine turned into a
828 * complete idle loop.
829 *
830 * All @c SuspendEnginesUsing() methods only serve one thread by one and
831 * block all other threads until the current active thread called
832 * @c ResumeAllEngines() .
833 *
834 * @param pInstrument - search criteria
835 */
836 void InstrumentResourceManager::SuspendEnginesUsing(::gig::Instrument* pInstrument) {
837 // make sure no other thread suspends whole engines at the same time
838 suspendedEnginesMutex.Lock();
839 // get all engines that use that same gig::Instrument
840 suspendedEngines = GetEnginesUsing(pInstrument, true/*lock*/);
841 // finally, completely suspend all engines that use that same gig::Instrument
842 std::set<Engine*>::iterator iter = suspendedEngines.begin();
843 std::set<Engine*>::iterator end = suspendedEngines.end();
844 for (; iter != end; ++iter) (*iter)->SuspendAll();
845 }
846
847 /**
848 * Suspend all gig engines that use the given instrument file. This means
849 * completely stopping playback on those engines and killing all their
850 * voices and disk streams. This method will block until all voices AND
851 * their disk streams are finally deleted and the engine turned into a
852 * complete idle loop.
853 *
854 * All @c SuspendEnginesUsing() methods only serve one thread by one and
855 * block all other threads until the current active thread called
856 * @c ResumeAllEngines() .
857 *
858 * @param pFile - search criteria
859 */
860 void InstrumentResourceManager::SuspendEnginesUsing(::gig::File* pFile) {
861 // make sure no other thread suspends whole engines at the same time
862 suspendedEnginesMutex.Lock();
863 // get all engines that use that same gig::File
864 suspendedEngines = GetEnginesUsing(pFile, true/*lock*/);
865 // finally, completely suspend all engines that use that same gig::File
866 std::set<Engine*>::iterator iter = suspendedEngines.begin();
867 std::set<Engine*>::iterator end = suspendedEngines.end();
868 for (; iter != end; ++iter) (*iter)->SuspendAll();
869 }
870
871 /**
872 * MUST be called after one called one of the @c SuspendEnginesUsing()
873 * methods, to resume normal playback on all previously suspended engines.
874 * As it's only possible for one thread to suspend whole engines at the
875 * same time, this method doesn't take any arguments.
876 */
877 void InstrumentResourceManager::ResumeAllEngines() {
878 // resume all previously completely suspended engines
879 std::set<Engine*>::iterator iter = suspendedEngines.begin();
880 std::set<Engine*>::iterator end = suspendedEngines.end();
881 for (; iter != end; ++iter) (*iter)->ResumeAll();
882 // no more suspended engines ...
883 suspendedEngines.clear();
884 // allow another thread to suspend whole engines
885 suspendedEnginesMutex.Unlock();
886 }
887
888
889
890 // internal gig file manager
891
892 ::gig::File* InstrumentResourceManager::GigResourceManager::Create(String Key, GigConsumer* pConsumer, void*& pArg) {
893 dmsg(1,("Loading gig file \'%s\'...", Key.c_str()));
894 ::RIFF::File* pRIFF = new ::RIFF::File(Key);
895 ::gig::File* pGig = new ::gig::File(pRIFF);
896 pArg = pRIFF;
897 dmsg(1,("OK\n"));
898 return pGig;
899 }
900
901 void InstrumentResourceManager::GigResourceManager::Destroy(::gig::File* pResource, void* pArg) {
902 dmsg(1,("Freeing gig file '%s' from memory ...", pResource->GetFileName().c_str()));
903
904 // Delete as much as possible of the gig file. Some of the
905 // dimension regions and samples may still be in use - these
906 // will be deleted later by the HandBackDimReg function.
907 bool deleteFile = true;
908 ::gig::Instrument* nextInstrument;
909 for (::gig::Instrument* instrument = pResource->GetFirstInstrument() ;
910 instrument ;
911 instrument = nextInstrument) {
912 nextInstrument = pResource->GetNextInstrument();
913 bool deleteInstrument = true;
914 ::gig::Region* nextRegion;
915 for (::gig::Region *region = instrument->GetFirstRegion() ;
916 region ;
917 region = nextRegion) {
918 nextRegion = instrument->GetNextRegion();
919 bool deleteRegion = true;
920 for (int i = 0 ; i < region->DimensionRegions ; i++)
921 {
922 ::gig::DimensionRegion *d = region->pDimensionRegions[i];
923 std::map< ::gig::DimensionRegion*, region_info_t>::iterator iter = parent->RegionInfo.find(d);
924 if (iter != parent->RegionInfo.end()) {
925 region_info_t& dimRegInfo = (*iter).second;
926 dimRegInfo.file = pResource;
927 dimRegInfo.pArg = (::RIFF::File*)pArg;
928 deleteFile = deleteInstrument = deleteRegion = false;
929 }
930 }
931 if (deleteRegion) instrument->DeleteRegion(region);
932 }
933 if (deleteInstrument) pResource->DeleteInstrument(instrument);
934 }
935 if (deleteFile) {
936 delete pResource;
937 delete (::RIFF::File*) pArg;
938 } else {
939 dmsg(2,("keeping some samples that are in use..."));
940 ::gig::Sample* nextSample;
941 for (::gig::Sample* sample = pResource->GetFirstSample() ;
942 sample ;
943 sample = nextSample) {
944 nextSample = pResource->GetNextSample();
945 if (parent->SampleRefCount.find(sample) == parent->SampleRefCount.end()) {
946 pResource->DeleteSample(sample);
947 }
948 }
949 }
950 dmsg(1,("OK\n"));
951 }
952
953 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC