/[svn]/linuxsampler/trunk/src/drivers/midi/MidiInputPort.h
ViewVC logotype

Annotation of /linuxsampler/trunk/src/drivers/midi/MidiInputPort.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 880 - (hide annotations) (download) (as text)
Tue Jun 27 22:57:37 2006 UTC (17 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 11119 byte(s)
just some refactoring work:
- renamed class LinuxSamplerException -> Exception
- encapsulated LS API relevant files into LS namespace
- removed unnecessary header inclusions

1 schoenebeck 221 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5     * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 880 * Copyright (C) 2005, 2006 Christian Schoenebeck *
7 schoenebeck 221 * *
8     * This program is free software; you can redistribute it and/or modify *
9     * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13     * This program is distributed in the hope that it will be useful, *
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19     * along with this program; if not, write to the Free Software *
20     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #ifndef __LS_MIDIINPUTPORT_H__
25     #define __LS_MIDIINPUTPORT_H__
26    
27     #include "../../common/global.h"
28 schoenebeck 551 #include "../../common/Mutex.h"
29 schoenebeck 880 #include "../../common/Exception.h"
30 schoenebeck 221 #include "../DeviceParameter.h"
31 schoenebeck 675 #include "midi.h"
32 schoenebeck 221 #include "MidiInputDevice.h"
33 schoenebeck 411 #include "../../engines/common/EngineChannel.h"
34 persson 840 #include "../../common/SynchronizedConfig.h"
35 schoenebeck 221
36     namespace LinuxSampler {
37    
38     // just symbol prototyping
39     class MidiInputDevice;
40 schoenebeck 675 class EngineChannel;
41 schoenebeck 221
42     class MidiInputPort {
43     public:
44    
45     /////////////////////////////////////////////////////////////////
46     // type definitions
47    
48     /** MIDI Port Parameter 'NAME'
49     *
50     * Used to assign an arbitrary name to the MIDI port.
51     */
52     class ParameterName : public DeviceRuntimeParameterString {
53     public:
54     ParameterName(MidiInputPort* pPort);
55     ParameterName(MidiInputPort* pPort, String val);
56     virtual String Description();
57     virtual bool Fix();
58     virtual std::vector<String> PossibilitiesAsString();
59 schoenebeck 880 virtual void OnSetValue(String s) throw (Exception);
60 schoenebeck 221 protected:
61     MidiInputPort* pPort;
62     };
63    
64    
65    
66     /////////////////////////////////////////////////////////////////
67     // normal methods
68     // (usually not to be overriden by descendant)
69    
70     /**
71     * Connect given sampler engine with this MIDI input device.
72     * The engine can either be connected to one specific MIDI
73     * channel or all MIDI channels. If an engine gets connected
74     * twice to this MIDI input device, then the engine's old
75     * connection will be detached (no matter on which MIDI channel).
76     *
77     * @param pEngine - sampler engine
78     * @param MidiChannel - MIDI channel to connect to
79     * @throws MidiInputException if MidiChannel argument invalid
80     */
81 schoenebeck 411 void Connect(EngineChannel* pEngineChannel, midi_chan_t MidiChannel);
82 schoenebeck 221
83     /**
84     * Disconnect given sampler engine from this MIDI input device.
85 schoenebeck 551 * If the given engine was not connected with this device,
86     * nothing happens.
87 schoenebeck 221 *
88     * @param pEngine - sampler engine
89     */
90 schoenebeck 411 void Disconnect(EngineChannel* pEngineChannel);
91 schoenebeck 221
92     /**
93     * Return MIDI device where this MIDI port belongs to.
94     */
95     MidiInputDevice* GetDevice();
96    
97     /**
98     * Return port number with which this MIDI port is registered to
99     * the MIDI device.
100     */
101     uint GetPortNumber();
102    
103     /**
104     * Return all parameter settings of this MIDI port.
105     */
106     std::map<String,DeviceRuntimeParameter*> PortParameters();
107    
108 persson 846 /**
109     * Registers that an engine wants to have sysex messages.
110     */
111     static void AddSysexListener(Engine* engine);
112 schoenebeck 221
113 persson 846 /**
114     * Removes engine from list of engines getting sysex
115     * messages.
116     *
117     * @returns true if engine was removed, false if it wasn't
118     * present in the list.
119     */
120     static bool RemoveSysexListener(Engine* engine);
121 schoenebeck 221
122    
123     /////////////////////////////////////////////////////////////////
124     // dispatch methods
125     // (should be called by the MidiInputDevice descendant on events)
126    
127     /**
128     * Should be called by the implementing MIDI input device
129     * whenever a note on event arrived, this will cause the note on
130     * event to be forwarded to all connected engines on the
131     * corresponding MIDI channel.
132     *
133     * @param Key - MIDI key number of the triggered key
134     * @param Velocity - MIDI velocity of the triggered key
135     * @param MidiChannel - MIDI channel on which event occured on
136 schoenebeck 274 * (low level indexing, means 0..15)
137 schoenebeck 221 */
138     void DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel);
139    
140     /**
141     * Should be called by the implementing MIDI input device
142     * whenever a note off event arrived, this will cause the note
143     * off event to be forwarded to all connected engines on the
144     * corresponding MIDI channel.
145     *
146     * @param Key - MIDI key number of the released key
147     * @param Velocity - MIDI velocity of the released key
148     * @param MidiChannel - MIDI channel on which event occured on
149 schoenebeck 274 * (low level indexing, means 0..15)
150 schoenebeck 221 */
151     void DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel);
152    
153     /**
154     * Should be called by the implementing MIDI input device
155     * whenever a pitchbend event arrived, this will cause the
156     * pitchbend event to be forwarded to all connected engines.
157     *
158     * @param Pitch - MIDI pitch value
159     * @param MidiChannel - MIDI channel on which event occured on
160 schoenebeck 274 * (low level indexing, means 0..15)
161 schoenebeck 221 */
162     void DispatchPitchbend(int Pitch, uint MidiChannel);
163    
164     /**
165     * Should be called by the implementing MIDI input device
166     * whenever a control change event arrived, this will cause the
167     * control change event to be forwarded to all engines on the
168     * corresponding MIDI channel.
169     *
170     * @param Controller - MIDI controller number
171     * @param Value - MIDI control change value
172     * @param MidiChannel - MIDI channel on which event occured on
173 schoenebeck 274 * (low level indexing, means 0..15)
174 schoenebeck 221 */
175     void DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel);
176    
177 schoenebeck 244 /**
178     * Should be called by the implementing MIDI input device
179 schoenebeck 551 * whenever a program change event arrived, this will cause the
180     * appropriate sampler channel to be connected with this MIDI
181     * device.
182     *
183     * For example consider a program change event on MIDI channel
184     * 3 for program number 18. This would cause this MIDI input
185     * device to be connected to sampler channel 18 and would cause
186     * sampler channel 18 to listen to MIDI channel 3.
187     *
188     * This is the current, general implementation of program
189     * change events. It might change in future, e.g to allow
190     * sampler engines to allow by themselfes how to act on a
191     * program change event.
192     *
193     * @param Program - sampler channel to connect to this MIDI
194     * input device
195     * @param MidiChannel - MIDI channel on which sampler channel
196     * \a Program should listen to
197     */
198     void DispatchProgramChange(uint8_t Program, uint MidiChannel);
199    
200     /**
201     * Should be called by the implementing MIDI input device
202 schoenebeck 244 * whenever a system exclusive message arrived, this will cause
203     * the message to be forwarded to all connected engines.
204     *
205     * @param pData - pointer to the sysex data
206     * @param Size - length of the sysex data (in bytes)
207     */
208     void DispatchSysex(void* pData, uint Size);
209    
210 schoenebeck 221 protected:
211     MidiInputDevice* pDevice;
212     int portNumber;
213     std::map<String,DeviceRuntimeParameter*> Parameters; ///< All port parameters.
214 persson 840 typedef std::set<EngineChannel*> MidiChannelMap_t[17];
215     SynchronizedConfig<MidiChannelMap_t> MidiChannelMap; ///< Contains the list of connected engines for each MIDI channel, where index 0 points to the list of engines which are connected to all MIDI channels. Usually it's not necessary for the descendant to use this map, instead it should just use the Dispatch* methods.
216 persson 846 SynchronizedConfig<MidiChannelMap_t>::Reader MidiChannelMapReader; ///< MIDI thread access to MidiChannelMap
217 schoenebeck 551 Mutex MidiChannelMapMutex; ///< Used to protect the MidiChannelMap from being used at the same time by different threads.
218 persson 846 SynchronizedConfig<std::set<Engine*> >::Reader SysexListenersReader; ///< MIDI thread access to SysexListeners
219 schoenebeck 221
220     /**
221     * Constructor
222     */
223     MidiInputPort(MidiInputDevice* pDevice, int portNumber);
224    
225     /**
226     * Destructor
227     */
228     virtual ~MidiInputPort();
229    
230     friend class MidiInputDevice;
231 schoenebeck 675
232 schoenebeck 551 private:
233     EngineChannel* pPreviousProgramChangeEngineChannel; ///< Points to the engine channel which was connected by the previous DispatchProgramChange() call.
234 persson 846 static SynchronizedConfig<std::set<Engine*> > SysexListeners; ///< All engines that are listening to sysex messages.
235 schoenebeck 221 };
236    
237     } // namsepace LinuxSampler
238    
239     #endif // __LS_MIDIINPUTPORT_H__

  ViewVC Help
Powered by ViewVC