upgrade to libremidi 5.1, raylib and raygui latest

include/libremidi/backends/winmidi/config.hpp

@@ -1,19 +1,34 @@
 #pragma once
 #include <libremidi/config.hpp>
 
+#include <string>
+
+namespace winrt::Microsoft::Windows::Devices::Midi2
+{
+class MidiSession;
+class MidiEndpointDeviceInformation;
+class MidiEndpointConnection;
+}
+
+// TODO allow to share midi session and endpoints
 namespace libremidi::winmidi
 {
 
 struct input_configuration
 {
+  std::string client_name = "libremidi input";
+  winrt::Microsoft::Windows::Devices::Midi2::MidiSession* context{};
 };
 
 struct output_configuration
 {
+  std::string client_name = "libremidi output";
+  winrt::Microsoft::Windows::Devices::Midi2::MidiSession* context{};
 };
 
 struct observer_configuration
 {
+  std::string client_name = "libremidi observer";
 };
 
 }

include/libremidi/backends/winmidi/helpers.hpp

@@ -3,58 +3,94 @@
 #define NOMINMAX 1
 #define WIN32_LEAN_AND_MEAN 1
 #include <libremidi/detail/midi_api.hpp>
+#include <libremidi/detail/memory.hpp>
 
-#include <mutex>
 #include <cctype>
 #include <string>
-#include <thread>
-#include <vector>
 #include <guiddef.h>
 
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Devices.Enumeration.h>
-#include <winrt/Windows.Devices.Midi2.h>
+#include <winrt/Microsoft.Windows.Devices.Midi2.h>
+#include <libremidi/cmidi2.hpp>
 
+// MinGW support
+#if !defined(_MSC_VER)
+namespace Microsoft::Windows::Devices::Midi2::Initialization
+{
+struct IMidiClientInitializer;
+struct MidiClientInitializerUuid;
+}
 
-namespace midi2 = winrt::Windows::Devices::Midi2;
-namespace foundation = winrt::Windows::Foundation;
-namespace collections = winrt::Windows::Foundation::Collections;
-
+__CRT_UUID_DECL(Microsoft::Windows::Devices::Midi2::Initialization::IMidiClientInitializer,
+ 0x8087b303, 0xd551, 0xbce2, 0x1e, 0xad, 0xa2, 0x50, 0x0d, 0x50, 0xc5, 0x80);
+__CRT_UUID_DECL(Microsoft::Windows::Devices::Midi2::Initialization::MidiClientInitializerUuid,
+ 0xc3263827, 0xc3b0, 0xbdbd, 0x25, 0x00, 0xce, 0x63, 0xa3, 0xf3, 0xf2, 0xc3);
+#endif
 
+#include <init/Microsoft.Windows.Devices.Midi2.Initialization.hpp>
 // clang-format on
 
+namespace midi2 = winrt::Microsoft::Windows::Devices::Midi2;
+namespace foundation = winrt::Windows::Foundation;
+
 namespace libremidi::winmidi
 {
 using namespace winrt;
 using namespace winrt::Windows::Foundation;
 using namespace winrt::Windows::Devices::Enumeration;
 using namespace winrt::Windows::Storage::Streams;
-using namespace winrt::Windows::Devices::Midi2;
+using namespace winrt::Microsoft::Windows::Devices::Midi2;
 using namespace Windows::Devices::Enumeration;
+using namespace ::Microsoft::Windows::Devices::Midi2::Initialization;
 
 inline bool ichar_equals(char a, char b)
 {
   return std::tolower(static_cast<unsigned char>(a)) ==
          std::tolower(static_cast<unsigned char>(b));
 }
+
 inline bool iequals(std::string_view lhs, std::string_view rhs)
 {
   return std::ranges::equal(lhs, rhs, ichar_equals);
 }
 
-inline winrt::Windows::Devices::Midi2::MidiEndpointDeviceInformation
-get_port_by_name(const std::string& port) {
+inline std::pair<
+    winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointDeviceInformation,
+    winrt::Microsoft::Windows::Devices::Midi2::MidiGroupTerminalBlock>
+get_port(const std::string& device_name, int group_terminal_block)
+{
   auto eps = MidiEndpointDeviceInformation::FindAll();
   for (const auto& ep : eps)
   {
-    auto str = to_string(ep.Id());
+    auto str = to_string(ep.EndpointDeviceId());
     if (str.empty())
       continue;
 
-    if (iequals(str, port))
-      return ep;
+    if (iequals(str, device_name))
+    {
+      for (const auto& gp : ep.GetGroupTerminalBlocks())
+      {
+        if (gp.Number() == group_terminal_block)
+        {
+          return std::make_pair(ep, gp);
+        }
+      }
+    }
   }
-  return {nullptr};
+  return {nullptr, nullptr};
 }
+struct winmidi_shared_data
+{
+  std::shared_ptr<MidiDesktopAppSdkInitializer> initializer;
+  bool m_ready{false};
+  winmidi_shared_data()
+      : initializer{libremidi::instance<MidiDesktopAppSdkInitializer>()}
+      , m_ready{
+            initializer && initializer->InitializeSdkRuntime()
+            && initializer->EnsureServiceAvailable()}
+  {
+  }
+};
 }

include/libremidi/backends/winmidi/midi_in.hpp

@@ -5,14 +5,12 @@
 #include <libremidi/detail/midi_in.hpp>
 #include <libremidi/detail/midi_stream_decoder.hpp>
 
-#include <iostream>
-
 namespace libremidi::winmidi
 {
-
 class midi_in_impl final
     : public midi2::in_api
     , public error_handler
+    , public winmidi_shared_data
 {
 public:
   struct
@@ -24,7 +22,9 @@ public:
   explicit midi_in_impl(
       libremidi::ump_input_configuration&& conf, winmidi::input_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
-      , m_session{MidiSession::CreateSession(L"libremidi session")}
+      , m_session{
+            configuration.context ? *configuration.context
+                                  : MidiSession::Create(to_hstring(configuration.client_name))}
   {
     this->client_open_ = stdx::error{};
   }
@@ -42,15 +42,23 @@ public:
 
   stdx::error open_port(const input_port& port, std::string_view) override
   {
-    auto ep = get_port_by_name(port.port_name);
-    if (!ep)
+    auto device_id = std::get_if<std::string>(&port.device);
+    if (!device_id)
+      return std::errc::invalid_argument;
+
+    auto [ep, gp] = get_port(*device_id, port.port);
+    if (!ep || !gp)
       return std::errc::address_not_available;
 
-    m_endpoint = m_session.CreateEndpointConnection(ep.Id());
+    m_group_filter = port.port - 1;
+
+    // TODO use a MidiGroupEndpointListener for the filtering
+    m_endpoint = m_session.CreateEndpointConnection(ep.EndpointDeviceId());
 
     m_revoke_token = m_endpoint.MessageReceived(
-        [&](const foundation::IInspectable& sender,
-            const winrt::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& args) {
+        [this](
+            const winrt::Microsoft::Windows::Devices::Midi2::IMidiMessageReceivedEventSource&,
+            const winrt::Microsoft::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& args) {
       process_message(args);
     });
 
@@ -59,7 +67,7 @@ public:
     return stdx::error{};
   }
 
-  void process_message(const winrt::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& msg)
+  void process_message(const winrt::Microsoft::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& msg)
   {
     static constexpr timestamp_backend_info timestamp_info{
         .has_absolute_timestamps = true,
@@ -68,6 +76,14 @@ public:
     };
 
     const auto& ump = msg.GetMessagePacket();
+    auto pk = msg.PeekFirstWord();
+    if (m_group_filter >= 0)
+    {
+      int group = cmidi2_ump_get_group(&pk);
+      if (group != m_group_filter)
+        return;
+    }
+
     const auto& b = ump.GetAllWords();
 
     uint32_t ump_space[64];
@@ -91,7 +107,8 @@ public:
 private:
   MidiSession m_session;
   winrt::event_token m_revoke_token{};
-  winrt::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
+  winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
   midi2::input_state_machine m_processing{this->configuration};
+  int m_group_filter = -1;
 };
 }

include/libremidi/backends/winmidi/midi_out.hpp

@@ -11,6 +11,7 @@ namespace libremidi::winmidi
 class midi_out_impl final
     : public midi2::out_api
     , public error_handler
+    , public winmidi_shared_data
 {
 public:
   struct
@@ -21,7 +22,9 @@ public:
 
   midi_out_impl(libremidi::output_configuration&& conf, winmidi::output_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
-      , m_session{MidiSession::CreateSession(L"libremidi session")}
+      , m_session{
+            configuration.context ? *configuration.context
+                                  : MidiSession::Create(to_hstring(configuration.client_name))}
   {
     this->client_open_ = stdx::error{};
   }
@@ -35,11 +38,15 @@ public:
 
   stdx::error open_port(const output_port& port, std::string_view) override
   {
-    auto ep = get_port_by_name(port.port_name);
-    if (!ep)
+    auto device_id = std::get_if<std::string>(&port.device);
+    if (!device_id)
+      return std::errc::invalid_argument;
+
+    auto [ep, gp] = get_port(*device_id, port.port);
+    if (!ep || !gp)
       return std::errc::address_not_available;
 
-    m_endpoint = m_session.CreateEndpointConnection(ep.Id());
+    m_endpoint = m_session.CreateEndpointConnection(ep.EndpointDeviceId());
     m_endpoint.Open();
 
     return stdx::error{};
@@ -83,7 +90,7 @@ public:
 
 private:
   MidiSession m_session;
-  winrt::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
+  winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
 };
 
 }

include/libremidi/backends/winmidi/observer.hpp

@@ -2,7 +2,7 @@
 #include <libremidi/backends/winmidi/config.hpp>
 #include <libremidi/backends/winmidi/helpers.hpp>
 #include <libremidi/detail/observer.hpp>
-;
+
 namespace libremidi::winmidi
 {
 struct port_info
@@ -11,7 +11,9 @@ struct port_info
   hstring name;
 };
 
-class observer_impl final : public observer_api
+class observer_impl final
+    : public observer_api
+    , public winmidi_shared_data
 {
 public:
   struct
@@ -20,11 +22,17 @@ public:
   {
   } configuration;
 
+  MidiEndpointDeviceWatcher watcher = nullptr;
+  MidiEndpointDeviceWatcher::Added_revoker m_addHandler;
+  MidiEndpointDeviceWatcher::Updated_revoker m_updHandler;
+  MidiEndpointDeviceWatcher::Removed_revoker m_delHandler;
+  std::map<hstring, std::vector<input_port>> m_known_input_devices;
+  std::map<hstring, std::vector<output_port>> m_known_output_devices;
+  std::mutex m_devices_mtx;
 
   explicit observer_impl(
       libremidi::observer_configuration&& conf, winmidi::observer_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
-      , session{MidiSession::CreateSession(L"libremidi session")}
   {
     if (!configuration.has_callbacks())
       return;
@@ -40,26 +48,35 @@ public:
           configuration.output_added(p);
     }
 
-    /*
-    evTokenOnInputAdded_
-        = internalInPortObserver_.PortAdded([this](const port_info& p) { on_input_added(p); });
-    evTokenOnInputRemoved_
-        = internalInPortObserver_.PortRemoved([this](const port_info& p) { on_input_removed(p); });
-    evTokenOnOutputAdded_
-        = internalOutPortObserver_.PortAdded([this](const port_info& p) { on_output_added(p); });
-    evTokenOnOutputRemoved_ = internalOutPortObserver_.PortRemoved(
-        [this](const port_info& p) { on_output_removed(p); });
-*/
+    if ((watcher = MidiEndpointDeviceWatcher::Create()))
+    {
+      namespace enumeration = winrt::Windows::Devices::Enumeration;
+      auto addHandler = foundation::TypedEventHandler<
+          MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationAddedEventArgs>(
+          this, &observer_impl::on_device_added);
+      auto updHandler = foundation::TypedEventHandler<
+          MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationUpdatedEventArgs>(
+          this, &observer_impl::on_device_updated);
+      auto delHandler = foundation::TypedEventHandler<
+          MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationRemovedEventArgs>(
+          this, &observer_impl::on_device_removed);
+
+      m_addHandler = watcher.Added(winrt::auto_revoke, addHandler);
+      m_updHandler = watcher.Updated(winrt::auto_revoke, updHandler);
+      m_delHandler = watcher.Removed(winrt::auto_revoke, delHandler);
+
+      watcher.Start();
+    }
   }
 
   ~observer_impl()
   {
     if (!configuration.has_callbacks())
       return;
-    // internalInPortObserver_.PortAdded(evTokenOnInputAdded_);
-    // internalInPortObserver_.PortRemoved(evTokenOnInputRemoved_);
-    // internalOutPortObserver_.PortAdded(evTokenOnOutputAdded_);
-    // internalOutPortObserver_.PortRemoved(evTokenOnOutputRemoved_);
+
+    m_addHandler.revoke();
+    m_updHandler.revoke();
+    m_delHandler.revoke();
   }
 
   libremidi::API get_current_api() const noexcept override
@@ -67,33 +84,56 @@ public:
     return libremidi::API::WINDOWS_MIDI_SERVICES;
   }
 
-  template <bool Input>
-  auto to_port_info(const DeviceInformation& p) const noexcept
-      -> std::conditional_t<Input, input_port, output_port>
+  static port_information::port_type code_to_type(std::string_view str) noexcept
   {
+    using enum port_information::port_type;
+
+    if (str.starts_with("KS"))
+      return hardware;
+    if (str == "BLE")
+      return port_information::port_type(hardware | bluetooth);
+    if (str == "VPB" || str == "APP")
+      return software;
+    if (str == "LOOP")
+      return port_information::port_type(software | loopback);
+    if (str.starts_with("NET"))
+      return network;
+    return unknown;
+  }
+
+  template <bool Input>
+  auto to_port_info(const MidiEndpointDeviceInformation& p, const MidiGroupTerminalBlock& gp)
+      const noexcept -> std::conditional_t<Input, input_port, output_port>
+  {
+    const auto& tinfo = p.GetTransportSuppliedInfo();
+
     return {
         {.client = 0,
-         .port = 0,
-         .manufacturer = "",
-         .device_name = "",
-         .port_name = to_string(p.Id()),
-         .display_name = to_string(p.Name())}};
+         .container = std::bit_cast<libremidi::uuid>(p.ContainerId()),
+         .device = to_string(p.EndpointDeviceId()),
+         .port = gp.Number(),
+         .manufacturer = to_string(tinfo.ManufacturerName),
+         .device_name = to_string(p.Name()),
+         .port_name = to_string(gp.Name()),
+         .display_name = to_string(gp.Name()) + " " + std::to_string(gp.Number()),
+         .type = code_to_type(to_string(p.GetTransportSuppliedInfo().TransportCode))}};
   }
 
   std::vector<libremidi::input_port> get_input_ports() const noexcept override
   {
     std::vector<libremidi::input_port> ret;
 
-    auto deviceSelector = MidiEndpointConnection::GetDeviceSelector();
-    auto endpointDevices = DeviceInformation::FindAllAsync(deviceSelector).get();
-    for (const auto& ep : endpointDevices)
+    for (const auto& ep : MidiEndpointDeviceInformation::FindAll())
     {
       if(ep.Name().starts_with(L"Diagnostics")) {
         continue;
       }
-      // FIXME if(has input...)
 
-      ret.emplace_back(to_port_info<true>(ep));
+      for (const auto& gp : ep.GetGroupTerminalBlocks())
+      {
+        if (gp.Direction() != MidiGroupTerminalBlockDirection::BlockOutput)
+          ret.emplace_back(to_port_info<true>(ep, gp));
+      }
     }
 
     return ret;
@@ -103,46 +143,132 @@ public:
   {
     std::vector<libremidi::output_port> ret;
 
-    auto deviceSelector = MidiEndpointConnection::GetDeviceSelector();
-    auto endpointDevices = DeviceInformation::FindAllAsync(deviceSelector).get();
-    for (const auto& ep : endpointDevices)
+    for (const auto& ep : MidiEndpointDeviceInformation::FindAll())
     {
       if(ep.Name().starts_with(L"Diagnostics")) {
         continue;
       }
-      // FIXME if(has output...)
-      ret.emplace_back(to_port_info<false>(ep));
+
+      for (const auto& gp : ep.GetGroupTerminalBlocks())
+      {
+        if (gp.Direction() != MidiGroupTerminalBlockDirection::BlockInput)
+          ret.emplace_back(to_port_info<false>(ep, gp));
+      }
     }
 
     return ret;
   }
 
-  void on_input_added(const DeviceInformation& name)
+  // Note: these callbacks are called from some random thread!
+  void on_device_added(
+      const MidiEndpointDeviceWatcher&, const MidiEndpointDeviceInformationAddedEventArgs& result)
   {
-    if (configuration.input_added)
-      configuration.input_added(to_port_info<true>(name));
+    add_device(result.AddedDevice());
   }
 
-  void on_input_removed(const DeviceInformation& name)
+  void on_device_updated(
+      const MidiEndpointDeviceWatcher& e,
+      const MidiEndpointDeviceInformationUpdatedEventArgs& result)
   {
+    // OPTIMIZEME
+    remove_device(result.EndpointDeviceId());
+
+    add_device(
+        MidiEndpointDeviceInformation::CreateFromEndpointDeviceId(result.EndpointDeviceId()));
+  }
+
+  void on_device_removed(
+      const MidiEndpointDeviceWatcher&,
+      const MidiEndpointDeviceInformationRemovedEventArgs& result)
+  {
+    remove_device(result.EndpointDeviceId());
+  }
+
+  void add_device(const MidiEndpointDeviceInformation& ep)
+  {
+    for (const auto& gp : ep.GetGroupTerminalBlocks())
+    {
+      MidiGroupTerminalBlockDirection direction = gp.Direction();
+      switch (direction)
+      {
+        case MidiGroupTerminalBlockDirection::Bidirectional: {
+          if (configuration.input_added)
+          {
+            auto ip = to_port_info<true>(ep, gp);
+            {
+              std::lock_guard _{m_devices_mtx};
+              m_known_input_devices[ep.EndpointDeviceId()].push_back(ip);
+            }
+            configuration.input_added(std::move(ip));
+          }
+          if (configuration.output_added)
+          {
+            auto op = to_port_info<false>(ep, gp);
+            {
+              std::lock_guard _{m_devices_mtx};
+              m_known_output_devices[ep.EndpointDeviceId()].push_back(op);
+            }
+            configuration.output_added(std::move(op));
+          }
+          break;
+        }
+        case MidiGroupTerminalBlockDirection::BlockInput:
+          if (configuration.input_added)
+          {
+            auto ip = to_port_info<true>(ep, gp);
+            {
+              std::lock_guard _{m_devices_mtx};
+              m_known_input_devices[ep.EndpointDeviceId()].push_back(ip);
+            }
+            configuration.input_added(std::move(ip));
+          }
+          break;
+        case MidiGroupTerminalBlockDirection::BlockOutput:
+          if (configuration.output_added)
+          {
+            auto op = to_port_info<false>(ep, gp);
+            {
+              std::lock_guard _{m_devices_mtx};
+              m_known_output_devices[ep.EndpointDeviceId()].push_back(op);
+            }
+            configuration.output_added(std::move(op));
+          }
+          break;
+      }
+    }
+  }
+  void remove_device(hstring eid)
+  {
+    std::vector<input_port> to_remove_in;
+    std::vector<output_port> to_remove_out;
+
+    {
+      std::lock_guard _{m_devices_mtx};
+      if (auto it = m_known_input_devices.find(eid); it != m_known_input_devices.end())
+      {
+        for (auto& ip : it->second)
+        {
+          to_remove_in.push_back(ip);
+        }
+        m_known_input_devices.erase(it);
+      }
+      if (auto it = m_known_output_devices.find(eid); it != m_known_output_devices.end())
+      {
+        for (auto& op : it->second)
+        {
+          to_remove_out.push_back(op);
+        }
+        m_known_output_devices.erase(it);
+      }
+    }
+
     if (configuration.input_removed)
-      configuration.input_removed(to_port_info<true>(name));
-  }
-
-  void on_output_added(const DeviceInformation& name)
-  {
-    if (configuration.output_added)
-      configuration.output_added(to_port_info<false>(name));
-  }
-
-  void on_output_removed(const DeviceInformation& name)
-  {
+      for (auto& port : to_remove_in)
+        configuration.input_removed(port);
     if (configuration.output_removed)
-      configuration.output_removed(to_port_info<false>(name));
+      for (auto& port : to_remove_out)
+        configuration.output_removed(port);
   }
-
-private:
-  MidiSession session;
 };
 
 }