sebastian/viseq
Public Access
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

working on win32 uwp! and libremidi update

Browse Source
This commit is contained in:
Sebastian @ HfG
2024-10-28 19:24:18 +01:00
parent 06cb6d8319
commit 1e3755148c
106 changed files with 8474 additions and 2198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/libremidi/backends/alsa_raw/midi_in.hpp
+58 -52
View File
@@ -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{};
}
};
}