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

Diff of /linuxsampler/trunk/src/engines/EngineChannel.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 906 by schoenebeck, Sun Jul 23 16:44:08 2006 UTC revision 1297 by iliev, Thu Aug 16 15:55:21 2007 UTC
# Line 1  Line 1 
1  /***************************************************************************  /***************************************************************************
2   *                                                                         *   *                                                                         *
3   *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *   *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
4   *                                                                         *   *                                                                         *
5   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
6   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 21  Line 21 
21  #ifndef __LS_ENGINECHANNEL_H__  #ifndef __LS_ENGINECHANNEL_H__
22  #define __LS_ENGINECHANNEL_H__  #define __LS_ENGINECHANNEL_H__
23    
24    #include "../EventListeners.h"
25  #include "../drivers/audio/AudioOutputDevice.h"  #include "../drivers/audio/AudioOutputDevice.h"
26  #include "../drivers/midi/midi.h"  #include "../drivers/midi/midi.h"
27  #include "../drivers/midi/MidiInputDevice.h"  #include "../drivers/midi/MidiInputDevice.h"
28  #include "../drivers/midi/MidiInputPort.h"  #include "../drivers/midi/MidiInputPort.h"
29  #include "Engine.h"  #include "Engine.h"
30    #include "FxSend.h"
31    
32  namespace LinuxSampler {  namespace LinuxSampler {
33    
34      // just symbol prototyping      // just symbol prototyping
35      class AudioOutputDevice;      class AudioOutputDevice;
36      class MidiInputPort;      class MidiInputPort;
37        class FxSend;
38    
39    
40      /** @brief Channel Interface for LinuxSampler Sampler Engines      /** @brief Channel Interface for LinuxSampler Sampler Engines
41       *       *
# Line 68  namespace LinuxSampler { Line 72  namespace LinuxSampler {
72              virtual uint    Channels() = 0;              virtual uint    Channels() = 0;
73              virtual void    Connect(AudioOutputDevice* pAudioOut) = 0;              virtual void    Connect(AudioOutputDevice* pAudioOut) = 0;
74              virtual void    DisconnectAudioOutputDevice() = 0;              virtual void    DisconnectAudioOutputDevice() = 0;
75                virtual AudioOutputDevice* GetAudioOutputDevice() = 0;
76              virtual void    SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) = 0;              virtual void    SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) = 0;
77              virtual int     OutputChannel(uint EngineAudioChannel) = 0;              virtual int     OutputChannel(uint EngineAudioChannel) = 0;
78              virtual void    Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel) = 0;              virtual void    Connect(MidiInputPort* pMidiPort, midi_chan_t MidiChannel) = 0;
# Line 80  namespace LinuxSampler { Line 85  namespace LinuxSampler {
85              virtual int     InstrumentStatus() = 0;              virtual int     InstrumentStatus() = 0;
86              virtual Engine* GetEngine() = 0;              virtual Engine* GetEngine() = 0;
87              virtual String  EngineName() = 0;              virtual String  EngineName() = 0;
88                virtual FxSend* AddFxSend(uint8_t MidiCtrl, String Name = "") throw (Exception) = 0;
89                virtual FxSend* GetFxSend(uint FxSendIndex) = 0;
90                virtual uint    GetFxSendCount() = 0;
91                virtual void    RemoveFxSend(FxSend* pFxSend) = 0;
92    
93    
94                /////////////////////////////////////////////////////////////////
95                // normal methods
96                //     (usually not to be overridden by descendant)
97    
98              /**              /**
99               * Sets the mute state of this channel.               * Sets the mute state of this channel.
# Line 113  namespace LinuxSampler { Line 127  namespace LinuxSampler {
127               */               */
128              bool GetSolo();              bool GetSolo();
129    
130                /**
131                 * Returns current MIDI program (change) number of this
132                 * EngineChannel.
133                 */
134                uint8_t GetMidiProgram();
135    
136                /**
137                 * Change EngineChannel's MIDI program.
138                 */
139                void SetMidiProgram(uint8_t Program);
140    
141                /**
142                 * Returns current MIDI bank MSB (coarse) number of this
143                 * EngineChannel.
144                 */
145                uint8_t GetMidiBankMsb();
146    
147                /**
148                 * Change current MIDI bank MSB (coarse) number of this
149                 * EngineChannel.
150                 */
151                void SetMidiBankMsb(uint8_t BankMSB);
152    
153                /**
154                 * Returns current MIDI bank LSB (fine) number of this
155                 * EngineChannel.
156                 */
157                uint8_t GetMidiBankLsb();
158    
159                /**
160                 * Change current MIDI bank LSB (fine) number of this
161                 * EngineChannel.
162                 */
163                void SetMidiBankLsb(uint8_t BankLSB);
164    
165                /**
166                 * Returns true if this EngineChannel is using no MIDI
167                 * instrument map at all, that is if it will ignore all MIDI
168                 * program change messages.
169                 *
170                 * @see UsesDefaultMidiInstrumentMap()
171                 * @see GetMidiInstrumentMap()
172                 */
173                bool UsesNoMidiInstrumentMap();
174    
175                /**
176                 * Returns true if this EngineChannel is using the default MIDI
177                 * instrument map for handling MIDI program changes.
178                 *
179                 * @see UsesNoMidiInstrumentMap()
180                 * @see GetMidiInstrumentMap()
181                 */
182                bool UsesDefaultMidiInstrumentMap();
183    
184                /**
185                 * Returns ID of the MIDI instrument map currently used by this
186                 * EngineChannel to handle MIDI program changes. You should
187                 * always call @c UsesNoMidiInstrumentMap() and
188                 * @c UsesDefaultMidiInstrumentMap() before calling this method
189                 * to check if this EngineChannel is probably using the default
190                 * map or no map at all, because in these two particular cases
191                 * this method would throw an exception!
192                 *
193                 * @throws Exception - if EngineChannel is set to no map at all
194                 *                     or is set to the default map
195                 * @see UsesNoMidiInstrumentMap()
196                 * @see UsesDefaultMidiInstrumentMap()
197                 */
198                int GetMidiInstrumentMap() throw (Exception);
199    
200                /**
201                 * Let this EngineChannel use no MIDI instrument map at all,
202                 * that is to let it ignore all MIDI program change messages.
203                 *
204                 * @see SetMidiInstrumentMapToDefault()
205                 * @see SetMidiInstrumentMap()
206                 */
207                void SetMidiInstrumentMapToNone();
208    
209                /**
210                 * Let this EngineChannel use the default MIDI instrument map to
211                 * handle MIDI program changes.
212                 *
213                 * @see SetMidiInstrumentMapToNone()
214                 * @see SetMidiInstrumentMap()
215                 */
216                void SetMidiInstrumentMapToDefault();
217    
218                /**
219                 * Set a specific MIDI instrument map this EngineChannel should
220                 * use to handle MIDI program changes.
221                 *
222                 * @see SetMidiInstrumentMapToNone()
223                 * @see SetMidiInstrumentMapToDefault()
224                 *
225                 * @throws Exception - in case given map does not exist
226                 */
227                void SetMidiInstrumentMap(int MidiMap) throw (Exception);
228    
229                /**
230                 * Set MIDI Registered Parameter Number (RPN) Controller
231                 * (upper 8 bits / coarse).
232                 */
233                void SetMidiRpnControllerMsb(uint8_t CtrlMSB);
234    
235                /**
236                 * Set MIDI Registered Parameter Number (RPN) Controller
237                 * (lower 8 bits / fine).
238                 */
239                void SetMidiRpnControllerLsb(uint8_t CtrlLSB);
240    
241                /**
242                 * Reset to no RPN controller currently selected.
243                 */
244                void ResetMidiRpnController();
245                
246                 /**
247                 * Registers the specified listener to be notified when the number
248                 * of effect sends on this channel is changed.
249                 */
250                void AddFxSendCountListener(FxSendCountListener* l);
251    
252                /**
253                 * Removes the specified listener.
254                 */
255                void RemoveFxSendCountListener(FxSendCountListener* l);
256    
257                /**
258                 * Removes all listeners.
259                 */
260                void RemoveAllFxSendCountListeners();
261    
262                /**
263                 * Get currently selected MIDI Registered Parameter Number
264                 * (RPN) Controller, this method will return the already merged
265                 * value (MSB and LSB value).
266                 *
267                 * @e WARNING: you have to call @c ResetMidiRpnController()
268                 * after using this value, otherwise all subsequent MIDI CC #6
269                 * (Data) messages are interpreted as RPN controller value
270                 * messages.
271                 *
272                 * @returns currently selected RPN controller number, a negative
273                 *          value if no RPN controller currently selected
274                 */
275                int GetMidiRpnController();
276    
277                /**
278                 * Gets the current number of active voices.
279                 */
280                uint GetVoiceCount();
281    
282                /**
283                 * Sets the current number of active voices.
284                 */
285                void SetVoiceCount(uint Voices);
286    
287                /**
288                 * Gets the current number of active disk streams.
289                 */
290                uint GetDiskStreamCount();
291    
292                /**
293                 * Sets the current number of active disk streams.
294                 */
295                void SetDiskStreamCount(uint Streams);
296    
297              int iSamplerChannelIndex; ///< FIXME: nasty hack, might be removed (should be 'virtual EngineChannel* EngineChannel() = 0;', but due to cyclic dependencies only a void* solution would be possible ATM)              int iSamplerChannelIndex; ///< FIXME: nasty hack, might be removed (should be 'virtual EngineChannel* EngineChannel() = 0;', but due to cyclic dependencies only a void* solution would be possible ATM)
298    
299          protected:          protected:
300              EngineChannel();              EngineChannel();
301              virtual ~EngineChannel() {}; // MUST only be destroyed by EngineChannelFactory              virtual ~EngineChannel() {}; // MUST only be destroyed by EngineChannelFactory
302    
303                /**
304                 * Notifies listeners that the number of effect sends
305                 * on a this channel is changed.
306                 * @param ChannelId The numerical ID of the sampler channel.
307                 * @param NewCount The new number of sampler channels.
308                 */
309                void fireFxSendCountChanged(int ChannelId, int NewCount);
310    
311              friend class EngineChannelFactory;              friend class EngineChannelFactory;
312    
313          private:          private:
314              int  iMute;              int     iMute;
315              bool bSolo;              bool    bSolo;
316                uint8_t uiMidiProgram;
317                uint8_t uiMidiBankMsb;
318                uint8_t uiMidiBankLsb;
319                uint8_t uiMidiRpnMsb; ///< MIDI Registered Parameter Number (upper 8 bits / coarse)
320                uint8_t uiMidiRpnLsb; ///< MIDI Registered Parameter Number (lower 8 bits / fine)
321                bool    bMidiBankMsbReceived;
322                bool    bMidiBankLsbReceived;
323                bool    bProgramChangeReceived;
324                bool    bMidiRpnReceived;
325                int     iMidiInstrumentMap;
326                uint    uiVoiceCount;
327                uint    uiDiskStreamCount;
328                ListenerList<FxSendCountListener*> llFxSendCountListeners;
329      };      };
330    
331  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.906  
changed lines
  Added in v.1297
  ViewVC Help
Powered by ViewVC