port information: add more metadata

Author: jcelerier

examples/utils.hpp

@@ -59,6 +59,10 @@ inline std::ostream& operator<<(std::ostream& s, const libremidi::device_identif
   {
     std::ostream& s;
     void operator()(const std::string& u) { s << u; }
+    void operator()(libremidi::usb_device_identifier u)
+    {
+      s << u.vendor_id << ":" << u.product_id;
+    }
     void operator()(uint64_t u)
     {
       auto res = static_cast<uint32_t>(u);
@@ -160,23 +164,27 @@ inline std::ostream& operator<<(std::ostream& s, const libremidi::port_informati
 {
   s << "[ client: " << rhs.client;
   if (rhs.container.index() > 0)
-    s << ", container: " << rhs.container;
+    s << "\n    , container: " << rhs.container;
   if (rhs.device.index() > 0)
-    s << ", device_id: " << rhs.device;
+    s << "\n    , device_id: " << rhs.device;
 
-  s << ", port: " << rhs.port;
+  s << "\n    , port: " << rhs.port;
 
   if (!rhs.manufacturer.empty())
-    s << ", manufacturer: " << rhs.manufacturer;
+    s << "\n    , manufacturer: " << rhs.manufacturer;
+  if (!rhs.product.empty())
+    s << "\n    , product: " << rhs.product;
+  if (!rhs.serial.empty())
+    s << "\n    , serial: " << rhs.serial;
   if (!rhs.device_name.empty())
-    s << ", device_name: " << rhs.device_name;
+    s << "\n    , device_name: " << rhs.device_name;
   if (!rhs.port_name.empty())
-    s << ", port_name: " << rhs.port_name;
+    s << "\n    , port_name: " << rhs.port_name;
   if (!rhs.display_name.empty())
-    s << ", display_name: " << rhs.display_name;
-  if (rhs.type != libremidi::port_information::unknown)
-    s << ", type: " << rhs.type;
-  return s << "]";
+    s << "\n    , display_name: " << rhs.display_name;
+  if (rhs.type != libremidi::transport_type::unknown)
+    s << "\n    , type: " << rhs.type;
+  return s << "\n  ]";
 }
 
 namespace libremidi::examples

include/libremidi/backends/alsa_raw/helpers.hpp

@@ -53,6 +53,7 @@ namespace alsa_raw
 {
 struct alsa_raw_port_info
 {
+  // hw:1,2,0
   std::string device;
   std::string card_name;
   std::string device_name;

include/libremidi/backends/alsa_raw/observer.hpp

@@ -28,6 +28,21 @@ class observer_impl_base
   explicit observer_impl_base(
       observer_configuration&& conf, alsa_raw_observer_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
+  {
+  }
+
+  ~observer_impl_base()
+  {
+#if LIBREMIDI_HAS_UDEV
+    m_termination_event.notify();
+
+    if (m_thread.joinable())
+      m_thread.join();
+#endif
+  }
+
+  // Must be called for child classes due to virtual function calls
+  void finish_init()
   {
     if (!configuration.has_callbacks())
       return;
@@ -48,16 +63,6 @@ class observer_impl_base
 #endif
   }
 
-  ~observer_impl_base()
-  {
-#if LIBREMIDI_HAS_UDEV
-    m_termination_event.notify();
-
-    if (m_thread.joinable())
-      m_thread.join();
-#endif
-  }
-
   std::vector<libremidi::input_port> get_input_ports() const noexcept override
   {
     std::vector<libremidi::input_port> ret;
@@ -84,7 +89,6 @@ class observer_impl_base
     return ret;
   }
 
-private:
 #if LIBREMIDI_HAS_UDEV
   void run()
   {
@@ -98,6 +102,12 @@ class observer_impl_base
           return;
       }
 
+      // Check eventfd to see if we need to exit
+      if (m_fds[1].revents & POLLIN)
+      {
+        break;
+      }
+
       // Check udev
       if (m_fds[0].revents & POLLIN)
       {
@@ -122,12 +132,6 @@ class observer_impl_base
         m_fds[0].revents = 0;
       }
 
-      // Check eventfd
-      if (m_fds[1].revents & POLLIN)
-      {
-        break;
-      }
-
       // Check timer
       if (m_fds[2].revents & POLLIN)
       {
@@ -146,26 +150,35 @@ class observer_impl_base
       -> std::conditional_t<Input, input_port, output_port>
   {
 #if LIBREMIDI_HAS_UDEV
-    auto [container, device, type] = get_udev_soundcard_info(m_udev, p.card);
+    auto [container, device, type, manufacturer, product, serial]
+        = get_udev_soundcard_info(m_udev, p.card);
 #else
     container_identifier container{};
     device_identifier device{};
-    libremidi::port_information::port_type type{};
+    libremidi::transport_type type{};
+    std::string manufacturer;
+    std::string product;
+    std::string serial;
 #endif
     std::string display_name = p.subdevice_name;
     if (display_name.empty())
       display_name = p.device_name;
     if (display_name.empty())
       display_name = p.card_name;
+    if (display_name.empty())
+      display_name = product;
     if (display_name.empty())
       display_name = "unknown";
 
     return {
-        {.client = 0,
+        {.api = get_current_api(),
+         .client = 0,
          .container = container,
          .device = device,
          .port = raw_to_port_handle({p.card, p.dev, p.sub}),
-         .manufacturer = p.card_name,
+         .manufacturer = manufacturer,
+         .product = product,
+         .serial = serial,
          .device_name = p.device_name,
          .port_name = p.subdevice_name,
          .display_name = std::move(display_name),
@@ -247,7 +260,12 @@ namespace libremidi::alsa_raw
 {
 struct observer_impl : observer_impl_base<alsa_raw::midi1_enumerator>
 {
-  using alsa_raw::observer_impl_base<midi1_enumerator>::observer_impl_base;
+  observer_impl(observer_configuration&& conf, alsa_raw_observer_configuration&& apiconf)
+      : observer_impl_base<alsa_raw::midi1_enumerator>{std::move(conf), std::move(apiconf)}
+  {
+    finish_init();
+  }
+
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW; }
 };
 }

include/libremidi/backends/alsa_raw_ump/observer.hpp

@@ -4,11 +4,16 @@
 
 namespace libremidi::alsa_raw_ump
 {
-
 class observer_impl : public alsa_raw::observer_impl_base<midi2_enumerator>
 {
-  using alsa_raw::observer_impl_base<midi2_enumerator>::observer_impl_base;
+public:
+  observer_impl(
+      libremidi::observer_configuration&& conf, alsa_raw_ump::observer_configuration&& apiconf)
+      : observer_impl_base<alsa_raw_ump::midi2_enumerator>{std::move(conf), std::move(apiconf)}
+  {
+    finish_init();
+  }
+
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW_UMP; }
 };
-
 }

include/libremidi/backends/alsa_seq/observer.hpp

@@ -153,22 +153,31 @@ class observer_impl
 
     container_identifier container{};
     device_identifier device{};
-    libremidi::port_information::port_type type = p.type;
+    libremidi::transport_type type = p.type;
+    std::string manufacturer;
+    std::string product;
+    std::string serial;
 #if LIBREMIDI_HAS_UDEV
     if (p.card)
     {
       auto res = get_udev_soundcard_info(m_udev, *p.card);
       container = res.container;
       device = res.path;
       type = res.type;
+      manufacturer = res.vendor;
+      product = res.product;
+      serial = res.serial;
     }
 #endif
     return {
-        {.client = std::uintptr_t(this->seq),
+        {.api = get_current_api(),
+         .client = std::uintptr_t(this->seq),
          .container = container,
          .device = device,
          .port = alsa_seq::seq_to_port_handle(p.client, p.port),
-         .manufacturer = "",
+         .manufacturer = manufacturer,
+         .product = product,
+         .serial = serial,
          .device_name = p.client_name,
          .port_name = p.port_name,
          .display_name = p.port_name,

include/libremidi/backends/android/observer.hpp

@@ -53,6 +53,7 @@ class observer final
     for (size_t i = 0; i < context::midi_devices.size(); ++i)
     {
       libremidi::input_port port;
+      port.api = libremidi::API::ANDROID_AMIDI;
       port.port_name = context::port_name(env, i);
       port.port = i;
       ports.push_back(std::move(port));

include/libremidi/backends/coremidi/observer.hpp

@@ -22,6 +22,10 @@ class observer_core
 
   explicit observer_core(observer_configuration&& conf, coremidi_observer_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
+  {
+  }
+
+  void finish_init()
   {
     if (configuration.client_name.empty())
       configuration.client_name = "libremidi observer";
@@ -77,7 +81,7 @@ class observer_core
       return {};
 
     // Get the MIDI device from the entity
-    libremidi::port_information::port_type type{};
+    libremidi::transport_type type{};
     libremidi::container_identifier usb_location_id{};
     libremidi::device_identifier usb_vendor_product{};
     {
@@ -86,37 +90,38 @@ class observer_core
       {
         if (device)
         {
-          using enum libremidi::port_information::port_type;
+          using enum libremidi::transport_type;
           SInt32 devid_res{};
           if (MIDIObjectGetIntegerProperty(device, CFSTR("USBLocationID"), &devid_res) == noErr)
           {
-            type = (libremidi::port_information::port_type)(hardware | usb);
+            type = (libremidi::transport_type)(hardware | usb);
             usb_location_id = (uint64_t)devid_res;
           }
 
           SInt32 vendor_res{};
           if (MIDIObjectGetIntegerProperty(device, CFSTR("USBVendorProduct"), &vendor_res)
               == noErr)
           {
-            type = (libremidi::port_information::port_type)(hardware | usb);
+            type = (libremidi::transport_type)(hardware | usb);
             usb_vendor_product = (uint64_t)vendor_res;
           }
 
           const auto driver = get_string_property(device, kMIDIPropertyDriverOwner);
           if (driver == "com.apple.AppleMIDIUSBDriver")
-            type = (libremidi::port_information::port_type)(hardware | usb);
+            type = (libremidi::transport_type)(hardware | usb);
           if (driver == "com.apple.AppleMIDIBluetoothDriver")
-            type = (libremidi::port_information::port_type)(hardware | bluetooth);
+            type = (libremidi::transport_type)(hardware | bluetooth);
           if (driver == "com.apple.AppleMIDIIACDriver")
-            type = (libremidi::port_information::port_type)(software);
+            type = (libremidi::transport_type)(software);
           if (driver == "com.apple.AppleMIDIRTPDriver")
-            type = (libremidi::port_information::port_type)(network);
+            type = (libremidi::transport_type)(network);
         }
       }
     }
 
     return std::conditional_t<Input, input_port, output_port>{
-        {.client = (std::uintptr_t)this->client,
+        {.api = get_current_api(),
+         .client = (std::uintptr_t)this->client,
          .container = usb_location_id,
          .device = usb_vendor_product,
          .port = std::bit_cast<uint32_t>(get_int_property(obj, kMIDIPropertyUniqueID)),
@@ -213,3 +218,17 @@ class observer_core
   MIDIClientRef client{};
 };
 }
+
+namespace libremidi::coremidi
+{
+struct observer_impl : observer_core
+{
+  observer_impl(observer_configuration&& conf, coremidi_observer_configuration&& apiconf)
+      : observer_core{std::move(conf), std::move(apiconf)}
+  {
+    finish_init();
+  }
+
+  libremidi::API get_current_api() const noexcept override { return libremidi::API::COREMIDI; }
+};
+}

include/libremidi/backends/coremidi_ump/observer.hpp

@@ -14,6 +14,7 @@ class observer_impl final : public libremidi::observer_core
             std::move(conf),
             coremidi_observer_configuration{apiconf.client_name, apiconf.on_create_context}}
   {
+    finish_init();
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::COREMIDI_UMP; }

include/libremidi/backends/emscripten/observer.cpp

@@ -42,7 +42,8 @@ static auto to_port_info(int index, const webmidi_helpers::device_information& d
     -> std::conditional_t<Input, input_port, output_port>
 {
   return {
-      {.client = 0,
+      {.api = libremidi::API::WEBMIDI,
+       .client = 0,
        .port = (uint64_t)index,
        .manufacturer = "",
        .device_name = "",

include/libremidi/backends/jack/helpers.hpp

@@ -41,11 +41,12 @@ struct jack_client
     }
   }
 
-  template <bool Input>
+  template <bool Input, libremidi::API Api>
   static auto to_port_info(jack_client_t* client, jack_port_t* port)
       -> std::conditional_t<Input, input_port, output_port>
   {
     return {{
+        .api = Api,
         .client = reinterpret_cast<std::uintptr_t>(client),
         .port = 0,
         .manufacturer = "",
@@ -55,7 +56,7 @@ struct jack_client
     }};
   }
 
-  template <bool Input>
+  template <bool Input, libremidi::API Api>
   static auto get_ports(
       jack_client_t* client, const char* pattern, const char* type, const JackPortFlags flags,
       bool midi2) noexcept -> std::vector<std::conditional_t<Input, input_port, output_port>>
@@ -78,7 +79,7 @@ struct jack_client
       if (port)
       {
         if (bool(midi2) == bool(jack_port_flags(port) & 0x20))
-          ret.push_back(to_port_info<Input>(client, port));
+          ret.push_back(to_port_info<Input, Api>(client, port));
       }
       i++;
     }