more stuff compiles

[ardour.git] / libs / ardour / ardour / jack_audiobackend.h

diff --git a/libs/ardour/ardour/jack_audiobackend.h b/libs/ardour/ardour/jack_audiobackend.h
index 07214ee77a4950bb90e5f3b417ab0b4a77affb9f..0855b8e90fcdbf0d631902c6b202d81efc6a3475 100644 (file)
--- a/libs/ardour/ardour/jack_audiobackend.h
+++ b/libs/ardour/ardour/jack_audiobackend.h
@@ -17,53 +17,103 @@
 
 */
 
-#ifndef __ardour_jack_audiobackend_h__
-#define __ardour_jack_audiobackend_h__
+#ifndef __libardour_jack_audiobackend_h__
+#define __libardour_jack_audiobackend_h__
 
 #include <string>
 #include <vector>
+#include <map>
 
 #include <stdint.h>
 
+#include <boost/shared_ptr.hpp>
+
+#include <jack/jack.h>
+#ifdef HAVE_JACK_SESSION
+#include <jack/session.h>
+#endif
+
 #include "ardour/audio_backend.h"
 
 namespace ARDOUR {
 
-class JACKAudioBackend : public {
+class JackConnection;
+
+class JACKAudioBackend : public AudioBackend {
   public:
-    JACKAudioBackend (AudioEngine& e);
+    JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnection>);
     ~JACKAudioBackend ();
 
+    std::string name() const;
+    void* private_handle() const;
+    bool connected() const;
+    bool is_realtime () const;
+
     std::vector<std::string> enumerate_devices () const;
     std::vector<float> available_sample_rates (const std::string& device) const;
     std::vector<uint32_t> available_buffer_sizes (const std::string& device) const;
-
-    int set_parameters (const Parameters&);
-    int get_parameters (Parameters&) const;
+    uint32_t available_input_channel_count (const std::string& device) const;
+    uint32_t available_output_channel_count (const std::string& device) const;
+
+    int set_device_name (const std::string&);
+    int set_sample_rate (float);
+    int set_buffer_size (uint32_t);
+    int set_sample_format (SampleFormat);
+    int set_interleaved (bool yn);
+    int set_input_channels (uint32_t);
+    int set_output_channels (uint32_t);
+    int set_systemic_input_latency (uint32_t);
+    int set_systemic_output_latency (uint32_t);
+
+    std::string  device_name () const;
+    float        sample_rate () const;
+    uint32_t     buffer_size () const;
+    SampleFormat sample_format () const;
+    bool         interleaved () const;
+    uint32_t     input_channels () const;
+    uint32_t     output_channels () const;
+    uint32_t     systemic_input_latency () const;
+    uint32_t     systemic_output_latency () const;
 
     int start ();
     int stop ();
     int pause ();
-    int freewheel ();
+    int freewheel (bool);
+
+    float cpu_load() const;
+
+    pframes_t sample_time ();
+    pframes_t sample_time_at_cycle_start ();
+    pframes_t samples_since_cycle_start ();
+
+    size_t raw_buffer_size (DataType t);
+
+    int create_process_thread (boost::function<void()> func, pthread_t*, size_t stacksize);
+
+    void transport_start ();
+    void transport_stop ();
+    void transport_locate (framepos_t /*pos*/);
+    TransportState transport_state () const;
+    framepos_t transport_frame() const;
+
+    int set_time_master (bool /*yn*/);
+    bool get_sync_offset (pframes_t& /*offset*/) const;
 
   private:
-    jack_client_t* volatile   _jack; /* could be reset to null by SIGPIPE or another thread */
-    std::string                jack_client_name;
+    boost::shared_ptr<JackConnection>  _jack_connection; //< shared with JACKPortEngine
+    bool            _running;
+    bool            _freewheeling;
+    std::map<DataType,size_t> _raw_buffer_sizes;
 
     static int  _xrun_callback (void *arg);
-    static int  _graph_order_callback (void *arg);
     static void* _process_thread (void *arg);
     static int  _sample_rate_callback (pframes_t nframes, void *arg);
     static int  _bufsize_callback (pframes_t nframes, void *arg);
     static void _jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int, void*);
     static int  _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg);
     static void _freewheel_callback (int , void *arg);
-    static void _registration_callback (jack_port_id_t, int, void *);
-    static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *);
-    static void _latency_callback (jack_latency_callback_mode_t, void*);#
-    static void  halted (void *);
-    static void  halted_info (jack_status_t,const char*,void *);
-ifdef HAVE_JACK_SESSION
+    static void _latency_callback (jack_latency_callback_mode_t, void*);
+#ifdef HAVE_JACK_SESSION
     static void _session_callback (jack_session_event_t *event, void *arg);
 #endif
     
@@ -72,12 +122,12 @@ ifdef HAVE_JACK_SESSION
     int  jack_bufsize_callback (pframes_t);
     int  jack_sample_rate_callback (pframes_t);
     void freewheel_callback (int);
-    void connect_callback (jack_port_id_t, jack_port_id_t, int);
     int  process_callback (pframes_t nframes);
     void jack_latency_callback (jack_latency_callback_mode_t);
-    
+    void disconnected (const char*);
+
     void set_jack_callbacks ();
-    int connect_to_jack (std::string client_name, std::string session_uuid);
+    int reconnect_to_jack ();
     
     struct ThreadData {
        JACKAudioBackend* engine;
@@ -93,9 +143,28 @@ ifdef HAVE_JACK_SESSION
 
     ChanCount n_physical (unsigned long) const;
     void get_physical (DataType, unsigned long, std::vector<std::string> &);
+
+    /* pffooo */
+
+    std::string  _target_device;
+    float        _target_sample_rate;
+    uint32_t     _target_buffer_size;
+    SampleFormat _target_sample_format;
+    bool         _target_interleaved;
+    uint32_t     _target_input_channels;
+    uint32_t     _target_output_channels;
+    uint32_t      _target_systemic_input_latency;
+    uint32_t      _target_systemic_output_latency;
+
+    uint32_t _current_sample_rate;
+    uint32_t _current_buffer_size;
+    uint32_t _current_usecs_per_cycle;
+    uint32_t _current_systemic_input_latency;
+    uint32_t _current_systemic_output_latency;
+    
 };
 
-}
+} // namespace
 
 #endif /* __ardour_audiobackend_h__ */