working on win32 uwp! and libremidi update

include/libremidi/backends/alsa_raw/config.hpp

@@ -61,6 +61,7 @@ struct manual_poll_parameters
 struct alsa_raw_input_configuration
 {
   std::function<bool(const manual_poll_parameters&)> manual_poll;
+  std::chrono::milliseconds poll_period{2};
 };
 
 struct alsa_raw_output_configuration

include/libremidi/backends/alsa_raw/helpers.hpp

@@ -3,14 +3,9 @@
 #include <libremidi/config.hpp>
 #include <libremidi/detail/observer.hpp>
 
-#include <chrono>
 #include <functional>
-#include <iostream>
-#include <optional>
-#include <span>
 #include <string>
 #include <string_view>
-#include <thread>
 #include <vector>
 
 // Credits: greatly inspired from
@@ -87,39 +82,16 @@ struct snd_ctl_wrapper
 struct enumerator
 {
   const libasound& snd = libasound::instance();
+  const error_handler& handler;
+  const observer_configuration& configuration;
   std::vector<alsa_raw_port_info> inputs;
   std::vector<alsa_raw_port_info> outputs;
 
-  std::function<void(std::string_view)> error_callback;
-  std::function<void(std::string_view)> warn_callback;
+  explicit enumerator(const auto& self)
+      : handler{self}
+      , configuration{self.configuration}
+  {
 
-  template <typename... Args>
-  void warning(Args&&... args)
-  {
-    std::string s;
-    ((s += args), ...);
-    if (warn_callback)
-    {
-      warn_callback(std::move(s));
-    }
-    else
-    {
-      std::cerr << s << std::endl;
-    }
-  }
-  template <typename... Args>
-  void error(Args&&... args)
-  {
-    std::string s;
-    ((s += args), ...);
-    if (error_callback)
-    {
-      error_callback(std::move(s));
-    }
-    else
-    {
-      throw std::runtime_error(s.c_str());
-    }
   }
 
   // 1: is an input / output
@@ -141,9 +113,9 @@ struct enumerator
     }
     else if (status < 0 && status != -ENXIO)
     {
-      error(
-          "alsa_raw_helpers::enumerator::is: cannot get rawmidi information:", card, device, sub,
-          snd.strerror(status));
+      handler.libremidi_handle_error(
+          configuration, "Cannot get rawmidi information: " + device_identifier(card, device, sub)
+                             + " : " + snd.strerror(status));
       return status;
     }
     else
@@ -185,26 +157,23 @@ struct enumerator
     return s;
   }
 
-  void enumerate_cards()
+  stdx::error enumerate_cards()
   {
+    using namespace std::literals;
     int card = -1;
 
     int status = snd.card.next(&card);
     if (status < 0)
     {
-      error(
-          "alsa_raw_helpers::enumerator::enumerate_cards: "
-          "cannot determine card number: ",
-          snd.strerror(status));
-      return;
+      handler.libremidi_handle_error(
+          configuration, "Cannot determine card number: "s + snd.strerror(status));
+      return from_errc(status);
     }
 
     if (card < 0)
     {
-      error(
-          "alsa_raw_helpers::enumerator::enumerate_cards: "
-          "no sound cards found");
-      return;
+      handler.libremidi_handle_error(configuration, "No sound cards found");
+      return std::errc::no_such_device;
     }
 
     while (card >= 0)
@@ -213,13 +182,12 @@ struct enumerator
 
       if ((status = snd.card.next(&card)) < 0)
       {
-        error(
-            "alsa_raw_helpers::enumerator::enumerate_cards: "
-            "cannot determine card number: ",
-            snd.strerror(status));
-        break;
+        handler.libremidi_handle_error(
+            configuration, "cannot determine card number: "s + snd.strerror(status));
+        return std::errc::no_such_device;
       }
     }
+    return stdx::error{};
   }
 
   virtual void enumerate_devices(int card) = 0;
@@ -228,20 +196,22 @@ struct enumerator
 inline snd_ctl_wrapper::snd_ctl_wrapper(enumerator& self, const char* name)
     : snd{self.snd}
 {
+  using namespace std::literals;
   int status = snd.ctl.open(&ctl, name, 0);
   if (status < 0)
   {
-    self.error(
-        "alsa_raw_helpers::enumerator::snd_ctl_wrapper: "
-        "cannot open control for card",
-        name, snd.strerror(status));
+    self.handler.libremidi_handle_error(
+        self.configuration, "cannot open control for card"s + name + " : " + snd.strerror(status));
   }
 }
 
 struct midi1_enumerator : enumerator
 {
+  using alsa_raw::enumerator::enumerator;
+
   void enumerate_devices(int card) override
   {
+    using namespace std::literals;
     char name[128];
 
     sprintf(name, "hw:%d", card);
@@ -261,10 +231,8 @@ struct midi1_enumerator : enumerator
 
       if (status < 0)
       {
-        error(
-            "alsa_raw::midi1_enumerator::enumerate_devices: "
-            "cannot determine device number: ",
-            snd.strerror(status));
+        handler.libremidi_handle_error(
+            configuration, "Cannot determine device number: "s + snd.strerror(status));
         break;
       }
 

include/libremidi/backends/alsa_raw/midi_in.hpp

@@ -33,83 +33,72 @@ public:
 
   ~midi_in_impl() override { }
 
-  bool open_virtual_port(std::string_view) override
-  {
-    warning(configuration, "midi_in_alsa_raw: open_virtual_port unsupported");
-    return false;
-  }
-  void set_client_name(std::string_view) override
-  {
-    warning(configuration, "midi_in_alsa_raw: set_client_name unsupported");
-  }
-  void set_port_name(std::string_view) override
-  {
-    warning(configuration, "midi_in_alsa_raw: set_port_name unsupported");
-  }
-
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW; }
 
   // Must be a string such as: "hw:2,4,1"
-  [[nodiscard]] int do_init_port(const char* portname)
+  [[nodiscard]] stdx::error do_init_port(const char* portname)
   {
     constexpr int mode = SND_RAWMIDI_NONBLOCK;
     if (const int err = snd.rawmidi.open(&midiport_, nullptr, portname, mode); err < 0)
     {
-      error<driver_error>(this->configuration, "midi_in_alsa_raw::open_port: cannot open device.");
-      return err;
+      libremidi_handle_error(this->configuration, "cannot open device.");
+      return from_errc(err);
     }
 
     snd_rawmidi_params_t* params{};
     snd_rawmidi_params_alloca(&params);
 
     if (const int err = snd.rawmidi.params_current(midiport_, params); err < 0)
-      return err;
+      return from_errc(err);
     if (const int err = snd.rawmidi.params_set_no_active_sensing(midiport_, params, 1); err < 0)
-      return err;
+      return from_errc(err);
 #if LIBREMIDI_ALSA_HAS_RAWMIDI_TREAD
     if (configuration.timestamps == timestamp_mode::NoTimestamp)
     {
       if (const int err
           = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_STANDARD);
           err < 0)
-        return err;
+        return from_errc(err);
       if (const int err
           = snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_NONE);
           err < 0)
-        return err;
+        return from_errc(err);
     }
     else
     {
       if (const int err
           = snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_TSTAMP);
           err < 0)
-        return err;
+        return from_errc(err);
       if (const int err
           = snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_MONOTONIC);
           err < 0)
-        return err;
+        return from_errc(err);
     }
 #endif
 
     if (const int err = snd.rawmidi.params(midiport_, params); err < 0)
-      return err;
+      return from_errc(err);
 
     return init_pollfd();
   }
 
-  [[nodiscard]] int init_port(const port_information& p)
+  [[nodiscard]] stdx::error init_port(const port_information& p)
   {
     return do_init_port(raw_from_port_handle(p.port).to_string().c_str());
   }
 
-  [[nodiscard]] int init_pollfd()
+  [[nodiscard]] stdx::error init_pollfd()
   {
     const int num_fds = snd.rawmidi.poll_descriptors_count(this->midiport_);
 
     this->fds_.clear();
     this->fds_.resize(num_fds);
 
-    return snd.rawmidi.poll_descriptors(this->midiport_, fds_.data(), num_fds);
+    int ret = snd.rawmidi.poll_descriptors(this->midiport_, fds_.data(), num_fds);
+    if (ret < 0)
+      return from_errc(ret);
+    return stdx::error{};
   }
 
   ssize_t do_read_events(auto parse_func, std::span<pollfd> fds)
@@ -155,7 +144,8 @@ public:
     while ((err = snd.rawmidi.read(this->midiport_, bytes, nbytes)) > 0)
     {
       const auto to_ns = [this] { return absolute_timestamp(); };
-      decoder_.on_bytes({bytes, bytes + err}, decoder_.timestamp<timestamp_info>(to_ns, 0));
+      m_processing.on_bytes(
+          {bytes, bytes + err}, m_processing.timestamp<timestamp_info>(to_ns, 0));
     }
     return err;
   }
@@ -180,7 +170,8 @@ public:
       const auto to_ns = [ts] {
         return static_cast<int64_t>(ts.tv_sec) * 1'000'000'000 + static_cast<int64_t>(ts.tv_nsec);
       };
-      decoder_.on_bytes({bytes, bytes + err}, decoder_.timestamp<timestamp_info>(to_ns, 0));
+      m_processing.on_bytes(
+          {bytes, bytes + err}, m_processing.timestamp<timestamp_info>(to_ns, 0));
     }
     return err;
   }
@@ -188,18 +179,19 @@ public:
   ssize_t read_input_buffer_with_timestamps() { return read_input_buffer(); }
 #endif
 
-  void close_port() override
+  stdx::error close_port() override
   {
     if (midiport_)
       snd.rawmidi.close(midiport_);
     midiport_ = nullptr;
+    return stdx::error{};
   }
 
   timestamp absolute_timestamp() const noexcept final override { return system_ns(); }
 
   snd_rawmidi_t* midiport_{};
   std::vector<pollfd> fds_;
-  midi1::input_state_machine decoder_{this->configuration};
+  midi1::input_state_machine m_processing{this->configuration};
 };
 
 class midi_in_alsa_raw_threaded : public midi_in_impl
@@ -210,26 +202,33 @@ public:
   {
     if (this->termination_event < 0)
     {
-      error<driver_error>(
-          this->configuration, "midi_in_alsa::initialize: error creating eventfd.");
+      libremidi_handle_error(this->configuration, "error creating eventfd.");
+      return;
     }
+
+    client_open_ = stdx::error{};
   }
 
   ~midi_in_alsa_raw_threaded() override
   {
     // Close a connection if it exists.
     this->midi_in_alsa_raw_threaded::close_port();
+
+    client_open_ = std::errc::not_connected;
   }
 
 private:
   void run_thread(auto parse_func)
   {
     fds_.push_back(this->termination_event);
+    const auto period
+        = std::chrono::duration_cast<std::chrono::milliseconds>(this->configuration.poll_period)
+              .count();
 
     for (;;)
     {
       // Poll
-      ssize_t err = poll(fds_.data(), fds_.size(), -1);
+      ssize_t err = poll(fds_.data(), fds_.size(), period);
       if (err == -EAGAIN)
         continue;
       else if (err < 0)
@@ -245,7 +244,7 @@ private:
     }
   }
 
-  [[nodiscard]] ssize_t start_thread()
+  [[nodiscard]] stdx::error start_thread()
   {
     try
     {
@@ -258,36 +257,37 @@ private:
         this->thread_ = std::thread{
             [this] { run_thread(&midi_in_impl::read_input_buffer_with_timestamps); }};
       }
+      return stdx::error{};
     }
     catch (const std::system_error& e)
     {
       using namespace std::literals;
 
-      error<thread_error>(
+      libremidi_handle_error(
           this->configuration,
-          "midi_in_alsa::start_thread: error starting MIDI input thread: "s + e.what());
-      return false;
+          "error starting MIDI input thread: "s + e.what());
+      return e.code();
     }
-    return true;
+    return stdx::error{};
   }
 
-  bool open_port(const input_port& port, std::string_view /*name*/) override
+  stdx::error open_port(const input_port& port, std::string_view /*name*/) override
   {
-    if (const int err = midi_in_impl::init_port(port); err < 0)
-      return false;
-    if (!start_thread())
-      return false;
-    return true;
+    if (auto err = midi_in_impl::init_port(port); err != stdx::error{})
+      return err;
+    if (auto err = start_thread(); err != stdx::error{})
+      return err;
+    return stdx::error{};
   }
 
-  void close_port() override
+  stdx::error close_port() override
   {
     termination_event.notify();
     if (thread_.joinable())
       thread_.join();
     termination_event.consume(); // Reset to zero
 
-    midi_in_impl::close_port();
+    return midi_in_impl::close_port();
   }
 
   std::thread thread_;
@@ -297,12 +297,18 @@ private:
 class midi_in_alsa_raw_manual : public midi_in_impl
 {
 public:
-  using midi_in_impl::midi_in_impl;
+  midi_in_alsa_raw_manual(input_configuration&& conf, alsa_raw_input_configuration&& apiconf)
+      : midi_in_impl{std::move(conf), std::move(apiconf)}
+  {
+    client_open_ = stdx::error{};
+  }
 
   ~midi_in_alsa_raw_manual()
   {
     // Close a connection if it exists.
     this->close_port();
+
+    client_open_ = std::errc::not_connected;
   }
 
 private:
@@ -326,12 +332,12 @@ private:
     }
   }
 
-  bool open_port(const input_port& p, std::string_view /*name*/) override
+  stdx::error open_port(const input_port& p, std::string_view /*name*/) override
   {
-    if (midi_in_impl::init_port(p) < 0)
-      return false;
+    if (auto err = midi_in_impl::init_port(p); err != stdx::error{})
+      return err;
     send_poll_callback();
-    return true;
+    return stdx::error{};
   }
 };
 }

include/libremidi/backends/alsa_raw/midi_out.hpp

@@ -26,83 +26,73 @@ public:
   midi_out_impl(output_configuration&& conf, alsa_raw_output_configuration&& apiconf)
       : configuration{std::move(conf), std::move(apiconf)}
   {
+    client_open_ = stdx::error{};
   }
 
   ~midi_out_impl() override
   {
     // Close a connection if it exists.
     midi_out_impl::close_port();
+    client_open_ = std::errc::not_connected;
   }
 
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW; }
 
-  bool open_virtual_port(std::string_view) override
-  {
-    warning(configuration, "midi_out_alsa_raw: open_virtual_port unsupported");
-    return false;
-  }
-  void set_client_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_alsa_raw: set_client_name unsupported");
-  }
-  void set_port_name(std::string_view) override
-  {
-    warning(configuration, "midi_out_alsa_raw: set_port_name unsupported");
-  }
-
-  int connect_port(const char* portname)
+  stdx::error connect_port(const char* portname)
   {
     constexpr int mode = SND_RAWMIDI_SYNC;
     int status = snd.rawmidi.open(NULL, &midiport_, portname, mode);
     if (status < 0)
     {
-      error<driver_error>(
-          this->configuration, "midi_out_alsa_raw::open_port: cannot open device.");
-      return status;
+      libremidi_handle_error(
+          this->configuration, "cannot open device.");
+      return from_errc(status);
     }
-    return status;
+    return stdx::error{};
   }
 
-  bool open_port(const output_port& p, std::string_view) override
+  stdx::error open_port(const output_port& p, std::string_view) override
   {
-    return connect_port(raw_from_port_handle(p.port).to_string().c_str()) == 0;
+    return connect_port(raw_from_port_handle(p.port).to_string().c_str());
   }
 
-  void close_port() override
+  stdx::error close_port() override
   {
     if (midiport_)
       snd.rawmidi.close(midiport_);
     midiport_ = nullptr;
+
+    return stdx::error{};
   }
 
-  void send_message(const unsigned char* message, size_t size) override
+  stdx::error send_message(const unsigned char* message, size_t size) override
   {
     if (!midiport_)
-      error<invalid_use_error>(
+      libremidi_handle_error(
           this->configuration,
-          "midi_out_alsa_raw::send_message: trying to send a message without an open "
+          "trying to send a message without an open "
           "port.");
 
     if (!this->configuration.chunking)
     {
-      write(message, size);
+      return write(message, size);
     }
     else
     {
-      write_chunked(message, size);
+      return write_chunked(message, size);
     }
   }
 
-  bool write(const unsigned char* message, size_t size)
+  stdx::error write(const unsigned char* message, size_t size)
   {
-    if (snd.rawmidi.write(midiport_, message, size) < 0)
+    if (auto err = snd.rawmidi.write(midiport_, message, size); err < 0)
     {
-      error<driver_error>(
-          this->configuration, "midi_out_alsa_raw::send_message: cannot write message.");
-      return false;
+      libremidi_handle_error(
+          this->configuration, "cannot write message.");
+      return from_errc(err);
     }
 
-    return true;
+    return stdx::error{};
   }
 
   std::size_t get_chunk_size() const noexcept
@@ -125,7 +115,7 @@ public:
   }
 
   // inspired from ALSA amidi.c source code
-  void write_chunked(const unsigned char* const begin, size_t size)
+  stdx::error write_chunked(const unsigned char* const begin, size_t size)
   {
     const unsigned char* data = begin;
     const unsigned char* end = begin + size;
@@ -135,8 +125,8 @@ public:
     // Send the first buffer
     std::size_t len = chunk_size;
 
-    if (!write(data, len))
-      return;
+    if (auto err = write(data, len); err != stdx::error{})
+      return err;
 
     data += len;
 
@@ -149,11 +139,11 @@ public:
       {
         if (!configuration.chunking->wait(
                 std::chrono::microseconds((chunk_size - available) * 320), written_bytes))
-          return;
+          return std::errc::protocol_error;
       };
 
       if (!configuration.chunking->wait(configuration.chunking->interval, written_bytes))
-        return;
+        return std::errc::protocol_error;
 
       // Write more data
       len = end - data;
@@ -165,11 +155,13 @@ public:
       if (len > chunk_size)
         len = chunk_size;
 
-      if (!write(data, len))
-        return;
+      if (auto err = write(data, len); err != stdx::error{})
+        return err;
 
       data += len;
     }
+
+    return stdx::error{};
   }
 
   snd_rawmidi_t* midiport_{};

include/libremidi/backends/alsa_raw/observer.hpp

@@ -8,12 +8,12 @@
   #include <libremidi/backends/linux/udev.hpp>
   #include <libremidi/detail/observer.hpp>
 
-  #include <stdexcept>
-
 namespace libremidi::alsa_raw
 {
 template <typename Enumerator>
-class observer_impl_base : public observer_api
+class observer_impl_base
+    : public observer_api
+    , public error_handler
 {
 public:
   struct
@@ -54,7 +54,7 @@ public:
   std::vector<libremidi::input_port> get_input_ports() const noexcept override
   {
     std::vector<libremidi::input_port> ret;
-    Enumerator new_devs;
+    Enumerator new_devs{*this};
 
     new_devs.enumerate_cards();
     for (auto& d : new_devs.inputs)
@@ -67,7 +67,7 @@ public:
   std::vector<libremidi::output_port> get_output_ports() const noexcept override
   {
     std::vector<libremidi::output_port> ret;
-    Enumerator new_devs;
+    Enumerator new_devs{*this};
 
     new_devs.enumerate_cards();
     for (auto& d : new_devs.outputs)
@@ -147,7 +147,7 @@ private:
 
   void check_devices()
   {
-    Enumerator new_devs;
+    Enumerator new_devs{*this};
 
     new_devs.enumerate_cards();