drivers/audio/AudioOutputDeviceJack.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_AUDIOOUTPUTDEVICEJACK_H__
#define __LS_AUDIOOUTPUTDEVICEJACK_H__

#include "../../common/global_private.h"

#if HAVE_JACK

#include <vector>
#include <sstream>
#include <jack/jack.h>

#include "AudioOutputDevice.h"
#include "../../common/ConditionServer.h"

#if HAVE_JACK_MIDI
#include "../midi/MidiInputDeviceJack.h"
#endif

namespace LinuxSampler {

    /** JACK audio output driver
     *
     * Implements audio output to the JACK Audio Connection Kit (JACK).
     */
    class AudioOutputDeviceJack : public AudioOutputDevice {
        public:
            AudioOutputDeviceJack(std::map<String,DeviceCreationParameter*> Parameters);
            virtual ~AudioOutputDeviceJack();

            /**
             * Audio channel implementation for the JACK audio driver.
             */
            class AudioChannelJack : public AudioChannel {
                public:
                    /** Audio Channel Parameter 'NAME'
                     *
                     * Used to assign an arbitrary name to an audio channel.
                     */
                    class ParameterName : public AudioChannel::ParameterName {
                        public:
                            ParameterName(AudioChannelJack* pChannel);
                            virtual void OnSetValue(String s);
                        protected:
                            AudioChannelJack* pChannel;
                    };

                    /** Audio Channel Parameter 'JACK_BINDINGS'
                     *
                     * Used to connect to other JACK clients.
                     */
                    class ParameterJackBindings : public DeviceRuntimeParameterStrings {
                        public:
                            ParameterJackBindings(AudioChannelJack* pChannel);
                            virtual String              Description();
                            virtual bool                Fix();
                            virtual std::vector<String> PossibilitiesAsString();
                            virtual void                OnSetValue(std::vector<String> vS);
                            static String Name();
                        protected:
                            AudioChannelJack*   pChannel;
                            std::vector<String> Bindings;
                    };
                protected:
                    AudioChannelJack(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
                    ~AudioChannelJack();
                    friend class AudioOutputDeviceJack;
                private:
                    AudioOutputDeviceJack* pDevice;
                    jack_port_t*           hJackPort;
                    uint                   ChannelNr;

                    float* CreateJackPort(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
            };

            /** Audio Device Parameter 'NAME'
             *
             * Used to assign an arbitrary name to the JACK client of this
             * audio device.
             */
            class ParameterName : public DeviceCreationParameterString {
                public:
                    ParameterName();
                    ParameterName(String s) throw (Exception);
                    virtual String              Description();
                    virtual bool                Fix();
                    virtual bool                Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
                    virtual optional<String>    DefaultAsString(std::map<String,String> Parameters);
                    virtual void                OnSetValue(String s) throw (Exception);
                    static String Name();
            };

            // derived abstract methods from class 'AudioOutputDevice'
            virtual void Play();
            virtual bool IsPlaying();
            virtual void Stop();
            virtual uint MaxSamplesPerCycle();
            virtual uint SampleRate();
            virtual AudioChannel* CreateChannel(uint ChannelNr);


            static String Name();

            virtual String Driver();

            static String Description();
            static String Version();

            int Process(uint Samples);  // FIXME: should be private
        protected:
            AudioOutputDeviceJack(String* AutoConnectPortIDs = NULL, uint AutoConnectPorts = 0);
        private:
            ConditionServer csIsPlaying;
            uint            uiMaxSamplesPerCycle;
            jack_client_t*  hJackClient;
    };

    // Callback functions for the libjack API
    int  linuxsampler_libjack_process_callback(jack_nframes_t nframes, void* arg);
    void linuxsampler_libjack_shutdown_callback(void* arg);


    /** JACK client
     *
     * Represents a jack client. This class is shared by
     * AudioOutputDeviceJack and MidiInputDeviceJack. The jack server
     * calls JackClient::Process, which in turn calls
     * AudioOutputDeviceJack::Process and/or
     * MidiInputDeviceJack::Process.
     */
    class JackClient {
        public:
            static JackClient* CreateAudio(String Name);
            static JackClient* CreateMidi(String Name);
            static void ReleaseAudio(String Name);
            static void ReleaseMidi(String Name);
            int Process(uint Samples);
            void Stop();
            void SetAudioOutputDevice(AudioOutputDeviceJack* device);
            #if HAVE_JACK_MIDI
            void SetMidiInputDevice(MidiInputDeviceJack* device);
            #endif

            jack_client_t* hJackClient;

        private:
            static std::map<String, JackClient*> Clients;
            struct config_t {
                AudioOutputDeviceJack* AudioDevice;
                #if HAVE_JACK_MIDI
                MidiInputDeviceJack* MidiDevice;
                #endif
            };
            SynchronizedConfig<config_t> Config;
            SynchronizedConfig<config_t>::Reader ConfigReader;
            bool audio;
            bool midi;

            JackClient(String Name);
            ~JackClient();
    };
}

#endif // HAVE_JACK
#endif // __LS_AUDIOOUTPUTDEVICEJACK_H__
1	schoenebeck	200	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	persson	1651	* Copyright (C) 2005 - 2008 Christian Schoenebeck *
7	schoenebeck	200	* *
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	schoenebeck	1424	#include "../../common/global_private.h"
28	schoenebeck	200
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	schoenebeck	1682
38			#if HAVE_JACK_MIDI
39	persson	1651	#include "../midi/MidiInputDeviceJack.h"
40	schoenebeck	1682	#endif
41	schoenebeck	200
42			namespace LinuxSampler {
43
44			/** JACK audio output driver
45			*
46			* Implements audio output to the JACK Audio Connection Kit (JACK).
47			*/
48			class AudioOutputDeviceJack : public AudioOutputDevice {
49			public:
50			AudioOutputDeviceJack(std::map<String,DeviceCreationParameter*> Parameters);
51	schoenebeck	374	virtual ~AudioOutputDeviceJack();
52	schoenebeck	200
53	schoenebeck	226	/**
54			* Audio channel implementation for the JACK audio driver.
55	schoenebeck	221	*/
56	schoenebeck	226	class AudioChannelJack : public AudioChannel {
57	schoenebeck	200	public:
58	schoenebeck	226	/** Audio Channel Parameter 'NAME'
59			*
60			* Used to assign an arbitrary name to an audio channel.
61			*/
62			class ParameterName : public AudioChannel::ParameterName {
63			public:
64			ParameterName(AudioChannelJack* pChannel);
65			virtual void OnSetValue(String s);
66			protected:
67			AudioChannelJack* pChannel;
68			};
69
70			/** Audio Channel Parameter 'JACK_BINDINGS'
71			*
72			* Used to connect to other JACK clients.
73			*/
74			class ParameterJackBindings : public DeviceRuntimeParameterStrings {
75			public:
76			ParameterJackBindings(AudioChannelJack* pChannel);
77			virtual String Description();
78			virtual bool Fix();
79			virtual std::vector<String> PossibilitiesAsString();
80			virtual void OnSetValue(std::vector<String> vS);
81			static String Name();
82			protected:
83	schoenebeck	483	AudioChannelJack* pChannel;
84			std::vector<String> Bindings;
85	schoenebeck	226	};
86	schoenebeck	200	protected:
87	schoenebeck	226	AudioChannelJack(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
88			~AudioChannelJack();
89			friend class AudioOutputDeviceJack;
90			private:
91			AudioOutputDeviceJack* pDevice;
92			jack_port_t* hJackPort;
93			uint ChannelNr;
94
95			float* CreateJackPort(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
96	schoenebeck	200	};
97
98	schoenebeck	374	/** Audio Device Parameter 'NAME'
99			*
100			* Used to assign an arbitrary name to the JACK client of this
101			* audio device.
102			*/
103			class ParameterName : public DeviceCreationParameterString {
104			public:
105			ParameterName();
106	schoenebeck	880	ParameterName(String s) throw (Exception);
107	schoenebeck	374	virtual String Description();
108			virtual bool Fix();
109			virtual bool Mandatory();
110			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
111			virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
112			virtual optional<String> DefaultAsString(std::map<String,String> Parameters);
113	schoenebeck	880	virtual void OnSetValue(String s) throw (Exception);
114	schoenebeck	374	static String Name();
115			};
116
117	schoenebeck	200	// derived abstract methods from class 'AudioOutputDevice'
118			virtual void Play();
119			virtual bool IsPlaying();
120			virtual void Stop();
121			virtual uint MaxSamplesPerCycle();
122			virtual uint SampleRate();
123	schoenebeck	226	virtual AudioChannel* CreateChannel(uint ChannelNr);
124	schoenebeck	200
125	schoenebeck	226
126	persson	1651	static String Name();
127	schoenebeck	200
128			virtual String Driver();
129
130			static String Description();
131			static String Version();
132
133			int Process(uint Samples); // FIXME: should be private
134			protected:
135			AudioOutputDeviceJack(String* AutoConnectPortIDs = NULL, uint AutoConnectPorts = 0);
136			private:
137	schoenebeck	226	ConditionServer csIsPlaying;
138			uint uiMaxSamplesPerCycle;
139			jack_client_t* hJackClient;
140	schoenebeck	200	};
141
142			// Callback functions for the libjack API
143	persson	1651	int linuxsampler_libjack_process_callback(jack_nframes_t nframes, void* arg);
144			void linuxsampler_libjack_shutdown_callback(void* arg);
145
146
147			/** JACK client
148			*
149			* Represents a jack client. This class is shared by
150			* AudioOutputDeviceJack and MidiInputDeviceJack. The jack server
151			* calls JackClient::Process, which in turn calls
152			* AudioOutputDeviceJack::Process and/or
153			* MidiInputDeviceJack::Process.
154			*/
155			class JackClient {
156			public:
157			static JackClient* CreateAudio(String Name);
158			static JackClient* CreateMidi(String Name);
159			static void ReleaseAudio(String Name);
160			static void ReleaseMidi(String Name);
161			int Process(uint Samples);
162			void Stop();
163			void SetAudioOutputDevice(AudioOutputDeviceJack* device);
164	schoenebeck	1682	#if HAVE_JACK_MIDI
165	persson	1651	void SetMidiInputDevice(MidiInputDeviceJack* device);
166	schoenebeck	1682	#endif
167	persson	1651
168			jack_client_t* hJackClient;
169
170			private:
171			static std::map<String, JackClient*> Clients;
172			struct config_t {
173			AudioOutputDeviceJack* AudioDevice;
174	schoenebeck	1682	#if HAVE_JACK_MIDI
175	persson	1651	MidiInputDeviceJack* MidiDevice;
176	schoenebeck	1682	#endif
177	persson	1651	};
178			SynchronizedConfig<config_t> Config;
179			SynchronizedConfig<config_t>::Reader ConfigReader;
180			bool audio;
181			bool midi;
182
183			JackClient(String Name);
184			~JackClient();
185			};
186	schoenebeck	200	}
187
188			#endif // HAVE_JACK
189			#endif // __LS_AUDIOOUTPUTDEVICEJACK_H__