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

        protected:
            AudioChannel*             pChannelLeft;             ///< encapsulates the audio rendering buffer (left)
            AudioChannel*             pChannelRight;            ///< encapsulates the audio rendering buffer (right)
            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	2354	protected:
93	iliev	2012	AudioChannel* pChannelLeft; ///< encapsulates the audio rendering buffer (left)
94			AudioChannel* pChannelRight; ///< encapsulates the audio rendering buffer (right)
95			int AudioDeviceChannelLeft; ///< audio device channel number to which the left channel is connected to
96			int AudioDeviceChannelRight; ///< audio device channel number to which the right channel is connected to
97			MidiInputPort* pMidiInputPort; ///< Points to the connected MIDI input port or NULL if none assigned.
98			midi_chan_t midiChannel; ///< MIDI channel(s) on which this engine channel listens to.
99			RingBuffer<Event,false>* pEventQueue; ///< Input event queue.
100			RTList<Event>* pEvents; ///< All engine channel specific events for the current audio fragment.
101			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).
102			String InstrumentFile;
103			int InstrumentIdx;
104			String InstrumentIdxName;
105			int InstrumentStat;
106			double GlobalVolume; ///< Master volume factor set through the C++ API / LSCP (a value < 1.0 means attenuation, a value > 1.0 means amplification)
107			double MidiVolume; ///< Volume factor altered by MIDI CC#7 (a value < 1.0 means attenuation, a value > 1.0 means amplification)
108			float GlobalPanLeft;
109			float GlobalPanRight;
110			int Pitch; ///< Current (absolute) MIDI pitch value.
111			float CurrentKeyDimension; ///< Current value (0-1.0) for the keyboard dimension, altered by pressing a keyswitching key.
112			bool PortamentoMode; ///< in Portamento Mode we slide the pitch from the last note to the current note.
113			float PortamentoTime; ///< How long it will take to glide from the previous note to the current (in seconds)
114			float PortamentoPos; ///< Current position on the keyboard, that is integer and fractional part (only used if PortamentoMode is on)
115			std::vector<FxSend*> fxSends;
116			int GlobalTranspose; ///< amount of semi tones all notes should be transposed
117			int iLastPanRequest; ///< just for the return value of Pan(), so we don't have to make an injective function
118			int iEngineIndexSelf; ///< Reflects the index of this EngineChannel in the Engine's ArrayList.
119			bool bStatusChanged; ///< true in case an engine parameter has changed (e.g. new instrument, another volumet)
120	persson	2043	uint32_t RoundRobinIndex; ///< counter for round robin sample selection, incremented for each note on
121	iliev	2012
122			SynchronizedConfig< ArrayList<VirtualMidiDevice*> > virtualMidiDevices;
123			SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_AudioThread;
124			SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_MidiThread;
125
126	persson	2127	// specialization of RTList that doesn't require the pool
127			// to be provided at construction time
128			template<typename T>
129			class LazyList : public RTList<T> {
130			public:
131			using RTList<T>::allocAppend;
132			using RTList<T>::pPool;
133	persson	2114
134	persson	2127	LazyList() : RTList<T>(0) { }
135			typename RTList<T>::Iterator allocAppend(Pool<T>* pool) {
136			pPool = pool;
137			return allocAppend();
138			}
139			};
140
141			typedef std::map<uint, LazyList<Event>*> ActiveKeyGroupMap;
142			ActiveKeyGroupMap ActiveKeyGroups; ///< Contains event queues for key groups, ordered by key group ID.
143
144	iliev	2012	virtual void ResetControllers();
145			virtual void ResetInternal();
146			virtual void RemoveAllFxSends();
147
148			void ImportEvents(uint Samples);
149	persson	2114
150			void AddGroup(uint group);
151			void HandleKeyGroupConflicts(uint KeyGroup, Pool<Event>::Iterator& itNoteOnEvent);
152			void ClearGroupEventLists();
153			void DeleteGroupEventLists();
154	iliev	2012	};
155
156			} // namespace LinuxSampler
157
158	persson	2114	#endif /* __LS_ABSTRACTENGINECHANNEL_H__ */
159	iliev	2012