--- linuxsampler/trunk/src/drivers/audio/AudioOutputDeviceJack.h	2008/01/27 15:07:11	1651
+++ linuxsampler/trunk/src/drivers/audio/AudioOutputDeviceJack.h	2013/04/23 12:19:57	2444
@@ -3,7 +3,7 @@
  *   LinuxSampler - modular, streaming capable sampler                     *
  *                                                                         *
  *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
- *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
+ *   Copyright (C) 2005 - 2013 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  *
@@ -34,9 +34,15 @@
 
 #include "AudioOutputDevice.h"
 #include "../../common/ConditionServer.h"
+
+#if HAVE_JACK_MIDI
 #include "../midi/MidiInputDeviceJack.h"
+#endif
 
 namespace LinuxSampler {
+    
+    class JackClient;
+    class JackListener;
 
     /** JACK audio output driver
      *
@@ -59,7 +65,7 @@
                     class ParameterName : public AudioChannel::ParameterName {
                         public:
                             ParameterName(AudioChannelJack* pChannel);
-                            virtual void OnSetValue(String s);
+                            virtual void OnSetValue(String s) OVERRIDE;
                         protected:
                             AudioChannelJack* pChannel;
                     };
@@ -71,10 +77,10 @@
                     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);
+                            virtual String              Description() OVERRIDE;
+                            virtual bool                Fix() OVERRIDE;
+                            virtual std::vector<String> PossibilitiesAsString() OVERRIDE;
+                            virtual void                OnSetValue(std::vector<String> vS) OVERRIDE;
                             static String Name();
                         protected:
                             AudioChannelJack*   pChannel;
@@ -83,6 +89,7 @@
                 protected:
                     AudioChannelJack(uint ChannelNr, AudioOutputDeviceJack* pDevice) throw (AudioOutputException);
                     ~AudioChannelJack();
+                    void UpdateJackBuffer(uint size);
                     friend class AudioOutputDeviceJack;
                 private:
                     AudioOutputDeviceJack* pDevice;
@@ -101,45 +108,46 @@
                 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);
+                    virtual String              Description() OVERRIDE;
+                    virtual bool                Fix() OVERRIDE;
+                    virtual bool                Mandatory() OVERRIDE;
+                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() OVERRIDE;
+                    virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) OVERRIDE;
+                    virtual optional<String>    DefaultAsString(std::map<String,String> Parameters) OVERRIDE;
+                    virtual void                OnSetValue(String s) throw (Exception) OVERRIDE;
                     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);
-
-
+            virtual void Play() OVERRIDE;
+            virtual bool IsPlaying() OVERRIDE;
+            virtual void Stop() OVERRIDE;
+            virtual uint MaxSamplesPerCycle() OVERRIDE;
+            virtual uint SampleRate() OVERRIDE;
+            virtual AudioChannel* CreateChannel(uint ChannelNr) OVERRIDE;
+            virtual String Driver() OVERRIDE;
+            virtual float latency() OVERRIDE;
+            
             static String Name();
 
-            virtual String Driver();
-
             static String Description();
             static String Version();
 
             int Process(uint Samples);  // FIXME: should be private
+            void UpdateJackBuffers(uint size);
+            void addListener(JackListener* listener);
+            jack_client_t* jackClientHandle();
         protected:
             AudioOutputDeviceJack(String* AutoConnectPortIDs = NULL, uint AutoConnectPorts = 0);
         private:
             ConditionServer csIsPlaying;
             uint            uiMaxSamplesPerCycle;
             jack_client_t*  hJackClient;
+            JackClient* pJackClient;
     };
 
     // 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
      *
@@ -158,15 +166,21 @@
             int Process(uint Samples);
             void Stop();
             void SetAudioOutputDevice(AudioOutputDeviceJack* device);
+            #if HAVE_JACK_MIDI
             void SetMidiInputDevice(MidiInputDeviceJack* device);
+            #endif
+            void addListener(JackListener* listener);
 
             jack_client_t* hJackClient;
 
         private:
+            std::vector<JackListener*> jackListeners;
             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;
@@ -175,6 +189,24 @@
 
             JackClient(String Name);
             ~JackClient();
+        
+            // Callback functions for the libjack API
+            static void libjackShutdownCallback(jack_status_t code, const char* reason, void *arg);
+            static int libjackSampleRateCallback(jack_nframes_t nframes, void *arg);
+            static int libjackBufferSizeCallback(jack_nframes_t nframes, void *arg);
+    };
+    
+    /**
+     * Currently not derived / instantiated by the sampler itself, however this
+     * class can be subclassed and used i.e. by a GUI build on top of the sampler,
+     * to react on JACK events. Because registering JACK callback functions through
+     * the general JACK API is not possible after the JACK client has been activated,
+     * and the latter is already the case as soon as an AudioOutputDeviceJack object
+     * has been instantiated.
+     */
+    class JackListener {
+    public:
+        virtual void onJackShutdown(jack_status_t code, const char* reason) = 0;
     };
 }