replace "None" with DeviceNone in ALSA/Coreaudio

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

diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc
index 1eb55ca61ea5918cf355ab3125be5b4436c9e49e..6047b8002e05e816b3b50bc67f3fe3869cbb4c95 100644 (file)
--- a/libs/backends/coreaudio/coreaudio_backend.cc
+++ b/libs/backends/coreaudio/coreaudio_backend.cc
@@ -109,7 +109,7 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
        , _last_process_start (0)
        , _input_audio_device("")
        , _output_audio_device("")
-       , _midi_driver_option(_("None"))
+       , _midi_driver_option(get_standard_device_name(DeviceNone))
        , _samplerate (48000)
        , _samples_per_period (1024)
        , _n_inputs (0)
@@ -186,7 +186,7 @@ CoreAudioBackend::enumerate_input_devices () const
        std::map<size_t, std::string> devices;
        _pcmio->input_device_list(devices);
 
-       _input_audio_device_status.push_back (DeviceStatus (_("None"), true));
+       _input_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true));
        for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
                if (_input_audio_device == "") _input_audio_device = i->second;
                _input_audio_device_status.push_back (DeviceStatus (i->second, true));
@@ -202,7 +202,7 @@ CoreAudioBackend::enumerate_output_devices () const
        std::map<size_t, std::string> devices;
        _pcmio->output_device_list(devices);
 
-       _output_audio_device_status.push_back (DeviceStatus (_("None"), true));
+       _output_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true));
        for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
                if (_output_audio_device == "") _output_audio_device = i->second;
                _output_audio_device_status.push_back (DeviceStatus (i->second, true));
@@ -211,51 +211,68 @@ CoreAudioBackend::enumerate_output_devices () const
 }
 
 std::vector<float>
-CoreAudioBackend::available_sample_rates (const std::string&) const
+CoreAudioBackend::available_sample_rates (const std::string& device) const
+{
+       std::vector<float> sr;
+       _pcmio->available_sample_rates (name_to_id (device), sr);
+       return sr;
+}
+
+std::vector<float>
+CoreAudioBackend::available_sample_rates2 (const std::string& input_device, const std::string& output_device) const
 {
        std::vector<float> sr;
        std::vector<float> sr_in;
        std::vector<float> sr_out;
 
-       const uint32_t inp = name_to_id(_input_audio_device);
-       const uint32_t out = name_to_id(_output_audio_device);
+       const uint32_t inp = name_to_id (input_device);
+       const uint32_t out = name_to_id (output_device);
+
        if (inp == UINT32_MAX && out == UINT32_MAX) {
                return sr;
        } else if (inp == UINT32_MAX) {
-               _pcmio->available_sample_rates(out, sr_out);
+               _pcmio->available_sample_rates (out, sr_out);
                return sr_out;
        } else if (out == UINT32_MAX) {
-               _pcmio->available_sample_rates(inp, sr_in);
+               _pcmio->available_sample_rates (inp, sr_in);
                return sr_in;
        } else {
-               _pcmio->available_sample_rates(inp, sr_in);
-               _pcmio->available_sample_rates(out, sr_out);
+               _pcmio->available_sample_rates (inp, sr_in);
+               _pcmio->available_sample_rates (out, sr_out);
                // TODO allow to use different SR per device, tweak aggregate
-               std::set_intersection(sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr));
+               std::set_intersection (sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr));
                return sr;
        }
 }
 
 std::vector<uint32_t>
-CoreAudioBackend::available_buffer_sizes (const std::string&) const
+CoreAudioBackend::available_buffer_sizes (const std::string& device) const
+{
+       std::vector<uint32_t> bs;
+       _pcmio->available_buffer_sizes (name_to_id (device), bs);
+       return bs;
+}
+
+std::vector<uint32_t>
+CoreAudioBackend::available_buffer_sizes2 (const std::string& input_device, const std::string& output_device) const
 {
        std::vector<uint32_t> bs;
        std::vector<uint32_t> bs_in;
        std::vector<uint32_t> bs_out;
-       const uint32_t inp = name_to_id(_input_audio_device);
-       const uint32_t out = name_to_id(_output_audio_device);
+       const uint32_t inp = name_to_id (input_device);
+       const uint32_t out = name_to_id (output_device);
        if (inp == UINT32_MAX && out == UINT32_MAX) {
                return bs;
        } else if (inp == UINT32_MAX) {
-               _pcmio->available_buffer_sizes(out, bs_out);
+               _pcmio->available_buffer_sizes (out, bs_out);
                return bs_out;
        } else if (out == UINT32_MAX) {
-               _pcmio->available_buffer_sizes(out, bs_in);
+               _pcmio->available_buffer_sizes (inp, bs_in);
                return bs_in;
        } else {
-               _pcmio->available_buffer_sizes(inp, bs_in);
-               _pcmio->available_buffer_sizes(out, bs_out);
-               std::set_intersection(bs_in.begin(), bs_in.end(), bs_out.begin(), bs_out.end(), std::back_inserter(bs));
+               _pcmio->available_buffer_sizes (inp, bs_in);
+               _pcmio->available_buffer_sizes (out, bs_out);
+               std::set_intersection (bs_in.begin(), bs_in.end(), bs_out.begin(), bs_out.end(), std::back_inserter(bs));
                return bs;
        }
 }
@@ -315,7 +332,7 @@ CoreAudioBackend::set_output_device_name (const std::string& d)
 int
 CoreAudioBackend::set_sample_rate (float sr)
 {
-       std::vector<float> srs = available_sample_rates (/* really ignored */_input_audio_device);
+       std::vector<float> srs = available_sample_rates2 (_input_audio_device, _output_audio_device);
        if (std::find(srs.begin(), srs.end(), sr) == srs.end()) {
                return -1;
        }
@@ -439,7 +456,7 @@ CoreAudioBackend::enumerate_midi_options () const
 {
        if (_midi_options.empty()) {
                _midi_options.push_back (_("CoreMidi"));
-               _midi_options.push_back (_("None"));
+               _midi_options.push_back (get_standard_device_name(DeviceNone));
        }
        return _midi_options;
 }
@@ -447,7 +464,7 @@ CoreAudioBackend::enumerate_midi_options () const
 int
 CoreAudioBackend::set_midi_option (const std::string& opt)
 {
-       if (opt != _("None") && opt != _("CoreMidi")) {
+       if (opt != get_standard_device_name(DeviceNone) && opt != _("CoreMidi")) {
                return -1;
        }
        _midi_driver_option = opt;
@@ -463,7 +480,12 @@ CoreAudioBackend::midi_option () const
 void
 CoreAudioBackend::launch_control_app ()
 {
-    _pcmio->launch_control_app(name_to_id(_input_audio_device));
+       if (name_to_id (_input_audio_device) != UINT32_MAX) {
+               _pcmio->launch_control_app(name_to_id(_input_audio_device));
+       }
+       if (name_to_id (_output_audio_device) != UINT32_MAX) {
+               _pcmio->launch_control_app(name_to_id(_output_audio_device));
+       }
 }
 
 /* State Control */
@@ -848,7 +870,7 @@ int
 CoreAudioBackend::set_port_name (PortEngine::PortHandle port, const std::string& name)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg;
+               PBD::warning << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg;
                return -1;
        }
        return static_cast<CoreBackendPort*>(port)->set_name (_instance_name + ":" + name);
@@ -858,7 +880,7 @@ std::string
 CoreAudioBackend::get_port_name (PortEngine::PortHandle port) const
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
+               PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
                return std::string ();
        }
        return static_cast<CoreBackendPort*>(port)->name ();
@@ -868,7 +890,7 @@ int
 CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, std::string& value, std::string& type) const
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
+               PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
                return -1;
        }
        if (key == "http://jackaudio.org/metadata/pretty-name") {
@@ -945,7 +967,7 @@ CoreAudioBackend::add_port (
 {
        assert(name.size ());
        if (find_port (name)) {
-               PBD::error << _("CoreAudioBackend::register_port: Port already exists:")
+               PBD::warning << _("CoreAudioBackend::register_port: Port already exists:")
                                << " (" << name << ")" << endmsg;
                return 0;
        }
@@ -976,7 +998,7 @@ CoreAudioBackend::unregister_port (PortEngine::PortHandle port_handle)
        CoreBackendPort* port = static_cast<CoreBackendPort*>(port_handle);
        std::vector<CoreBackendPort*>::iterator i = std::find (_ports.begin (), _ports.end (), static_cast<CoreBackendPort*>(port_handle));
        if (i == _ports.end ()) {
-               PBD::error << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg;
                return;
        }
        disconnect_all(port_handle);
@@ -1156,12 +1178,12 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst)
        CoreBackendPort* dst_port = find_port (dst);
 
        if (!src_port) {
-               PBD::error << _("CoreAudioBackend::connect: Invalid Source port:")
+               PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:")
                                << " (" << src <<")" << endmsg;
                return -1;
        }
        if (!dst_port) {
-               PBD::error << _("CoreAudioBackend::connect: Invalid Destination port:")
+               PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:")
                        << " (" << dst <<")" << endmsg;
                return -1;
        }
@@ -1175,7 +1197,7 @@ CoreAudioBackend::disconnect (const std::string& src, const std::string& dst)
        CoreBackendPort* dst_port = find_port (dst);
 
        if (!src_port || !dst_port) {
-               PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
+               PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
                return -1;
        }
        return src_port->disconnect (dst_port);
@@ -1186,11 +1208,11 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst)
 {
        CoreBackendPort* dst_port = find_port (dst);
        if (!valid_port (src)) {
-               PBD::error << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg;
+               PBD::warning << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg;
                return -1;
        }
        if (!dst_port) {
-               PBD::error << _("CoreAudioBackend::connect: Invalid Destination Port")
+               PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port")
                        << " (" << dst << ")" << endmsg;
                return -1;
        }
@@ -1202,7 +1224,7 @@ CoreAudioBackend::disconnect (PortEngine::PortHandle src, const std::string& dst
 {
        CoreBackendPort* dst_port = find_port (dst);
        if (!valid_port (src) || !dst_port) {
-               PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
+               PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
                return -1;
        }
        return static_cast<CoreBackendPort*>(src)->disconnect (dst_port);
@@ -1212,7 +1234,7 @@ int
 CoreAudioBackend::disconnect_all (PortEngine::PortHandle port)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
                return -1;
        }
        static_cast<CoreBackendPort*>(port)->disconnect_all ();
@@ -1223,7 +1245,7 @@ bool
 CoreAudioBackend::connected (PortEngine::PortHandle port, bool /* process_callback_safe*/)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
                return false;
        }
        return static_cast<CoreBackendPort*>(port)->is_connected ();
@@ -1234,7 +1256,7 @@ CoreAudioBackend::connected_to (PortEngine::PortHandle src, const std::string& d
 {
        CoreBackendPort* dst_port = find_port (dst);
        if (!valid_port (src) || !dst_port) {
-               PBD::error << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg;
                return false;
        }
        return static_cast<CoreBackendPort*>(src)->is_connected (dst_port);
@@ -1244,7 +1266,7 @@ bool
 CoreAudioBackend::physically_connected (PortEngine::PortHandle port, bool /*process_callback_safe*/)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg;
                return false;
        }
        return static_cast<CoreBackendPort*>(port)->is_physically_connected ();
@@ -1254,7 +1276,7 @@ int
 CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector<std::string>& names, bool /*process_callback_safe*/)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg;
+               PBD::warning << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg;
                return -1;
        }
 
@@ -1356,7 +1378,8 @@ void
 CoreAudioBackend::set_latency_range (PortEngine::PortHandle port, bool for_playback, LatencyRange latency_range)
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg;
+               PBD::warning << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg;
+               return;
        }
        static_cast<CoreBackendPort*>(port)->set_latency_range (latency_range, for_playback);
 }
@@ -1366,7 +1389,7 @@ CoreAudioBackend::get_latency_range (PortEngine::PortHandle port, bool for_playb
 {
        LatencyRange r;
        if (!valid_port (port)) {
-               PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
+               PBD::warning << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
                r.min = 0;
                r.max = 0;
                return r;
@@ -1394,7 +1417,7 @@ bool
 CoreAudioBackend::port_is_physical (PortEngine::PortHandle port) const
 {
        if (!valid_port (port)) {
-               PBD::error << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg;
+               PBD::warning << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg;
                return false;
        }
        return static_cast<CoreBackendPort*>(port)->is_physical ();
@@ -1970,33 +1993,33 @@ CoreBackendPort::~CoreBackendPort () {
 int CoreBackendPort::connect (CoreBackendPort *port)
 {
        if (!port) {
-               PBD::error << _("CoreBackendPort::connect (): invalid (null) port") << endmsg;
+               PBD::warning << _("CoreBackendPort::connect (): invalid (null) port") << endmsg;
                return -1;
        }
 
        if (type () != port->type ()) {
-               PBD::error << _("CoreBackendPort::connect (): wrong port-type") << endmsg;
+               PBD::warning << _("CoreBackendPort::connect (): wrong port-type") << endmsg;
                return -1;
        }
 
        if (is_output () && port->is_output ()) {
-               PBD::error << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg;
+               PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg;
                return -1;
        }
 
        if (is_input () && port->is_input ()) {
-               PBD::error << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg;
+               PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg;
                return -1;
        }
 
        if (this == port) {
-               PBD::error << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg;
+               PBD::warning << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg;
                return -1;
        }
 
        if (is_connected (port)) {
 #if 0 // don't bother to warn about this for now. just ignore it
-               PBD::error << _("CoreBackendPort::connect (): ports are already connected:")
+               PBD::info << _("CoreBackendPort::connect (): ports are already connected:")
                        << " (" << name () << ") -> (" << port->name () << ")"
                        << endmsg;
 #endif
@@ -2020,12 +2043,12 @@ void CoreBackendPort::_connect (CoreBackendPort *port, bool callback)
 int CoreBackendPort::disconnect (CoreBackendPort *port)
 {
        if (!port) {
-               PBD::error << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg;
+               PBD::warning << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg;
                return -1;
        }
 
        if (!is_connected (port)) {
-               PBD::error << _("CoreBackendPort::disconnect (): ports are not connected:")
+               PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:")
                        << " (" << name () << ") -> (" << port->name () << ")"
                        << endmsg;
                return -1;