add AudioEngine API to configure individual MIDI devices

diff --git a/libs/ardour/ardour/audio_backend.h b/libs/ardour/ardour/audio_backend.h
index 78e390318259597c9a708378acd906aaeb8bffda..bf860e9aebbfb1bd79f405aefe1dfdb647bfc820 100644 (file)
--- a/libs/ardour/ardour/audio_backend.h
+++ b/libs/ardour/ardour/audio_backend.h
@@ -263,6 +263,14 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
      * external D-A/D-A converters. Units are samples.
      */
     virtual int set_systemic_output_latency (uint32_t) = 0;
      * external D-A/D-A converters. Units are samples.
      */
     virtual int set_systemic_output_latency (uint32_t) = 0;

+    /** Set the (additional) input latency for a specific midi device,
+     * or if the identifier is empty, apply to all midi devices.
+     */
+    virtual int set_systemic_midi_input_latency (std::string const, uint32_t) = 0;
+    /** Set the (additional) output latency for a specific midi device,
+     * or if the identifier is empty, apply to all midi devices.
+     */
+    virtual int set_systemic_midi_output_latency (std::string const, uint32_t) = 0;

 
     /* Retrieving parameters */
 
 
     /* Retrieving parameters */
 


@@ -274,6 +282,8 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual uint32_t     output_channels () const = 0;
     virtual uint32_t     systemic_input_latency () const = 0;
     virtual uint32_t     systemic_output_latency () const = 0;
     virtual uint32_t     output_channels () const = 0;
     virtual uint32_t     systemic_input_latency () const = 0;
     virtual uint32_t     systemic_output_latency () const = 0;

+    virtual uint32_t     systemic_midi_input_latency (std::string const) const = 0;
+    virtual uint32_t     systemic_midi_output_latency (std::string const) const = 0;

 
     /** override this if this implementation returns true from
      * requires_driver_selection()
 
     /** override this if this implementation returns true from
      * requires_driver_selection()


@@ -311,7 +321,19 @@ class LIBARDOUR_API AudioBackend : public PortEngine {
     virtual int set_midi_option (const std::string& option) = 0;
 
     virtual std::string midi_option () const = 0;
     virtual int set_midi_option (const std::string& option) = 0;
 
     virtual std::string midi_option () const = 0;

-    
+
+    /** Detailed MIDI device list - if available */
+    virtual std::vector<DeviceStatus> enumerate_midi_devices () const = 0;
+
+    /** mark a midi-devices as enabled */
+    virtual int set_midi_device_enabled (std::string const, bool) = 0;
+
+    /** query if a midi-device is enabled */
+    virtual bool midi_device_enabled (std::string const) const = 0;
+
+    /** if backend supports systemic_midi_[in|ou]tput_latency() */
+    virtual bool can_set_systemic_midi_latencies () const = 0;
+

     /* State Control */
  
     /** Start using the device named in the most recent call
     /* State Control */
  
     /** Start using the device named in the most recent call

diff --git a/libs/backends/alsa/alsa_audiobackend.cc b/libs/backends/alsa/alsa_audiobackend.cc
index ad50d5fe2cefec8c843e1925fa5322048f9ee46f..1b8f6ca7d1a265d4351e31bc1efac6c0496c6e83 100644 (file)
--- a/libs/backends/alsa/alsa_audiobackend.cc
+++ b/libs/backends/alsa/alsa_audiobackend.cc
@@ -45,19 +45,18 @@ AlsaAudioBackend::AlsaAudioBackend (AudioEngine& e, AudioBackendInfo& info)
        , _run (false)
        , _active (false)
        , _freewheeling (false)
        , _run (false)
        , _active (false)
        , _freewheeling (false)

+       , _measure_latency (false)

        , _audio_device("")
        , _audio_device("")

-       , _midi_device("")
+       , _midi_driver_option("")

        , _device_reservation(0)
        , _samplerate (48000)
        , _samples_per_period (1024)
        , _periods_per_cycle (2)
        , _device_reservation(0)
        , _samplerate (48000)
        , _samples_per_period (1024)
        , _periods_per_cycle (2)

-       , _dsp_load (0)

        , _n_inputs (0)
        , _n_outputs (0)
        , _systemic_audio_input_latency (0)
        , _systemic_audio_output_latency (0)
        , _n_inputs (0)
        , _n_outputs (0)
        , _systemic_audio_input_latency (0)
        , _systemic_audio_output_latency (0)

-       , _systemic_midi_input_latency (0)
-       , _systemic_midi_output_latency (0)
+       , _dsp_load (0)

        , _processed_samples (0)
        , _port_change_flag (false)
 {
        , _processed_samples (0)
        , _port_change_flag (false)
 {


@@ -281,7 +280,6 @@ int
 AlsaAudioBackend::set_systemic_input_latency (uint32_t sl)
 {
        _systemic_audio_input_latency = sl;
 AlsaAudioBackend::set_systemic_input_latency (uint32_t sl)
 {
        _systemic_audio_input_latency = sl;

-       _systemic_midi_input_latency = sl;

        return 0;
 }
 
        return 0;
 }
 


@@ -289,7 +287,24 @@ int
 AlsaAudioBackend::set_systemic_output_latency (uint32_t sl)
 {
        _systemic_audio_output_latency = sl;
 AlsaAudioBackend::set_systemic_output_latency (uint32_t sl)
 {
        _systemic_audio_output_latency = sl;

-       _systemic_midi_output_latency = sl;
+       return 0;
+}
+
+int
+AlsaAudioBackend::set_systemic_midi_input_latency (std::string const device, uint32_t sl)
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return -1;
+       nfo->systemic_input_latency = sl;
+       return 0;
+}
+
+int
+AlsaAudioBackend::set_systemic_midi_output_latency (std::string const device, uint32_t sl)
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return -1;
+       nfo->systemic_output_latency = sl;

        return 0;
 }
 
        return 0;
 }
 


@@ -342,11 +357,47 @@ AlsaAudioBackend::systemic_output_latency () const
        return _systemic_audio_output_latency;
 }
 
        return _systemic_audio_output_latency;
 }
 

+uint32_t
+AlsaAudioBackend::systemic_midi_input_latency (std::string const device) const
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return 0;
+       return nfo->systemic_input_latency;
+}
+
+uint32_t
+AlsaAudioBackend::systemic_midi_output_latency (std::string const device) const
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return 0;
+       return nfo->systemic_output_latency;
+}
+

 /* MIDI */
 /* MIDI */

+struct AlsaAudioBackend::AlsaMidiDeviceInfo *
+AlsaAudioBackend::midi_device_info(std::string const name) const {
+       for (std::map<std::string, struct AlsaMidiDeviceInfo*>::const_iterator i = _midi_devices.begin (); i != _midi_devices.end(); ++i) {
+               if (i->first == name) {
+                       return (i->second);
+               }
+       }
+
+       std::map<std::string, std::string> devices;
+       get_alsa_rawmidi_device_names(devices);
+       for (std::map<std::string, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
+               if (i->first == name) {
+                       _midi_devices[name] = new AlsaMidiDeviceInfo();
+                       return _midi_devices[name];
+               }
+       }
+       return 0;
+}
+

 std::vector<std::string>
 AlsaAudioBackend::enumerate_midi_options () const
 {
        std::vector<std::string> m;
 std::vector<std::string>
 AlsaAudioBackend::enumerate_midi_options () const
 {
        std::vector<std::string> m;

+#if 1 // OLD GUI

        m.push_back (_("-None-"));
        std::map<std::string, std::string> devices;
        get_alsa_rawmidi_device_names(devices);
        m.push_back (_("-None-"));
        std::map<std::string, std::string> devices;
        get_alsa_rawmidi_device_names(devices);


@@ -357,20 +408,55 @@ AlsaAudioBackend::enumerate_midi_options () const
        if (m.size() > 2) {
                m.push_back (_("-All-"));
        }
        if (m.size() > 2) {
                m.push_back (_("-All-"));
        }

+#else
+       m.push_back (_("None"));
+       m.push_back (_("ALSA raw devices"));
+#endif

        return m;
 }
 
        return m;
 }
 

+std::vector<AudioBackend::DeviceStatus>
+AlsaAudioBackend::enumerate_midi_devices () const
+{
+       std::vector<AudioBackend::DeviceStatus> s;
+
+       std::map<std::string, std::string> devices;
+       get_alsa_rawmidi_device_names(devices);
+
+       for (std::map<std::string, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
+               s.push_back (DeviceStatus (i->first, true));
+       }
+       return s;
+}
+

 int
 AlsaAudioBackend::set_midi_option (const std::string& opt)
 {
 int
 AlsaAudioBackend::set_midi_option (const std::string& opt)
 {

-       _midi_device = opt;
+       _midi_driver_option = opt;

        return 0;
 }
 
 std::string
 AlsaAudioBackend::midi_option () const
 {
        return 0;
 }
 
 std::string
 AlsaAudioBackend::midi_option () const
 {

-       return _midi_device;
+       return _midi_driver_option;
+}
+
+int
+AlsaAudioBackend::set_midi_device_enabled (std::string const device, bool enable)
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return -1;
+       nfo->enabled = enable;
+       return 0;
+}
+
+bool
+AlsaAudioBackend::midi_device_enabled (std::string const device) const
+{
+       struct AlsaMidiDeviceInfo * nfo = midi_device_info(device);
+       if (!nfo) return false;
+       return nfo->enabled;

 }
 
 /* State Control */
 }
 
 /* State Control */


@@ -472,12 +558,7 @@ AlsaAudioBackend::_start (bool for_latency_measurement)
                PBD::warning << _("AlsaAudioBackend: sample rate does not match.") << endmsg;
        }
 
                PBD::warning << _("AlsaAudioBackend: sample rate does not match.") << endmsg;
        }
 

-       if (for_latency_measurement) {
-               _systemic_audio_input_latency = 0;
-               _systemic_audio_output_latency = 0;
-               _systemic_midi_input_latency = 0;
-               _systemic_midi_output_latency = 0;
-       }
+       _measure_latency = for_latency_measurement;

 
        register_system_midi_ports();
 
 
        register_system_midi_ports();
 


@@ -849,7 +930,7 @@ AlsaAudioBackend::register_system_audio_ports()
        const int a_out = _n_outputs > 0 ? _n_outputs : 2;
 
        /* audio ports */
        const int a_out = _n_outputs > 0 ? _n_outputs : 2;
 
        /* audio ports */

-       lr.min = lr.max = _samples_per_period + _systemic_audio_input_latency;
+       lr.min = lr.max = _samples_per_period + _measure_latency ? 0 : _systemic_audio_input_latency;

        for (int i = 1; i <= a_ins; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:capture_%d", i);
        for (int i = 1; i <= a_ins; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:capture_%d", i);


@@ -859,7 +940,7 @@ AlsaAudioBackend::register_system_audio_ports()
                _system_inputs.push_back(static_cast<AlsaPort*>(p));
        }
 
                _system_inputs.push_back(static_cast<AlsaPort*>(p));
        }
 

-       lr.min = lr.max = _samples_per_period + _systemic_audio_output_latency;
+       lr.min = lr.max = _samples_per_period + _measure_latency ? 0 : _systemic_audio_output_latency;

        for (int i = 1; i <= a_out; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:playback_%d", i);
        for (int i = 1; i <= a_out; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:playback_%d", i);


@@ -877,10 +958,11 @@ AlsaAudioBackend::register_system_midi_ports()
        LatencyRange lr;
        std::vector<std::string> devices;
 
        LatencyRange lr;
        std::vector<std::string> devices;
 

-       if (_midi_device == _("-None-")) {
+       // TODO new API use midi_device_info();
+       if (_midi_driver_option == _("-None-")) {

                return 0;
        }
                return 0;
        }

-       else if (_midi_device == _("-All-")) {
+       else if (_midi_driver_option == _("-All-")) {

                std::map<std::string, std::string> devmap;
                get_alsa_rawmidi_device_names(devmap);
                for (std::map<std::string, std::string>::const_iterator i = devmap.begin (); i != devmap.end(); ++i) {
                std::map<std::string, std::string> devmap;
                get_alsa_rawmidi_device_names(devmap);
                for (std::map<std::string, std::string>::const_iterator i = devmap.begin (); i != devmap.end(); ++i) {


@@ -890,7 +972,7 @@ AlsaAudioBackend::register_system_midi_ports()
                std::map<std::string, std::string> devmap;
                get_alsa_rawmidi_device_names(devmap);
                for (std::map<std::string, std::string>::const_iterator i = devmap.begin (); i != devmap.end(); ++i) {
                std::map<std::string, std::string> devmap;
                get_alsa_rawmidi_device_names(devmap);
                for (std::map<std::string, std::string>::const_iterator i = devmap.begin (); i != devmap.end(); ++i) {

-                       if (i->first == _midi_device) {
+                       if (i->first == _midi_driver_option) {

                                devices.push_back (i->second);
                                break;
                        }
                                devices.push_back (i->second);
                                break;
                        }


@@ -941,7 +1023,7 @@ AlsaAudioBackend::register_system_midi_ports()
        const int m_ins = _rmidi_in.size();
        const int m_out = _rmidi_out.size();
 
        const int m_ins = _rmidi_in.size();
        const int m_out = _rmidi_out.size();
 

-       lr.min = lr.max = _samples_per_period + _systemic_midi_input_latency;
+       lr.min = lr.max = _samples_per_period; // + _systemic_midi_input_latency;

        for (int i = 1; i <= m_ins; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:midi_capture_%d", i);
        for (int i = 1; i <= m_ins; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:midi_capture_%d", i);


@@ -951,7 +1033,7 @@ AlsaAudioBackend::register_system_midi_ports()
                _system_midi_in.push_back(static_cast<AlsaPort*>(p));
        }
 
                _system_midi_in.push_back(static_cast<AlsaPort*>(p));
        }
 

-       lr.min = lr.max = _samples_per_period + _systemic_midi_output_latency;
+       lr.min = lr.max = _samples_per_period; // + _systemic_midi_output_latency;

        for (int i = 1; i <= m_out; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:midi_playback_%d", i);
        for (int i = 1; i <= m_out; ++i) {
                char tmp[64];
                snprintf(tmp, sizeof(tmp), "system:midi_playback_%d", i);

diff --git a/libs/backends/alsa/alsa_audiobackend.h b/libs/backends/alsa/alsa_audiobackend.h
index 1f6c3d34001ba038d46a8c318a674d972c0e08c6..e0d1f114c314410d5aabf52788a6f2052f4873b5 100644 (file)
--- a/libs/backends/alsa/alsa_audiobackend.h
+++ b/libs/backends/alsa/alsa_audiobackend.h
@@ -178,6 +178,8 @@ class AlsaAudioBackend : public AudioBackend {
                int set_output_channels (uint32_t);
                int set_systemic_input_latency (uint32_t);
                int set_systemic_output_latency (uint32_t);
                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);

 
                /* Retrieving parameters */
                std::string  device_name () const;
 
                /* Retrieving parameters */
                std::string  device_name () const;


@@ -188,6 +190,10 @@ class AlsaAudioBackend : public AudioBackend {
                uint32_t     output_channels () const;
                uint32_t     systemic_input_latency () const;
                uint32_t     systemic_output_latency () const;
                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;
+
+               bool can_set_systemic_midi_latencies () const { return true; }

 
                /* External control app */
                std::string control_app_name () const { return std::string (); }
 
                /* External control app */
                std::string control_app_name () const { return std::string (); }


@@ -198,6 +204,10 @@ class AlsaAudioBackend : public AudioBackend {
                int set_midi_option (const std::string&);
                std::string midi_option () const;
 
                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;
+

                /* State Control */
        protected:
                int _start (bool for_latency_measurement);
                /* State Control */
        protected:
                int _start (bool for_latency_measurement);


@@ -287,10 +297,10 @@ class AlsaAudioBackend : public AudioBackend {
                bool  _run; /* keep going or stop, ardour thread */
                bool  _active; /* is running, process thread */
                bool  _freewheeling;
                bool  _run; /* keep going or stop, ardour thread */
                bool  _active; /* is running, process thread */
                bool  _freewheeling;

+               bool  _measure_latency;

 
 

-               void enumerate_midi_devices (std::vector<std::string> &) const;

                std::string _audio_device;
                std::string _audio_device;

-               std::string _midi_device;
+               std::string _midi_driver_option;

 
                /* audio device reservation */
                ARDOUR::SystemExec *_device_reservation;
 
                /* audio device reservation */
                ARDOUR::SystemExec *_device_reservation;


@@ -300,10 +310,10 @@ class AlsaAudioBackend : public AudioBackend {
                void release_device();
                bool _reservation_succeeded;
 
                void release_device();
                bool _reservation_succeeded;
 

+               /* audio settings */

                float  _samplerate;
                size_t _samples_per_period;
                size_t _periods_per_cycle;
                float  _samplerate;
                size_t _samples_per_period;
                size_t _periods_per_cycle;

-               float  _dsp_load;

                static size_t _max_buffer_size;
 
                uint32_t _n_inputs;
                static size_t _max_buffer_size;
 
                uint32_t _n_inputs;


@@ -311,11 +321,25 @@ class AlsaAudioBackend : public AudioBackend {
 
                uint32_t _systemic_audio_input_latency;
                uint32_t _systemic_audio_output_latency;
 
                uint32_t _systemic_audio_input_latency;
                uint32_t _systemic_audio_output_latency;

-               uint32_t _systemic_midi_input_latency;
-               uint32_t _systemic_midi_output_latency;

 
 

-               uint64_t _processed_samples;
+               /* midi settings */
+               struct AlsaMidiDeviceInfo {
+                       bool     enabled;
+                       uint32_t systemic_input_latency;
+                       uint32_t systemic_output_latency;
+                       AlsaMidiDeviceInfo()
+                               : enabled (true)
+                               , systemic_input_latency (0)
+                               , systemic_output_latency (0)
+                       {}
+               };
+
+               mutable std::map<std::string, struct AlsaMidiDeviceInfo *> _midi_devices;
+               struct AlsaMidiDeviceInfo * midi_device_info(std::string const) const;

 
 

+               /* processing */
+               float  _dsp_load;
+               uint64_t _processed_samples;

                pthread_t _main_thread;
 
                /* process threads */
                pthread_t _main_thread;
 
                /* process threads */

diff --git a/libs/backends/dummy/dummy_audiobackend.h b/libs/backends/dummy/dummy_audiobackend.h
index b8069ee4296d59ef4f1547a1c894e952b750bf44..d4732f5eeb22fa52e92c292c4056eb08c896ccd4 100644 (file)
--- a/libs/backends/dummy/dummy_audiobackend.h
+++ b/libs/backends/dummy/dummy_audiobackend.h
@@ -171,6 +171,8 @@ class DummyAudioBackend : public AudioBackend {
                int set_output_channels (uint32_t);
                int set_systemic_input_latency (uint32_t);
                int set_systemic_output_latency (uint32_t);
                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) { return 0; }
+               int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }

 
                /* Retrieving parameters */
                std::string  device_name () const;
 
                /* Retrieving parameters */
                std::string  device_name () const;


@@ -181,6 +183,8 @@ class DummyAudioBackend : public AudioBackend {
                uint32_t     output_channels () const;
                uint32_t     systemic_input_latency () const;
                uint32_t     systemic_output_latency () const;
                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 { return 0; }
+               uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }

 
                /* External control app */
                std::string control_app_name () const { return std::string (); }
 
                /* External control app */
                std::string control_app_name () const { return std::string (); }


@@ -191,6 +195,19 @@ class DummyAudioBackend : public AudioBackend {
                int set_midi_option (const std::string&);
                std::string midi_option () const;
 
                int set_midi_option (const std::string&);
                std::string midi_option () const;
 

+               std::vector<DeviceStatus> enumerate_midi_devices () const {
+                       return std::vector<AudioBackend::DeviceStatus> ();
+               }
+               int set_midi_device_enabled (std::string const, bool) {
+                       return 0;
+               }
+               bool midi_device_enabled (std::string const) const {
+                       return true;
+               }
+               bool can_set_systemic_midi_latencies () const {
+                       return false;
+               }
+

                /* State Control */
        protected:
                int _start (bool for_latency_measurement);
                /* State Control */
        protected:
                int _start (bool for_latency_measurement);

diff --git a/libs/backends/jack/jack_audiobackend.h b/libs/backends/jack/jack_audiobackend.h
index 52edd55c638d199cc6a8415e402497aaca84be8c..000a34816191fc94ceff80e624fa3bd96ada7eea 100644 (file)
--- a/libs/backends/jack/jack_audiobackend.h
+++ b/libs/backends/jack/jack_audiobackend.h
@@ -73,6 +73,8 @@ class JACKAudioBackend : public AudioBackend {
     int set_output_channels (uint32_t);
     int set_systemic_input_latency (uint32_t);
     int set_systemic_output_latency (uint32_t);
     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) { return 0; }
+    int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }

 
     std::string  device_name () const;
     float        sample_rate () const;
 
     std::string  device_name () const;
     float        sample_rate () const;


@@ -82,6 +84,8 @@ class JACKAudioBackend : public AudioBackend {
     uint32_t     output_channels () const;
     uint32_t     systemic_input_latency () const;
     uint32_t     systemic_output_latency () const;
     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 { return 0; }
+    uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }

     std::string  driver_name() const;
 
     std::string control_app_name () const;
     std::string  driver_name() const;
 
     std::string control_app_name () const;


@@ -149,6 +153,19 @@ class JACKAudioBackend : public AudioBackend {
     int set_midi_option (const std::string&);
     std::string midi_option () const;
 
     int set_midi_option (const std::string&);
     std::string midi_option () const;
 

+    std::vector<DeviceStatus> enumerate_midi_devices () const {
+       return std::vector<AudioBackend::DeviceStatus> ();
+    }
+    int set_midi_device_enabled (std::string const, bool) {
+       return 0;
+    }
+    bool midi_device_enabled (std::string const) const {
+       return true;
+    }
+    bool can_set_systemic_midi_latencies () const {
+       return false;
+    }
+

     int      midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
     int      midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
     uint32_t get_midi_event_count (void* port_buffer);
     int      midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
     int      midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
     uint32_t get_midi_event_count (void* port_buffer);

diff --git a/libs/backends/wavesaudio/waves_audiobackend.h b/libs/backends/wavesaudio/waves_audiobackend.h
index 115b00101433dba2540a0e888108a2d9ef4db545..6c027824c476f7192f5339bb523e82bc4f50b151 100644 (file)
--- a/libs/backends/wavesaudio/waves_audiobackend.h
+++ b/libs/backends/wavesaudio/waves_audiobackend.h
@@ -121,6 +121,10 @@ class WavesMidiPort;
 
     virtual int set_systemic_output_latency (uint32_t);
 
 
     virtual int set_systemic_output_latency (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; }
+

     virtual std::string device_name () const;
     
     virtual float sample_rate () const;
     virtual std::string device_name () const;
     
     virtual float sample_rate () const;


@@ -139,6 +143,10 @@ class WavesMidiPort;
     
     virtual uint32_t systemic_output_latency () const;
 
     
     virtual uint32_t systemic_output_latency () 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; }
+

     virtual std::string control_app_name () const;
 
     virtual void launch_control_app ();
     virtual std::string control_app_name () const;
 
     virtual void launch_control_app ();


@@ -149,6 +157,19 @@ class WavesMidiPort;
 
     virtual std::string midi_option () const;
 
 
     virtual std::string midi_option () const;
 

+    std::vector<DeviceStatus> enumerate_midi_devices () const {
+       return std::vector<AudioBackend::DeviceStatus> ();
+    }
+    int set_midi_device_enabled (std::string const, bool) {
+       return 0;
+    }
+    bool midi_device_enabled (std::string const) const {
+       return true;
+    }
+    bool can_set_systemic_midi_latencies () const {
+       return false;
+    }
+

     virtual int _start (bool for_latency_measurement);
 
     virtual int stop ();
     virtual int _start (bool for_latency_measurement);
 
     virtual int stop ();