alsa: refactor get_info a bit

Author: jcelerier

include/libremidi/backends/alsa_seq/helpers.hpp

@@ -159,15 +159,15 @@ struct alsa_data
         snd.seq.set_client_name(seq, configuration.client_name.data());
 
 #if __has_include(<alsa/ump.h>)
-      if (snd.seq.ump.set_client_midi_version)
+      if (snd.seq.set_client_midi_version)
       {
         switch (configuration.midi_version)
         {
           case 1:
-            snd.seq.ump.set_client_midi_version(seq, SND_SEQ_CLIENT_LEGACY_MIDI);
+            snd.seq.set_client_midi_version(seq, SND_SEQ_CLIENT_LEGACY_MIDI);
             break;
           case 2:
-            snd.seq.ump.set_client_midi_version(seq, SND_SEQ_CLIENT_UMP_MIDI_2_0);
+            snd.seq.set_client_midi_version(seq, SND_SEQ_CLIENT_UMP_MIDI_2_0);
             break;
         }
       }

include/libremidi/backends/alsa_seq/observer.hpp

@@ -22,10 +22,10 @@ struct port_info
   std::string port_name;
   int client{};
   int port{};
-  bool isInput{};
-  bool isOutput{};
+  bool is_input{};
+  bool is_output{};
   std::optional<int> card{};
-  libremidi::port_information::port_type type{};
+  libremidi::transport_type type{};
 };
 
 template <typename ConfigurationImpl>
@@ -93,57 +93,67 @@ class observer_impl
     }
   }
 
-  std::optional<port_info> get_info(int client, int port) const noexcept
+  std::optional<port_info> get_info(
+      int client, int port, snd_seq_client_info_t& cinfo,
+      snd_seq_port_info_t& pinfo) const noexcept
   {
+    const auto tp = snd.seq.port_info_get_type(&pinfo);
+    const auto cap = snd.seq.port_info_get_capability(&pinfo);
+    if ((cap & SND_SEQ_PORT_CAP_NO_EXPORT) != 0)
+      return std::nullopt;
+
     port_info p;
     p.client = client;
     p.port = port;
 
-    snd_seq_client_info_t* cinfo;
-    snd_seq_client_info_alloca(&cinfo);
-    if (int err = snd.seq.get_any_client_info(seq, client, cinfo); err < 0)
-      return std::nullopt;
-
-    snd_seq_port_info_t* pinfo;
-    snd_seq_port_info_alloca(&pinfo);
-    if (int err = snd.seq.get_any_port_info(seq, client, port, pinfo); err < 0)
-      return std::nullopt;
-
-    const auto tp = snd.seq.port_info_get_type(pinfo);
     bool ok = this->configuration.track_any;
 
     static constexpr auto virtual_port = SND_SEQ_PORT_TYPE_SOFTWARE | SND_SEQ_PORT_TYPE_SYNTHESIZER
                                          | SND_SEQ_PORT_TYPE_APPLICATION;
 
     if ((tp & SND_SEQ_PORT_TYPE_HARDWARE) && this->configuration.track_hardware)
     {
-      p.type = libremidi::port_information::port_type::hardware;
+      p.type = libremidi::transport_type::hardware;
       ok = true;
     }
     else if ((tp & virtual_port) && this->configuration.track_virtual)
     {
-      p.type = libremidi::port_information::port_type::software;
+      p.type = libremidi::transport_type::software;
       ok = true;
     }
     if (!ok)
       return {};
 
-    if (auto name = snd.seq.client_info_get_name(cinfo))
+    if (auto name = snd.seq.client_info_get_name(&cinfo))
       p.client_name = name;
 
-    if (auto name = snd.seq.port_info_get_name(pinfo))
+    if (auto name = snd.seq.port_info_get_name(&pinfo))
       p.port_name = name;
 
-    if (int card = snd.seq.client_info_get_card(cinfo); card >= 0)
+    if (int card = snd.seq.client_info_get_card(&cinfo); card >= 0)
       p.card = card;
 
-    const auto cap = snd.seq.port_info_get_capability(pinfo);
-    p.isInput = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_READ);
-    p.isOutput = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_WRITE);
+    p.is_input = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_READ);
+    p.is_output = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_WRITE);
 
     return p;
   }
 
+  std::optional<port_info> get_info(int client, int port) const noexcept
+  {
+    snd_seq_client_info_t* cinfo;
+    snd_seq_client_info_alloca(&cinfo);
+    if (int err = snd.seq.get_any_client_info(seq, client, cinfo); err < 0)
+      return std::nullopt;
+
+    snd_seq_port_info_t* pinfo;
+    snd_seq_port_info_alloca(&pinfo);
+    if (int err = snd.seq.get_any_port_info(seq, client, port, pinfo); err < 0)
+      return std::nullopt;
+
+    return get_info(client, port, *cinfo, *pinfo);
+  }
+
   template <bool Input>
   auto to_port_info(const port_info& p) const noexcept
       -> std::conditional_t<Input, input_port, output_port>
@@ -209,8 +219,8 @@ class observer_impl
         snd, this->seq, [this, &ret](snd_seq_client_info_t& client, snd_seq_port_info_t& port) {
       int clt = snd.seq.client_info_get_client(&client);
       int pt = snd.seq.port_info_get_port(&port);
-      if (auto p = get_info(clt, pt))
-        if (p->isInput)
+      if (auto p = get_info(clt, pt, client, port))
+        if (p->is_input)
           ret.push_back(to_port_info<true>(*p));
     });
     return ret;
@@ -223,8 +233,8 @@ class observer_impl
         snd, this->seq, [this, &ret](snd_seq_client_info_t& client, snd_seq_port_info_t& port) {
       int clt = snd.seq.client_info_get_client(&client);
       int pt = snd.seq.port_info_get_port(&port);
-      if (auto p = get_info(clt, pt))
-        if (p->isOutput)
+      if (auto p = get_info(clt, pt, client, port))
+        if (p->is_output)
           ret.push_back(to_port_info<false>(*p));
     });
     return ret;
@@ -240,12 +250,12 @@ class observer_impl
       return;
 
     m_knownClients[{p.client, p.port}] = p;
-    if (p.isInput && configuration.input_added)
+    if (p.is_input && configuration.input_added)
     {
       configuration.input_added(to_port_info<true>(p));
     }
 
-    if (p.isOutput && configuration.output_added)
+    if (p.is_output && configuration.output_added)
     {
       configuration.output_added(to_port_info<false>(p));
     }
@@ -259,12 +269,12 @@ class observer_impl
       auto p = it->second;
       m_knownClients.erase(it);
 
-      if (p.isInput && configuration.input_removed)
+      if (p.is_input && configuration.input_removed)
       {
         configuration.input_removed(to_port_info<true>(p));
       }
 
-      if (p.isOutput && configuration.output_removed)
+      if (p.is_output && configuration.output_removed)
       {
         configuration.output_removed(to_port_info<false>(p));
       }

include/libremidi/backends/linux/alsa.hpp

@@ -292,6 +292,12 @@ struct libasound
       LIBREMIDI_SYMBOL_INIT(snd_seq, set_queue_tempo)
       LIBREMIDI_SYMBOL_INIT(snd_seq, subscribe_port)
       LIBREMIDI_SYMBOL_INIT(snd_seq, unsubscribe_port)
+
+#if LIBREMIDI_ALSA_HAS_UMP
+      LIBREMIDI_SYMBOL_INIT(snd_seq, set_client_midi_version)
+      LIBREMIDI_SYMBOL_INIT(snd_seq, get_ump_endpoint_info)
+      LIBREMIDI_SYMBOL_INIT(snd_seq, get_ump_block_info)
+#endif
     }
 
     bool available{true};
@@ -336,6 +342,7 @@ struct libasound
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_info_sizeof)
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_free)
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_malloc)
+    LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_sizeof)
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_set_dest)
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_set_sender)
     LIBREMIDI_SYMBOL_DEF(snd_seq, port_subscribe_set_time_real)
@@ -352,6 +359,12 @@ struct libasound
     LIBREMIDI_SYMBOL_DEF(snd_seq, subscribe_port)
     LIBREMIDI_SYMBOL_DEF(snd_seq, unsubscribe_port)
 
+#if LIBREMIDI_ALSA_HAS_UMP
+    LIBREMIDI_SYMBOL_DEF(snd_seq, set_client_midi_version)
+    LIBREMIDI_SYMBOL_DEF(snd_seq, get_ump_endpoint_info)
+    LIBREMIDI_SYMBOL_DEF(snd_seq, get_ump_block_info)
+#endif
+
 #if LIBREMIDI_ALSA_HAS_UMP
     struct ump_t
     {
@@ -362,18 +375,17 @@ struct libasound
           available = false;
           return;
         }
-        LIBREMIDI_SYMBOL_INIT(snd_seq, set_client_midi_version)
         LIBREMIDI_SYMBOL_INIT(snd_seq_ump, event_input)
         LIBREMIDI_SYMBOL_INIT(snd_seq_ump, event_output)
         LIBREMIDI_SYMBOL_INIT(snd_seq_ump, event_output_direct)
       }
 
       bool available{true};
 
-      LIBREMIDI_SYMBOL_DEF(snd_seq, set_client_midi_version)
       LIBREMIDI_SYMBOL_DEF(snd_seq_ump, event_input)
       LIBREMIDI_SYMBOL_DEF(snd_seq_ump, event_output)
       LIBREMIDI_SYMBOL_DEF(snd_seq_ump, event_output_direct)
+
     } ump;
 #endif
   } seq{library};
@@ -389,39 +401,98 @@ struct libasound
         return;
       }
 
-      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_name)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_sizeof)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, close)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_name)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_sizeof)
+      // Core UMP functions
       LIBREMIDI_SYMBOL_INIT(snd_ump, open)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors_count)
-      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors_revents)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, close)
       LIBREMIDI_SYMBOL_INIT(snd_ump, rawmidi)
       LIBREMIDI_SYMBOL_INIT(snd_ump, rawmidi_params)
       LIBREMIDI_SYMBOL_INIT(snd_ump, rawmidi_params_current)
       LIBREMIDI_SYMBOL_INIT(snd_ump, read)
       LIBREMIDI_SYMBOL_INIT(snd_ump, tread)
       LIBREMIDI_SYMBOL_INIT(snd_ump, write)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors_count)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, poll_descriptors_revents)
+
+      // Endpoint info functions
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_sizeof)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_card)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_device)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_flags)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_protocol_caps)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_protocol)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_num_blocks)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_version)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_manufacturer_id)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_family_id)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_model_id)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_sw_revision)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_name)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, endpoint_info_get_product_id)
+
+      // Block info functions
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_sizeof)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_set_block_id)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_block_id)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_active)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_flags)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_direction)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_first_group)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_num_groups)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_midi_ci_version)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_sysex8_streams)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_ui_hint)
+      LIBREMIDI_SYMBOL_INIT(snd_ump, block_info_get_name)
     }
 
     bool available{true};
-    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_name)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_sizeof)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, close)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_name)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_sizeof)
+
+    // Core UMP functions
     LIBREMIDI_SYMBOL_DEF(snd_ump, open)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors_count)
-    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors_revents)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, close)
     LIBREMIDI_SYMBOL_DEF(snd_ump, rawmidi)
     LIBREMIDI_SYMBOL_DEF(snd_ump, rawmidi_params)
     LIBREMIDI_SYMBOL_DEF(snd_ump, rawmidi_params_current)
     LIBREMIDI_SYMBOL_DEF(snd_ump, read)
     LIBREMIDI_SYMBOL_DEF(snd_ump, tread)
     LIBREMIDI_SYMBOL_DEF(snd_ump, write)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors_count)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, poll_descriptors_revents)
+
+    // Endpoint info functions
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_sizeof)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_card)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_device)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_flags)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_protocol_caps)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_protocol)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_num_blocks)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_version)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_manufacturer_id)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_family_id)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_model_id)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_sw_revision)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_name)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, endpoint_info_get_product_id)
+
+    // Block info functions
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_sizeof)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_set_block_id)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_block_id)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_active)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_flags)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_direction)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_first_group)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_num_groups)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_midi_ci_version)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_sysex8_streams)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_ui_hint)
+    LIBREMIDI_SYMBOL_DEF(snd_ump, block_info_get_name)
   } ump{library};
 #endif
 };
@@ -449,6 +520,8 @@ struct libasound
 #define snd_seq_client_info_alloca(ptr) snd_dylib_alloca(ptr, seq, client_info)
 #undef snd_seq_port_info_alloca
 #define snd_seq_port_info_alloca(ptr) snd_dylib_alloca(ptr, seq, port_info)
+#undef snd_seq_port_subscribe_alloca
+#define snd_seq_port_subscribe_alloca(ptr) snd_dylib_alloca(ptr, seq, port_subscribe)
 #undef snd_seq_queue_tempo_alloca
 #define snd_seq_queue_tempo_alloca(ptr) snd_dylib_alloca(ptr, seq, queue_tempo)