engines/gig/Engine.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 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"

#if DEBUG_HEADERS
# warning Engine.h included
#endif // DEBUG_HEADERS

#include <map>

#include "EngineGlobals.h"
#include "../../common/RingBuffer.h"
#include "../../common/Pool.h"
#include "../../common/ConditionServer.h"
#include "../common/Engine.h"
#include "../common/Event.h"
#include "../common/BiquadFilter.h"
#include "../../lib/fileloader/libgig/gig.h"
#include "../../network/lscp.h"
#include "EngineChannel.h"

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();
           ~Engine();
            int  RenderAudio(LinuxSampler::gig::EngineChannel* pEngineChannel, uint Samples);
            void Connect(AudioOutputDevice* pAudioOut);

            // implementation of abstract methods derived from class 'LinuxSampler::Engine'
            virtual void   SendSysex(void* pData, uint Size);
            virtual void   Reset();
            virtual void   Enable();
            virtual void   Disable();
            virtual uint   VoiceCount();
            virtual uint   VoiceCountMax();
            virtual bool   DiskStreamSupported();
            virtual uint   DiskStreamCount();
            virtual uint   DiskStreamCountMax();
            virtual String DiskStreamBufferFillBytes();
            virtual String DiskStreamBufferFillPercentage();
            virtual String Description();
            virtual String Version();
            virtual String EngineName();
                        
        //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>*      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>*          pEvents;               ///< All events for the current audio fragment.
            Pool<Event>*            pEventPool;            ///< Contains all Event objects that can be used.
            RTList<Event>*          pCCEvents;             ///< All control change events for the current audio fragment.
            RingBuffer<uint8_t>*    pSysexBuffer;          ///< Input buffer for MIDI system exclusive messages.
            RTList<Event>*          pSynthesisEvents[Event::destination_count];     ///< Events directly affecting synthesis parameter (like pitch, volume and filter).
            float*                  pSynthesisParameters[Event::destination_count]; ///< Matrix with final synthesis parameters for the current audio fragment which will be used in the main synthesis loop.
            biquad_param_t*         pBasicFilterParameters; ///< Biquad parameters of the basic bandpass filter.
            biquad_param_t*         pMainFilterParameters;  ///< Main biquad parameters of the individual filter (lowpass / bandpass / highpass).
            int                     ActiveVoiceCount;      ///< number of currently active voices
            int                     ActiveVoiceCountMax;   ///< the maximum voice usage since application start
            bool                    SuspensionRequested;
            ConditionServer         EngineDisabled;
            int8_t                  ScaleTuning[12];       ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave
            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.
            int                     MaxFadeOutPos;         ///< The last position in an audio fragment to allow an instant fade out (e.g. for voice stealing) without leading to clicks.

            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);
            Pool<Voice>::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing);
            void 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 ResetSynthesisParameters(Event::destination_t dst, float val);
            void ResetInternal();

            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;
            friend class EGADSR;
            friend class EGDecay;
            friend class VCAManipulator;
            friend class VCFCManipulator;
            friend class VCOManipulator;            
        private:
            std::list<EngineChannel*> samplerChannels; ///< All sampler channels of a gig::Engine instance.
                        
            static std::map<AudioOutputDevice*,Engine*> engines; ///< All instances of gig::Engine.
                        
            uint8_t GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize);
            void    AdjustScale(int8_t ScaleTunes[12]);
    };

}} // namespace LinuxSampler::gig

#endif // __LS_GIG_ENGINE_H__
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	schoenebeck	411	* Copyright (C) 2005 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			#ifndef __LS_GIG_ENGINE_H__
25			#define __LS_GIG_ENGINE_H__
26
27			#include "../../common/global.h"
28
29			#if DEBUG_HEADERS
30			# warning Engine.h included
31			#endif // DEBUG_HEADERS
32
33	schoenebeck	239	#include <map>
34
35	schoenebeck	411	#include "EngineGlobals.h"
36	schoenebeck	53	#include "../../common/RingBuffer.h"
37	schoenebeck	271	#include "../../common/Pool.h"
38	schoenebeck	53	#include "../../common/ConditionServer.h"
39			#include "../common/Engine.h"
40			#include "../common/Event.h"
41	schoenebeck	80	#include "../common/BiquadFilter.h"
42	schoenebeck	53	#include "../../lib/fileloader/libgig/gig.h"
43			#include "../../network/lscp.h"
44	schoenebeck	411	#include "EngineChannel.h"
45	schoenebeck	53
46			namespace LinuxSampler { namespace gig {
47
48			// just symbol prototyping
49			class Voice;
50			class DiskThread;
51			class InstrumentResourceManager;
52	schoenebeck	411	class midi_key_info_t;
53			class EngineChannel;
54	schoenebeck	53
55			/**
56			* Sampler engine for the Gigasampler format.
57			*/
58	schoenebeck	411	class Engine : public LinuxSampler::Engine {
59			public:
60	schoenebeck	53	// methods
61			Engine();
62			~Engine();
63	schoenebeck	411	int RenderAudio(LinuxSampler::gig::EngineChannel* pEngineChannel, uint Samples);
64			void Connect(AudioOutputDevice* pAudioOut);
65	schoenebeck	53
66	schoenebeck	411	// implementation of abstract methods derived from class 'LinuxSampler::Engine'
67			virtual void SendSysex(void* pData, uint Size);
68	schoenebeck	53	virtual void Reset();
69			virtual void Enable();
70			virtual void Disable();
71			virtual uint VoiceCount();
72			virtual uint VoiceCountMax();
73			virtual bool DiskStreamSupported();
74			virtual uint DiskStreamCount();
75			virtual uint DiskStreamCountMax();
76			virtual String DiskStreamBufferFillBytes();
77			virtual String DiskStreamBufferFillPercentage();
78			virtual String Description();
79			virtual String Version();
80	senkov	112	virtual String EngineName();
81	schoenebeck	411
82			//protected:
83			static InstrumentResourceManager instruments;
84	schoenebeck	53
85			AudioOutputDevice* pAudioOutputDevice;
86	schoenebeck	225	uint SampleRate; ///< Sample rate of the engines output audio signal (in Hz)
87			uint MaxSamplesPerCycle; ///< Size of each audio output buffer
88	schoenebeck	411	DiskThread* pDiskThread;
89			RingBuffer<Event>* pEventQueue; ///< Input event queue for engine global events (e.g. SysEx messages).
90			Pool<Voice>* pVoicePool; ///< Contains all voices that can be activated.
91			EventGenerator* pEventGenerator;
92	schoenebeck	271	RTList<Event>* pVoiceStealingQueue; ///< All voice-launching events which had to be postponed due to free voice shortage.
93			RTList<Event>* pEvents; ///< All events for the current audio fragment.
94	schoenebeck	411	Pool<Event>* pEventPool; ///< Contains all Event objects that can be used.
95	schoenebeck	271	RTList<Event>* pCCEvents; ///< All control change events for the current audio fragment.
96	schoenebeck	411	RingBuffer<uint8_t>* pSysexBuffer; ///< Input buffer for MIDI system exclusive messages.
97	schoenebeck	271	RTList<Event>* pSynthesisEvents[Event::destination_count]; ///< Events directly affecting synthesis parameter (like pitch, volume and filter).
98	schoenebeck	53	float* pSynthesisParameters[Event::destination_count]; ///< Matrix with final synthesis parameters for the current audio fragment which will be used in the main synthesis loop.
99	schoenebeck	80	biquad_param_t* pBasicFilterParameters; ///< Biquad parameters of the basic bandpass filter.
100			biquad_param_t* pMainFilterParameters; ///< Main biquad parameters of the individual filter (lowpass / bandpass / highpass).
101	schoenebeck	53	int ActiveVoiceCount; ///< number of currently active voices
102			int ActiveVoiceCountMax; ///< the maximum voice usage since application start
103			bool SuspensionRequested;
104			ConditionServer EngineDisabled;
105	schoenebeck	244	int8_t ScaleTuning[12]; ///< contains optional detune factors (-64..+63 cents) for all 12 semitones of an octave
106	schoenebeck	271	RTList<Voice>::Iterator itLastStolenVoice; ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
107			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.
108	schoenebeck	411	int MaxFadeOutPos; ///< The last position in an audio fragment to allow an instant fade out (e.g. for voice stealing) without leading to clicks.
109	schoenebeck	53
110	schoenebeck	411	void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
111			void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent);
112			void ProcessPitchbend(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent);
113			void ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent);
114	schoenebeck	271	void ProcessSysex(Pool<Event>::Iterator& itSysexEvent);
115	schoenebeck	411	Pool<Voice>::Iterator LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing);
116			void StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent);
117			void FreeVoice(EngineChannel* pEngineChannel, Pool<Voice>::Iterator& itVoice);
118			void FreeKey(EngineChannel* pEngineChannel, midi_key_info_t* pKey);
119	schoenebeck	53	void ResetSynthesisParameters(Event::destination_t dst, float val);
120			void ResetInternal();
121
122	schoenebeck	411	static Engine* AcquireEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
123			static void FreeEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice);
124
125			void DisableAndLock(); // FIXME: should at least be protected
126
127	schoenebeck	53	friend class Voice;
128			friend class EGADSR;
129			friend class EGDecay;
130			friend class VCAManipulator;
131			friend class VCFCManipulator;
132	schoenebeck	411	friend class VCOManipulator;
133	schoenebeck	53	private:
134	schoenebeck	411	std::list<EngineChannel*> samplerChannels; ///< All sampler channels of a gig::Engine instance.
135
136			static std::map<AudioOutputDevice,Engine> engines; ///< All instances of gig::Engine.
137
138	schoenebeck	244	uint8_t GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize);
139			void AdjustScale(int8_t ScaleTunes[12]);
140	schoenebeck	53	};
141
142			}} // namespace LinuxSampler::gig
143
144			#endif // __LS_GIG_ENGINE_H__