/[svn]/linuxsampler/trunk/src/drivers/audio/AudioOutputDeviceJack.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/audio/AudioOutputDeviceJack.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2513 - (show annotations) (download) (as text)
Sun Jan 26 17:59:32 2014 UTC (6 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 10806 byte(s)
- Fixed compilation error regarding previous commit.

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2014 Christian Schoenebeck *
7 * *
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_AUDIOOUTPUTDEVICEJACK_H__
25 #define __LS_AUDIOOUTPUTDEVICEJACK_H__
26
27 #include "../../common/global_private.h"
28
29 #if HAVE_JACK
30
31 #include <vector>
32 #include <sstream>
33 #include <jack/jack.h>
34
35 #include "AudioOutputDevice.h"
36 #include "../../common/ConditionServer.h"
37
38 #if HAVE_JACK_MIDI
39 #include "../midi/MidiInputDeviceJack.h"
40 #endif
41
42 namespace LinuxSampler {
43
44 class JackClient;
45 class JackListener;
46
47 /** JACK audio output driver
48 *
49 * Implements audio output to the JACK Audio Connection Kit (JACK).
50 */
51 class AudioOutputDeviceJack : public AudioOutputDevice {
52 public:
53 AudioOutputDeviceJack(std::map<String,DeviceCreationParameter*> Parameters);
54 virtual ~AudioOutputDeviceJack();
55
56 /**
57 * Audio channel implementation for the JACK audio driver.
58 */
59 class AudioChannelJack : public AudioChannel {
60 public:
61 /** Audio Channel Parameter 'NAME'
62 *
63 * Used to assign an arbitrary name to an audio channel.
64 */
65 class ParameterName : public AudioChannel::ParameterName {
66 public:
67 ParameterName(AudioChannelJack* pChannel);
68 virtual void OnSetValue(String s) OVERRIDE;
69 protected:
70 AudioChannelJack* pChannel;
71 };
72
73 /** Audio Channel Parameter 'JACK_BINDINGS'
74 *
75 * Used to connect to other JACK clients.
76 */
77 class ParameterJackBindings : public DeviceRuntimeParameterStrings {
78 public:
79 ParameterJackBindings(AudioChannelJack* pChannel);
80 virtual String Description() OVERRIDE;
81 virtual bool Fix() OVERRIDE;
82 virtual std::vector<String> PossibilitiesAsString() OVERRIDE;
83 virtual void OnSetValue(std::vector<String> vS) OVERRIDE;
84 static String Name();
85 protected:
86 AudioChannelJack* pChannel;
87 std::vector<String> Bindings;
88 };
89 protected:
90 AudioChannelJack(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
91 ~AudioChannelJack();
92 void UpdateJackBuffer(uint size);
93 friend class AudioOutputDeviceJack;
94 private:
95 AudioOutputDeviceJack* pDevice;
96 jack_port_t* hJackPort;
97 uint ChannelNr;
98
99 float* CreateJackPort(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
100 };
101
102 /** Audio Device Parameter 'NAME'
103 *
104 * Used to assign an arbitrary name to the JACK client of this
105 * audio device.
106 */
107 class ParameterName : public DeviceCreationParameterString {
108 public:
109 ParameterName();
110 ParameterName(String s) throw (Exception);
111 virtual String Description() OVERRIDE;
112 virtual bool Fix() OVERRIDE;
113 virtual bool Mandatory() OVERRIDE;
114 virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() OVERRIDE;
115 virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) OVERRIDE;
116 virtual optional<String> DefaultAsString(std::map<String,String> Parameters) OVERRIDE;
117 virtual void OnSetValue(String s) throw (Exception) OVERRIDE;
118 static String Name();
119 };
120
121 /** Audio Device Parameter 'SAMPLERATE'
122 *
123 * Used to retrieve the sample rate of the JACK audio output
124 * device. Even though the sample rate of the JACK server might
125 * change during runtime, the JACK API currently however does not
126 * allow clients to change the sample rate. So this parameter is
127 * read only.
128 *
129 * This base parameter class has just been overridden for this JACK
130 * driver to implement a valid default value for sample rate. The
131 * default value will simply return the sample rate of the currently
132 * running JACK server. It will return "nothing" if the JACK server
133 * is not running at that point.
134 */
135 class ParameterSampleRate : public AudioOutputDevice::ParameterSampleRate {
136 public:
137 ParameterSampleRate();
138 ParameterSampleRate(String s);
139 virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) OVERRIDE;
140 virtual void OnSetValue(int i) throw (Exception) OVERRIDE;
141 };
142
143 // derived abstract methods from class 'AudioOutputDevice'
144 virtual void Play() OVERRIDE;
145 virtual bool IsPlaying() OVERRIDE;
146 virtual void Stop() OVERRIDE;
147 virtual uint MaxSamplesPerCycle() OVERRIDE;
148 virtual uint SampleRate() OVERRIDE;
149 virtual AudioChannel* CreateChannel(uint ChannelNr) OVERRIDE;
150 virtual String Driver() OVERRIDE;
151 virtual float latency() OVERRIDE;
152
153 static String Name();
154
155 static String Description();
156 static String Version();
157
158 int Process(uint Samples); // FIXME: should be private
159 void UpdateJackBuffers(uint size);
160 void addListener(JackListener* listener);
161 jack_client_t* jackClientHandle();
162 protected:
163 AudioOutputDeviceJack(String* AutoConnectPortIDs = NULL, uint AutoConnectPorts = 0);
164 private:
165 ConditionServer csIsPlaying;
166 uint uiMaxSamplesPerCycle;
167 jack_client_t* hJackClient;
168 JackClient* pJackClient;
169 };
170
171 // Callback functions for the libjack API
172 int linuxsampler_libjack_process_callback(jack_nframes_t nframes, void* arg);
173
174 /** JACK client
175 *
176 * Represents a jack client. This class is shared by
177 * AudioOutputDeviceJack and MidiInputDeviceJack. The jack server
178 * calls JackClient::Process, which in turn calls
179 * AudioOutputDeviceJack::Process and/or
180 * MidiInputDeviceJack::Process.
181 */
182 class JackClient {
183 public:
184 static JackClient* CreateAudio(String Name);
185 static JackClient* CreateMidi(String Name);
186 static void ReleaseAudio(String Name);
187 static void ReleaseMidi(String Name);
188 int Process(uint Samples);
189 void Stop();
190 void SetAudioOutputDevice(AudioOutputDeviceJack* device);
191 #if HAVE_JACK_MIDI
192 void SetMidiInputDevice(MidiInputDeviceJack* device);
193 #endif
194 void addListener(JackListener* listener);
195
196 jack_client_t* hJackClient;
197
198 private:
199 std::vector<JackListener*> jackListeners;
200 static std::map<String, JackClient*> Clients;
201 struct config_t {
202 AudioOutputDeviceJack* AudioDevice;
203 #if HAVE_JACK_MIDI
204 MidiInputDeviceJack* MidiDevice;
205 #endif
206 };
207 SynchronizedConfig<config_t> Config;
208 SynchronizedConfig<config_t>::Reader ConfigReader;
209 bool audio;
210 bool midi;
211
212 JackClient(String Name);
213 ~JackClient();
214
215 // Callback functions for the libjack API
216 #if HAVE_JACK_ON_INFO_SHUTDOWN
217 static void libjackShutdownCallback(jack_status_t code, const char* reason, void *arg);
218 #else
219 static void libjackShutdownCallback(void *arg);
220 #endif
221 static int libjackSampleRateCallback(jack_nframes_t nframes, void *arg);
222 static int libjackBufferSizeCallback(jack_nframes_t nframes, void *arg);
223 };
224
225 /**
226 * Currently not derived / instantiated by the sampler itself, however this
227 * class can be subclassed and used i.e. by a GUI build on top of the sampler,
228 * to react on JACK events. Because registering JACK callback functions through
229 * the general JACK API is not possible after the JACK client has been activated,
230 * and the latter is already the case as soon as an AudioOutputDeviceJack object
231 * has been instantiated.
232 */
233 class JackListener {
234 public:
235 virtual void onJackShutdown(jack_status_t code, const char* reason) = 0;
236 };
237 }
238
239 #endif // HAVE_JACK
240 #endif // __LS_AUDIOOUTPUTDEVICEJACK_H__

  ViewVC Help
Powered by ViewVC