very, very simple WP with midi CC out
This commit is contained in:
Sebastian
@@ -0,0 +1,79 @@
|
||||
#pragma once
|
||||
#include <libremidi/config.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <span>
|
||||
#include <thread>
|
||||
|
||||
#if __has_include(<poll.h>)
|
||||
#include <poll.h>
|
||||
namespace libremidi
|
||||
{
|
||||
using poll_descriptors = pollfd;
|
||||
}
|
||||
#else
|
||||
namespace libremidi
|
||||
{
|
||||
struct poll_descriptors
|
||||
{
|
||||
int fd;
|
||||
short int events;
|
||||
short int revents;
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace libremidi
|
||||
{
|
||||
|
||||
/**
|
||||
* Used to determine how large sent messages will be chunked.
|
||||
*/
|
||||
struct LIBREMIDI_EXPORT chunking_parameters
|
||||
{
|
||||
std::chrono::milliseconds interval{};
|
||||
int32_t size{};
|
||||
|
||||
/**
|
||||
* @brief Will be called by the chunking code to allow the API user to wait.
|
||||
*
|
||||
* By default just calls sleep.
|
||||
* Arguments are: the time that must be waited, the bytes currently written.
|
||||
* Return false if you want to abort the transfer, and true otherwise.
|
||||
*/
|
||||
std::function<bool(std::chrono::microseconds, int64_t)> wait = chunking_parameters::default_wait;
|
||||
|
||||
static bool default_wait(std::chrono::microseconds time_to_wait, int64_t /*written_bytes*/)
|
||||
{
|
||||
std::this_thread::sleep_for(time_to_wait);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
struct manual_poll_parameters
|
||||
{
|
||||
std::span<poll_descriptors> fds;
|
||||
std::function<int64_t(std::span<poll_descriptors> fds)> callback;
|
||||
};
|
||||
|
||||
struct alsa_raw_input_configuration
|
||||
{
|
||||
std::function<bool(const manual_poll_parameters&)> manual_poll;
|
||||
};
|
||||
|
||||
struct alsa_raw_output_configuration
|
||||
{
|
||||
/**
|
||||
* For large messages, chunk their content and wait.
|
||||
* Setting a null optional will disable chunking.
|
||||
*/
|
||||
std::optional<chunking_parameters> chunking;
|
||||
};
|
||||
|
||||
struct alsa_raw_observer_configuration
|
||||
{
|
||||
std::chrono::milliseconds poll_period{100};
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
#pragma once
|
||||
#include <libremidi/backends/linux/alsa.hpp>
|
||||
#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
|
||||
// https://ccrma.stanford.edu/~craig/articles/linuxmidi/alsa-1.0/alsarawmidiout.c
|
||||
// https://ccrma.stanford.edu/~craig/articles/linuxmidi/alsa-1.0/alsarawportlist.c
|
||||
// Thanks Craig Stuart Sapp <craig@ccrma.stanford.edu>
|
||||
|
||||
namespace libremidi
|
||||
{
|
||||
namespace
|
||||
{
|
||||
struct alsa_raw_port_id
|
||||
{
|
||||
int card{}, dev{}, port{};
|
||||
std::string to_string() const noexcept
|
||||
{
|
||||
return "hw:" + std::to_string(card) + "," + std::to_string(dev) + "," + std::to_string(port);
|
||||
}
|
||||
};
|
||||
inline constexpr port_handle raw_to_port_handle(alsa_raw_port_id id) noexcept
|
||||
{
|
||||
return (uint64_t(id.card) << 32) + (uint64_t(id.dev) << 16) + id.port;
|
||||
}
|
||||
inline constexpr alsa_raw_port_id raw_from_port_handle(port_handle p) noexcept
|
||||
{
|
||||
alsa_raw_port_id ret;
|
||||
ret.card = (p & 0x00'00'FF'FF'00'00'00'00) >> 32;
|
||||
ret.dev = (p & 0x00'00'00'00'FF'FF'00'00) >> 16;
|
||||
ret.port = (p & 0x00'00'00'00'00'00'FF'FF);
|
||||
return ret;
|
||||
}
|
||||
static_assert(raw_from_port_handle(raw_to_port_handle({102, 7, 3})).card == 102);
|
||||
static_assert(raw_from_port_handle(raw_to_port_handle({12, 7, 3})).dev == 7);
|
||||
static_assert(raw_from_port_handle(raw_to_port_handle({12, 7, 3})).port == 3);
|
||||
}
|
||||
|
||||
namespace alsa_raw
|
||||
{
|
||||
struct alsa_raw_port_info
|
||||
{
|
||||
std::string device;
|
||||
std::string card_name;
|
||||
std::string device_name;
|
||||
std::string subdevice_name;
|
||||
int card{}, dev{}, sub{};
|
||||
|
||||
std::string pretty_name() const
|
||||
{
|
||||
return device + ": " + card_name + " : " + device_name + " : " + subdevice_name;
|
||||
}
|
||||
|
||||
bool operator==(const alsa_raw_port_info& other) const noexcept = default;
|
||||
};
|
||||
|
||||
struct enumerator;
|
||||
struct snd_ctl_wrapper
|
||||
{
|
||||
const libasound& snd;
|
||||
snd_ctl_t* ctl{};
|
||||
inline snd_ctl_wrapper(enumerator& self, const char* name);
|
||||
|
||||
~snd_ctl_wrapper()
|
||||
{
|
||||
if (ctl)
|
||||
{
|
||||
snd.ctl.close(ctl);
|
||||
}
|
||||
}
|
||||
|
||||
snd_ctl_t& operator*() const noexcept { return *ctl; }
|
||||
snd_ctl_t* operator->() const noexcept { return ctl; }
|
||||
operator snd_ctl_t*() const noexcept { return ctl; }
|
||||
};
|
||||
struct enumerator
|
||||
{
|
||||
const libasound& snd = libasound::instance();
|
||||
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;
|
||||
|
||||
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
|
||||
// 0: isn't an input / output
|
||||
// < 0: error
|
||||
int is(snd_rawmidi_stream_t stream, snd_ctl_t* ctl, int card, int device, int sub)
|
||||
{
|
||||
snd_rawmidi_info_t* info;
|
||||
|
||||
snd_rawmidi_info_alloca(&info);
|
||||
snd.rawmidi.info_set_device(info, device);
|
||||
snd.rawmidi.info_set_subdevice(info, sub);
|
||||
snd.rawmidi.info_set_stream(info, stream);
|
||||
|
||||
const int status = snd.ctl.rawmidi.info(ctl, info);
|
||||
if (status == 0)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
else if (status < 0 && status != -ENXIO)
|
||||
{
|
||||
error(
|
||||
"alsa_raw_helpers::enumerator::is: cannot get rawmidi information:", card, device, sub,
|
||||
snd.strerror(status));
|
||||
return status;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int is_input(snd_ctl_t* ctl, int card, int device, int sub)
|
||||
{
|
||||
return is(SND_RAWMIDI_STREAM_INPUT, ctl, card, device, sub);
|
||||
}
|
||||
|
||||
int is_output(snd_ctl_t* ctl, int card, int device, int sub)
|
||||
{
|
||||
return is(SND_RAWMIDI_STREAM_OUTPUT, ctl, card, device, sub);
|
||||
}
|
||||
|
||||
std::string get_card_name(int card)
|
||||
{
|
||||
char* card_name{};
|
||||
snd.card.get_name(card, &card_name);
|
||||
|
||||
std::string str = card_name;
|
||||
free(card_name);
|
||||
return str;
|
||||
}
|
||||
|
||||
static std::string device_identifier(int card, int device, int sub)
|
||||
{
|
||||
std::string s;
|
||||
s.reserve(12);
|
||||
s += "hw:";
|
||||
s += std::to_string(card);
|
||||
s += ",";
|
||||
s += std::to_string(device);
|
||||
s += ",";
|
||||
s += std::to_string(sub);
|
||||
return s;
|
||||
}
|
||||
|
||||
void enumerate_cards()
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
if (card < 0)
|
||||
{
|
||||
error(
|
||||
"alsa_raw_helpers::enumerator::enumerate_cards: "
|
||||
"no sound cards found");
|
||||
return;
|
||||
}
|
||||
|
||||
while (card >= 0)
|
||||
{
|
||||
enumerate_devices(card);
|
||||
|
||||
if ((status = snd.card.next(&card)) < 0)
|
||||
{
|
||||
error(
|
||||
"alsa_raw_helpers::enumerator::enumerate_cards: "
|
||||
"cannot determine card number: ",
|
||||
snd.strerror(status));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual void enumerate_devices(int card) = 0;
|
||||
};
|
||||
|
||||
inline snd_ctl_wrapper::snd_ctl_wrapper(enumerator& self, const char* name)
|
||||
: snd{self.snd}
|
||||
{
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
struct midi1_enumerator : enumerator
|
||||
{
|
||||
void enumerate_devices(int card) override
|
||||
{
|
||||
char name[128];
|
||||
|
||||
sprintf(name, "hw:%d", card);
|
||||
|
||||
// Open card.
|
||||
snd_ctl_wrapper ctl{*this, name};
|
||||
if (!ctl)
|
||||
return;
|
||||
|
||||
// Enumerate devices.
|
||||
int device = -1;
|
||||
do
|
||||
{
|
||||
const int status = snd.ctl.rawmidi.next_device(ctl, &device);
|
||||
if (device == -1)
|
||||
return;
|
||||
|
||||
if (status < 0)
|
||||
{
|
||||
error(
|
||||
"alsa_raw::midi1_enumerator::enumerate_devices: "
|
||||
"cannot determine device number: ",
|
||||
snd.strerror(status));
|
||||
break;
|
||||
}
|
||||
|
||||
if (device >= 0)
|
||||
enumerate_subdevices(ctl, card, device);
|
||||
|
||||
} while (device >= 0);
|
||||
}
|
||||
|
||||
void enumerate_subdevices(snd_ctl_t* ctl, int card, int device)
|
||||
{
|
||||
snd_rawmidi_info_t* info;
|
||||
snd_rawmidi_info_alloca(&info);
|
||||
snd.rawmidi.info_set_device(info, device);
|
||||
|
||||
snd.rawmidi.info_set_stream(info, SND_RAWMIDI_STREAM_INPUT);
|
||||
snd.ctl.rawmidi.info(ctl, info);
|
||||
const int subs_in = snd.rawmidi.info_get_subdevices_count(info);
|
||||
|
||||
snd.rawmidi.info_set_stream(info, SND_RAWMIDI_STREAM_OUTPUT);
|
||||
snd.ctl.rawmidi.info(ctl, info);
|
||||
const int subs_out = snd.rawmidi.info_get_subdevices_count(info);
|
||||
|
||||
alsa_raw_port_info d;
|
||||
d.card = card;
|
||||
d.dev = device;
|
||||
d.card_name = get_card_name(card);
|
||||
d.device_name = snd.rawmidi.info_get_name(info);
|
||||
|
||||
auto read_subdevice_info = [&](int sub) {
|
||||
snd.rawmidi.info_set_subdevice(info, sub);
|
||||
snd.ctl.rawmidi.info(ctl, info);
|
||||
|
||||
d.device = device_identifier(card, device, sub);
|
||||
d.subdevice_name = snd.rawmidi.info_get_subdevice_name(info);
|
||||
d.sub = sub;
|
||||
};
|
||||
|
||||
if (subs_in > 0)
|
||||
{
|
||||
snd.rawmidi.info_set_stream(info, SND_RAWMIDI_STREAM_INPUT);
|
||||
for (int sub = 0; sub < subs_in; sub++)
|
||||
{
|
||||
read_subdevice_info(sub);
|
||||
inputs.push_back(d);
|
||||
}
|
||||
}
|
||||
|
||||
if (subs_out > 0)
|
||||
{
|
||||
snd.rawmidi.info_set_stream(info, SND_RAWMIDI_STREAM_OUTPUT);
|
||||
for (int sub = 0; sub < subs_out; sub++)
|
||||
{
|
||||
read_subdevice_info(sub);
|
||||
outputs.push_back(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
#pragma once
|
||||
#include <libremidi/backends/alsa_raw/config.hpp>
|
||||
#include <libremidi/backends/alsa_raw/helpers.hpp>
|
||||
#include <libremidi/backends/linux/helpers.hpp>
|
||||
#include <libremidi/detail/midi_in.hpp>
|
||||
#include <libremidi/detail/midi_stream_decoder.hpp>
|
||||
|
||||
#include <alsa/asoundlib.h>
|
||||
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
namespace libremidi::alsa_raw
|
||||
{
|
||||
class midi_in_impl
|
||||
: public midi1::in_api
|
||||
, public error_handler
|
||||
{
|
||||
public:
|
||||
struct
|
||||
: input_configuration
|
||||
, alsa_raw_input_configuration
|
||||
{
|
||||
} configuration;
|
||||
|
||||
const libasound& snd = libasound::instance();
|
||||
|
||||
explicit midi_in_impl(input_configuration&& conf, alsa_raw_input_configuration&& apiconf)
|
||||
: configuration{std::move(conf), std::move(apiconf)}
|
||||
{
|
||||
fds_.reserve(4);
|
||||
}
|
||||
|
||||
~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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
snd_rawmidi_params_t* params{};
|
||||
snd_rawmidi_params_alloca(¶ms);
|
||||
|
||||
if (const int err = snd.rawmidi.params_current(midiport_, params); err < 0)
|
||||
return err;
|
||||
if (const int err = snd.rawmidi.params_set_no_active_sensing(midiport_, params, 1); err < 0)
|
||||
return 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;
|
||||
if (const int err
|
||||
= snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_NONE);
|
||||
err < 0)
|
||||
return err;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (const int err
|
||||
= snd.rawmidi.params_set_read_mode(midiport_, params, SND_RAWMIDI_READ_TSTAMP);
|
||||
err < 0)
|
||||
return err;
|
||||
if (const int err
|
||||
= snd.rawmidi.params_set_clock_type(midiport_, params, SND_RAWMIDI_CLOCK_MONOTONIC);
|
||||
err < 0)
|
||||
return err;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (const int err = snd.rawmidi.params(midiport_, params); err < 0)
|
||||
return err;
|
||||
|
||||
return init_pollfd();
|
||||
}
|
||||
|
||||
[[nodiscard]] int init_port(const port_information& p)
|
||||
{
|
||||
return do_init_port(raw_from_port_handle(p.port).to_string().c_str());
|
||||
}
|
||||
|
||||
[[nodiscard]] int 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);
|
||||
}
|
||||
|
||||
ssize_t do_read_events(auto parse_func, std::span<pollfd> fds)
|
||||
{
|
||||
// Read events
|
||||
if (fds.empty())
|
||||
{
|
||||
return (this->*parse_func)();
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned short res{};
|
||||
const int err = snd.rawmidi.poll_descriptors_revents(
|
||||
this->midiport_, fds.data(), static_cast<unsigned int>(fds.size()), &res);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
// Did we encounter an error during polling
|
||||
if (res & (POLLERR | POLLHUP))
|
||||
return -EIO;
|
||||
|
||||
// Is there data to read
|
||||
if (res & POLLIN)
|
||||
return (this->*parse_func)();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
ssize_t read_input_buffer()
|
||||
{
|
||||
static const constexpr int nbytes = 1024;
|
||||
static constexpr timestamp_backend_info timestamp_info{
|
||||
.has_absolute_timestamps = false,
|
||||
.absolute_is_monotonic = false,
|
||||
.has_samples = false,
|
||||
};
|
||||
|
||||
unsigned char bytes[nbytes];
|
||||
|
||||
ssize_t err = 0;
|
||||
// err is the amount of bytes read
|
||||
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));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
#if LIBREMIDI_ALSA_HAS_RAWMIDI_TREAD
|
||||
ssize_t read_input_buffer_with_timestamps()
|
||||
{
|
||||
static 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];
|
||||
struct timespec ts;
|
||||
|
||||
ssize_t err = 0;
|
||||
// err is the amount of bytes read
|
||||
while ((err = snd.rawmidi.tread(this->midiport_, &ts, bytes, nbytes)) > 0)
|
||||
{
|
||||
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));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
#else
|
||||
ssize_t read_input_buffer_with_timestamps() { return read_input_buffer(); }
|
||||
#endif
|
||||
|
||||
void close_port() override
|
||||
{
|
||||
if (midiport_)
|
||||
snd.rawmidi.close(midiport_);
|
||||
midiport_ = nullptr;
|
||||
}
|
||||
|
||||
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};
|
||||
};
|
||||
|
||||
class midi_in_alsa_raw_threaded : public midi_in_impl
|
||||
{
|
||||
public:
|
||||
midi_in_alsa_raw_threaded(input_configuration&& conf, alsa_raw_input_configuration&& apiconf)
|
||||
: midi_in_impl{std::move(conf), std::move(apiconf)}
|
||||
{
|
||||
if (this->termination_event < 0)
|
||||
{
|
||||
error<driver_error>(
|
||||
this->configuration, "midi_in_alsa::initialize: error creating eventfd.");
|
||||
}
|
||||
}
|
||||
|
||||
~midi_in_alsa_raw_threaded() override
|
||||
{
|
||||
// Close a connection if it exists.
|
||||
this->midi_in_alsa_raw_threaded::close_port();
|
||||
}
|
||||
|
||||
private:
|
||||
void run_thread(auto parse_func)
|
||||
{
|
||||
fds_.push_back(this->termination_event);
|
||||
|
||||
for (;;)
|
||||
{
|
||||
// Poll
|
||||
ssize_t err = poll(fds_.data(), fds_.size(), -1);
|
||||
if (err == -EAGAIN)
|
||||
continue;
|
||||
else if (err < 0)
|
||||
return;
|
||||
else if (termination_event.ready(fds_.back()))
|
||||
break;
|
||||
|
||||
err = do_read_events(parse_func, {fds_.data(), fds_.size() - 1});
|
||||
if (err == -EAGAIN)
|
||||
continue;
|
||||
else if (err < 0)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] ssize_t start_thread()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (configuration.timestamps == timestamp_mode::NoTimestamp)
|
||||
{
|
||||
this->thread_ = std::thread{[this] { run_thread(&midi_in_impl::read_input_buffer); }};
|
||||
}
|
||||
else
|
||||
{
|
||||
this->thread_ = std::thread{
|
||||
[this] { run_thread(&midi_in_impl::read_input_buffer_with_timestamps); }};
|
||||
}
|
||||
}
|
||||
catch (const std::system_error& e)
|
||||
{
|
||||
using namespace std::literals;
|
||||
|
||||
error<thread_error>(
|
||||
this->configuration,
|
||||
"midi_in_alsa::start_thread: error starting MIDI input thread: "s + e.what());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool 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;
|
||||
}
|
||||
|
||||
void close_port() override
|
||||
{
|
||||
termination_event.notify();
|
||||
if (thread_.joinable())
|
||||
thread_.join();
|
||||
termination_event.consume(); // Reset to zero
|
||||
|
||||
midi_in_impl::close_port();
|
||||
}
|
||||
|
||||
std::thread thread_;
|
||||
eventfd_notifier termination_event{};
|
||||
};
|
||||
|
||||
class midi_in_alsa_raw_manual : public midi_in_impl
|
||||
{
|
||||
public:
|
||||
using midi_in_impl::midi_in_impl;
|
||||
|
||||
~midi_in_alsa_raw_manual()
|
||||
{
|
||||
// Close a connection if it exists.
|
||||
this->close_port();
|
||||
}
|
||||
|
||||
private:
|
||||
void send_poll_callback()
|
||||
{
|
||||
if (configuration.timestamps == timestamp_mode::NoTimestamp)
|
||||
{
|
||||
configuration.manual_poll(manual_poll_parameters{
|
||||
.fds = {this->fds_.data(), this->fds_.size()},
|
||||
.callback = [this](std::span<pollfd> fds) {
|
||||
return do_read_events(&midi_in_impl::read_input_buffer, fds);
|
||||
}});
|
||||
}
|
||||
else
|
||||
{
|
||||
configuration.manual_poll(manual_poll_parameters{
|
||||
.fds = {this->fds_.data(), this->fds_.size()},
|
||||
.callback = [this](std::span<pollfd> fds) {
|
||||
return do_read_events(&midi_in_impl::read_input_buffer_with_timestamps, fds);
|
||||
}});
|
||||
}
|
||||
}
|
||||
|
||||
bool open_port(const input_port& p, std::string_view /*name*/) override
|
||||
{
|
||||
if (midi_in_impl::init_port(p) < 0)
|
||||
return false;
|
||||
send_poll_callback();
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace libremidi
|
||||
{
|
||||
template <>
|
||||
inline std::unique_ptr<midi_in_api> make<alsa_raw::midi_in_impl>(
|
||||
libremidi::input_configuration&& conf, libremidi::alsa_raw_input_configuration&& api)
|
||||
{
|
||||
if (api.manual_poll)
|
||||
return std::make_unique<alsa_raw::midi_in_alsa_raw_manual>(std::move(conf), std::move(api));
|
||||
else
|
||||
return std::make_unique<alsa_raw::midi_in_alsa_raw_threaded>(std::move(conf), std::move(api));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
#pragma once
|
||||
#include <libremidi/backends/alsa_raw/config.hpp>
|
||||
#include <libremidi/backends/alsa_raw/helpers.hpp>
|
||||
#include <libremidi/detail/midi_out.hpp>
|
||||
|
||||
#include <alsa/asoundlib.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
|
||||
namespace libremidi::alsa_raw
|
||||
{
|
||||
class midi_out_impl final
|
||||
: public midi1::out_api
|
||||
, public error_handler
|
||||
{
|
||||
public:
|
||||
struct
|
||||
: output_configuration
|
||||
, alsa_raw_output_configuration
|
||||
{
|
||||
} configuration;
|
||||
|
||||
const libasound& snd = libasound::instance();
|
||||
|
||||
midi_out_impl(output_configuration&& conf, alsa_raw_output_configuration&& apiconf)
|
||||
: configuration{std::move(conf), std::move(apiconf)}
|
||||
{
|
||||
}
|
||||
|
||||
~midi_out_impl() override
|
||||
{
|
||||
// Close a connection if it exists.
|
||||
midi_out_impl::close_port();
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
bool open_port(const output_port& p, std::string_view) override
|
||||
{
|
||||
return connect_port(raw_from_port_handle(p.port).to_string().c_str()) == 0;
|
||||
}
|
||||
|
||||
void close_port() override
|
||||
{
|
||||
if (midiport_)
|
||||
snd.rawmidi.close(midiport_);
|
||||
midiport_ = nullptr;
|
||||
}
|
||||
|
||||
void send_message(const unsigned char* message, size_t size) override
|
||||
{
|
||||
if (!midiport_)
|
||||
error<invalid_use_error>(
|
||||
this->configuration,
|
||||
"midi_out_alsa_raw::send_message: trying to send a message without an open "
|
||||
"port.");
|
||||
|
||||
if (!this->configuration.chunking)
|
||||
{
|
||||
write(message, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
write_chunked(message, size);
|
||||
}
|
||||
}
|
||||
|
||||
bool write(const unsigned char* message, size_t size)
|
||||
{
|
||||
if (snd.rawmidi.write(midiport_, message, size) < 0)
|
||||
{
|
||||
error<driver_error>(
|
||||
this->configuration, "midi_out_alsa_raw::send_message: cannot write message.");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
std::size_t get_chunk_size() const noexcept
|
||||
{
|
||||
snd_rawmidi_params_t* param;
|
||||
snd_rawmidi_params_alloca(¶m);
|
||||
snd.rawmidi.params_current(midiport_, param);
|
||||
|
||||
std::size_t buffer_size = snd.rawmidi.params_get_buffer_size(param);
|
||||
return std::min(buffer_size, (std::size_t)configuration.chunking->size);
|
||||
}
|
||||
|
||||
std::size_t get_available_bytes_to_write() const noexcept
|
||||
{
|
||||
snd_rawmidi_status_t* st{};
|
||||
snd_rawmidi_status_alloca(&st);
|
||||
snd.rawmidi.status(midiport_, st);
|
||||
|
||||
return snd.rawmidi.status_get_avail(st);
|
||||
}
|
||||
|
||||
// inspired from ALSA amidi.c source code
|
||||
void write_chunked(const unsigned char* const begin, size_t size)
|
||||
{
|
||||
const unsigned char* data = begin;
|
||||
const unsigned char* end = begin + size;
|
||||
|
||||
const std::size_t chunk_size = std::min(get_chunk_size(), size);
|
||||
|
||||
// Send the first buffer
|
||||
std::size_t len = chunk_size;
|
||||
|
||||
if (!write(data, len))
|
||||
return;
|
||||
|
||||
data += len;
|
||||
|
||||
while (data < end)
|
||||
{
|
||||
// Wait for the buffer to have some space available
|
||||
const std::size_t written_bytes = data - begin;
|
||||
std::size_t available{};
|
||||
while ((available = get_available_bytes_to_write()) < chunk_size)
|
||||
{
|
||||
if (!configuration.chunking->wait(
|
||||
std::chrono::microseconds((chunk_size - available) * 320), written_bytes))
|
||||
return;
|
||||
};
|
||||
|
||||
if (!configuration.chunking->wait(configuration.chunking->interval, written_bytes))
|
||||
return;
|
||||
|
||||
// Write more data
|
||||
len = end - data;
|
||||
|
||||
// Maybe until the end of the sysex
|
||||
if (const auto sysex_end = static_cast<const unsigned char*>(memchr(data, 0xf7, len)))
|
||||
len = sysex_end - data + 1;
|
||||
|
||||
if (len > chunk_size)
|
||||
len = chunk_size;
|
||||
|
||||
if (!write(data, len))
|
||||
return;
|
||||
|
||||
data += len;
|
||||
}
|
||||
}
|
||||
|
||||
snd_rawmidi_t* midiport_{};
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
#pragma once
|
||||
#include <libremidi/backends/alsa_raw/config.hpp>
|
||||
#include <libremidi/backends/alsa_raw/helpers.hpp>
|
||||
#include <libremidi/backends/dummy.hpp>
|
||||
|
||||
#if LIBREMIDI_HAS_UDEV
|
||||
#include <libremidi/backends/linux/helpers.hpp>
|
||||
#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
|
||||
{
|
||||
public:
|
||||
struct
|
||||
: observer_configuration
|
||||
, alsa_raw_observer_configuration
|
||||
{
|
||||
} configuration;
|
||||
|
||||
const libasound& snd = libasound::instance();
|
||||
|
||||
explicit observer_impl_base(
|
||||
observer_configuration&& conf, alsa_raw_observer_configuration&& apiconf)
|
||||
: configuration{std::move(conf), std::move(apiconf)}
|
||||
{
|
||||
if (!configuration.has_callbacks())
|
||||
return;
|
||||
|
||||
fds[0] = this->udev;
|
||||
fds[1] = termination_event;
|
||||
fds[2] = timer_fd;
|
||||
|
||||
// Set-up initial state
|
||||
if (configuration.notify_in_constructor)
|
||||
this->check_devices();
|
||||
|
||||
// Start thread
|
||||
thread = std::thread{[this] { this->run(); }};
|
||||
}
|
||||
|
||||
~observer_impl_base()
|
||||
{
|
||||
termination_event.notify();
|
||||
|
||||
if (thread.joinable())
|
||||
thread.join();
|
||||
}
|
||||
|
||||
std::vector<libremidi::input_port> get_input_ports() const noexcept override
|
||||
{
|
||||
std::vector<libremidi::input_port> ret;
|
||||
Enumerator new_devs;
|
||||
|
||||
new_devs.enumerate_cards();
|
||||
for (auto& d : new_devs.inputs)
|
||||
{
|
||||
ret.push_back(to_port_info<true>(d));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::vector<libremidi::output_port> get_output_ports() const noexcept override
|
||||
{
|
||||
std::vector<libremidi::output_port> ret;
|
||||
Enumerator new_devs;
|
||||
|
||||
new_devs.enumerate_cards();
|
||||
for (auto& d : new_devs.outputs)
|
||||
{
|
||||
ret.push_back(to_port_info<false>(d));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
void run()
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
if (int err = poll(fds, 3, -1); err < 0)
|
||||
{
|
||||
if (err == -EAGAIN)
|
||||
continue;
|
||||
else
|
||||
return;
|
||||
}
|
||||
|
||||
// Check udev
|
||||
if (fds[0].revents & POLLIN)
|
||||
{
|
||||
udev_device* dev = udev.udev.monitor_receive_device(udev.monitor);
|
||||
if (!dev)
|
||||
continue;
|
||||
|
||||
std::string_view act = udev.udev.device_get_action(dev);
|
||||
std::string_view ss = udev.udev.device_get_subsystem(dev);
|
||||
if (!act.empty() && ss == "snd_seq")
|
||||
{
|
||||
if (act == "add" || act == "remove")
|
||||
{
|
||||
// Check every 100 milliseconds for ten seconds
|
||||
this->timer_fd.restart(configuration.poll_period.count());
|
||||
timer_check_counts = 100;
|
||||
}
|
||||
}
|
||||
|
||||
udev.udev.device_unref(dev);
|
||||
|
||||
fds[0].revents = 0;
|
||||
}
|
||||
|
||||
// Check eventfd
|
||||
if (fds[1].revents & POLLIN)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// Check timer
|
||||
if (fds[2].revents & POLLIN)
|
||||
{
|
||||
if (this->timer_check_counts-- <= 0)
|
||||
this->timer_fd.cancel();
|
||||
fds[2].revents = 0;
|
||||
|
||||
check_devices();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <bool Input>
|
||||
auto to_port_info(alsa_raw::alsa_raw_port_info p) const noexcept
|
||||
-> std::conditional_t<Input, input_port, output_port>
|
||||
{
|
||||
return {
|
||||
{.client = 0,
|
||||
.port = raw_to_port_handle({p.card, p.dev, p.sub}),
|
||||
.manufacturer = p.card_name,
|
||||
.device_name = p.device_name,
|
||||
.port_name = p.subdevice_name,
|
||||
.display_name = p.subdevice_name}};
|
||||
}
|
||||
|
||||
void check_devices()
|
||||
{
|
||||
Enumerator new_devs;
|
||||
|
||||
new_devs.enumerate_cards();
|
||||
|
||||
for (auto& in_prev : current_inputs)
|
||||
{
|
||||
if (auto it = std::find(new_devs.inputs.begin(), new_devs.inputs.end(), in_prev);
|
||||
it == new_devs.inputs.end())
|
||||
{
|
||||
if (auto& cb = this->configuration.input_removed)
|
||||
{
|
||||
cb(to_port_info<true>(in_prev));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& in_next : new_devs.inputs)
|
||||
{
|
||||
if (auto it = std::find(current_inputs.begin(), current_inputs.end(), in_next);
|
||||
it == current_inputs.end())
|
||||
{
|
||||
if (auto& cb = this->configuration.input_added)
|
||||
{
|
||||
cb(to_port_info<true>(in_next));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& out_prev : current_outputs)
|
||||
{
|
||||
if (auto it = std::find(new_devs.outputs.begin(), new_devs.outputs.end(), out_prev);
|
||||
it == new_devs.outputs.end())
|
||||
{
|
||||
if (auto& cb = this->configuration.output_removed)
|
||||
{
|
||||
cb(to_port_info<false>(out_prev));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& out_next : new_devs.outputs)
|
||||
{
|
||||
if (auto it = std::find(current_outputs.begin(), current_outputs.end(), out_next);
|
||||
it == current_outputs.end())
|
||||
{
|
||||
if (auto& cb = this->configuration.output_added)
|
||||
{
|
||||
cb(to_port_info<false>(out_next));
|
||||
}
|
||||
}
|
||||
}
|
||||
current_inputs = std::move(new_devs.inputs);
|
||||
current_outputs = std::move(new_devs.outputs);
|
||||
}
|
||||
|
||||
udev_helper udev{};
|
||||
eventfd_notifier termination_event{};
|
||||
timerfd_timer timer_fd{};
|
||||
int timer_check_counts = 0;
|
||||
std::thread thread;
|
||||
std::vector<alsa_raw_port_info> current_inputs;
|
||||
std::vector<alsa_raw_port_info> current_outputs;
|
||||
|
||||
pollfd fds[3]{};
|
||||
};
|
||||
}
|
||||
#else
|
||||
#include <libremidi/backends/dummy.hpp>
|
||||
namespace libremidi::alsa_raw
|
||||
{
|
||||
template <typename Enumerator>
|
||||
struct observer_impl_base : observer_dummy
|
||||
{
|
||||
explicit observer_impl_base(
|
||||
[[maybe_unused]] observer_configuration&& conf,
|
||||
[[maybe_unused]] alsa_raw_observer_configuration&& apiconf)
|
||||
: observer_dummy{dummy_configuration{}, dummy_configuration{}}
|
||||
{
|
||||
}
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace libremidi::alsa_raw
|
||||
{
|
||||
struct observer_impl : observer_impl_base<alsa_raw::midi1_enumerator>
|
||||
{
|
||||
using alsa_raw::observer_impl_base<midi1_enumerator>::observer_impl_base;
|
||||
libremidi::API get_current_api() const noexcept override { return libremidi::API::ALSA_RAW; }
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user