engines/gig/Engine.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
 *   Copyright (C) 2005-2008 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  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_GIG_ENGINE_H__
#define __LS_GIG_ENGINE_H__

#include "../../common/global.h"

#include <map>
#include <gig.h>

#include "EngineGlobals.h"
#include "../../common/RingBuffer.h"
#include "../../common/Pool.h"
#include "../../common/ArrayList.h"
#include "../../common/Condition.h"
#include "../../common/ConditionServer.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 {
        public:
            // methods
            Engine();
            virtual ~Engine();
            void Connect(AudioOutputDevice* pAudioOut);
            void SuspendAll();
            void ResumeAll();
            void Suspend(::gig::Region* pRegion);
            void Resume(::gig::Region* pRegion);

            // 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<Event,false>* pEventQueue;          ///< Input event queue for engine global events (e.g. SysEx messages).
            Pool<Voice>*            pVoicePool;            ///< Contains all voices that can be activated.
            EventGenerator*         pEventGenerator;
            RTList<Event>*          pVoiceStealingQueue;   ///< All voice-launching events which had to be postponed due to free voice shortage.
            RTList<Event>*          pGlobalEvents;         ///< All engine global events for the current audio fragment (usually only SysEx messages).
            Pool<Event>*            pEventPool;            ///< Contains all Event objects that can be used.
            RingBuffer<uint8_t,false>* 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<Voice>::Iterator itLastStolenVoice;     ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
            RTList<uint>::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<Voice>::Iterator itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
            RTList<uint>::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<Event>::Iterator& itNoteOnEvent);
            void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent);
            void ProcessPitchbend(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent);
            void ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent);
            void ProcessSysex(Pool<Event>::Iterator& itSysexEvent);
            void ProcessSuspensionsChanges();
            void ProcessPendingStreamDeletions();
            Pool<Voice>::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing, bool HandleKeyGroupConflicts);
            int  StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
            void FreeVoice(EngineChannel* pEngineChannel, Pool<Voice>::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

            friend class Voice;
        private:
            Pool< ::gig::Region*> SuspendedRegions;
            Mutex                 SuspendedRegionsMutex;
            Condition             SuspensionChangeOngoing;
            ::gig::Region*        pPendingRegionSuspension;
            ::gig::Region*        pPendingRegionResumption;
            int                   iPendingStreamDeletions;

            ArrayList<EngineChannel*> engineChannels; ///< All engine channels of a gig::Engine instance.

            static std::map<AudioOutputDevice*,Engine*> engines; ///< All instances of gig::Engine.

            int SostenutoKeys[128];
            int SostenutoKeyCount;

            uint8_t GSCheckSum(const RingBuffer<uint8_t,false>::NonVolatileReader AddrReader, uint DataSize);
            void    AdjustScale(int8_t ScaleTunes[12]);
            void    ReleaseAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itReleaseEvent);
            void    KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::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

            atomic_t ActiveVoiceCount; ///< number of currently active voices
            int iMaxDiskStreams;
    };

}} // namespace LinuxSampler::gig

#endif // __LS_GIG_ENGINE_H__
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005-2008 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	#ifndef __LS_GIG_ENGINE_H__
25	#define __LS_GIG_ENGINE_H__
26
27	#include "../../common/global.h"
28
29	#include <map>
30	#include <gig.h>
31
32	#include "EngineGlobals.h"
33	#include "../../common/RingBuffer.h"
34	#include "../../common/Pool.h"
35	#include "../../common/ArrayList.h"
36	#include "../../common/Condition.h"
37	#include "../../common/ConditionServer.h"
38	#include "../Engine.h"
39	#include "../common/Event.h"
40	#include "../../network/lscp.h"
41	#include "EngineChannel.h"
42
43	// identifier of this sampler engine
44	#define LS_GIG_ENGINE_NAME "GIG"
45
46	namespace LinuxSampler { namespace gig {
47
48	// just symbol prototyping
49	class Voice;
50	class DiskThread;
51	class InstrumentResourceManager;
52	class midi_key_info_t;
53	class EngineChannel;
54
55	/**
56	* Sampler engine for the Gigasampler format.
57	*/
58	class Engine : public LinuxSampler::Engine {
59	public:
60	// methods
61	Engine();
62	virtual ~Engine();
63	void Connect(AudioOutputDevice* pAudioOut);
64	void SuspendAll();
65	void ResumeAll();
66	void Suspend(::gig::Region* pRegion);
67	void Resume(::gig::Region* pRegion);
68
69	// implementation of abstract methods derived from class 'LinuxSampler::Engine'
70	virtual int RenderAudio(uint Samples);
71	virtual void SendSysex(void* pData, uint Size, MidiInputPort* pSender);
72	virtual void Reset();
73	virtual void Enable();
74	virtual void Disable();
75	virtual uint VoiceCount();
76	virtual uint VoiceCountMax();
77	virtual int MaxVoices();
78	virtual void SetMaxVoices(int iVoices) throw (Exception);
79	virtual bool DiskStreamSupported();
80	virtual uint DiskStreamCount();
81	virtual uint DiskStreamCountMax();
82	virtual int MaxDiskStreams();
83	virtual void SetMaxDiskStreams(int iStreams) throw (Exception);
84	virtual String DiskStreamBufferFillBytes();
85	virtual String DiskStreamBufferFillPercentage();
86	virtual String Description();
87	virtual String Version();
88	virtual String EngineName();
89	virtual InstrumentManager* GetInstrumentManager();
90
91	void SetVoiceCount(uint Count);
92
93	// Simple array wrapper just to make sure memory is freed
94	// when liblinuxsampler is unloaded
95	class FloatTable {
96	private:
97	const float* array;
98	public:
99	FloatTable(const float* array) : array(array) { }
100	~FloatTable() { delete[] array; }
101	const float& operator[](int i) const { return array[i]; }
102	};
103
104	static const FloatTable VolumeCurve; ///< Table that maps volume control change values 0..127 to amplitude. Unity gain is at 90.
105	static const FloatTable PanCurve; ///< Table that maps pan control change values 0..128 to right channel amplitude. Unity gain is at 64 (center).
106	static const FloatTable CrossfadeCurve; ///< Table that maps crossfade control change values 0..127 to amplitude. Unity gain is at 127.
107
108	//protected:
109	static InstrumentResourceManager instruments;
110
111	AudioOutputDevice* pAudioOutputDevice;
112	uint SampleRate; ///< Sample rate of the engines output audio signal (in Hz)
113	uint MaxSamplesPerCycle; ///< Size of each audio output buffer
114	DiskThread* pDiskThread;
115	RingBuffer<Event,false>* pEventQueue; ///< Input event queue for engine global events (e.g. SysEx messages).
116	Pool<Voice>* pVoicePool; ///< Contains all voices that can be activated.
117	EventGenerator* pEventGenerator;
118	RTList<Event>* pVoiceStealingQueue; ///< All voice-launching events which had to be postponed due to free voice shortage.
119	RTList<Event>* pGlobalEvents; ///< All engine global events for the current audio fragment (usually only SysEx messages).
120	Pool<Event>* pEventPool; ///< Contains all Event objects that can be used.
121	RingBuffer<uint8_t,false>* pSysexBuffer; ///< Input buffer for MIDI system exclusive messages.
122	int ActiveVoiceCountTemp; ///< number of currently active voices (for internal usage, will be used for incrementation)
123	int ActiveVoiceCountMax; ///< the maximum voice usage since application start
124	int VoiceSpawnsLeft; ///< We only allow CONFIG_MAX_VOICES voices to be spawned per audio fragment, we use this variable to ensure this limit.
125	RTList<Voice>::Iterator itLastStolenVoice; ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
126	RTList<uint>::Iterator iuiLastStolenKey; ///< Only for voice stealing: key number of last key on which the last voice was theft in current audio fragment, NULL otherwise.
127	EngineChannel* pLastStolenChannel; ///< Only for voice stealing: points to the engine channel on which the previous voice was stolen in this audio fragment.
128	RTList<Voice>::Iterator itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
129	RTList<uint>::Iterator iuiLastStolenKeyGlobally; ///< Same as iuiLastStolenKey, but engine globally
130	bool SuspensionRequested;
131	ConditionServer EngineDisabled;
132	int8_t ScaleTuning[12]; ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave
133	int MinFadeOutSamples; ///< The number of samples needed to make an instant fade out (e.g. for voice stealing) without leading to clicks.
134	uint32_t RandomSeed; ///< State of the random number generator used by the random dimension.
135	Mutex ResetInternalMutex; ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads).
136	Pool< ::gig::DimensionRegion> pDimRegionPool[2]; ///< Double buffered pool, used by the engine channels to keep track of dimension regions in use.
137
138	void ProcessEvents(EngineChannel* pEngineChannel, uint Samples);
139	void RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples);
140	void RenderStolenVoices(uint Samples);
141	void RouteAudio(EngineChannel* pEngineChannel, uint Samples);
142	void PostProcess(EngineChannel* pEngineChannel);
143	void ClearEventLists();
144	void ImportEvents(uint Samples);
145	void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
146	void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent);
147	void ProcessPitchbend(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent);
148	void ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent);
149	void ProcessSysex(Pool<Event>::Iterator& itSysexEvent);
150	void ProcessSuspensionsChanges();
151	void ProcessPendingStreamDeletions();
152	Pool<Voice>::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing, bool HandleKeyGroupConflicts);
153	int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
154	void FreeVoice(EngineChannel* pEngineChannel, Pool<Voice>::Iterator& itVoice);
155	void FreeKey(EngineChannel* pEngineChannel, midi_key_info_t* pKey);
156	void ResetInternal();
157	void ResetScaleTuning();
158	void ResetSuspendedRegions();
159
160	static Engine* AcquireEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
161	static void FreeEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
162
163	void DisableAndLock(); // FIXME: should at least be protected
164
165	friend class Voice;
166	private:
167	Pool< ::gig::Region*> SuspendedRegions;
168	Mutex SuspendedRegionsMutex;
169	Condition SuspensionChangeOngoing;
170	::gig::Region* pPendingRegionSuspension;
171	::gig::Region* pPendingRegionResumption;
172	int iPendingStreamDeletions;
173
174	ArrayList<EngineChannel*> engineChannels; ///< All engine channels of a gig::Engine instance.
175
176	static std::map<AudioOutputDevice,Engine> engines; ///< All instances of gig::Engine.
177
178	int SostenutoKeys[128];
179	int SostenutoKeyCount;
180
181	uint8_t GSCheckSum(const RingBuffer<uint8_t,false>::NonVolatileReader AddrReader, uint DataSize);
182	void AdjustScale(int8_t ScaleTunes[12]);
183	void ReleaseAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itReleaseEvent);
184	void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent);
185	bool ShouldReleaseVoice(EngineChannel* pEngineChannel, int Key);
186	bool RegionSuspended(::gig::Region* pRegion);
187	static float* InitVolumeCurve();
188	static float* InitPanCurve();
189	static float* InitCrossfadeCurve();
190	static float* InitCurve(const float* segments, int size = 128);
191
192	unsigned long FrameTime; ///< Time in frames of the start of the current audio fragment
193
194	atomic_t ActiveVoiceCount; ///< number of currently active voices
195	int iMaxDiskStreams;
196	};
197
198	}} // namespace LinuxSampler::gig
199
200	#endif // __LS_GIG_ENGINE_H__