working on win32 uwp! and libremidi update

include/libremidi/backends/alsa_raw_ump/config.hpp

@@ -6,6 +6,7 @@ namespace libremidi::alsa_raw_ump
 struct input_configuration
 {
   std::function<bool(const manual_poll_parameters&)> manual_poll;
+  std::chrono::milliseconds poll_period{2};
 };
 
 struct output_configuration

include/libremidi/backends/alsa_raw_ump/helpers.hpp

@@ -7,8 +7,10 @@ namespace libremidi::alsa_raw_ump
 {
 struct midi2_enumerator : alsa_raw::enumerator
 {
+  using alsa_raw::enumerator::enumerator;
   void enumerate_devices(int card) override
   {
+    using namespace std::literals;
     char name[128];
 
     sprintf(name, "hw:%d", card);
@@ -28,10 +30,8 @@ struct midi2_enumerator : alsa_raw::enumerator
 
       if (status < 0)
       {
-        error(
-            "alsa_raw_ump::midi2_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_ump/midi_in.hpp

@@ -35,32 +35,17 @@ public:
 
   ~midi_in_impl() override { }
 
-  bool open_virtual_port(std::string_view) override
-  {
-    warning(configuration, "alsa_raw_ump::ump: open_virtual_port unsupported");
-    return false;
-  }
-  void set_client_name(std::string_view) override
-  {
-    warning(configuration, "alsa_raw_ump::ump: set_client_name unsupported");
-  }
-  void set_port_name(std::string_view) override
-  {
-    warning(configuration, "alsa_raw_ump::ump: set_port_name unsupported");
-  }
-
   libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW_UMP; }
 
   // 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 = 0;
-    SND_RAWMIDI_NONBLOCK;
+    SND_RAWMIDI_NONBLOCK; // fixme
     if (int err = snd.ump.open(&midiport_, 0, portname, mode); err < 0)
     {
-      error<driver_error>(
-          this->configuration, "alsa_raw_ump::ump::open_port: cannot open device.");
-      return err;
+      libremidi_handle_error(this->configuration, "alsa_raw_ump::ump::open_port: cannot open device.");
+      return from_errc(err);
     }
 
     snd_rawmidi_params_t* params{};
@@ -69,49 +54,52 @@ public:
     auto rawmidi = snd.ump.rawmidi(midiport_);
 
     if (int err = snd.ump.rawmidi_params_current(midiport_, params); err < 0)
-      return err;
+      return from_errc(err);
     if (int err = snd.rawmidi.params_set_no_active_sensing(rawmidi, params, 1); err < 0)
-      return err;
+      return from_errc(err);
 
     if (configuration.timestamps == timestamp_mode::NoTimestamp)
     {
       if (int err = snd.rawmidi.params_set_read_mode(rawmidi, params, SND_RAWMIDI_READ_STANDARD);
           err < 0)
-        return err;
+        return from_errc(err);
       if (int err = snd.rawmidi.params_set_clock_type(rawmidi, params, SND_RAWMIDI_CLOCK_NONE);
           err < 0)
-        return err;
+        return from_errc(err);
     }
     else
     {
       if (int err = snd.rawmidi.params_set_read_mode(rawmidi, params, SND_RAWMIDI_READ_TSTAMP);
           err < 0)
-        return err;
+        return from_errc(err);
       if (int err
           = snd.rawmidi.params_set_clock_type(rawmidi, params, SND_RAWMIDI_CLOCK_MONOTONIC);
           err < 0)
-        return err;
+        return from_errc(err);
     }
 
     if (int err = snd.ump.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()
   {
     int num_fds = snd.ump.poll_descriptors_count(this->midiport_);
 
     this->fds_.clear();
     this->fds_.resize(num_fds);
 
-    return snd.ump.poll_descriptors(this->midiport_, fds_.data(), num_fds);
+    int ret = snd.ump.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)
@@ -143,95 +131,60 @@ public:
 
   ssize_t read_input_buffer()
   {
-    static const constexpr int nbytes = 1024;
-
-    unsigned char bytes[nbytes];
+    static constexpr timestamp_backend_info timestamp_info{
+        .has_absolute_timestamps = false,
+        .absolute_is_monotonic = false,
+        .has_samples = false,
+    };
+    static const constexpr int nwords = 64;
+    uint32_t words[nwords];
 
     ssize_t err = 0;
-    while ((err = snd.ump.read(this->midiport_, bytes, nbytes)) > 0)
+    while ((err = snd.ump.read(this->midiport_, words, nwords * 4)) > 0)
     {
-      std::cerr << "We read: " << nbytes << "bytes !!!!";
-      return 1;
-      // err is the amount of bytes read
-      // decoder_.add_bytes(bytes, err);
+      const auto to_ns = [this] { return absolute_timestamp(); };
+      m_processing.on_bytes({words, words + err / 4}, m_processing.timestamp<timestamp_info>(to_ns, 0));
     }
     return err;
   }
 
-  void set_timestamp(struct timespec ts, timestamp& res)
-  {
-    static constexpr int64_t nanos = 1e9;
-    switch (configuration.timestamps)
-    {
-      // Unneeded here
-      case timestamp_mode::NoTimestamp:
-        break;
-      case timestamp_mode::Relative: {
-        const auto t = static_cast<int64_t>(ts.tv_sec) * nanos + static_cast<int64_t>(ts.tv_nsec);
-        if (firstMessage == true)
-        {
-          firstMessage = false;
-          res = 0;
-        }
-        else
-        {
-          res = t - last_time;
-        }
-        last_time = t;
-        break;
-      }
-      case timestamp_mode::Absolute:
-      case timestamp_mode::SystemMonotonic:
-        res = static_cast<int64_t>(ts.tv_sec) * nanos + static_cast<int64_t>(ts.tv_nsec);
-        break;
-      case timestamp_mode::Custom:
-        res = configuration.get_timestamp(
-            static_cast<int64_t>(ts.tv_sec) * nanos + static_cast<int64_t>(ts.tv_nsec));
-        break;
-    }
-  }
-
   ssize_t read_input_buffer_with_timestamps()
   {
-    static const constexpr int nbytes = 1024;
+    static constexpr timestamp_backend_info timestamp_info{
+        .has_absolute_timestamps = true,
+        .absolute_is_monotonic = true,
+        .has_samples = false,
+    };
 
-    unsigned char bytes[nbytes];
+    static const constexpr int nwords = 64;
+    uint32_t words[nwords];
     struct timespec ts;
 
     ssize_t err = 0;
-    while ((err = snd.ump.tread(this->midiport_, &ts, bytes, nbytes)) > 0)
+    while ((err = snd.ump.tread(this->midiport_, &ts, words, nwords * 4)) > 0)
     {
-      // err is the amount of bytes read
-      int64_t ns{};
-      set_timestamp(ts, ns);
-      std::cerr << "We read: " << nbytes << "bytes !!!!";
-      return 1;
-      // decoder_.add_bytes(bytes, err, ns);
+      const auto to_ns = [ts] {
+        return static_cast<int64_t>(ts.tv_sec) * 1'000'000'000 + static_cast<int64_t>(ts.tv_nsec);
+      };
+      m_processing.on_bytes({words, words + err / 4}, m_processing.timestamp<timestamp_info>(to_ns, 0));
     }
     return err;
   }
 
-  void close_port() override
+  stdx::error close_port() override
   {
     if (midiport_)
       snd.ump.close(midiport_);
     midiport_ = nullptr;
+
+    return stdx::error{};
   }
 
   timestamp absolute_timestamp() const noexcept override { return system_ns(); }
 
-  midi2_enumerator get_device_enumerator() const noexcept
-  {
-    midi2_enumerator device_list;
-    device_list.error_callback
-        = [this](std::string_view text) { this->error<driver_error>(this->configuration, text); };
-    return device_list;
-  }
-
   snd_ump_t* midiport_{};
   std::vector<pollfd> fds_;
-  // midi_stream_decoder decoder_{this->configuration.on_message};
-  int64_t last_time{};
+  midi2::input_state_machine m_processing{this->configuration};
 };
 
 class midi_in_impl_threaded : public midi_in_impl
@@ -243,26 +196,32 @@ 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_impl_threaded()
   {
     // Close a connection if it exists.
     this->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)
@@ -278,7 +237,7 @@ private:
     }
   }
 
-  [[nodiscard]] int start_thread()
+  [[nodiscard]] stdx::error start_thread()
   {
     try
     {
@@ -291,36 +250,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, [[maybe_unused]] std::string_view name) override
+  stdx::error open_port(const input_port& port, [[maybe_unused]] std::string_view name) override
   {
-    if (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_;
@@ -330,12 +290,18 @@ private:
 class midi_in_impl_manual : public midi_in_impl
 {
 public:
-  using midi_in_impl::midi_in_impl;
+  midi_in_impl_manual(ump_input_configuration&& conf, alsa_raw_ump::input_configuration&& apiconf)
+      : midi_in_impl{std::move(conf), std::move(apiconf)}
+  {
+    client_open_ = stdx::error{};
+  }
 
   ~midi_in_impl_manual()
   {
     // Close a connection if it exists.
     this->close_port();
+
+    client_open_ = std::errc::not_connected;
   }
 
 private:
@@ -359,12 +325,12 @@ private:
     }
   }
 
-  bool open_port(const input_port& p, [[maybe_unused]] std::string_view name) override
+  stdx::error open_port(const input_port& p, [[maybe_unused]] 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_ump/midi_out.hpp

@@ -29,76 +29,63 @@ public:
       : configuration{std::move(conf), std::move(apiconf)}
   {
     assert(snd.ump.available);
+    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; }
+  libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW_UMP; }
 
-  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.ump.open(NULL, &midiport_, portname, mode);
-    if (status < 0)
+    int ret = snd.ump.open(NULL, &midiport_, portname, mode);
+    if (ret < 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(ret);
     }
-    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.ump.close(midiport_);
     midiport_ = nullptr;
+    return stdx::error{};
   }
 
-  void send_ump(const uint32_t* ump_stream, std::size_t count) override
+  stdx::error send_ump(const uint32_t* ump_stream, std::size_t count) 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.");
 
-    write(ump_stream, count * sizeof(uint32_t));
+    return write(ump_stream, count * sizeof(uint32_t));
   }
 
-  bool write(const uint32_t* ump_stream, size_t bytes)
+  stdx::error write(const uint32_t* ump_stream, size_t bytes)
   {
-    if (snd.ump.write(midiport_, ump_stream, bytes) < 0)
+    if (auto err = snd.ump.write(midiport_, ump_stream, bytes); 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{};
   }
 
   snd_ump_t* midiport_{};