DSP load calculation: favor peak over average.

[ardour.git] / libs / backends / coreaudio / coreaudio_backend.h

diff --git a/libs/backends/coreaudio/coreaudio_backend.h b/libs/backends/coreaudio/coreaudio_backend.h
index 5e243656ead78ba7e4b7d7025b9b0dadc19afdbe..7ac8e1c6e1401c1b12869ef259a6e801dbf90c11 100644 (file)
--- a/libs/backends/coreaudio/coreaudio_backend.h
+++ b/libs/backends/coreaudio/coreaudio_backend.h
@@ -65,9 +65,11 @@ class CoreBackendPort {
                virtual ~CoreBackendPort ();
 
                const std::string& name () const { return _name; }
+               const std::string& pretty_name () const { return _pretty_name; }
                PortFlags flags () const { return _flags; }
 
                int set_name (const std::string &name) { _name = name; return 0; }
+               int set_pretty_name (const std::string &name) { _pretty_name = name; return 0; }
 
                virtual DataType type () const = 0;
 
@@ -87,7 +89,7 @@ class CoreBackendPort {
 
                virtual void* get_buffer (pframes_t nframes) = 0;
 
-               const LatencyRange& latency_range (bool for_playback) const
+               const LatencyRange latency_range (bool for_playback) const
                {
                        return for_playback ? _playback_latency_range : _capture_latency_range;
                }
@@ -107,6 +109,7 @@ class CoreBackendPort {
        private:
                CoreAudioBackend &_osx_backend;
                std::string _name;
+               std::string _pretty_name;
                const PortFlags _flags;
                LatencyRange _capture_latency_range;
                LatencyRange _playback_latency_range;
@@ -179,8 +182,8 @@ class CoreAudioBackend : public AudioBackend {
                int set_output_channels (uint32_t);
                int set_systemic_input_latency (uint32_t);
                int set_systemic_output_latency (uint32_t);
-               int set_systemic_midi_input_latency (std::string const, uint32_t);
-               int set_systemic_midi_output_latency (std::string const, uint32_t);
+               int set_systemic_midi_input_latency (std::string const, uint32_t) { return 0; }
+               int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }
 
                int reset_device () { return 0; };
 
@@ -193,8 +196,8 @@ class CoreAudioBackend : public AudioBackend {
                uint32_t     output_channels () const;
                uint32_t     systemic_input_latency () const;
                uint32_t     systemic_output_latency () const;
-               uint32_t     systemic_midi_input_latency (std::string const) const;
-               uint32_t     systemic_midi_output_latency (std::string const) const;
+               uint32_t     systemic_midi_input_latency (std::string const) const { return 0; }
+               uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }
 
                bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
 
@@ -207,13 +210,22 @@ class CoreAudioBackend : public AudioBackend {
                int set_midi_option (const std::string&);
                std::string midi_option () const;
 
-               std::vector<DeviceStatus> enumerate_midi_devices () const;
-               int set_midi_device_enabled (std::string const, bool);
-               bool midi_device_enabled (std::string const) const;
+               std::vector<DeviceStatus> enumerate_midi_devices () const {
+                       return std::vector<AudioBackend::DeviceStatus> ();
+               }
+               int set_midi_device_enabled (std::string const, bool) {
+                       return true;
+               }
+               bool midi_device_enabled (std::string const) const {
+                       return false;
+               }
 
                // really private, but needing static access:
-               int process_callback();
+               int process_callback(uint32_t, uint64_t);
                void error_callback();
+               void xrun_callback();
+               void buffer_size_callback();
+               void sample_rate_callback();
                void hw_changed_callback();
 
        protected:
@@ -247,6 +259,7 @@ class CoreAudioBackend : public AudioBackend {
                int         set_port_name (PortHandle, const std::string&);
                std::string get_port_name (PortHandle) const;
                PortHandle  get_port_by_name (const std::string&) const;
+               int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const;
 
                int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
 
@@ -297,7 +310,7 @@ class CoreAudioBackend : public AudioBackend {
                void* get_buffer (PortHandle, pframes_t);
 
                void* freewheel_thread ();
-               void post_process ();
+               void pre_process ();
                void coremidi_rediscover ();
 
        private:
@@ -314,8 +327,14 @@ class CoreAudioBackend : public AudioBackend {
                bool  _freewheel_ack;
                bool  _reinit_thread_callback;
                bool  _measure_latency;
+
+               uint64_t _last_process_start;
+
                pthread_mutex_t _process_callback_mutex;
 
+               pthread_mutex_t _freewheel_mutex;
+               pthread_cond_t  _freewheel_signal;
+
                static std::vector<std::string> _midi_options;
                static std::vector<AudioBackend::DeviceStatus> _audio_device_status;
                static std::vector<AudioBackend::DeviceStatus> _midi_device_status;
@@ -337,21 +356,6 @@ class CoreAudioBackend : public AudioBackend {
                /* coreaudio specific  */
                uint32_t name_to_id(std::string) const;
 
-               /* midi settings */
-               struct CoreMidiDeviceInfo {
-                       bool     enabled;
-                       uint32_t systemic_input_latency;
-                       uint32_t systemic_output_latency;
-                       CoreMidiDeviceInfo()
-                               : enabled (true)
-                               , systemic_input_latency (0)
-                               , systemic_output_latency (0)
-                       {}
-               };
-
-               mutable std::map<std::string, struct CoreMidiDeviceInfo *> _midi_devices;
-               struct CoreMidiDeviceInfo * midi_device_info(std::string const) const;
-
                /* processing */
                float  _dsp_load;
                uint64_t _processed_samples;
@@ -375,7 +379,6 @@ class CoreAudioBackend : public AudioBackend {
                /* port engine */
                PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
                int register_system_audio_ports ();
-               int register_system_midi_ports ();
                void unregister_ports (bool system_only = false);
 
                std::vector<CoreBackendPort *> _ports;
@@ -422,6 +425,15 @@ class CoreAudioBackend : public AudioBackend {
                        return NULL;
                }
 
+               CoreBackendPort * find_port_in (std::vector<CoreBackendPort *> plist, const std::string& port_name) const {
+                       for (std::vector<CoreBackendPort*>::const_iterator it = plist.begin (); it != plist.end (); ++it) {
+                               if ((*it)->name () == port_name) {
+                                       return *it;
+                               }
+                       }
+                       return NULL;
+               }
+
 }; // class CoreAudioBackend
 
 } // namespace