From 1c5decf5f85b7808a70885c820596fac013cf644 Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Sat, 28 Nov 2020 19:31:25 +0100
Subject: Factor out getting client and port metadata and send it with events
---
src/AlsaDriver.cpp | 60 +++++++++++++++++++++++++++--
src/ClientInfo.hpp | 28 ++++++++++++++
src/JackDriver.cpp | 103 ++++++++++++++++++++++++++++++--------------------
src/JackDriver.hpp | 5 +++
src/PatchageEvent.hpp | 8 +++-
src/PortInfo.hpp | 36 ++++++++++++++++++
src/PortNames.hpp | 15 ++++++--
7 files changed, 206 insertions(+), 49 deletions(-)
create mode 100644 src/ClientInfo.hpp
create mode 100644 src/PortInfo.hpp
(limited to 'src')
diff --git a/src/AlsaDriver.cpp b/src/AlsaDriver.cpp
index 0b32fe9..293ee63 100644
--- a/src/AlsaDriver.cpp
+++ b/src/AlsaDriver.cpp
@@ -17,10 +17,12 @@
#include "AlsaDriver.hpp"
#include "ClientID.hpp"
+#include "ClientInfo.hpp"
#include "Patchage.hpp"
#include "PatchageCanvas.hpp"
#include "PatchageModule.hpp"
#include "PatchagePort.hpp"
+#include "PortInfo.hpp"
#include "PortType.hpp"
#include "SignalDirection.hpp"
#include "handle_event.hpp"
@@ -37,12 +39,50 @@ PATCHAGE_RESTORE_WARNINGS
namespace {
-inline PortID
-addr_to_id(const snd_seq_addr_t& addr, bool is_input)
+PortID
+addr_to_id(const snd_seq_addr_t& addr, const bool is_input)
{
return PortID::alsa(addr.client, addr.port, is_input);
}
+SignalDirection
+port_direction(const snd_seq_port_info_t* const pinfo)
+{
+ const int caps = snd_seq_port_info_get_capability(pinfo);
+
+ if ((caps & SND_SEQ_PORT_CAP_READ) && (caps & SND_SEQ_PORT_CAP_WRITE)) {
+ return SignalDirection::duplex;
+ }
+
+ if (caps & SND_SEQ_PORT_CAP_READ) {
+ return SignalDirection::output;
+ }
+
+ if (caps & SND_SEQ_PORT_CAP_WRITE) {
+ return SignalDirection::input;
+ }
+
+ return SignalDirection::duplex;
+}
+
+ClientInfo
+client_info(snd_seq_client_info_t* const cinfo)
+{
+ return {snd_seq_client_info_get_name(cinfo)};
+}
+
+PortInfo
+port_info(const snd_seq_port_info_t* const pinfo)
+{
+ const int type = snd_seq_port_info_get_type(pinfo);
+
+ return {snd_seq_port_info_get_name(pinfo),
+ PortType::alsa_midi,
+ port_direction(pinfo),
+ snd_seq_port_info_get_port(pinfo),
+ (type & SND_SEQ_PORT_TYPE_APPLICATION) == 0};
+}
+
} // namespace
AlsaDriver::AlsaDriver(Patchage* app, ILog& log)
@@ -568,7 +608,19 @@ AlsaDriver::_refresh_main()
switch (ev->type) {
case SND_SEQ_EVENT_CLIENT_START:
+ snd_seq_get_any_client_info(_seq, ev->data.addr.client, cinfo);
+ _events.emplace(ClientCreationEvent{
+ ClientID::alsa(ev->data.addr.client),
+ client_info(cinfo),
+ });
+ break;
+
case SND_SEQ_EVENT_CLIENT_EXIT:
+ _events.emplace(ClientDestructionEvent{
+ ClientID::alsa(ev->data.addr.client),
+ });
+ break;
+
case SND_SEQ_EVENT_CLIENT_CHANGE:
break;
@@ -580,7 +632,9 @@ AlsaDriver::_refresh_main()
if (!ignore(ev->data.addr)) {
_events.emplace(PortCreationEvent{
- addr_to_id(ev->data.addr, (caps & SND_SEQ_PORT_CAP_READ))});
+ addr_to_id(ev->data.addr, (caps & SND_SEQ_PORT_CAP_READ)),
+ port_info(pinfo),
+ });
}
break;
diff --git a/src/ClientInfo.hpp b/src/ClientInfo.hpp
new file mode 100644
index 0000000..9229d16
--- /dev/null
+++ b/src/ClientInfo.hpp
@@ -0,0 +1,28 @@
+/* This file is part of Patchage.
+ * Copyright 2007-2020 David Robillard <d@drobilla.net>
+ *
+ * Patchage is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * Patchage is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Patchage. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PATCHAGE_CLIENTINFO_HPP
+#define PATCHAGE_CLIENTINFO_HPP
+
+#include <string>
+
+/// Extra information about a client (program) not expressed in its ID
+struct ClientInfo
+{
+ std::string label; ///< Human-friendly label
+};
+
+#endif // PATCHAGE_CLIENTINFO_HPP
diff --git a/src/JackDriver.cpp b/src/JackDriver.cpp
index 096b543..a491453 100644
--- a/src/JackDriver.cpp
+++ b/src/JackDriver.cpp
@@ -191,12 +191,12 @@ JackDriver::create_port_view(Patchage* patchage, const PortID& id)
return port;
}
-#ifdef HAVE_JACK_METADATA
static std::string
-get_property(jack_uuid_t subject, const char* key)
+get_property(const jack_uuid_t subject, const char* const key)
{
std::string result;
+#ifdef HAVE_JACK_METADATA
char* value = nullptr;
char* datatype = nullptr;
if (!jack_get_property(subject, key, &value, &datatype)) {
@@ -204,66 +204,88 @@ get_property(jack_uuid_t subject, const char* key)
}
jack_free(datatype);
jack_free(value);
+#else
+ (void)subject;
+ (void)key;
+#endif
return result;
}
-#endif
-PatchagePort*
-JackDriver::create_port(PatchageModule& parent,
- jack_port_t* port,
- const PortID& id)
+ClientInfo
+JackDriver::get_client_info(const char* const name)
{
- if (!port) {
- return nullptr;
- }
+ return {name}; // TODO: Pretty name?
+}
- std::string label;
- boost::optional<int> order;
+PortInfo
+JackDriver::get_port_info(const jack_port_t* const port)
+{
+ const auto uuid = jack_port_uuid(port);
+ const auto flags = jack_port_flags(port);
+ const std::string name = jack_port_name(port);
+ auto label = PortNames{name}.port();
+ // Get pretty name to use as a label, if present
#ifdef HAVE_JACK_METADATA
- const jack_uuid_t uuid = jack_port_uuid(port);
- if (_app->conf()->get_sort_ports()) {
- const std::string order_str = get_property(uuid, JACKEY_ORDER);
- label = get_property(uuid, JACK_METADATA_PRETTY_NAME);
- if (!order_str.empty()) {
- order = atoi(order_str.c_str());
- }
+ const auto pretty_name = get_property(uuid, JACK_METADATA_PRETTY_NAME);
+ if (!pretty_name.empty()) {
+ label = pretty_name;
}
#endif
- const char* const type_str = jack_port_type(port);
- PortType port_type = PortType::jack_audio;
+ // Determine detailed type, using metadata for fancy types if possible
+ const char* const type_str = jack_port_type(port);
+ PortType type = PortType::jack_audio;
if (!strcmp(type_str, JACK_DEFAULT_AUDIO_TYPE)) {
- port_type = PortType::jack_audio;
-#ifdef HAVE_JACK_METADATA
if (get_property(uuid, JACKEY_SIGNAL_TYPE) == "CV") {
- port_type = PortType::jack_cv;
+ type = PortType::jack_cv;
}
-#endif
} else if (!strcmp(type_str, JACK_DEFAULT_MIDI_TYPE)) {
- port_type = PortType::jack_midi;
-#ifdef HAVE_JACK_METADATA
+ type = PortType::jack_midi;
if (get_property(uuid, JACKEY_EVENT_TYPES) == "OSC") {
- port_type = PortType::jack_osc;
+ type = PortType::jack_osc;
}
-#endif
} else {
- _log.warning(fmt::format("[JACK] Port \"{}\" has unknown type \"{}\"",
- jack_port_name(port),
- type_str));
+ _log.warning(fmt::format(
+ "[JACK] Port \"{}\" has unknown type \"{}\"", name, type_str));
+ }
+
+ // Get direction from port flags
+ const SignalDirection direction =
+ ((flags & JackPortIsInput) ? SignalDirection::input
+ : SignalDirection::output);
+
+ // Get port order from metadata if possible
+ boost::optional<int> order;
+ const std::string order_str = get_property(uuid, JACKEY_ORDER);
+ if (!order_str.empty()) {
+ order = atoi(order_str.c_str());
+ }
+
+ return {label, type, direction, order, bool(flags & JackPortIsTerminal)};
+}
+
+PatchagePort*
+JackDriver::create_port(PatchageModule& parent,
+ jack_port_t* port,
+ const PortID& id)
+{
+ if (!port) {
return nullptr;
}
+ const auto info = get_port_info(port);
+
auto* ret = new PatchagePort(parent,
- port_type,
+ info.type,
id,
jack_port_short_name(port),
- label,
+ info.label,
(jack_port_flags(port) & JackPortIsInput),
- _app->conf()->get_port_color(port_type),
+ _app->conf()->get_port_color(info.type),
_app->show_human_names(),
- order);
+ info.order);
_app->canvas()->index_port(id, ret);
@@ -485,11 +507,11 @@ JackDriver::jack_client_registration_cb(const char* name,
int registered,
void* jack_driver)
{
- auto* me = static_cast<JackDriver*>(jack_driver);
+ auto* const me = static_cast<JackDriver*>(jack_driver);
assert(me->_client);
if (registered) {
- me->_events.emplace(ClientCreationEvent{ClientID::jack(name)});
+ me->_events.emplace(ClientCreationEvent{ClientID::jack(name), {name}});
} else {
me->_events.emplace(ClientDestructionEvent{ClientID::jack(name)});
}
@@ -505,11 +527,12 @@ JackDriver::jack_port_registration_cb(jack_port_id_t port_id,
jack_port_t* const port = jack_port_by_id(me->_client, port_id);
const char* const name = jack_port_name(port);
+ const auto id = PortID::jack(name);
if (registered) {
- me->_events.emplace(PortCreationEvent{PortID::jack(name)});
+ me->_events.emplace(PortCreationEvent{id, me->get_port_info(port)});
} else {
- me->_events.emplace(PortDestructionEvent{PortID::jack(name)});
+ me->_events.emplace(PortDestructionEvent{id});
}
}
diff --git a/src/JackDriver.hpp b/src/JackDriver.hpp
index 402ebc7..6e41fbb 100644
--- a/src/JackDriver.hpp
+++ b/src/JackDriver.hpp
@@ -17,8 +17,10 @@
#ifndef PATCHAGE_JACKDRIVER_HPP
#define PATCHAGE_JACKDRIVER_HPP
+#include "ClientInfo.hpp"
#include "Driver.hpp"
#include "PatchageEvent.hpp"
+#include "PortInfo.hpp"
#include <glibmm/thread.h>
#include <jack/jack.h>
@@ -81,6 +83,9 @@ public:
void process_events(Patchage* app) override;
private:
+ ClientInfo get_client_info(const char* name);
+ PortInfo get_port_info(const jack_port_t* port);
+
PatchagePort*
create_port(PatchageModule& parent, jack_port_t* port, const PortID& id);
diff --git a/src/PatchageEvent.hpp b/src/PatchageEvent.hpp
index 2a87a2e..d5add47 100644
--- a/src/PatchageEvent.hpp
+++ b/src/PatchageEvent.hpp
@@ -18,7 +18,9 @@
#define PATCHAGE_PATCHAGEEVENT_HPP
#include "ClientID.hpp"
+#include "ClientInfo.hpp"
#include "PortID.hpp"
+#include "PortInfo.hpp"
#include <boost/variant/variant.hpp>
@@ -26,7 +28,8 @@
struct ClientCreationEvent
{
- ClientID id;
+ ClientID id;
+ ClientInfo info;
};
struct ClientDestructionEvent
@@ -36,7 +39,8 @@ struct ClientDestructionEvent
struct PortCreationEvent
{
- PortID id;
+ PortID id;
+ PortInfo info;
};
struct PortDestructionEvent
diff --git a/src/PortInfo.hpp b/src/PortInfo.hpp
new file mode 100644
index 0000000..9b05c43
--- /dev/null
+++ b/src/PortInfo.hpp
@@ -0,0 +1,36 @@
+/* This file is part of Patchage.
+ * Copyright 2007-2020 David Robillard <d@drobilla.net>
+ *
+ * Patchage is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * Patchage is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Patchage. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PATCHAGE_PORTINFO_HPP
+#define PATCHAGE_PORTINFO_HPP
+
+#include "PortType.hpp"
+#include "SignalDirection.hpp"
+
+#include <boost/optional.hpp>
+#include <string>
+
+/// Extra information about a port not expressed in its ID
+struct PortInfo
+{
+ std::string label; ///< Human-friendly label
+ PortType type; ///< Detailed port type
+ SignalDirection direction; ///< Signal direction
+ boost::optional<int> order; ///< Order key on client
+ bool is_terminal; ///< True if this is a system port
+};
+
+#endif // PATCHAGE_PORTINFO_HPP
diff --git a/src/PortNames.hpp b/src/PortNames.hpp
index e976e34..f1f5391 100644
--- a/src/PortNames.hpp
+++ b/src/PortNames.hpp
@@ -24,13 +24,20 @@
class PortNames
{
public:
+ explicit PortNames(const std::string& jack_name)
+ {
+ const auto colon = jack_name.find(':');
+
+ if (colon != std::string::npos) {
+ _client_name = jack_name.substr(0, colon);
+ _port_name = jack_name.substr(colon + 1);
+ }
+ }
+
explicit PortNames(const PortID& id)
+ : PortNames(id.jack_name())
{
assert(id.type() == PortID::Type::jack);
-
- const auto colon = id.jack_name().find(':');
- _client_name = id.jack_name().substr(0, colon);
- _port_name = id.jack_name().substr(colon + 1);
}
const std::string& client() const { return _client_name; }
--
cgit v1.2.1