/[svn]/linuxsampler/trunk/src/engines/AbstractEngineChannel.h
ViewVC logotype

Annotation of /linuxsampler/trunk/src/engines/AbstractEngineChannel.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3557 - (hide annotations) (download) (as text)
Sun Aug 18 00:06:04 2019 UTC (5 weeks ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 15800 byte(s)
* NKSP: Introducing 64 bit support for NKSP integer scripts
  variables (declare $foo).
* Require C++11 compiler support.
* Autoconf: Added m4/ax_cxx_compile_stdcxx.m4 macro which is used
  for checking in configure for C++11 support (as mandatory
  requirement) and automatically adds compiler argument if required
  (e.g. -std=C++11).
* Bumped version (2.1.1.svn3).

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 schoenebeck 3073 * Copyright (C) 2012-2017 Christian Schoenebeck and Andreas Persson *
9 iliev 2012 * *
10     * This program is free software; you can redistribute it and/or modify *
11     * it under the terms of the GNU General Public License as published by *
12     * the Free Software Foundation; either version 2 of the License, or *
13     * (at your option) any later version. *
14     * *
15     * This program is distributed in the hope that it will be useful, *
16     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18     * GNU General Public License for more details. *
19     * *
20     * You should have received a copy of the GNU General Public License *
21     * along with this program; if not, write to the Free Software *
22     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
23     * MA 02111-1307 USA *
24     ***************************************************************************/
25    
26     #ifndef __LS_ABSTRACTENGINECHANNEL_H__
27 persson 2114 #define __LS_ABSTRACTENGINECHANNEL_H__
28 iliev 2012
29     #include "EngineChannel.h"
30     #include "AbstractEngine.h"
31    
32     #include "../common/Pool.h"
33     #include "../common/RingBuffer.h"
34 schoenebeck 2611 #include "../common/ResourceManager.h"
35     #include "common/AbstractInstrumentManager.h"
36     #include "common/InstrumentScriptVM.h"
37 iliev 2012
38 schoenebeck 2594 #define CTRL_TABLE_IDX_AFTERTOUCH 128
39     #define CTRL_TABLE_IDX_PITCHBEND 129
40 schoenebeck 3095 #define CTRL_TABLE_SIZE 130
41 schoenebeck 2594
42 iliev 2012 namespace LinuxSampler {
43    
44 schoenebeck 2613 class MidiKeyboardManagerBase;
45    
46 schoenebeck 2611 class AbstractEngineChannel: public EngineChannel, public InstrumentScriptConsumer {
47 iliev 2012 public:
48     // implementation of abstract methods derived from interface class 'LinuxSampler::EngineChannel'
49 schoenebeck 2434 virtual void PrepareLoadInstrument(const char* FileName, uint Instrument) OVERRIDE;
50     virtual void Reset() OVERRIDE;
51     virtual void SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel) OVERRIDE;
52     virtual void SendNoteOn(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
53     virtual void SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel) OVERRIDE;
54     virtual void SendNoteOff(uint8_t Key, uint8_t Velocity, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
55     virtual void SendPitchbend(int Pitch, uint8_t MidiChannel) OVERRIDE;
56     virtual void SendPitchbend(int Pitch, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
57     virtual void SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel) OVERRIDE;
58 schoenebeck 2559 virtual void SendControlChange(uint8_t Controller, uint8_t Value, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
59     virtual void SendChannelPressure(uint8_t Value, uint8_t MidiChannel) OVERRIDE;
60     virtual void SendChannelPressure(uint8_t Value, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
61     virtual void SendPolyphonicKeyPressure(uint8_t Key, uint8_t Value, uint8_t MidiChannel) OVERRIDE;
62     virtual void SendPolyphonicKeyPressure(uint8_t Key, uint8_t Value, uint8_t MidiChannel, int32_t FragmentPos) OVERRIDE;
63 schoenebeck 2434 virtual bool StatusChanged(bool bNewStatus = false) OVERRIDE;
64     virtual float Volume() OVERRIDE;
65     virtual void Volume(float f) OVERRIDE;
66     virtual float Pan() OVERRIDE;
67     virtual void Pan(float f) OVERRIDE;
68     virtual uint Channels() OVERRIDE;
69     virtual AudioOutputDevice* GetAudioOutputDevice() OVERRIDE;
70     virtual void SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) OVERRIDE;
71     virtual int OutputChannel(uint EngineAudioChannel) OVERRIDE;
72 schoenebeck 2500 virtual void Connect(MidiInputPort* pMidiPort) OVERRIDE;
73     virtual void Disconnect(MidiInputPort* pMidiPort) OVERRIDE;
74     virtual void DisconnectAllMidiInputPorts() OVERRIDE;
75     virtual uint GetMidiInputPortCount() OVERRIDE;
76     virtual MidiInputPort* GetMidiInputPort(uint index) OVERRIDE;
77 schoenebeck 2434 virtual midi_chan_t MidiChannel() OVERRIDE;
78 schoenebeck 2500 virtual void SetMidiChannel(midi_chan_t MidiChannel) OVERRIDE;
79     virtual void Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel) OVERRIDE; // deprecated, may be removed
80     virtual void DisconnectMidiInputPort() OVERRIDE; // deprecated, may be removed
81     virtual MidiInputPort* GetMidiInputPort() OVERRIDE; // deprecated, may be removed
82 schoenebeck 2434 virtual String InstrumentFileName() OVERRIDE;
83     virtual String InstrumentName() OVERRIDE;
84     virtual int InstrumentIndex() OVERRIDE;
85     virtual int InstrumentStatus() OVERRIDE;
86     virtual Engine* GetEngine() OVERRIDE;
87     virtual String EngineName() OVERRIDE;
88     virtual FxSend* AddFxSend(uint8_t MidiCtrl, String Name = "") throw (Exception) OVERRIDE;
89     virtual FxSend* GetFxSend(uint FxSendIndex) OVERRIDE;
90     virtual uint GetFxSendCount() OVERRIDE;
91     virtual void RemoveFxSend(FxSend* pFxSend) OVERRIDE;
92     virtual void Connect(VirtualMidiDevice* pDevice) OVERRIDE;
93     virtual void Disconnect(VirtualMidiDevice* pDevice) OVERRIDE;
94 iliev 2012
95 schoenebeck 2594 // implementation of abstract methods derived from AbstractEngine::ScriptConsumer
96     virtual void ResourceToBeUpdated(VMParserContext* pResource, void*& pUpdateArg) OVERRIDE {}
97     virtual void ResourceUpdated(VMParserContext* pOldResource, VMParserContext* pNewResource, void* pUpdateArg) OVERRIDE {}
98     virtual void OnResourceProgress(float fProgress) OVERRIDE {}
99 iliev 2012
100     virtual AbstractEngine::Format GetEngineFormat() = 0;
101 schoenebeck 2613 virtual MidiKeyboardManagerBase* GetMidiKeyboardManager() = 0;
102 iliev 2012
103 persson 2326 AudioOutputDevice* GetAudioOutputDeviceSafe();
104    
105 schoenebeck 2948 script_callback_id_t GetScriptCallbackID(const ScriptEvent* e) const {
106     return pScript->pEvents->getID(e);
107     }
108    
109     RTList<ScriptEvent>::Iterator ScriptCallbackByID(script_callback_id_t id) const {
110     return pScript->pEvents->fromID(id);
111     }
112    
113     void ScheduleResumeOfScriptCallback(RTList<ScriptEvent>::Iterator& itCallback, sched_time_t now, bool forever);
114    
115 schoenebeck 3557 bool hasFreeScriptCallbacks(vmint n) const {
116 schoenebeck 3293 return pScript->pEvents->poolHasFreeElements(n);
117     }
118    
119     RTList<ScriptEvent>::Iterator forkScriptCallback(ScriptEvent* parent, bool bAutoAbort);
120    
121 iliev 2015 friend class AbstractVoice;
122 iliev 2012 friend class AbstractEngine;
123     template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
124 iliev 2015 template<class EC, class R, class S, class D> friend class VoiceBase;
125 iliev 2012
126 schoenebeck 2594 //protected:
127 iliev 2012 AbstractEngineChannel();
128     virtual ~AbstractEngineChannel();
129    
130     AbstractEngine* pEngine;
131 persson 2326 Mutex EngineMutex; ///< protects the Engine from access by the instrument loader thread when lscp is disconnecting
132 schoenebeck 2500 Mutex MidiInputMutex; ///< Introduced when support for multiple MIDI inputs per engine channel was added: protects the MIDI event input ringbuffer on this engine channel to be accessed concurrently by multiple midi input threads. As alternative one might also move the ringbuffer from this engine channel to the individual MIDI ports/devices and let the sampler engine read the events from there instead of receiving them here.
133 persson 2326
134 schoenebeck 2594 //protected:
135 iliev 2012 AudioChannel* pChannelLeft; ///< encapsulates the audio rendering buffer (left)
136     AudioChannel* pChannelRight; ///< encapsulates the audio rendering buffer (right)
137     int AudioDeviceChannelLeft; ///< audio device channel number to which the left channel is connected to
138     int AudioDeviceChannelRight; ///< audio device channel number to which the right channel is connected to
139 schoenebeck 2500 DoubleBuffer< ArrayList<MidiInputPort*> > midiInputs; ///< MIDI input ports on which this sampler engine channel shall listen to.
140     midi_chan_t midiChannel; ///< MIDI channel(s) on which this engine channel listens to (on all MIDI input ports).
141 iliev 2012 RingBuffer<Event,false>* pEventQueue; ///< Input event queue.
142     RTList<Event>* pEvents; ///< All engine channel specific events for the current audio fragment.
143 schoenebeck 2871 struct _DelayedEvents {
144     RTList<Event>* pList; ///< Unsorted list where all delayed events are moved to and remain here until they're finally processed.
145     Pool<ScheduledEvent> schedulerNodes; ///< Nodes used to sort the delayed events (stored on pList) with time sorted queue.
146     RTAVLTree<ScheduledEvent> queue; ///< Used to access the delayed events (from pList) in time sorted manner.
147    
148     _DelayedEvents() : pList(NULL), schedulerNodes(CONFIG_MAX_EVENTS_PER_FRAGMENT) {}
149    
150     inline void clear() {
151     if (pList) pList->clear();
152     schedulerNodes.clear();
153     queue.clear();
154     }
155     } delayedEvents;
156 schoenebeck 3095 uint8_t ControllerTable[CTRL_TABLE_SIZE]; ///< Reflects the current values (0-127) of all MIDI controllers for this engine / sampler channel. Number 128 is for channel pressure (mono aftertouch), 129 for pitch bend.
157 iliev 2012 String InstrumentFile;
158     int InstrumentIdx;
159     String InstrumentIdxName;
160     int InstrumentStat;
161     double GlobalVolume; ///< Master volume factor set through the C++ API / LSCP (a value < 1.0 means attenuation, a value > 1.0 means amplification)
162     double MidiVolume; ///< Volume factor altered by MIDI CC#7 (a value < 1.0 means attenuation, a value > 1.0 means amplification)
163     int Pitch; ///< Current (absolute) MIDI pitch value.
164     float CurrentKeyDimension; ///< Current value (0-1.0) for the keyboard dimension, altered by pressing a keyswitching key.
165     bool PortamentoMode; ///< in Portamento Mode we slide the pitch from the last note to the current note.
166     float PortamentoTime; ///< How long it will take to glide from the previous note to the current (in seconds)
167     float PortamentoPos; ///< Current position on the keyboard, that is integer and fractional part (only used if PortamentoMode is on)
168     std::vector<FxSend*> fxSends;
169     int GlobalTranspose; ///< amount of semi tones all notes should be transposed
170     int iLastPanRequest; ///< just for the return value of Pan(), so we don't have to make an injective function
171     int iEngineIndexSelf; ///< Reflects the index of this EngineChannel in the Engine's ArrayList.
172     bool bStatusChanged; ///< true in case an engine parameter has changed (e.g. new instrument, another volumet)
173 persson 2043 uint32_t RoundRobinIndex; ///< counter for round robin sample selection, incremented for each note on
174 schoenebeck 2630 InstrumentScript* pScript; ///< Points to the real-time instrument script(s) to be executed, NULL if current instrument does not have an instrument script. Even though the underlying VM representation of the script is shared among multiple sampler channels, the InstrumentScript object here is not shared though, it exists for each sampler channel separately.
175 iliev 2012
176     SynchronizedConfig< ArrayList<VirtualMidiDevice*> > virtualMidiDevices;
177     SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_AudioThread;
178     SynchronizedConfig< ArrayList<VirtualMidiDevice*> >::Reader virtualMidiDevicesReader_MidiThread;
179    
180 persson 2127 // specialization of RTList that doesn't require the pool
181     // to be provided at construction time
182     template<typename T>
183     class LazyList : public RTList<T> {
184     public:
185     using RTList<T>::allocAppend;
186     using RTList<T>::pPool;
187 persson 2114
188 persson 2127 LazyList() : RTList<T>(0) { }
189     typename RTList<T>::Iterator allocAppend(Pool<T>* pool) {
190     pPool = pool;
191     return allocAppend();
192     }
193     };
194    
195     typedef std::map<uint, LazyList<Event>*> ActiveKeyGroupMap;
196     ActiveKeyGroupMap ActiveKeyGroups; ///< Contains event queues for key groups, ordered by key group ID.
197    
198 iliev 2012 virtual void ResetControllers();
199 schoenebeck 2871 virtual void ResetInternal(bool bResetEngine);
200 iliev 2012 virtual void RemoveAllFxSends();
201    
202     void ImportEvents(uint Samples);
203 schoenebeck 3557 virtual note_id_t ScheduleNoteMicroSec(const Event* pEvent, int64_t delay) = 0;
204     event_id_t ScheduleEventMicroSec(const Event* pEvent, int64_t delay);
205 schoenebeck 2879 void IgnoreEvent(event_id_t id);
206 schoenebeck 2884 virtual void IgnoreNote(note_id_t id) = 0;
207 schoenebeck 2879 void IgnoreEventByScriptID(const ScriptID& id);
208 schoenebeck 3073 virtual uint AllNoteIDs(note_id_t* dstBuf, uint bufSize) = 0;
209 persson 2114
210     void AddGroup(uint group);
211     void HandleKeyGroupConflicts(uint KeyGroup, Pool<Event>::Iterator& itNoteOnEvent);
212     void ClearGroupEventLists();
213     void DeleteGroupEventLists();
214 schoenebeck 2500
215     private:
216     /**
217     * Returns @c true if there are 2 ore more MidiInputPorts connected
218     * to this engine channel.
219     *
220     * This method is currently only used to prevent unnecessary
221     * MidiInputMutex.Lock() if there is not more than 1 MIDI input on
222     * this engine channel.
223     */
224     inline bool hasMultipleMIDIInputs() const {
225     //FIXME: leaves tiny time frames open (shortly after 1->2 devices connected or 2->1 disconnected) which could lead to concurrency issue for the purpose described above, however in practice it "should" be acceptable
226     return midiInputs.unsafeBack().size() > 1;
227     }
228 schoenebeck 2879
229     inline bool applyTranspose(Event* event);
230 iliev 2012 };
231    
232     } // namespace LinuxSampler
233    
234 persson 2114 #endif /* __LS_ABSTRACTENGINECHANNEL_H__ */
235 iliev 2012

  ViewVC Help
Powered by ViewVC