--- linuxsampler/trunk/src/engines/gig/Engine.h 2009/03/29 18:43:40 1879 +++ linuxsampler/trunk/src/engines/gig/Engine.h 2009/10/23 17:53:17 2012 @@ -4,6 +4,7 @@ * * * Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck * * Copyright (C) 2005-2009 Christian Schoenebeck * + * Copyright (C) 2009 Grigor Iliev * * * * 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 * @@ -22,180 +23,61 @@ ***************************************************************************/ #ifndef __LS_GIG_ENGINE_H__ -#define __LS_GIG_ENGINE_H__ +#define __LS_GIG_ENGINE_H__ -#include "../../common/global.h" - -#include +#include "DiskThread.h" +#include "../EngineBase.h" +#include "Voice.h" #include -#include "EngineGlobals.h" -#include "../../common/RingBuffer.h" -#include "../../common/Pool.h" -#include "../../common/ArrayList.h" -#include "../../common/Condition.h" -#include "../../common/ConditionServer.h" -#include "../../common/atomic.h" -#include "../Engine.h" -#include "../common/Event.h" -#include "../../network/lscp.h" -#include "EngineChannel.h" - -// identifier of this sampler engine -#define LS_GIG_ENGINE_NAME "GIG" - namespace LinuxSampler { namespace gig { - // just symbol prototyping - class Voice; - class DiskThread; - class InstrumentResourceManager; - class midi_key_info_t; - class EngineChannel; - - /** - * Sampler engine for the Gigasampler format. - */ - class Engine : public LinuxSampler::Engine { + class Engine: public LinuxSampler::EngineBase { public: - // methods - Engine(); - virtual ~Engine(); - void Connect(AudioOutputDevice* pAudioOut); - void SuspendAll(); - void ResumeAll(); - void Suspend(::gig::Region* pRegion); - void Resume(::gig::Region* pRegion); - + Engine() { } + virtual ~Engine() { } // implementation of abstract methods derived from class 'LinuxSampler::Engine' - virtual int RenderAudio(uint Samples); - virtual void SendSysex(void* pData, uint Size, MidiInputPort* pSender); - virtual void Reset(); - virtual void Enable(); - virtual void Disable(); - virtual uint VoiceCount(); - virtual uint VoiceCountMax(); - virtual int MaxVoices(); - virtual void SetMaxVoices(int iVoices) throw (Exception); - virtual bool DiskStreamSupported(); - virtual uint DiskStreamCount(); - virtual uint DiskStreamCountMax(); - virtual int MaxDiskStreams(); - virtual void SetMaxDiskStreams(int iStreams) throw (Exception); - virtual String DiskStreamBufferFillBytes(); - virtual String DiskStreamBufferFillPercentage(); - virtual String Description(); - virtual String Version(); - virtual String EngineName(); - virtual InstrumentManager* GetInstrumentManager(); - - void SetVoiceCount(uint Count); - - // Simple array wrapper just to make sure memory is freed - // when liblinuxsampler is unloaded - class FloatTable { - private: - const float* array; - public: - FloatTable(const float* array) : array(array) { } - ~FloatTable() { delete[] array; } - const float& operator[](int i) const { return array[i]; } - }; - - static const FloatTable VolumeCurve; ///< Table that maps volume control change values 0..127 to amplitude. Unity gain is at 90. - static const FloatTable PanCurve; ///< Table that maps pan control change values 0..128 to right channel amplitude. Unity gain is at 64 (center). - static const FloatTable CrossfadeCurve; ///< Table that maps crossfade control change values 0..127 to amplitude. Unity gain is at 127. - - //protected: - static InstrumentResourceManager instruments; - - AudioOutputDevice* pAudioOutputDevice; - uint SampleRate; ///< Sample rate of the engines output audio signal (in Hz) - uint MaxSamplesPerCycle; ///< Size of each audio output buffer - DiskThread* pDiskThread; - RingBuffer* pEventQueue; ///< Input event queue for engine global events (e.g. SysEx messages). - Pool* pVoicePool; ///< Contains all voices that can be activated. - EventGenerator* pEventGenerator; - RTList* pVoiceStealingQueue; ///< All voice-launching events which had to be postponed due to free voice shortage. - RTList* pGlobalEvents; ///< All engine global events for the current audio fragment (usually only SysEx messages). - Pool* pEventPool; ///< Contains all Event objects that can be used. - RingBuffer* pSysexBuffer; ///< Input buffer for MIDI system exclusive messages. - int ActiveVoiceCountTemp; ///< number of currently active voices (for internal usage, will be used for incrementation) - int ActiveVoiceCountMax; ///< the maximum voice usage since application start - int VoiceSpawnsLeft; ///< We only allow CONFIG_MAX_VOICES voices to be spawned per audio fragment, we use this variable to ensure this limit. - RTList::Iterator itLastStolenVoice; ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise. - RTList::Iterator iuiLastStolenKey; ///< Only for voice stealing: key number of last key on which the last voice was theft in current audio fragment, NULL otherwise. - EngineChannel* pLastStolenChannel; ///< Only for voice stealing: points to the engine channel on which the previous voice was stolen in this audio fragment. - RTList::Iterator itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally - RTList::Iterator iuiLastStolenKeyGlobally; ///< Same as iuiLastStolenKey, but engine globally - bool SuspensionRequested; - ConditionServer EngineDisabled; - int8_t ScaleTuning[12]; ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave - int MinFadeOutSamples; ///< The number of samples needed to make an instant fade out (e.g. for voice stealing) without leading to clicks. - uint32_t RandomSeed; ///< State of the random number generator used by the random dimension. - Mutex ResetInternalMutex; ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads). - Pool< ::gig::DimensionRegion*>* pDimRegionPool[2]; ///< Double buffered pool, used by the engine channels to keep track of dimension regions in use. - - void ProcessEvents(EngineChannel* pEngineChannel, uint Samples); - void RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples); - void RenderStolenVoices(uint Samples); - void RouteAudio(EngineChannel* pEngineChannel, uint Samples); - void PostProcess(EngineChannel* pEngineChannel); - void ClearEventLists(); - void ImportEvents(uint Samples); - void ProcessNoteOn(EngineChannel* pEngineChannel, Pool::Iterator& itNoteOnEvent); - void ProcessNoteOff(EngineChannel* pEngineChannel, Pool::Iterator& itNoteOffEvent); - void ProcessPitchbend(EngineChannel* pEngineChannel, Pool::Iterator& itPitchbendEvent); - void ProcessControlChange(EngineChannel* pEngineChannel, Pool::Iterator& itControlChangeEvent); - void ProcessSysex(Pool::Iterator& itSysexEvent); - void ProcessSuspensionsChanges(); - void ProcessPendingStreamDeletions(); - Pool::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing, bool HandleKeyGroupConflicts); - int StealVoice(EngineChannel* pEngineChannel, Pool::Iterator& itNoteOnEvent); - void FreeVoice(EngineChannel* pEngineChannel, Pool::Iterator& itVoice); - void FreeKey(EngineChannel* pEngineChannel, midi_key_info_t* pKey); - void ResetInternal(); - void ResetScaleTuning(); - void ResetSuspendedRegions(); - - static Engine* AcquireEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice); - static void FreeEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice); - - void DisableAndLock(); // FIXME: should at least be protected + virtual bool DiskStreamSupported(); + virtual String Description(); + virtual String Version(); + + virtual Format GetEngineFormat(); + + virtual void ProcessControlChange ( + LinuxSampler::EngineChannel* pEngineChannel, + Pool::Iterator& itControlChangeEvent + ); friend class Voice; - private: - Pool< ::gig::Region*> SuspendedRegions; - Mutex SuspendedRegionsMutex; - Condition SuspensionChangeOngoing; - ::gig::Region* pPendingRegionSuspension; - ::gig::Region* pPendingRegionResumption; - int iPendingStreamDeletions; - - ArrayList engineChannels; ///< All engine channels of a gig::Engine instance. - - static std::map engines; ///< All instances of gig::Engine. - - int SostenutoKeys[128]; - int SostenutoKeyCount; - - uint8_t GSCheckSum(const RingBuffer::NonVolatileReader AddrReader, uint DataSize); - void AdjustScale(int8_t ScaleTunes[12]); - void ReleaseAllVoices(EngineChannel* pEngineChannel, Pool::Iterator& itReleaseEvent); - void KillAllVoices(EngineChannel* pEngineChannel, Pool::Iterator& itKillEvent); - bool ShouldReleaseVoice(EngineChannel* pEngineChannel, int Key); - bool RegionSuspended(::gig::Region* pRegion); - static float* InitVolumeCurve(); - static float* InitPanCurve(); - static float* InitCrossfadeCurve(); - static float* InitCurve(const float* segments, int size = 128); - unsigned long FrameTime; ///< Time in frames of the start of the current audio fragment + protected: + virtual DiskThread* CreateDiskThread(); + + virtual Pool::Iterator LaunchVoice ( + LinuxSampler::EngineChannel* pEngineChannel, + Pool::Iterator& itNoteOnEvent, + int iLayer, + bool ReleaseTriggerVoice, + bool VoiceStealing, + bool HandleKeyGroupConflicts + ); + + virtual void TriggerNewVoices ( + LinuxSampler::EngineChannel* pEngineChannel, + RTList::Iterator& itNoteOnEvent, + bool HandleKeyGroupConflicts + ); + + void TriggerReleaseVoices ( + LinuxSampler::EngineChannel* pEngineChannel, + RTList::Iterator& itNoteOffEvent + ); - atomic_t ActiveVoiceCount; ///< number of currently active voices - int iMaxDiskStreams; + private: + uint32_t RandomSeed; ///< State of the random number generator used by the random dimension. }; }} // namespace LinuxSampler::gig -#endif // __LS_GIG_ENGINE_H__ +#endif /* __LS_GIG_ENGINE_H__ */ +