working on win32 uwp! and libremidi update

include/libremidi/backends/winmidi/midi_out.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <libremidi/detail/ump_stream.hpp>
 #include <libremidi/backends/winmidi/config.hpp>
 #include <libremidi/backends/winmidi/helpers.hpp>
 #include <libremidi/backends/winmidi/observer.hpp>
@@ -20,72 +21,69 @@ 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")}
   {
+    this->client_open_ = stdx::error{};
   }
 
   ~midi_out_impl() override { close_port(); }
 
-  bool open_virtual_port(std::string_view) override
-  {
-    warning(configuration, "midi_out_winmidi: open_virtual_port unsupported");
-    return false;
-  }
-  void set_client_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_winmidi: set_client_name unsupported");
-  }
-  void set_port_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_winmidi: set_port_name unsupported");
-  }
-
   libremidi::API get_current_api() const noexcept override
   {
     return libremidi::API::WINDOWS_MIDI_SERVICES;
   }
 
-  bool open_port(const output_port& port, std::string_view) override
+  stdx::error open_port(const output_port& port, std::string_view) override
   {
-#if 0
-    const auto id = winrt::to_hstring(port.port_name);
-    if (id.empty())
-      return false;
+    auto ep = get_port_by_name(port.port_name);
+    if (!ep)
+      return std::errc::address_not_available;
 
-    port_ = get(MidiOutPort::FromIdAsync(id));
-    return bool(port_);
-#endif
-    return true;
+    m_endpoint = m_session.CreateEndpointConnection(ep.Id());
+    m_endpoint.Open();
+
+    return stdx::error{};
   }
 
-  void close_port() override
+  stdx::error close_port() override
   {
-#if 0
-    if (port_)
-    {
-      port_.Close();
-      port_ = {};
-    }
-#endif
+    m_session.DisconnectEndpointConnection(m_endpoint.ConnectionId());
+    return stdx::error{};
   }
 
-  void send_ump(const uint32_t* message, size_t size) override
+  stdx::error send_ump(const uint32_t* message, size_t size) override
   {
-#if 0
-    if (!port_)
-      return;
+    auto write_func = [this](const uint32_t* ump, int64_t bytes) -> std::errc {
+      MidiSendMessageResults ret{};
+      switch(bytes / 4)
+      {
+        case 1:
+          ret = m_endpoint.SendSingleMessagePacket(MidiMessage32(0, ump[0]));
+          break;
+        case 2:
+          ret = m_endpoint.SendSingleMessagePacket(MidiMessage64(0, ump[0], ump[1]));
+          break;
+        case 3:
+          ret = m_endpoint.SendSingleMessagePacket(MidiMessage96(0, ump[0], ump[1], ump[2]));
+          break;
+        case 4:
+          ret = m_endpoint.SendSingleMessagePacket(MidiMessage128(0, ump[0], ump[1], ump[2], ump[3]));
+          break;
+        default:
+          return std::errc::bad_message;
+      }
 
-    InMemoryRandomAccessStream str;
-    DataWriter rb(str);
-    rb.WriteBytes(
-        winrt::array_view<const uint8_t>{(const uint8_t*)message, (const uint8_t*)message + size});
-    port_.SendBuffer(rb.DetachBuffer());
-#endif
+      if(ret != MidiSendMessageResults::Succeeded)
+        return std::errc::bad_message;
+      return std::errc{0};
+    };
+
+    return segment_ump_stream(message, size, write_func, []() {});
   }
 
 private:
-#if 0
-winrt::Windows::Devices::Midi2::IMidiOutPort port_{nullptr};
-#endif
+  MidiSession m_session;
+  winrt::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
 };
 
 }