--- linuxsampler/trunk/src/engines/gig/InstrumentResourceManager.h 2004/04/27 09:21:58 56 +++ linuxsampler/trunk/src/engines/gig/InstrumentResourceManager.h 2007/02/03 15:33:00 1038 @@ -3,6 +3,7 @@ * LinuxSampler - modular, streaming capable sampler * * * * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck * + * Copyright (C) 2005, 2006 Christian Schoenebeck * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * @@ -25,18 +26,13 @@ #include "../../common/global.h" -#if DEBUG_HEADERS -# warning InstrumentResourceManager.h included -#endif // DEBUG_HEADERS +#include #include "../../common/global.h" -#include "../../common/LinuxSamplerException.h" +#include "../../common/Exception.h" #include "../../common/ResourceManager.h" -#include "../../audiodriver/AudioOutputDevice.h" -#include "../../lib/fileloader/libgig/gig.h" - -// preload 64k samples = 128kB of data in RAM for 16 bit mono samples -#define NUM_RAM_PRELOAD_SAMPLES 32768 +#include "../../drivers/audio/AudioOutputDevice.h" +#include "../InstrumentManager.h" //namespace libgig = gig; @@ -46,48 +42,46 @@ }} // namespace LinuxSampler::gig +#include "EngineChannel.h" #include "Engine.h" namespace LinuxSampler { namespace gig { // just symbol prototyping - class Engine; - - /** - * Explicitly identifies a Gigasampler instrument. - */ - struct instrument_id_t { - String FileName; ///< name of the file which contains the instrument - uint iInstrument; ///< index of the instrument in the instrument file - - // TODO: we should extend operator<() so it will be able to detect that file x and file y are actually the same files, e.g. because one of them is a symlink / share the same inode - bool operator<(const instrument_id_t& o) const { - return (iInstrument < o.iInstrument || (iInstrument == o.iInstrument && FileName < o.FileName)); - } - }; + class EngineChannel; - /** Gig instrument manager + /** @brief Gig instrument manager * * Manager to share gig instruments between multiple Gigasampler - * engines. The engines Borrow() instruments when they need them and - * HandBack() when they don't need them anymore. The + * engine channels. The engine channels Borrow() instruments when they + * need them and HandBack() when they don't need them anymore. The * InstrumentResourceManager loads the corresponding gig file and gig - * instrument if needed, if it's already in use by another engine, then - * it just returns the same resource, if an gig instrument / file is not - * in use by any engine anymore, then it will be freed from memory. + * instrument if needed, if it's already in use by another engine + * channel, then it just returns the same resource, if an gig + * instrument / file is not needed anymore, then it will be freed from + * memory. */ - class InstrumentResourceManager : public ResourceManager { + class InstrumentResourceManager : public InstrumentManager, public ResourceManager { + public: + InstrumentResourceManager() : Gigs(this) {} + virtual ~InstrumentResourceManager() {} + static void OnInstrumentLoadingProgress(::gig::progress_t* pProgress); + + // implementation of derived abstract methods from 'InstrumentManager' + virtual std::vector Instruments(); + virtual InstrumentManager::mode_t GetMode(const instrument_id_t& ID); + virtual void SetMode(const instrument_id_t& ID, InstrumentManager::mode_t Mode); + virtual String GetInstrumentName(instrument_id_t ID); + + void HandBackInstrument(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, + ::gig::DimensionRegion** dimRegionsInUse); + void HandBackDimReg(::gig::DimensionRegion* pDimReg); + protected: virtual ::gig::Instrument* Create(instrument_id_t Key, InstrumentConsumer* pConsumer, void*& pArg); virtual void Destroy(::gig::Instrument* pResource, void* pArg); virtual void OnBorrow(::gig::Instrument* pResource, InstrumentConsumer* pConsumer, void*& pArg); private: - struct instr_entry_t { - ::gig::File* pGig; - uint iInstrument; - uint MaxSamplesPerCycle; ///< if some engine requests an already allocated instrument with a higher value, we have to reallocate the instrument - }; - typedef ResourceConsumer< ::gig::File> GigConsumer; class GigResourceManager : public ResourceManager { @@ -95,17 +89,31 @@ virtual ::gig::File* Create(String Key, GigConsumer* pConsumer, void*& pArg); virtual void Destroy(::gig::File* pResource, void* pArg); virtual void OnBorrow(::gig::File* pResource, GigConsumer* pConsumer, void*& pArg) {} // ignore + public: + GigResourceManager(InstrumentResourceManager* parent) : parent(parent) {} + virtual ~GigResourceManager() {} + private: + InstrumentResourceManager* parent; } Gigs; - void CacheInitialSamples(::gig::Sample* pSample, gig::Engine* pEngine); + void CacheInitialSamples(::gig::Sample* pSample, gig::EngineChannel* pEngineChannel); + + struct dimreg_info_t { + int refCount; + ::gig::File* file; + ::RIFF::File* riff; + }; + Mutex DimRegInfoMutex; ///< protects the DimRegInfo and SampleRefCount maps from concurrent access by the instrument loader and disk threads + std::map< ::gig::DimensionRegion*, dimreg_info_t> DimRegInfo; ///< contains dimension regions that are still in use but belong to released instrument + std::map< ::gig::Sample*, int> SampleRefCount; ///< contains samples that are still in use but belong to a released instrument }; /** * Will be thrown by the InstrumentResourceManager on errors. */ - class InstrumentResourceManagerException : public LinuxSamplerException { + class InstrumentResourceManagerException : public Exception { public: - InstrumentResourceManagerException(String msg) : LinuxSamplerException(msg) {} + InstrumentResourceManagerException(String msg) : Exception(msg) {} }; }} // namespace LinuxSampler::gig