/[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 2478 - (show annotations) (download) (as text)
Sat Oct 19 07:52:33 2013 UTC (7 years ago) by persson
File MIME type: text/x-c++hdr
File size: 9612 byte(s)
* fixed build error on newer MinGW
* support building with older jack versions
* support building with spaces in vst sdk path

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2013 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 // derived abstract methods from class 'AudioOutputDevice'
122 virtual void Play() OVERRIDE;
123 virtual bool IsPlaying() OVERRIDE;
124 virtual void Stop() OVERRIDE;
125 virtual uint MaxSamplesPerCycle() OVERRIDE;
126 virtual uint SampleRate() OVERRIDE;
127 virtual AudioChannel* CreateChannel(uint ChannelNr) OVERRIDE;
128 virtual String Driver() OVERRIDE;
129 virtual float latency() OVERRIDE;
130
131 static String Name();
132
133 static String Description();
134 static String Version();
135
136 int Process(uint Samples); // FIXME: should be private
137 void UpdateJackBuffers(uint size);
138 void addListener(JackListener* listener);
139 jack_client_t* jackClientHandle();
140 protected:
141 AudioOutputDeviceJack(String* AutoConnectPortIDs = NULL, uint AutoConnectPorts = 0);
142 private:
143 ConditionServer csIsPlaying;
144 uint uiMaxSamplesPerCycle;
145 jack_client_t* hJackClient;
146 JackClient* pJackClient;
147 };
148
149 // Callback functions for the libjack API
150 int linuxsampler_libjack_process_callback(jack_nframes_t nframes, void* arg);
151
152 /** JACK client
153 *
154 * Represents a jack client. This class is shared by
155 * AudioOutputDeviceJack and MidiInputDeviceJack. The jack server
156 * calls JackClient::Process, which in turn calls
157 * AudioOutputDeviceJack::Process and/or
158 * MidiInputDeviceJack::Process.
159 */
160 class JackClient {
161 public:
162 static JackClient* CreateAudio(String Name);
163 static JackClient* CreateMidi(String Name);
164 static void ReleaseAudio(String Name);
165 static void ReleaseMidi(String Name);
166 int Process(uint Samples);
167 void Stop();
168 void SetAudioOutputDevice(AudioOutputDeviceJack* device);
169 #if HAVE_JACK_MIDI
170 void SetMidiInputDevice(MidiInputDeviceJack* device);
171 #endif
172 void addListener(JackListener* listener);
173
174 jack_client_t* hJackClient;
175
176 private:
177 std::vector<JackListener*> jackListeners;
178 static std::map<String, JackClient*> Clients;
179 struct config_t {
180 AudioOutputDeviceJack* AudioDevice;
181 #if HAVE_JACK_MIDI
182 MidiInputDeviceJack* MidiDevice;
183 #endif
184 };
185 SynchronizedConfig<config_t> Config;
186 SynchronizedConfig<config_t>::Reader ConfigReader;
187 bool audio;
188 bool midi;
189
190 JackClient(String Name);
191 ~JackClient();
192
193 // Callback functions for the libjack API
194 #if HAVE_JACK_ON_INFO_SHUTDOWN
195 static void libjackShutdownCallback(jack_status_t code, const char* reason, void *arg);
196 #else
197 static void libjackShutdownCallback(void *arg);
198 #endif
199 static int libjackSampleRateCallback(jack_nframes_t nframes, void *arg);
200 static int libjackBufferSizeCallback(jack_nframes_t nframes, void *arg);
201 };
202
203 /**
204 * Currently not derived / instantiated by the sampler itself, however this
205 * class can be subclassed and used i.e. by a GUI build on top of the sampler,
206 * to react on JACK events. Because registering JACK callback functions through
207 * the general JACK API is not possible after the JACK client has been activated,
208 * and the latter is already the case as soon as an AudioOutputDeviceJack object
209 * has been instantiated.
210 */
211 class JackListener {
212 public:
213 virtual void onJackShutdown(jack_status_t code, const char* reason) = 0;
214 };
215 }
216
217 #endif // HAVE_JACK
218 #endif // __LS_AUDIOOUTPUTDEVICEJACK_H__

  ViewVC Help
Powered by ViewVC