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	iliev	2012	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6	persson	2114	* Copyright (C) 2005-2008 Christian Schoenebeck *
7	persson	2317	* Copyright (C) 2009-2012 Christian Schoenebeck and Grigor Iliev *
8	iliev	2012	* *
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	persson	2114	#define __LS_ABSTRACTENGINECHANNEL_H__
27	iliev	2012
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	persson	2317	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	iliev	2012	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	persson	2326	virtual Engine* GetEngine();
67	iliev	2012	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	persson	2326	AudioOutputDevice* GetAudioOutputDeviceSafe();
79
80	iliev	2015	friend class AbstractVoice;
81	iliev	2012	friend class AbstractEngine;
82			template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
83	iliev	2015	template<class EC, class R, class S, class D> friend class VoiceBase;
84	iliev	2012
85			protected:
86			AbstractEngineChannel();
87			virtual ~AbstractEngineChannel();
88
89			AbstractEngine* pEngine;
90	persson	2326	Mutex EngineMutex; ///< protects the Engine from access by the instrument loader thread when lscp is disconnecting
91
92	persson	2013	public: // TODO: should be protected
93	iliev	2012	AudioChannel* pChannelLeft; ///< encapsulates the audio rendering buffer (left)
94			AudioChannel* pChannelRight; ///< encapsulates the audio rendering buffer (right)
95	persson	2013	protected:
96	iliev	2012	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	persson	2043	uint32_t RoundRobinIndex; ///< counter for round robin sample selection, incremented for each note on
122	iliev	2012
123			SynchronizedConfig< ArrayList<VirtualMidiDevice*> > virtualMidiDevices;
124			SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_AudioThread;
125			SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_MidiThread;
126
127	persson	2127	// 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	persson	2114
135	persson	2127	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	iliev	2012	virtual void ResetControllers();
146			virtual void ResetInternal();
147			virtual void RemoveAllFxSends();
148
149			void ImportEvents(uint Samples);
150	persson	2114
151			void AddGroup(uint group);
152			void HandleKeyGroupConflicts(uint KeyGroup, Pool<Event>::Iterator& itNoteOnEvent);
153			void ClearGroupEventLists();
154			void DeleteGroupEventLists();
155	iliev	2012	};
156
157			} // namespace LinuxSampler
158
159	persson	2114	#endif /* __LS_ABSTRACTENGINECHANNEL_H__ */
160	iliev	2012