src/engines/AbstractEngineChannel.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
 *   Copyright (C) 2005-2008 Christian Schoenebeck                         *
 *   Copyright (C) 2009-2012 Christian Schoenebeck and 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  *
 *   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_ABSTRACTENGINECHANNEL_H__
#define __LS_ABSTRACTENGINECHANNEL_H__

#include "EngineChannel.h"
#include "AbstractEngine.h"

#include "../common/Pool.h"
#include "../common/RingBuffer.h"

namespace LinuxSampler {

    class AbstractEngineChannel: public EngineChannel {
        public:
            // implementation of abstract methods derived from interface class 'LinuxSampler::EngineChannel'
            virtual void    PrepareLoadInstrument(const char* FileName, uint Instrument);
            virtual void    Reset();
            virtual void    SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel);
            virtual void    SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos);
            virtual void    SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel);
            virtual void    SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos);
            virtual void    SendPitchbend(int Pitch, uint8_t MidiChannel);
            virtual void    SendPitchbend(int Pitch, uint8_t MidiChannel, int32_t FragmentPos);
            virtual void    SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel);
            virtual void    SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel, int32_t FragmentPos);
            virtual bool    StatusChanged(bool bNewStatus = false);
            virtual float   Volume();
            virtual void    Volume(float f);
            virtual float   Pan();
            virtual void    Pan(float f);
            virtual uint    Channels();
            virtual AudioOutputDevice* GetAudioOutputDevice();
            virtual void    SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel);
            virtual int     OutputChannel(uint EngineAudioChannel);
            virtual void    Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel);
            virtual void    DisconnectMidiInputPort();
            virtual MidiInputPort* GetMidiInputPort();
            virtual midi_chan_t MidiChannel();
            virtual String  InstrumentFileName();
            virtual String  InstrumentName();
            virtual int     InstrumentIndex();
            virtual int     InstrumentStatus();
            virtual Engine* GetEngine();
            virtual String  EngineName();
            virtual FxSend* AddFxSend(uint8_t MidiCtrl, String Name = "") throw (Exception);
            virtual FxSend* GetFxSend(uint FxSendIndex);
            virtual uint    GetFxSendCount();
            virtual void    RemoveFxSend(FxSend* pFxSend);
            virtual void    Connect(VirtualMidiDevice* pDevice);
            virtual void    Disconnect(VirtualMidiDevice* pDevice);


            virtual AbstractEngine::Format GetEngineFormat() = 0;

            AudioOutputDevice* GetAudioOutputDeviceSafe();

            friend class AbstractVoice;
            friend class AbstractEngine;
            template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
            template<class EC, class R, class S, class D> friend class VoiceBase;

        protected:
            AbstractEngineChannel();
            virtual ~AbstractEngineChannel();

            AbstractEngine*           pEngine;
            Mutex                     EngineMutex; ///< protects the Engine from access by the instrument loader thread when lscp is disconnecting

        public: // TODO: should be protected
            AudioChannel*             pChannelLeft;             ///< encapsulates the audio rendering buffer (left)
            AudioChannel*             pChannelRight;            ///< encapsulates the audio rendering buffer (right)
        protected:
            int                       AudioDeviceChannelLeft;   ///< audio device channel number to which the left channel is connected to
            int                       AudioDeviceChannelRight;  ///< audio device channel number to which the right channel is connected to
            MidiInputPort*            pMidiInputPort;           ///< Points to the connected MIDI input port or NULL if none assigned.
            midi_chan_t               midiChannel;              ///< MIDI channel(s) on which this engine channel listens to.
            RingBuffer<Event,false>*  pEventQueue;              ///< Input event queue.
            RTList<Event>*            pEvents;                  ///< All engine channel specific events for the current audio fragment.
            uint8_t                   ControllerTable[129];     ///< Reflects the current values (0-127) of all MIDI controllers for this engine / sampler channel. Number 128 is for channel pressure (mono aftertouch).
            String                    InstrumentFile;
            int                       InstrumentIdx;
            String                    InstrumentIdxName;
            int                       InstrumentStat;
            double                    GlobalVolume;             ///< Master volume factor set through the C++ API / LSCP (a value < 1.0 means attenuation, a value > 1.0 means amplification)
            double                    MidiVolume;               ///< Volume factor altered by MIDI CC#7 (a value < 1.0 means attenuation, a value > 1.0 means amplification)
            float                     GlobalPanLeft;
            float                     GlobalPanRight;
            int                       Pitch;                    ///< Current (absolute) MIDI pitch value.
            float                     CurrentKeyDimension;      ///< Current value (0-1.0) for the keyboard dimension, altered by pressing a keyswitching key.
            bool                      PortamentoMode;           ///< in Portamento Mode we slide the pitch from the last note to the current note.
            float                     PortamentoTime;           ///< How long it will take to glide from the previous note to the current (in seconds)
            float                     PortamentoPos;            ///< Current position on the keyboard, that is integer and fractional part (only used if PortamentoMode is on)
            std::vector<FxSend*>      fxSends;
            int                       GlobalTranspose;          ///< amount of semi tones all notes should be transposed
            int                       iLastPanRequest;          ///< just for the return value of Pan(), so we don't have to make an injective function
            int                       iEngineIndexSelf;         ///< Reflects the index of this EngineChannel in the Engine's ArrayList.
            bool                      bStatusChanged;           ///< true in case an engine parameter has changed (e.g. new instrument, another volumet)
            uint32_t                  RoundRobinIndex;          ///< counter for round robin sample selection, incremented for each note on

            SynchronizedConfig< ArrayList<VirtualMidiDevice*> > virtualMidiDevices;
            SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_AudioThread;
            SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_MidiThread;

            // specialization of RTList that doesn't require the pool
            // to be provided at construction time
            template<typename T>
            class LazyList : public RTList<T> {
            public:
                using RTList<T>::allocAppend;
                using RTList<T>::pPool;

                LazyList() : RTList<T>(0) { }
                typename RTList<T>::Iterator allocAppend(Pool<T>* pool) {
                    pPool = pool;
                    return allocAppend();
                }
            };
            
            typedef std::map<uint, LazyList<Event>*> ActiveKeyGroupMap;
            ActiveKeyGroupMap ActiveKeyGroups;      ///< Contains event queues for key groups, ordered by key group ID.

            virtual void ResetControllers();
            virtual void ResetInternal();
            virtual void RemoveAllFxSends();

            void ImportEvents(uint Samples);

            void AddGroup(uint group);
            void HandleKeyGroupConflicts(uint KeyGroup, Pool<Event>::Iterator& itNoteOnEvent);
            void ClearGroupEventLists();
            void DeleteGroupEventLists();
    };

} // namespace LinuxSampler

#endif  /* __LS_ABSTRACTENGINECHANNEL_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	* Copyright (C) 2009-2012 Christian Schoenebeck and Grigor Iliev *
8	* *
9	* This program is free software; you can redistribute it and/or modify *
10	* it under the terms of the GNU General Public License as published by *
11	* the Free Software Foundation; either version 2 of the License, or *
12	* (at your option) any later version. *
13	* *
14	* This program is distributed in the hope that it will be useful, *
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17	* GNU General Public License for more details. *
18	* *
19	* You should have received a copy of the GNU General Public License *
20	* along with this program; if not, write to the Free Software *
21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
22	* MA 02111-1307 USA *
23	***************************************************************************/
24
25	#ifndef __LS_ABSTRACTENGINECHANNEL_H__
26	#define __LS_ABSTRACTENGINECHANNEL_H__
27
28	#include "EngineChannel.h"
29	#include "AbstractEngine.h"
30
31	#include "../common/Pool.h"
32	#include "../common/RingBuffer.h"
33
34	namespace LinuxSampler {
35
36	class AbstractEngineChannel: public EngineChannel {
37	public:
38	// implementation of abstract methods derived from interface class 'LinuxSampler::EngineChannel'
39	virtual void PrepareLoadInstrument(const char* FileName, uint Instrument);
40	virtual void Reset();
41	virtual void SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel);
42	virtual void SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos);
43	virtual void SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel);
44	virtual void SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos);
45	virtual void SendPitchbend(int Pitch, uint8_t MidiChannel);
46	virtual void SendPitchbend(int Pitch, uint8_t MidiChannel, int32_t FragmentPos);
47	virtual void SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel);
48	virtual void SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel, int32_t FragmentPos);
49	virtual bool StatusChanged(bool bNewStatus = false);
50	virtual float Volume();
51	virtual void Volume(float f);
52	virtual float Pan();
53	virtual void Pan(float f);
54	virtual uint Channels();
55	virtual AudioOutputDevice* GetAudioOutputDevice();
56	virtual void SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel);
57	virtual int OutputChannel(uint EngineAudioChannel);
58	virtual void Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel);
59	virtual void DisconnectMidiInputPort();
60	virtual MidiInputPort* GetMidiInputPort();
61	virtual midi_chan_t MidiChannel();
62	virtual String InstrumentFileName();
63	virtual String InstrumentName();
64	virtual int InstrumentIndex();
65	virtual int InstrumentStatus();
66	virtual Engine* GetEngine();
67	virtual String EngineName();
68	virtual FxSend* AddFxSend(uint8_t MidiCtrl, String Name = "") throw (Exception);
69	virtual FxSend* GetFxSend(uint FxSendIndex);
70	virtual uint GetFxSendCount();
71	virtual void RemoveFxSend(FxSend* pFxSend);
72	virtual void Connect(VirtualMidiDevice* pDevice);
73	virtual void Disconnect(VirtualMidiDevice* pDevice);
74
75
76	virtual AbstractEngine::Format GetEngineFormat() = 0;
77
78	AudioOutputDevice* GetAudioOutputDeviceSafe();
79
80	friend class AbstractVoice;
81	friend class AbstractEngine;
82	template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
83	template<class EC, class R, class S, class D> friend class VoiceBase;
84
85	protected:
86	AbstractEngineChannel();
87	virtual ~AbstractEngineChannel();
88
89	AbstractEngine* pEngine;
90	Mutex EngineMutex; ///< protects the Engine from access by the instrument loader thread when lscp is disconnecting
91
92	public: // TODO: should be protected
93	AudioChannel* pChannelLeft; ///< encapsulates the audio rendering buffer (left)
94	AudioChannel* pChannelRight; ///< encapsulates the audio rendering buffer (right)
95	protected:
96	int AudioDeviceChannelLeft; ///< audio device channel number to which the left channel is connected to
97	int AudioDeviceChannelRight; ///< audio device channel number to which the right channel is connected to
98	MidiInputPort* pMidiInputPort; ///< Points to the connected MIDI input port or NULL if none assigned.
99	midi_chan_t midiChannel; ///< MIDI channel(s) on which this engine channel listens to.
100	RingBuffer<Event,false>* pEventQueue; ///< Input event queue.
101	RTList<Event>* pEvents; ///< All engine channel specific events for the current audio fragment.
102	uint8_t ControllerTable[129]; ///< Reflects the current values (0-127) of all MIDI controllers for this engine / sampler channel. Number 128 is for channel pressure (mono aftertouch).
103	String InstrumentFile;
104	int InstrumentIdx;
105	String InstrumentIdxName;
106	int InstrumentStat;
107	double GlobalVolume; ///< Master volume factor set through the C++ API / LSCP (a value < 1.0 means attenuation, a value > 1.0 means amplification)
108	double MidiVolume; ///< Volume factor altered by MIDI CC#7 (a value < 1.0 means attenuation, a value > 1.0 means amplification)
109	float GlobalPanLeft;
110	float GlobalPanRight;
111	int Pitch; ///< Current (absolute) MIDI pitch value.
112	float CurrentKeyDimension; ///< Current value (0-1.0) for the keyboard dimension, altered by pressing a keyswitching key.
113	bool PortamentoMode; ///< in Portamento Mode we slide the pitch from the last note to the current note.
114	float PortamentoTime; ///< How long it will take to glide from the previous note to the current (in seconds)
115	float PortamentoPos; ///< Current position on the keyboard, that is integer and fractional part (only used if PortamentoMode is on)
116	std::vector<FxSend*> fxSends;
117	int GlobalTranspose; ///< amount of semi tones all notes should be transposed
118	int iLastPanRequest; ///< just for the return value of Pan(), so we don't have to make an injective function
119	int iEngineIndexSelf; ///< Reflects the index of this EngineChannel in the Engine's ArrayList.
120	bool bStatusChanged; ///< true in case an engine parameter has changed (e.g. new instrument, another volumet)
121	uint32_t RoundRobinIndex; ///< counter for round robin sample selection, incremented for each note on
122
123	SynchronizedConfig< ArrayList<VirtualMidiDevice*> > virtualMidiDevices;
124	SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_AudioThread;
125	SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_MidiThread;
126
127	// specialization of RTList that doesn't require the pool
128	// to be provided at construction time
129	template<typename T>
130	class LazyList : public RTList<T> {
131	public:
132	using RTList<T>::allocAppend;
133	using RTList<T>::pPool;
134
135	LazyList() : RTList<T>(0) { }
136	typename RTList<T>::Iterator allocAppend(Pool<T>* pool) {
137	pPool = pool;
138	return allocAppend();
139	}
140	};
141
142	typedef std::map<uint, LazyList<Event>*> ActiveKeyGroupMap;
143	ActiveKeyGroupMap ActiveKeyGroups; ///< Contains event queues for key groups, ordered by key group ID.
144
145	virtual void ResetControllers();
146	virtual void ResetInternal();
147	virtual void RemoveAllFxSends();
148
149	void ImportEvents(uint Samples);
150
151	void AddGroup(uint group);
152	void HandleKeyGroupConflicts(uint KeyGroup, Pool<Event>::Iterator& itNoteOnEvent);
153	void ClearGroupEventLists();
154	void DeleteGroupEventLists();
155	};
156
157	} // namespace LinuxSampler
158
159	#endif /* __LS_ABSTRACTENGINECHANNEL_H__ */
160