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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2326 - (hide annotations) (download)
Thu Mar 8 19:40:14 2012 UTC (12 years 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 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 persson 2326 * Copyright (C) 2005 - 2012 Christian Schoenebeck *
7 schoenebeck 53 * *
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 iliev 2012 #include "EngineChannel.h"
28     #include "Engine.h"
29 schoenebeck 53
30 schoenebeck 1424 #include "../../common/global_private.h"
31 schoenebeck 1375 #include "../../plugins/InstrumentEditorFactory.h"
32 schoenebeck 1212
33 schoenebeck 53 namespace LinuxSampler { namespace gig {
34    
35 schoenebeck 517 // some data needed for the libgig callback function
36     struct progress_callback_arg_t {
37 schoenebeck 947 InstrumentResourceManager* pManager;
38     InstrumentManager::instrument_id_t* pInstrumentKey;
39 schoenebeck 517 };
40    
41 schoenebeck 1212 // 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 schoenebeck 1653 // the instrument editor we work on behalf
59     InstrumentEditor* pEditor;
60 schoenebeck 1212 };
61    
62 schoenebeck 517 /**
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 schoenebeck 947 String InstrumentResourceManager::GetInstrumentName(instrument_id_t ID) {
80 schoenebeck 970 Lock();
81     ::gig::Instrument* pInstrument = Resource(ID, false);
82     String res = (pInstrument) ? pInstrument->pInfo->Name : "";
83     Unlock();
84     return res;
85 schoenebeck 947 }
86    
87 schoenebeck 1321 String InstrumentResourceManager::GetInstrumentDataStructureName(instrument_id_t ID) {
88 schoenebeck 1212 return ::gig::libraryName();
89     }
90    
91 schoenebeck 1321 String InstrumentResourceManager::GetInstrumentDataStructureVersion(instrument_id_t ID) {
92 schoenebeck 1212 return ::gig::libraryVersion();
93     }
94    
95 schoenebeck 1525 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 iliev 1771 Lock();
125     ::gig::Instrument* pInstrument = Resource(ID, false);
126     bool loaded = (pInstrument != NULL);
127     if (!loaded) Unlock();
128    
129 schoenebeck 1525 ::RIFF::File* riff = NULL;
130     ::gig::File* gig = NULL;
131     try {
132 persson 2326 if (!loaded) {
133 iliev 1771 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 schoenebeck 1852
139 schoenebeck 1525 if (!pInstrument) throw InstrumentManagerException("There is no instrument " + ToString(ID.Index) + " in " + ID.FileName);
140 iliev 1771
141 schoenebeck 1525 instrument_info_t info;
142 iliev 1771 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 schoenebeck 1525 }
151 iliev 1771
152 schoenebeck 1525 info.InstrumentName = pInstrument->pInfo->Name;
153 iliev 1771
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 persson 1797
164 iliev 1771 pRegion = pInstrument->GetNextRegion();
165     }
166 persson 1797
167 iliev 1774 if (loaded) { // retrieve keyswitching only if the instrument is fully loaded.
168 persson 1797
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 iliev 1774 }
181 persson 1797
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 iliev 1771 }
192    
193     if (loaded) Unlock();
194    
195 schoenebeck 1525 if (gig) delete gig;
196     if (riff) delete riff;
197     return info;
198     } catch (::RIFF::Exception e) {
199 iliev 1771 if (loaded) Unlock();
200 schoenebeck 1525 if (gig) delete gig;
201     if (riff) delete riff;
202     throw InstrumentManagerException(e.Message);
203     } catch (...) {
204 iliev 1771 if (loaded) Unlock();
205 schoenebeck 1525 if (gig) delete gig;
206     if (riff) delete riff;
207     throw InstrumentManagerException("Unknown exception while trying to parse '" + ID.FileName + "'");
208     }
209     }
210    
211 schoenebeck 1876 InstrumentEditor* InstrumentResourceManager::LaunchInstrumentEditor(instrument_id_t ID, void* pUserData) throw (InstrumentManagerException) {
212 schoenebeck 1321 const String sDataType = GetInstrumentDataStructureName(ID);
213     const String sDataVersion = GetInstrumentDataStructureVersion(ID);
214 schoenebeck 1212 // 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 schoenebeck 1321 // register for receiving notifications from the instrument editor
226 schoenebeck 1212 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 schoenebeck 1653 pProxy->pEditor = pEditor;
234 schoenebeck 1212 InstrumentEditorProxiesMutex.Lock();
235 schoenebeck 1653 InstrumentEditorProxies.add(pProxy);
236 schoenebeck 1212 InstrumentEditorProxiesMutex.Unlock();
237     // launch the instrument editor for the given instrument
238 schoenebeck 1876 pEditor->Launch(pInstrument, sDataType, sDataVersion, pUserData);
239 schoenebeck 1659
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 schoenebeck 1868 return pEditor;
246 schoenebeck 1659 }
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 iliev 2012 std::set<EngineChannel*> engineChannels =
250 schoenebeck 1659 GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
251 iliev 2012 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 schoenebeck 1659 Unlock();
255 schoenebeck 1868
256     return pEditor;
257 schoenebeck 1212 }
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 schoenebeck 1659
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 schoenebeck 1212 InstrumentEditorProxiesMutex.Lock();
275 schoenebeck 1653 for (int i = 0; i < InstrumentEditorProxies.size(); i++) {
276 schoenebeck 1659 InstrumentEditorProxy* pCurProxy =
277 schoenebeck 1212 dynamic_cast<InstrumentEditorProxy*>(
278 schoenebeck 1653 InstrumentEditorProxies[i]
279 schoenebeck 1212 );
280 schoenebeck 1659 if (pCurProxy->pEditor == pSender) {
281     pProxy = pCurProxy;
282     iProxyIndex = i;
283     pInstrument = pCurProxy->pInstrument;
284 schoenebeck 1653 }
285 schoenebeck 1212 }
286 schoenebeck 1653 InstrumentEditorProxiesMutex.Unlock();
287 persson 1455
288 schoenebeck 1659 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 iliev 2012 std::set<EngineChannel*> engineChannels =
301 schoenebeck 1659 GetEngineChannelsUsing(pInstrument, false/*don't lock again*/);
302 iliev 2012 std::set<EngineChannel*>::iterator iter = engineChannels.begin();
303     std::set<EngineChannel*>::iterator end = engineChannels.end();
304 schoenebeck 1659 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 persson 1455 // 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 schoenebeck 1212 }
326    
327 schoenebeck 1662 #if 0 // currently unused :
328 schoenebeck 1653 /**
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 schoenebeck 1659 pProxy->pEditor->SendNoteOnToDevice(Key, Velocity);
345 schoenebeck 1653 }
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 schoenebeck 1659 pProxy->pEditor->SendNoteOffToDevice(Key, Velocity);
366 schoenebeck 1653 }
367     InstrumentEditorProxiesMutex.Unlock(); // naively assumes RT safe implementation
368     }
369 schoenebeck 1662 #endif // unused
370 schoenebeck 1653
371 schoenebeck 1321 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 iliev 2012 std::set<Engine*> engines =
411 schoenebeck 1321 GetEnginesUsing(pInstrument, false/*don't lock again*/);
412 iliev 2012 std::set<Engine*>::iterator iter = engines.begin();
413     std::set<Engine*>::iterator end = engines.end();
414 schoenebeck 1321 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 iliev 2012 std::set<Engine*> engines =
428 schoenebeck 1321 GetEnginesUsing(pInstrument, false/*don't lock again*/);
429 iliev 2012 std::set<Engine*>::iterator iter = engines.begin();
430     std::set<Engine*>::iterator end = engines.end();
431 schoenebeck 1321 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 schoenebeck 1852 } 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 iliev 2012 std::set<EngineChannel*> engineChannels =
464 schoenebeck 1852 GetEngineChannelsUsing(instruments[i], false/*don't lock again*/);
465 iliev 2012 std::set<EngineChannel*>::iterator iter = engineChannels.begin();
466     std::set<EngineChannel*>::iterator end = engineChannels.end();
467 schoenebeck 1852 for (; iter != end; ++iter)
468     CacheInitialSamples(pSample, *iter);
469     }
470     }
471     Unlock();
472 schoenebeck 1321 } 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 iliev 2012 std::set<Engine*> engines =
480 schoenebeck 1321 GetEnginesUsing(pInstrument, false/*don't lock again*/);
481 iliev 2012 std::set<Engine*>::iterator iter = engines.begin();
482     std::set<Engine*>::iterator end = engines.end();
483 schoenebeck 1321 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 iliev 2012 std::set<Engine*> engines =
495 schoenebeck 1321 GetEnginesUsing(pInstrument, false/*don't lock again*/);
496 iliev 2012 std::set<Engine*>::iterator iter = engines.begin();
497     std::set<Engine*>::iterator end = engines.end();
498 schoenebeck 1321 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 schoenebeck 1852 bool bSampleStillInUse = false;
516 schoenebeck 1321 std::vector< ::gig::Instrument*> instruments =
517     GetInstrumentsCurrentlyUsedOf(pFile, false/*don't lock again*/);
518 schoenebeck 1852 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 schoenebeck 1321 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 iliev 2012 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 schoenebeck 1321 for (; iter != end; ++iter)
537     CacheInitialSamples(pSample, *iter);
538     Unlock();
539     }
540     }
541    
542 schoenebeck 53 ::gig::Instrument* InstrumentResourceManager::Create(instrument_id_t Key, InstrumentConsumer* pConsumer, void*& pArg) {
543 schoenebeck 1321 // get gig file from internal gig file manager
544 persson 2185 ::gig::File* pGig = Gigs.Borrow(Key.FileName, reinterpret_cast<GigConsumer*>(Key.Index)); // conversion kinda hackish :/
545 schoenebeck 53
546 schoenebeck 517 // 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 schoenebeck 947 dmsg(1,("Loading gig instrument ('%s',%d)...",Key.FileName.c_str(),Key.Index));
556     ::gig::Instrument* pInstrument = pGig->GetInstrument(Key.Index, &progress);
557 schoenebeck 53 if (!pInstrument) {
558     std::stringstream msg;
559 schoenebeck 947 msg << "There's no instrument with index " << Key.Index << ".";
560 schoenebeck 1212 throw InstrumentManagerException(msg.str());
561 schoenebeck 53 }
562     pGig->GetFirstSample(); // just to force complete instrument loading
563     dmsg(1,("OK\n"));
564    
565 persson 2326 uint maxSamplesPerCycle = GetMaxSamplesPerCycle(pConsumer);
566    
567 schoenebeck 53 // cache initial samples points (for actually needed samples)
568     dmsg(1,("Caching initial samples..."));
569 schoenebeck 517 uint iRegion = 0; // just for progress calculation
570 schoenebeck 53 ::gig::Region* pRgn = pInstrument->GetFirstRegion();
571     while (pRgn) {
572 schoenebeck 517 // 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 schoenebeck 947 DispatchResourceProgressEvent(Key, localProgress);
575    
576 schoenebeck 354 if (pRgn->GetSample() && !pRgn->GetSample()->GetCache().Size) {
577 schoenebeck 53 dmsg(2,("C"));
578 persson 2326 CacheInitialSamples(pRgn->GetSample(), maxSamplesPerCycle);
579 schoenebeck 53 }
580     for (uint i = 0; i < pRgn->DimensionRegions; i++) {
581 persson 2326 CacheInitialSamples(pRgn->pDimensionRegions[i]->pSample, maxSamplesPerCycle);
582 schoenebeck 53 }
583    
584     pRgn = pInstrument->GetNextRegion();
585 schoenebeck 517 iRegion++;
586 schoenebeck 53 }
587     dmsg(1,("OK\n"));
588 schoenebeck 517 DispatchResourceProgressEvent(Key, 1.0f); // done; notify all consumers about progress 100%
589 schoenebeck 53
590     // we need the following for destruction later
591     instr_entry_t* pEntry = new instr_entry_t;
592 schoenebeck 947 pEntry->ID.FileName = Key.FileName;
593     pEntry->ID.Index = Key.Index;
594 persson 2326 pEntry->pFile = pGig;
595 persson 438
596 schoenebeck 2275 // (try to resolve the audio device context)
597 persson 2326 // and we save this to check if we need to reallocate for an engine with higher value of 'MaxSamplesPerSecond'
598     pEntry->MaxSamplesPerCycle = maxSamplesPerCycle;
599 schoenebeck 2275
600 schoenebeck 53 pArg = pEntry;
601    
602     return pInstrument;
603     }
604    
605 persson 2326 void InstrumentResourceManager::Destroy(::gig::Instrument* pResource, void* pArg) {
606 schoenebeck 53 instr_entry_t* pEntry = (instr_entry_t*) pArg;
607 schoenebeck 947 // we don't need the .gig file here anymore
608 persson 2326 Gigs.HandBack(pEntry->pFile, reinterpret_cast<GigConsumer*>(pEntry->ID.Index)); // conversion kinda hackish :/
609 schoenebeck 53 delete pEntry;
610     }
611    
612 iliev 2012 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 persson 1038 }
615 schoenebeck 2275
616 iliev 2012 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 persson 1038 }
626     }
627     }
628    
629     /**
630 schoenebeck 1321 * 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 iliev 2012 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, EngineChannel* pEngineChannel) {
638     Engine* pEngine =
639 schoenebeck 1321 (pEngineChannel && pEngineChannel->GetEngine()) ?
640 iliev 2012 dynamic_cast<Engine*>(pEngineChannel->GetEngine()) : NULL;
641 schoenebeck 1321 CacheInitialSamples(pSample, pEngine);
642     }
643    
644     /**
645 schoenebeck 53 * 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 schoenebeck 1321 * @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 schoenebeck 53 */
655 iliev 2012 void InstrumentResourceManager::CacheInitialSamples(::gig::Sample* pSample, AbstractEngine* pEngine) {
656 persson 2326 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 schoenebeck 420 if (!pSample) {
664 persson 438 dmsg(4,("gig::InstrumentResourceManager: Skipping sample (pSample == NULL)\n"));
665 schoenebeck 420 return;
666     }
667     if (!pSample->SamplesTotal) return; // skip zero size samples
668 persson 438
669 schoenebeck 554 if (pSample->SamplesTotal <= CONFIG_PRELOAD_SAMPLES) {
670 schoenebeck 53 // Sample is too short for disk streaming, so we load the whole
671 schoenebeck 554 // sample into RAM and place 'pAudioIO->FragmentSize << CONFIG_MAX_PITCH'
672 schoenebeck 53 // 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 persson 438 // the sample.
675 schoenebeck 554 const uint neededSilenceSamples = (maxSamplesPerCycle << CONFIG_MAX_PITCH) + 3;
676 schoenebeck 420 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 schoenebeck 53 }
683 schoenebeck 554 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 schoenebeck 53 }
686    
687     if (!pSample->GetCache().Size) std::cerr << "Unable to cache sample - maybe memory full!" << std::endl << std::flush;
688     }
689    
690 schoenebeck 1321 void InstrumentResourceManager::UncacheInitialSamples(::gig::Sample* pSample) {
691     dmsg(1,("Uncaching sample %x\n",pSample));
692     if (pSample->GetCache().Size) pSample->ReleaseSampleData();
693     }
694 schoenebeck 53
695 schoenebeck 1321 /**
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 schoenebeck 53
716 schoenebeck 1321 /**
717 schoenebeck 1659 * 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 iliev 2012 std::set<EngineChannel*> InstrumentResourceManager::GetEngineChannelsUsing(::gig::Instrument* pInstrument, bool bLock) {
725 schoenebeck 1659 if (bLock) Lock();
726 iliev 2012 std::set<EngineChannel*> result;
727 schoenebeck 1659 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 iliev 2012 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
732 schoenebeck 1659 if (!pEngineChannel) continue;
733     result.insert(pEngineChannel);
734     }
735     if (bLock) Unlock();
736     return result;
737     }
738    
739     /**
740 schoenebeck 1321 * 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 iliev 2012 std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::Instrument* pInstrument, bool bLock) {
748 schoenebeck 1321 if (bLock) Lock();
749 iliev 2012 std::set<Engine*> result;
750 schoenebeck 1321 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 iliev 2012 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
755 schoenebeck 1321 if (!pEngineChannel) continue;
756 iliev 2012 Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
757 schoenebeck 1321 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 iliev 2012 std::set<Engine*> InstrumentResourceManager::GetEnginesUsing(::gig::File* pFile, bool bLock) {
773 schoenebeck 1321 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 iliev 2012 std::set<Engine*> result;
780 schoenebeck 1321 {
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 iliev 2012 EngineChannel* pEngineChannel = dynamic_cast<EngineChannel*>(*iter);
787 schoenebeck 1321 if (!pEngineChannel) continue;
788 iliev 2012 Engine* pEngine = dynamic_cast<Engine*>(pEngineChannel->GetEngine());
789 schoenebeck 1321 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 iliev 2012 std::set<Engine*>::iterator iter = suspendedEngines.begin();
843     std::set<Engine*>::iterator end = suspendedEngines.end();
844 schoenebeck 1321 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 iliev 2012 std::set<Engine*>::iterator iter = suspendedEngines.begin();
867     std::set<Engine*>::iterator end = suspendedEngines.end();
868 schoenebeck 1321 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 schoenebeck 53 // 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 schoenebeck 2275 dmsg(1,("Freeing gig file '%s' from memory ...", pResource->GetFileName().c_str()));
903 persson 1038
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 iliev 2012 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 persson 1038 dimRegInfo.file = pResource;
927 iliev 2012 dimRegInfo.pArg = (::RIFF::File*)pArg;
928 persson 1038 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 schoenebeck 53 dmsg(1,("OK\n"));
951     }
952    
953     }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC