X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Faudioengine.h;h=a9c414e5663745be1e29f9c4a5cef5b704d25baf;hb=afd9fc30e51c41fb42b34d74d6043c2e0e3d1a13;hp=cb5a6d72ceedd6c1a236b655727ddfb8df142365;hpb=b5af3bb8e313e13166cc54c60a14e5492e674065;p=ardour.git diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h index cb5a6d72ce..a9c414e566 100644 --- a/libs/ardour/ardour/audioengine.h +++ b/libs/ardour/ardour/audioengine.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2004 Paul Davis + Copyright (C) 2002-2004 Paul Davis 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 @@ -30,18 +30,20 @@ #include -#include +#include "pbd/rcu.h" -#include +#include "ardour/ardour.h" #include #include -#include -#include +#include "ardour/types.h" +#include "ardour/data_type.h" namespace ARDOUR { -class Session; +class InternalPort; +class MidiPort; class Port; +class Session; class AudioEngine : public sigc::trackable { @@ -50,8 +52,8 @@ class AudioEngine : public sigc::trackable AudioEngine (std::string client_name); virtual ~AudioEngine (); - - jack_client_t* jack() const { return _jack; } + + jack_client_t* jack() const; bool connected() const { return _jack != 0; } bool is_realtime () const; @@ -73,61 +75,78 @@ class AudioEngine : public sigc::trackable nframes_t frame_rate(); nframes_t frames_per_cycle(); + size_t raw_buffer_size(DataType t); + int usecs_per_cycle () const { return _usecs_per_cycle; } bool get_sync_offset (nframes_t& offset) const; nframes_t frames_since_cycle_start () { - if (!_running || !_jack) return 0; - return jack_frames_since_cycle_start (_jack); + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frames_since_cycle_start (_priv_jack); } nframes_t frame_time () { - if (!_running || !_jack) return 0; - return jack_frame_time (_jack); + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frame_time (_priv_jack); } nframes_t transport_frame () const { - if (!_running || !_jack) return 0; - return jack_get_current_transport_frame (_jack); + const jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_get_current_transport_frame (_priv_jack); } - + int request_buffer_size (nframes_t); - + nframes_t set_monitor_check_interval (nframes_t); + nframes_t processed_frames() const { return _processed_frames; } - float get_cpu_load() { - if (!_running || !_jack) return 0; - return jack_cpu_load (_jack); + float get_cpu_load() { + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_cpu_load (_priv_jack); } void set_session (Session *); void remove_session (); class PortRegistrationFailure : public std::exception { - public: - virtual const char *what() const throw() { return "failed port registration"; } + public: + PortRegistrationFailure (const char* why = "") { + reason = why; + } + virtual const char *what() const throw() { return reason; } + + private: + const char* reason; }; class NoBackendAvailable : public std::exception { - public: + public: virtual const char *what() const throw() { return "could not connect to engine backend"; } }; - Port *register_input_port (DataType type, const std::string& portname); - Port *register_output_port (DataType type, const std::string& portname); + Port *register_input_port (DataType, const std::string& portname); + Port *register_output_port (DataType, const std::string& portname); int unregister_port (Port &); - + + void split_cycle (nframes_t offset); + int connect (const std::string& source, const std::string& destination); int disconnect (const std::string& source, const std::string& destination); int disconnect (Port &); - + const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags); - uint32_t n_physical_outputs () const; - uint32_t n_physical_inputs () const; + bool can_request_hardware_monitoring (); - void get_physical_outputs (std::vector&); - void get_physical_inputs (std::vector&); + uint32_t n_physical_outputs (DataType type) const; + uint32_t n_physical_inputs (DataType type) const; + + void get_physical_outputs (DataType type, std::vector&); + void get_physical_inputs (DataType type, std::vector&); std::string get_nth_physical_output (DataType type, uint32_t n) { return get_nth_physical (type, n, JackPortIsInput); @@ -137,13 +156,11 @@ class AudioEngine : public sigc::trackable return get_nth_physical (type, n, JackPortIsOutput); } - nframes_t get_port_total_latency (const Port&); void update_total_latencies (); void update_total_latency (const Port&); - /** Caller may not delete the object pointed to by the return value - */ - Port *get_port_by_name (const std::string& name, bool keep = true); + Port *get_port_by_name (const std::string &); + Port *get_port_by_name_locked (const std::string &); enum TransportState { TransportStopped = JackTransportStopped, @@ -165,7 +182,7 @@ class AudioEngine : public sigc::trackable bool freewheeling() const { return _freewheeling; } /* this signal is sent for every process() cycle while freewheeling. - the regular process() call to session->process() is not made. +_ the regular process() call to session->process() is not made. */ sigc::signal Freewheel; @@ -191,45 +208,54 @@ class AudioEngine : public sigc::trackable sigc::signal Running; sigc::signal Stopped; + /* this signal is emitted if a JACK port is registered or unregistered */ + + sigc::signal PortRegisteredOrUnregistered; + std::string make_port_name_relative (std::string); std::string make_port_name_non_relative (std::string); + static AudioEngine* instance() { return _instance; } + void died (); + private: - ARDOUR::Session *session; - jack_client_t *_jack; - std::string jack_client_name; - Glib::Mutex _process_lock; - Glib::Cond session_removed; - bool session_remove_pending; - bool _running; - bool _has_run; - nframes_t _buffer_size; - nframes_t _frame_rate; + static AudioEngine* _instance; + + ARDOUR::Session* session; + jack_client_t* volatile _jack; /* could be reset to null by SIGPIPE or another thread */ + std::string jack_client_name; + Glib::Mutex _process_lock; + Glib::Cond session_removed; + bool session_remove_pending; + bool _running; + bool _has_run; + nframes_t _buffer_size; + std::map _raw_buffer_sizes; + nframes_t _frame_rate; /// number of frames between each check for changes in monitor input - nframes_t monitor_check_interval; + nframes_t monitor_check_interval; /// time of the last monitor check in frames - nframes_t last_monitor_check; + nframes_t last_monitor_check; /// the number of frames processed since start() was called - nframes_t _processed_frames; - bool _freewheeling; - bool _freewheel_thread_registered; - sigc::slot freewheel_action; - bool reconnect_on_halt; - int _usecs_per_cycle; + nframes_t _processed_frames; + bool _freewheeling; + bool _freewheel_pending; + bool _freewheel_thread_registered; + sigc::slot freewheel_action; + bool reconnect_on_halt; + int _usecs_per_cycle; SerializedRCUManager ports; + Port *register_port (DataType type, const std::string& portname, bool input); + int process_callback (nframes_t nframes); void remove_all_ports (); - typedef std::pair PortConnection; - typedef std::list PortConnections; - - PortConnections port_connections; - void remove_connections_for (Port&); - std::string get_nth_physical (DataType type, uint32_t n, int flags); + void port_registration_failure (const std::string& portname); + static int _xrun_callback (void *arg); static int _graph_order_callback (void *arg); static int _process_callback (nframes_t nframes, void *arg); @@ -238,16 +264,17 @@ class AudioEngine : public sigc::trackable static void _jack_timebase_callback (jack_transport_state_t, nframes_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 *); void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int); int jack_sync_callback (jack_transport_state_t, jack_position_t*); int jack_bufsize_callback (nframes_t); int jack_sample_rate_callback (nframes_t); - static void halted (void *); - int connect_to_jack (std::string client_name); + static void halted (void *); + void meter_thread (); void start_metering_thread (); void stop_metering_thread ();