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

Compare commits

merge into: sebastian/viseq:main
Branches Tags
sebastian/viseq:main sebastian/viseq:rework-interaction-system sebastian/viseq:minimal-ui sebastian/viseq:orbit-ui sebastian/viseq:virtual-midi sebastian/viseq:refactor-orbit-ui sebastian/viseq:refactor-orbit-ui-conflict sebastian/viseq:vector-ui sebastian/viseq:next-ui sebastian/viseq:macos sebastian/viseq:graph sebastian/viseq:win32 sebastian/viseq:raylib
..
pull from: sebastian/viseq:macos
Branches Tags
sebastian/viseq:rework-interaction-system sebastian/viseq:minimal-ui sebastian/viseq:orbit-ui sebastian/viseq:virtual-midi sebastian/viseq:refactor-orbit-ui sebastian/viseq:refactor-orbit-ui-conflict sebastian/viseq:main sebastian/viseq:vector-ui sebastian/viseq:next-ui sebastian/viseq:macos sebastian/viseq:graph sebastian/viseq:win32 sebastian/viseq:raylib

1 Commits
main .. macos

Author SHA1 Message Date
Jay 7f6cbdfad0 init macos make routine 2024-11-24 18:27:10 +01:00
116 changed files with 1980 additions and 6536 deletions
Expand all files Collapse all files
.gitignore
+1
View File
@@ -4,3 +4,4 @@ viseq
viseq.exe
compile_commands.json
*.json
.DS_STORE
MakefileMacOSarm64
+33
View File
@@ -0,0 +1,33 @@
CXX = g++
CXXFLAGS = -std=c++23 -Wall -g -fno-omit-frame-pointer -gdwarf-4 -Og -Wnarrowing
CXXINC = -Iinclude
LDLIBS = -lraylib -pthread -lobjc
LDFLAGS = -Llib -L/usr/lib -L/usr/local/lib -framework CoreFoundation -framework Cocoa -framework IOKit
hdr_files = ${wildcard src/*.h}
src_files = ${wildcard src/*.cpp}
src_files += ${wildcard include/libremidi/*.cpp}
all: viseq
viseq: $(src_files) $(hdr_files)
mkdir -p build
$(CXX) ${wildcard build/*.o} -o viseq $(LDFLAGS) $(LDLIBS)
$(src_files): %.cpp : %_src
$(CXX) -c $@ -o build/$(*F).o $(CXXFLAGS) $(CXXINC)
$(hdr_files): %.h : %_hdr
@echo "G++ >---------- $(*F).h -----------<"
%_src:
@echo "G++ >---------- $(*F).cpp -----------<"
%_hdr:
@echo "G++ >---------- $(*F).h -----------<"
clean:
rm -f build/*
rm -f viseq
README.md
+4 -56
View File
@@ -1,57 +1,5 @@
# VISEQ - THE VISUAL SEQUENCER
## BUILD
### LINUX
```
make
```
### WINDOWS
You need MingW64.
```
make -f MakefileMingW64
```
## USAGE
### CHANGING NODES
Nodes can be moved around, connected and modified. A right-cick opens a context menu with settings. Midi settings can also be changed with the mouse-wheel and modifier keys while hovering a node. All selected nodes can be changed at once. Draw a selectionbox around all nodes that you want to change, or select them by holding shift while clicking or dragging.
#### MOUSE WHEEL
- ctrl + wheel -> change midi note
- shift + wheel -> change midi velocity
- alt + wheel -> change midi gate
#### DRAGGING NODES
While dragging nodes one can use ctrl and shift to activate two different snapping modes. Ctrl enables snap to grid, while shift enables snap to next nodes. The grid is divided into 32nd notes. Snap to next nodes shows the time divisions to the closest nodes and can snap to two nodes at once.
#### SELECTING NODES
Dragging the mouse on the canvas, creates a selection rectangle. All nodes in the rectanlge will be highlighted. Using the above mentioned modification methods, one can change all selected nodes at once.
All selected nodes can also be moved together.
### CONNECTIONS
Connect nodes by dragging from the orbiting circle to another node. A new connection appears. Connections can be closed for signals in one, or both directions. Click the small green circle and it will block traffic in this direction.
#### DISTRIBUTION MODES
Nodes can have three distribution modes, "Geometric", "RR" (Round Robin), and "Random".
**Geometric Distribution**
Geometric distribution means that signals take the straightest path that is available, when more than two paths are available. By moving around nodes so that another connection becomes the straighter path, one can divert signals to other areas of the canvas.
**Round Robin Distribution**
Round Robin means, that every signal that arrives at a node with RR distribution switches the node to the next connection. With multiple signals in one path, this can lead to some beautiful patterns emerging.
**Random Distribution**
Random distribution sends every arriving signal to a random connection.
prerequisite for MacOS ARM64:
local raylib install (e.g. brew install raylib)
Build:
make -f MakefileMacOSarm64
include/libremidi/api-c.h
-2
View File
@@ -30,8 +30,6 @@ typedef enum libremidi_api
WINDOWS_MIDI_SERVICES, /*!< Windows API for MIDI 2.0. Requires Windows 11 */
KEYBOARD_UMP, /*!< Computer keyboard input */
NETWORK_UMP, /*!< MIDI2 over IP */
JACK_UMP, /*!< MIDI2 over JACK, type "32 bit raw UMP". Requires PipeWire v1.4+. */
PIPEWIRE_UMP, /*!< MIDI2 over PipeWire. Requires v1.4+. */
DUMMY = 0xFFFF /*!< A compilable but non-functional API. */
} libremidi_api;
include/libremidi/api.hpp
+6 -2
View File
@@ -2,6 +2,7 @@
#include <libremidi/api-c.h>
#include <libremidi/config.hpp>
#include <any>
#include <string_view>
#include <vector>
@@ -30,6 +31,9 @@ LIBREMIDI_EXPORT std::vector<libremidi::API> available_apis() noexcept;
*/
LIBREMIDI_EXPORT std::vector<libremidi::API> available_ump_apis() noexcept;
LIBREMIDI_EXPORT
libremidi::API midi_api(const std::any& conf);
//! A static function to determine the current version.
LIBREMIDI_EXPORT std::string_view get_version() noexcept;
@@ -60,7 +64,7 @@ inline constexpr libremidi::API default_api() noexcept
return API::COREMIDI;
#elif defined(_WIN32)
return API::WINDOWS_MM;
#elif defined(LIBREMIDI_ALSA)
#elif defined(__linux__)
return API::ALSA_SEQ;
#elif defined(__emscripten__)
return API::EMSCRIPTEN_WEBMIDI;
@@ -79,7 +83,7 @@ inline constexpr libremidi::API default_api() noexcept
return API::COREMIDI_UMP;
#elif defined(_WIN32)
return API::WINDOWS_MIDI_SERVICES;
#elif defined(LIBREMIDI_ALSA)
#elif defined(__linux__)
return API::ALSA_SEQ_UMP;
#elif defined(__emscripten__)
return API::DUMMY;
include/libremidi/backends.hpp
+8 -19
View File
@@ -1,6 +1,7 @@
#pragma once
#include <libremidi/config.hpp>
#include <any>
#include <tuple>
#if !__has_include(<weak_libjack.h>) && !__has_include(<jack/jack.h>)
@@ -29,14 +30,10 @@
#if defined(LIBREMIDI_JACK)
#include <libremidi/backends/jack.hpp>
#include <libremidi/backends/jack_ump.hpp>
#endif
#if defined(LIBREMIDI_PIPEWIRE)
#include <libremidi/backends/pipewire.hpp>
#if defined(LIBREMIDI_PIPEWIRE_UMP)
#include <libremidi/backends/pipewire_ump.hpp>
#endif
#endif
#if defined(LIBREMIDI_COREMIDI)
@@ -166,14 +163,6 @@ static constexpr auto available_backends = make_tl(
#if defined(LIBREMIDI_NETWORK)
,
net_ump::backend{}
#endif
#if defined(LIBREMIDI_JACK)
,
jack_ump::backend{}
#endif
#if defined(LIBREMIDI_PIPEWIRE_UMP)
,
pipewire_ump::backend{}
#endif
,
dummy_backend{});
@@ -184,7 +173,7 @@ static_assert(std::tuple_size_v<decltype(available_backends)> >= 1);
template <typename F>
auto for_all_backends(F&& f)
{
std::apply([&](auto&&... x) { ((x.available() && (f(x), true)), ...); }, available_backends);
std::apply([&](auto&&... x) { (f(x), ...); }, available_backends);
}
template <typename F>
@@ -213,10 +202,10 @@ auto for_backend(libremidi::API api, F&& f)
midi2::for_backend(api, f);
}
void for_input_configuration(auto f, libremidi::input_api_configuration& api_conf)
void for_input_configuration(auto f, std::any& api_conf)
{
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_in_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_in_configuration>(&api_conf))
{
f(*conf);
return true;
@@ -228,10 +217,10 @@ void for_input_configuration(auto f, libremidi::input_api_configuration& api_con
std::apply([&](auto&&... b) { return (from_api(b) || ...); }, midi2::available_backends);
}
void for_output_configuration(auto f, libremidi::output_api_configuration& api_conf)
void for_output_configuration(auto f, std::any& api_conf)
{
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_out_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_out_configuration>(&api_conf))
{
f(*conf);
return true;
@@ -243,10 +232,10 @@ void for_output_configuration(auto f, libremidi::output_api_configuration& api_c
std::apply([&](auto&&... b) { return (from_api(b) || ...); }, midi2::available_backends);
}
void for_observer_configuration(auto f, libremidi::observer_api_configuration& api_conf)
void for_observer_configuration(auto f, std::any& api_conf)
{
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_observer_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_observer_configuration>(&api_conf))
{
f(*conf);
return true;
include/libremidi/backends/alsa_raw.hpp
+2 -3
View File
@@ -3,7 +3,6 @@
#include <libremidi/backends/alsa_raw/midi_out.hpp>
#include <libremidi/backends/alsa_raw/observer.hpp>
#include <string_view>
// 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
@@ -20,8 +19,8 @@ struct backend
using midi_out_configuration = alsa_raw_output_configuration;
using midi_observer_configuration = alsa_raw_observer_configuration;
static const constexpr auto API = libremidi::API::ALSA_RAW;
static const constexpr std::string_view name = "alsa_raw";
static const constexpr std::string_view display_name = "ALSA (raw)";
static const constexpr auto name = "alsa_raw";
static const constexpr auto display_name = "ALSA (raw)";
static inline bool available() noexcept
{
include/libremidi/backends/alsa_raw/config.hpp
-1
View File
@@ -2,7 +2,6 @@
#include <libremidi/config.hpp>
#include <chrono>
#include <cstdint>
#include <functional>
#include <optional>
#include <span>
include/libremidi/backends/alsa_raw/helpers.hpp
+4 -11
View File
@@ -2,17 +2,10 @@
#include <libremidi/backends/linux/alsa.hpp>
#include <libremidi/config.hpp>
#include <libremidi/detail/observer.hpp>
#include <libremidi/observer_configuration.hpp>
#include <alsa/asoundlib.h>
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
// Credits: greatly inspired from
@@ -34,14 +27,14 @@ struct alsa_raw_port_id
};
inline constexpr port_handle raw_to_port_handle(alsa_raw_port_id id) noexcept
{
return (uint64_t(id.port) << 32) + (uint64_t(id.dev) << 16) + id.card;
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.port = (p & 0x00'00'FF'FF'00'00'00'00) >> 32;
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.card = (p & 0x00'00'00'00'00'00'FF'FF);
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);
include/libremidi/backends/alsa_raw/midi_in.hpp
+12 -12
View File
@@ -200,7 +200,7 @@ 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->m_termination_event < 0)
if (this->termination_event < 0)
{
libremidi_handle_error(this->configuration, "error creating eventfd.");
return;
@@ -220,7 +220,7 @@ public:
private:
void run_thread(auto parse_func)
{
fds_.push_back(this->m_termination_event);
fds_.push_back(this->termination_event);
const auto period
= std::chrono::duration_cast<std::chrono::milliseconds>(this->configuration.poll_period)
.count();
@@ -228,12 +228,12 @@ private:
for (;;)
{
// Poll
ssize_t err = poll(fds_.data(), fds_.size(), static_cast<int32_t>(period));
ssize_t err = poll(fds_.data(), fds_.size(), period);
if (err == -EAGAIN)
continue;
else if (err < 0)
return;
else if (m_termination_event.ready(fds_.back()))
else if (termination_event.ready(fds_.back()))
break;
err = do_read_events(parse_func, {fds_.data(), fds_.size() - 1});
@@ -250,11 +250,11 @@ private:
{
if (configuration.timestamps == timestamp_mode::NoTimestamp)
{
this->m_thread = std::thread{[this] { run_thread(&midi_in_impl::read_input_buffer); }};
this->thread_ = std::thread{[this] { run_thread(&midi_in_impl::read_input_buffer); }};
}
else
{
this->m_thread = std::thread{
this->thread_ = std::thread{
[this] { run_thread(&midi_in_impl::read_input_buffer_with_timestamps); }};
}
return stdx::error{};
@@ -282,16 +282,16 @@ private:
stdx::error close_port() override
{
m_termination_event.notify();
if (m_thread.joinable())
m_thread.join();
m_termination_event.consume(); // Reset to zero
termination_event.notify();
if (thread_.joinable())
thread_.join();
termination_event.consume(); // Reset to zero
return midi_in_impl::close_port();
}
std::thread m_thread;
eventfd_notifier m_termination_event{};
std::thread thread_;
eventfd_notifier termination_event{};
};
class midi_in_alsa_raw_manual : public midi_in_impl
include/libremidi/backends/alsa_raw/observer.hpp
+56 -69
View File
@@ -6,8 +6,7 @@
#if LIBREMIDI_HAS_UDEV
#include <libremidi/backends/linux/helpers.hpp>
#include <libremidi/backends/linux/udev.hpp>
#endif
#include <libremidi/detail/observer.hpp>
#include <libremidi/detail/observer.hpp>
namespace libremidi::alsa_raw
{
@@ -32,30 +31,24 @@ public:
if (!configuration.has_callbacks())
return;
#if LIBREMIDI_HAS_UDEV
m_fds[0] = this->m_udev;
m_fds[1] = m_termination_event;
m_fds[2] = m_timer_fd;
#endif
fds[0] = this->udev;
fds[1] = termination_event;
fds[2] = timer_fd;
// Set-up initial state
if (configuration.notify_in_constructor)
this->check_devices();
#if LIBREMIDI_HAS_UDEV
// Start thread
m_thread = std::thread{[this] { this->run(); }};
#endif
thread = std::thread{[this] { this->run(); }};
}
~observer_impl_base()
{
#if LIBREMIDI_HAS_UDEV
m_termination_event.notify();
termination_event.notify();
if (m_thread.joinable())
m_thread.join();
#endif
if (thread.joinable())
thread.join();
}
std::vector<libremidi::input_port> get_input_ports() const noexcept override
@@ -85,12 +78,11 @@ public:
}
private:
#if LIBREMIDI_HAS_UDEV
void run()
{
for (;;)
{
if (int err = poll(m_fds, 3, -1); err < 0)
if (int err = poll(fds, 3, -1); err < 0)
{
if (err == -EAGAIN)
continue;
@@ -99,77 +91,58 @@ private:
}
// Check udev
if (m_fds[0].revents & POLLIN)
if (fds[0].revents & POLLIN)
{
udev_device* dev = m_udev.udev.monitor_receive_device(m_udev.monitor);
udev_device* dev = udev.udev.monitor_receive_device(udev.monitor);
if (!dev)
continue;
std::string_view act = m_udev.udev.device_get_action(dev);
std::string_view ss = m_udev.udev.device_get_subsystem(dev);
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->m_timer_fd.restart(configuration.poll_period.count());
m_timer_check_counts = 100;
this->timer_fd.restart(configuration.poll_period.count());
timer_check_counts = 100;
}
}
m_udev.udev.device_unref(dev);
udev.udev.device_unref(dev);
m_fds[0].revents = 0;
fds[0].revents = 0;
}
// Check eventfd
if (m_fds[1].revents & POLLIN)
if (fds[1].revents & POLLIN)
{
break;
}
// Check timer
if (m_fds[2].revents & POLLIN)
if (fds[2].revents & POLLIN)
{
if (this->m_timer_check_counts-- <= 0)
this->m_timer_fd.cancel();
m_fds[2].revents = 0;
if (this->timer_check_counts-- <= 0)
this->timer_fd.cancel();
fds[2].revents = 0;
check_devices();
}
}
}
#endif
template <bool Input>
auto to_port_info(const alsa_raw::alsa_raw_port_info& p) const noexcept
auto to_port_info(alsa_raw::alsa_raw_port_info p) const noexcept
-> std::conditional_t<Input, input_port, output_port>
{
#if LIBREMIDI_HAS_UDEV
auto [container, device, type] = get_udev_soundcard_info(m_udev, p.card);
#else
container_identifier container{};
device_identifier device{};
libremidi::port_information::port_type type{};
#endif
std::string display_name = p.subdevice_name;
if (display_name.empty())
display_name = p.device_name;
if (display_name.empty())
display_name = p.card_name;
if (display_name.empty())
display_name = "unknown";
return {
{.client = 0,
.container = container,
.device = device,
.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 = std::move(display_name),
.type = type}};
.display_name = p.subdevice_name}};
}
void check_devices()
@@ -178,7 +151,7 @@ private:
new_devs.enumerate_cards();
for (auto& in_prev : m_current_inputs)
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())
@@ -192,8 +165,8 @@ private:
for (auto& in_next : new_devs.inputs)
{
if (auto it = std::find(m_current_inputs.begin(), m_current_inputs.end(), in_next);
it == m_current_inputs.end())
if (auto it = std::find(current_inputs.begin(), current_inputs.end(), in_next);
it == current_inputs.end())
{
if (auto& cb = this->configuration.input_added)
{
@@ -202,7 +175,7 @@ private:
}
}
for (auto& out_prev : m_current_outputs)
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())
@@ -216,8 +189,8 @@ private:
for (auto& out_next : new_devs.outputs)
{
if (auto it = std::find(m_current_outputs.begin(), m_current_outputs.end(), out_next);
it == m_current_outputs.end())
if (auto it = std::find(current_outputs.begin(), current_outputs.end(), out_next);
it == current_outputs.end())
{
if (auto& cb = this->configuration.output_added)
{
@@ -225,23 +198,37 @@ private:
}
}
}
m_current_inputs = std::move(new_devs.inputs);
m_current_outputs = std::move(new_devs.outputs);
current_inputs = std::move(new_devs.inputs);
current_outputs = std::move(new_devs.outputs);
}
#if LIBREMIDI_HAS_UDEV
udev_helper m_udev{};
eventfd_notifier m_termination_event{};
timerfd_timer m_timer_fd{};
int m_timer_check_counts = 0;
std::thread m_thread;
pollfd m_fds[3]{};
#endif
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;
std::vector<alsa_raw_port_info> m_current_inputs;
std::vector<alsa_raw_port_info> m_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
{
include/libremidi/backends/alsa_raw_ump.hpp
+5 -6
View File
@@ -5,8 +5,6 @@
#include <libremidi/backends/alsa_raw_ump/observer.hpp>
#include <libremidi/backends/dummy.hpp>
#include <string_view>
namespace libremidi::alsa_raw_ump
{
struct backend
@@ -16,11 +14,12 @@ struct backend
using midi_observer = observer_impl;
using midi_in_configuration = alsa_raw_ump::input_configuration;
using midi_out_configuration = alsa_raw_ump::output_configuration;
using midi_observer_configuration = alsa_raw_ump::observer_configuration;
struct midi_observer_configuration : alsa_raw_observer_configuration
{
};
static const constexpr auto API = libremidi::API::ALSA_RAW_UMP;
static const constexpr std::string_view name = "alsa_raw_ump";
static const constexpr std::string_view display_name = "ALSA (raw UMP)";
static const constexpr auto name = "alsa_raw_ump";
static const constexpr auto display_name = "ALSA (raw UMP)";
static inline bool available() noexcept
{
include/libremidi/backends/alsa_raw_ump/config.hpp
+2 -4
View File
@@ -1,9 +1,6 @@
#pragma once
#include <libremidi/backends/alsa_raw/config.hpp>
#include <chrono>
#include <functional>
namespace libremidi::alsa_raw_ump
{
struct input_configuration
@@ -21,7 +18,8 @@ struct output_configuration
std::optional<chunking_parameters> chunking;
};
struct observer_configuration : public alsa_raw_observer_configuration
struct observer_configuration
{
std::chrono::milliseconds poll_period{100};
};
}
include/libremidi/backends/alsa_raw_ump/helpers.hpp
-2
View File
@@ -3,8 +3,6 @@
#include <libremidi/config.hpp>
#include <libremidi/detail/observer.hpp>
#include <cstdio>
namespace libremidi::alsa_raw_ump
{
struct midi2_enumerator : alsa_raw::enumerator
include/libremidi/backends/alsa_raw_ump/midi_in.hpp
+14 -14
View File
@@ -194,7 +194,7 @@ public:
libremidi::ump_input_configuration&& conf, alsa_raw_ump::input_configuration&& apiconf)
: midi_in_impl{std::move(conf), std::move(apiconf)}
{
if (this->m_termination_event < 0)
if (this->termination_event < 0)
{
libremidi_handle_error(this->configuration, "error creating eventfd.");
return;
@@ -206,14 +206,14 @@ public:
~midi_in_impl_threaded()
{
// Close a connection if it exists.
midi_in_impl_threaded::close_port();
this->close_port();
client_open_ = std::errc::not_connected;
}
private:
void run_thread(auto parse_func)
{
fds_.push_back(this->m_termination_event);
fds_.push_back(this->termination_event);
const auto period
= std::chrono::duration_cast<std::chrono::milliseconds>(this->configuration.poll_period)
.count();
@@ -221,12 +221,12 @@ private:
for (;;)
{
// Poll
ssize_t err = poll(fds_.data(), fds_.size(), static_cast<int32_t>(period));
ssize_t err = poll(fds_.data(), fds_.size(), period);
if (err == -EAGAIN)
continue;
else if (err < 0)
return;
else if (m_termination_event.ready(fds_.back()))
else if (termination_event.ready(fds_.back()))
break;
err = do_read_events(parse_func, {fds_.data(), fds_.size() - 1});
@@ -243,11 +243,11 @@ private:
{
if (configuration.timestamps == timestamp_mode::NoTimestamp)
{
this->m_thread = std::thread{[this] { run_thread(&midi_in_impl::read_input_buffer); }};
this->thread_ = std::thread{[this] { run_thread(&midi_in_impl::read_input_buffer); }};
}
else
{
this->m_thread = std::thread{
this->thread_ = std::thread{
[this] { run_thread(&midi_in_impl::read_input_buffer_with_timestamps); }};
}
return stdx::error{};
@@ -275,16 +275,16 @@ private:
stdx::error close_port() override
{
m_termination_event.notify();
if (m_thread.joinable())
m_thread.join();
m_termination_event.consume(); // Reset to zero
termination_event.notify();
if (thread_.joinable())
thread_.join();
termination_event.consume(); // Reset to zero
return midi_in_impl::close_port();
}
std::thread m_thread;
eventfd_notifier m_termination_event{};
std::thread thread_;
eventfd_notifier termination_event{};
};
class midi_in_impl_manual : public midi_in_impl
@@ -299,7 +299,7 @@ public:
~midi_in_impl_manual()
{
// Close a connection if it exists.
midi_in_impl_manual::close_port();
this->close_port();
client_open_ = std::errc::not_connected;
}
include/libremidi/backends/alsa_raw_ump/midi_out.hpp
+2 -7
View File
@@ -1,17 +1,12 @@
#pragma once
#include <libremidi/backends/alsa_raw_ump/config.hpp>
#include <libremidi/backends/alsa_raw_ump/helpers.hpp>
#include <libremidi/backends/linux/alsa.hpp>
#include <libremidi/detail/midi_out.hpp>
#include <libremidi/error_handler.hpp>
#include <libremidi/output_configuration.hpp>
#include <alsa/asoundlib.h>
#include <cassert>
#include <cstdint>
#include <system_error>
#include <utility>
#include <atomic>
#include <thread>
namespace libremidi::alsa_raw_ump
{
include/libremidi/backends/alsa_seq.hpp
+3 -10
View File
@@ -16,10 +16,6 @@
#include <libremidi/backends/alsa_seq/midi_out.hpp>
#include <libremidi/backends/alsa_seq/observer.hpp>
#include <unistd.h>
#include <string_view>
namespace libremidi::alsa_seq
{
@@ -33,16 +29,13 @@ struct backend
using midi_out_configuration = alsa_seq::output_configuration;
using midi_observer_configuration = alsa_seq::observer_configuration;
static const constexpr auto API = libremidi::API::ALSA_SEQ;
static const constexpr std::string_view name = "alsa_seq";
static const constexpr std::string_view display_name = "ALSA (sequencer)";
static const constexpr auto name = "alsa_seq";
static const constexpr auto display_name = "ALSA (sequencer)";
static inline bool available() noexcept
{
static const libasound& snd = libasound::instance();
if (!snd.available || !snd.seq.available)
return false;
return ::access("/dev/snd/seq", F_OK) == 0;
return snd.available && snd.seq.available;
}
};
include/libremidi/backends/alsa_seq/helpers.hpp
+4 -4
View File
@@ -46,19 +46,19 @@ namespace
{
inline constexpr port_handle seq_to_port_handle(uint64_t client, uint64_t port) noexcept
{
return (port << 32) + client;
return (client << 32) + port;
}
inline constexpr std::pair<int, int> seq_from_port_handle(port_handle p) noexcept
{
int port = p >> 32;
int client = p & 0xFFFFFFFF;
int client = p >> 32;
int port = p & 0xFFFFFFFF;
return {client, port};
}
inline void for_all_ports(
const libasound& snd, snd_seq_t* seq,
const std::function<void(snd_seq_client_info_t&, snd_seq_port_info_t&)>& func)
std::function<void(snd_seq_client_info_t&, snd_seq_port_info_t&)> func)
{
snd_seq_client_info_t* cinfo{};
snd_seq_client_info_alloca(&cinfo);
include/libremidi/backends/alsa_seq/midi_in.hpp
+18 -18
View File
@@ -212,7 +212,7 @@ public:
.count();
}
int64_t process_event(const snd_seq_event_t& ev)
int process_event(const snd_seq_event_t& ev)
{
if constexpr (ConfigurationImpl::midi_version == 1)
{
@@ -258,17 +258,17 @@ public:
return 0;
}
int64_t process_events()
int process_events()
{
if constexpr (ConfigurationImpl::midi_version == 1)
{
snd_seq_event_t* ev{};
event_handle handle{snd};
int64_t result = 0;
int result = 0;
if ((result = snd.seq.event_input(seq, &ev)) > 0)
{
handle.reset(ev);
if (auto err = process_event(*ev); err < 0)
if (int err = process_event(*ev); err < 0)
{
return err;
}
@@ -353,7 +353,7 @@ public:
midi_in_alsa_threaded(ConfigurationBase&& conf, ConfigurationImpl&& apiconf)
: midi_in_impl<ConfigurationBase, ConfigurationImpl>{std::move(conf), std::move(apiconf)}
{
if (this->m_termination_event < 0)
if (this->termination_event < 0)
{
this->libremidi_handle_error(this->configuration, "error creating eventfd.");
return;
@@ -364,7 +364,7 @@ public:
~midi_in_alsa_threaded()
{
midi_in_alsa_threaded::close_port();
this->close_port();
this->client_open_ = std::errc::not_connected;
}
@@ -399,7 +399,7 @@ private:
{
try
{
this->m_thread = std::thread([this] { thread_handler(); });
this->thread = std::thread([this] { thread_handler(); });
return stdx::error{};
}
catch (const std::system_error& e)
@@ -415,12 +415,12 @@ private:
stdx::error stop_thread()
{
m_termination_event.notify();
termination_event.notify();
if (this->m_thread.joinable())
this->m_thread.join();
if (this->thread.joinable())
this->thread.join();
m_termination_event.consume();
termination_event.consume();
return stdx::error{};
}
@@ -428,7 +428,7 @@ private:
{
int poll_fd_count = alsa_data::snd.seq.poll_descriptors_count(this->seq, POLLIN) + 1;
auto poll_fds = (struct pollfd*)alloca(poll_fd_count * sizeof(struct pollfd));
poll_fds[0] = this->m_termination_event;
poll_fds[0] = this->termination_event;
alsa_data::snd.seq.poll_descriptors(this->seq, poll_fds + 1, poll_fd_count - 1, POLLIN);
const auto period
@@ -439,10 +439,10 @@ private:
if (alsa_data::snd.seq.event_input_pending(this->seq, 1) == 0)
{
// No data pending
if (poll(poll_fds, poll_fd_count, static_cast<int32_t>(period)) >= 0)
if (poll(poll_fds, poll_fd_count, period) >= 0)
{
// We got our stop-thread signal
if (m_termination_event.ready(poll_fds[0]))
if (termination_event.ready(poll_fds[0]))
{
break;
}
@@ -450,7 +450,7 @@ private:
continue;
}
int64_t res{};
int res{};
if constexpr (ConfigurationImpl::midi_version == 1)
{
res = this->process_events();
@@ -467,8 +467,8 @@ private:
}
}
std::thread m_thread{};
eventfd_notifier m_termination_event{};
std::thread thread{};
eventfd_notifier termination_event{};
};
template <typename ConfigurationBase, typename ConfigurationImpl>
@@ -497,7 +497,7 @@ public:
return 0;
}
~midi_in_alsa_manual() { midi_in_alsa_manual::close_port(); }
~midi_in_alsa_manual() { this->close_port(); }
stdx::error open_port(const input_port& pt, std::string_view local_port_name) override
{
include/libremidi/backends/alsa_seq/midi_out.hpp
+8 -9
View File
@@ -30,7 +30,7 @@ public:
return;
}
if (snd.midi.event_new(this->m_bufferSize, &this->coder) < 0)
if (snd.midi.event_new(this->bufferSize, &this->coder) < 0)
{
libremidi_handle_error(this->configuration, "error initializing MIDI event parser.");
return;
@@ -68,9 +68,8 @@ public:
stdx::error open_port(const output_port& p, std::string_view portName) override
{
unsigned int n_src
= this->get_port_count(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
if (n_src < 1)
unsigned int nSrc = this->get_port_count(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
if (nSrc < 1)
{
libremidi_handle_error(this->configuration, "no MIDI output sources found!");
return make_error_code(std::errc::no_such_device);
@@ -123,9 +122,9 @@ public:
stdx::error send_message(const unsigned char* message, std::size_t size) override
{
int64_t result{};
if (size > this->m_bufferSize)
if (size > this->bufferSize)
{
this->m_bufferSize = size;
this->bufferSize = size;
result = snd.midi.event_resize_buffer(this->coder, size);
if (result != 0)
{
@@ -147,8 +146,8 @@ public:
// FIXME direct is set but snd_seq_event_output_direct is not used...
snd_seq_ev_set_direct(&ev);
const int64_t n_bytes = size; // signed to avoir potential overflow with size - offset below
result = snd.midi.event_encode(this->coder, message + offset, (long)(n_bytes - offset), &ev);
const int64_t nBytes = size; // signed to avoir potential overflow with size - offset below
result = snd.midi.event_encode(this->coder, message + offset, (long)(nBytes - offset), &ev);
if (result < 0)
{
libremidi_handle_warning(this->configuration, "event parsing error!");
@@ -175,6 +174,6 @@ public:
}
private:
uint64_t m_bufferSize{32};
uint64_t bufferSize{32};
};
}
include/libremidi/backends/alsa_seq/observer.hpp
+15 -49
View File
@@ -7,10 +7,7 @@
#include <alsa/asoundlib.h>
#if LIBREMIDI_HAS_UDEV
#include <libremidi/backends/linux/udev.hpp>
#endif
#include <bitset>
#include <map>
namespace libremidi::alsa_seq
@@ -24,8 +21,6 @@ struct port_info
int port{};
bool isInput{};
bool isOutput{};
std::optional<int> card{};
libremidi::port_information::port_type type{};
};
template <typename ConfigurationImpl>
@@ -112,19 +107,13 @@ public:
const auto tp = snd.seq.port_info_get_type(pinfo);
bool ok = this->configuration.track_any;
static constexpr auto virtual_port = SND_SEQ_PORT_TYPE_SOFTWARE | SND_SEQ_PORT_TYPE_SYNTHESIZER
| SND_SEQ_PORT_TYPE_APPLICATION;
static constexpr auto virtual_port
= SND_SEQ_PORT_TYPE_SOFTWARE | SND_SEQ_PORT_TYPE_SYNTHESIZER;
if ((tp & SND_SEQ_PORT_TYPE_HARDWARE) && this->configuration.track_hardware)
{
p.type = libremidi::port_information::port_type::hardware;
ok = true;
}
else if ((tp & virtual_port) && this->configuration.track_virtual)
{
p.type = libremidi::port_information::port_type::software;
ok = true;
}
if (!ok)
return {};
@@ -134,10 +123,7 @@ public:
if (auto name = snd.seq.port_info_get_name(pinfo))
p.port_name = name;
if (int card = snd.seq.client_info_get_card(cinfo); card >= 0)
p.card = card;
const auto cap = snd.seq.port_info_get_capability(pinfo);
auto cap = snd.seq.port_info_get_capability(pinfo);
p.isInput = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_READ);
p.isOutput = (cap & SND_SEQ_PORT_CAP_DUPLEX) | (cap & SND_SEQ_PORT_CAP_WRITE);
@@ -145,34 +131,18 @@ public:
}
template <bool Input>
auto to_port_info(const port_info& p) const noexcept
auto to_port_info(port_info p) const noexcept
-> std::conditional_t<Input, input_port, output_port>
{
static_assert(sizeof(this->seq) <= sizeof(libremidi::client_handle));
static_assert(sizeof(std::uintptr_t) <= sizeof(libremidi::client_handle));
container_identifier container{};
device_identifier device{};
libremidi::port_information::port_type type = p.type;
#if LIBREMIDI_HAS_UDEV
if (p.card)
{
auto res = get_udev_soundcard_info(m_udev, *p.card);
container = res.container;
device = res.path;
type = res.type;
}
#endif
return {
{.client = std::uintptr_t(this->seq),
.container = container,
.device = device,
.port = alsa_seq::seq_to_port_handle(p.client, p.port),
.manufacturer = "",
.device_name = p.client_name,
.port_name = p.port_name,
.display_name = p.port_name,
.type = type}};
.display_name = p.port_name}};
}
void init_all_ports()
@@ -230,7 +200,7 @@ public:
if (p.client == snd.seq.client_id(seq))
return;
m_knownClients[{p.client, p.port}] = p;
knownClients_[{p.client, p.port}] = p;
if (p.isInput && configuration.input_added)
{
configuration.input_added(to_port_info<true>(p));
@@ -244,11 +214,11 @@ public:
void unregister_port(int client, int port)
{
auto it = m_knownClients.find({client, port});
if (it != m_knownClients.end())
auto it = knownClients_.find({client, port});
if (it != knownClients_.end())
{
auto p = it->second;
m_knownClients.erase(it);
knownClients_.erase(it);
if (p.isInput && configuration.input_removed)
{
@@ -293,11 +263,7 @@ public:
}
private:
std::map<std::pair<int, int>, port_info> m_knownClients;
#if LIBREMIDI_HAS_UDEV
udev_helper m_udev{};
#endif
std::map<std::pair<int, int>, port_info> knownClients_;
};
template <typename ConfigurationImpl>
@@ -309,9 +275,9 @@ public:
{
// Create relevant descriptors
auto& snd = alsa_data::snd;
const auto n = snd.seq.poll_descriptors_count(this->seq, POLLIN);
descriptors_.resize(n + 1);
snd.seq.poll_descriptors(this->seq, descriptors_.data(), n, POLLIN);
const auto N = snd.seq.poll_descriptors_count(this->seq, POLLIN);
descriptors_.resize(N + 1);
snd.seq.poll_descriptors(this->seq, descriptors_.data(), N, POLLIN);
descriptors_.back() = this->termination_event;
// Start the listening thread
@@ -322,7 +288,7 @@ public:
.count();
for (;;)
{
int err = poll(descriptors_.data(), descriptors_.size(), static_cast<int32_t>(period));
int err = poll(descriptors_.data(), descriptors_.size(), period);
if (err >= 0)
{
// We got our stop-thread signal
include/libremidi/backends/alsa_seq/shared_handler.hpp
+7 -5
View File
@@ -61,7 +61,7 @@ struct shared_handler : public libremidi::shared_context
{
auto clt = std::make_shared<shared_handler>(client_name);
auto cb = [client = std::weak_ptr{clt}](libremidi::alsa_seq::poll_parameters params) {
auto cb = [client = std::weak_ptr{clt}](const libremidi::alsa_seq::poll_parameters& params) {
if (auto clt = client.lock())
{
clt->events.push(
@@ -74,7 +74,8 @@ struct shared_handler : public libremidi::shared_context
auto stop_cb = [client = std::weak_ptr{clt}](snd_seq_addr_t id) {
if (auto clt = client.lock())
{
clt->events.push({.type = shared_handler::event_type::callback_removed, .payload = id});
clt->events.push(
{.type = shared_handler::event_type::callback_removed, .payload = std::move(id)});
clt->queue_event.notify();
}
return true;
@@ -133,7 +134,7 @@ struct shared_handler : public libremidi::shared_context
break;
}
case callback_removed:
auto addr = *std::get_if<snd_seq_addr_t>(&ev.payload);
auto addr = std::move(*std::get_if<snd_seq_addr_t>(&ev.payload));
if (auto index = index_of_address(addr); index >= 0)
{
addresses.erase(addresses.begin() + index);
@@ -145,14 +146,15 @@ struct shared_handler : public libremidi::shared_context
}
// Look for who's ready
for (int64_t i = 0, n = std::ssize(fds) - 2; i < n; i++)
for (int64_t i = 0, N = std::ssize(fds) - 2; i < N; i++)
{
if (fds[i].revents & POLLIN)
{
// Read alsa event
snd_seq_event_t* ev{};
event_handle handle{snd};
while (snd.seq.event_input(client, &ev) > 0)
int result = 0;
while ((result = snd.seq.event_input(client, &ev)) > 0)
{
handle.reset(ev);
include/libremidi/backends/alsa_seq_ump.hpp
+3 -10
View File
@@ -5,10 +5,6 @@
#include <libremidi/backends/alsa_seq_ump/config.hpp>
#include <libremidi/backends/alsa_seq_ump/midi_out.hpp>
#include <unistd.h>
#include <string_view>
namespace libremidi
{
template <>
@@ -54,16 +50,13 @@ struct backend
using midi_out_configuration = alsa_seq_ump::output_configuration;
using midi_observer_configuration = alsa_seq_ump::observer_configuration;
static const constexpr auto API = libremidi::API::ALSA_SEQ_UMP;
static const constexpr std::string_view name = "alsa_seq_ump";
static const constexpr std::string_view display_name = "ALSA (sequencer, UMP)";
static const constexpr auto name = "alsa_seq_ump";
static const constexpr auto display_name = "ALSA (sequencer, UMP)";
static inline bool available() noexcept
{
static const libasound& snd = libasound::instance();
if (!snd.available || !snd.seq.available || !snd.seq.ump.available || !snd.ump.available)
return false;
return ::access("/dev/snd/seq", F_OK) == 0;
return snd.available && snd.seq.available && snd.seq.ump.available && snd.ump.available;
}
};
}
include/libremidi/backends/alsa_seq_ump/midi_out.hpp
+3 -5
View File
@@ -64,9 +64,8 @@ public:
stdx::error open_port(const output_port& p, std::string_view portName) override
{
unsigned int n_src
= this->get_port_count(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
if (n_src < 1)
unsigned int nSrc = this->get_port_count(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
if (nSrc < 1)
{
libremidi_handle_error(this->configuration, "no MIDI output sources found!");
return make_error_code(std::errc::no_such_device);
@@ -134,8 +133,7 @@ public:
libremidi_handle_warning(this->configuration, "error sending MIDI message to port.");
return static_cast<std::errc>(-ret);
}
static_assert(std::errc{0} == std::errc{});
return std::errc{};
return std::errc{0};
};
segment_ump_stream(ump_stream, count, write_func, []() {});
include/libremidi/backends/coremidi.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/coremidi/midi_out.hpp>
#include <libremidi/backends/coremidi/observer.hpp>
#include <string_view>
namespace libremidi
{
struct core_backend
@@ -16,8 +14,8 @@ struct core_backend
using midi_out_configuration = coremidi_output_configuration;
using midi_observer_configuration = coremidi_observer_configuration;
static const constexpr auto API = libremidi::API::COREMIDI;
static const constexpr std::string_view name = "core";
static const constexpr std::string_view display_name = "CoreMIDI";
static const constexpr auto name = "core";
static const constexpr auto display_name = "CoreMIDI";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/coremidi/helpers.hpp
+9 -11
View File
@@ -71,22 +71,20 @@ inline uint64_t AudioConvertHostTimeToNanos(uint64_t hostTime)
return static_cast<uint64_t>(res);
}
#endif
static inline auto get_cfstring_property(MIDIObjectRef prop, CFStringRef name)
{
CFStringRef str = nullptr;
MIDIObjectGetStringProperty(prop, name, &str);
return CFString_handle{str};
};
// This function was submitted by Douglas Casey Tucker and apparently
// derived largely from PortMidi.
inline CFStringRef EndpointName(MIDIEndpointRef endpoint, bool isExternal)
{
CFMutableStringRef result = CFStringCreateMutable(nullptr, 0);
static constexpr auto getProp = [](MIDIObjectRef prop) {
CFStringRef str = nullptr;
MIDIObjectGetStringProperty(prop, kMIDIPropertyName, &str);
return CFString_handle{str};
};
// Begin with the endpoint's name.
if (auto endpoint_name = get_cfstring_property(endpoint, kMIDIPropertyName))
if (auto endpoint_name = getProp(endpoint))
{
CFStringAppend(result, endpoint_name.get());
}
@@ -103,7 +101,7 @@ inline CFStringRef EndpointName(MIDIEndpointRef endpoint, bool isExternal)
if (CFStringGetLength(result) == 0)
{
// endpoint name has zero length -- try the entity
if (auto entity_name = get_cfstring_property(entity, kMIDIPropertyName))
if (auto entity_name = getProp(entity))
{
CFStringAppend(result, entity_name.get());
}
@@ -114,7 +112,7 @@ inline CFStringRef EndpointName(MIDIEndpointRef endpoint, bool isExternal)
if (device == 0)
goto finish;
if (auto dev_name = get_cfstring_property(device, kMIDIPropertyName))
if (auto dev_name = getProp(device))
{
const auto dev_strlen = CFStringGetLength(dev_name.get());
include/libremidi/backends/coremidi/observer.hpp
+1 -43
View File
@@ -78,55 +78,13 @@ public:
if (!ok)
return {};
// Get the MIDI device from the entity
libremidi::port_information::port_type type{};
libremidi::container_identifier usb_location_id{};
libremidi::device_identifier usb_vendor_product{};
{
MIDIDeviceRef device{};
if (MIDIEntityGetDevice(e, &device) == noErr)
{
if (device)
{
using enum libremidi::port_information::port_type;
SInt32 devid_res{};
if (MIDIObjectGetIntegerProperty(device, CFSTR("USBLocationID"), &devid_res) == noErr)
{
type = (libremidi::port_information::port_type)(hardware | usb);
usb_location_id = (uint64_t)devid_res;
}
SInt32 vendor_res{};
if (MIDIObjectGetIntegerProperty(device, CFSTR("USBVendorProduct"), &vendor_res)
== noErr)
{
type = (libremidi::port_information::port_type)(hardware | usb);
usb_vendor_product = (uint64_t)vendor_res;
}
const auto driver = get_string_property(device, kMIDIPropertyDriverOwner);
if (driver == "com.apple.AppleMIDIUSBDriver")
type = (libremidi::port_information::port_type)(hardware | usb);
if (driver == "com.apple.AppleMIDIBluetoothDriver")
type = (libremidi::port_information::port_type)(hardware | bluetooth);
if (driver == "com.apple.AppleMIDIIACDriver")
type = (libremidi::port_information::port_type)(software);
if (driver == "com.apple.AppleMIDIRTPDriver")
type = (libremidi::port_information::port_type)(network);
}
}
}
return std::conditional_t<Input, input_port, output_port>{
{.client = (std::uintptr_t)this->client,
.container = usb_location_id,
.device = usb_vendor_product,
.port = std::bit_cast<uint32_t>(get_int_property(obj, kMIDIPropertyUniqueID)),
.manufacturer = get_string_property(obj, kMIDIPropertyManufacturer),
.device_name = get_string_property(obj, kMIDIPropertyModel),
.port_name = get_string_property(obj, kMIDIPropertyName),
.display_name = get_string_property(obj, kMIDIPropertyDisplayName),
.type = type}};
.display_name = get_string_property(obj, kMIDIPropertyDisplayName)}};
}
std::vector<libremidi::input_port> get_input_ports() const noexcept override
include/libremidi/backends/coremidi_ump.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/coremidi_ump/midi_out.hpp>
#include <libremidi/backends/coremidi_ump/observer.hpp>
#include <string_view>
namespace libremidi::coremidi_ump
{
struct backend
@@ -16,8 +14,8 @@ struct backend
using midi_out_configuration = coremidi_ump::output_configuration;
using midi_observer_configuration = coremidi_ump::observer_configuration;
static const constexpr auto API = libremidi::API::COREMIDI_UMP;
static const constexpr std::string_view name = "core_ump";
static const constexpr std::string_view display_name = "CoreMIDI UMP";
static const constexpr auto name = "core_ump";
static const constexpr auto display_name = "CoreMIDI UMP";
static constexpr inline bool available() noexcept { return true; /* todo? */ }
};
include/libremidi/backends/dummy.hpp
+5 -9
View File
@@ -5,8 +5,6 @@
#include <libremidi/detail/midi_out.hpp>
#include <libremidi/detail/observer.hpp>
#include <string_view>
namespace libremidi
{
class observer_dummy : public observer_api
@@ -25,12 +23,11 @@ class midi_in_dummy final
, public error_handler
{
public:
explicit midi_in_dummy(const input_configuration& configuration, const input_api_configuration&)
explicit midi_in_dummy(const input_configuration& configuration, std::any)
{
libremidi_handle_warning(configuration, "This class provides no functionality.");
}
explicit midi_in_dummy(
const ump_input_configuration& configuration, const input_api_configuration&)
explicit midi_in_dummy(const ump_input_configuration& configuration, std::any)
{
libremidi_handle_warning(configuration, "This class provides no functionality.");
}
@@ -61,8 +58,7 @@ class midi_out_dummy final
, public error_handler
{
public:
explicit midi_out_dummy(
const output_configuration& configuration, const output_api_configuration&)
explicit midi_out_dummy(const output_configuration& configuration, std::any)
{
libremidi_handle_warning(configuration, "This class provides no functionality.");
}
@@ -101,8 +97,8 @@ struct dummy_backend
using midi_out_configuration = dummy_configuration;
using midi_observer_configuration = dummy_configuration;
static const constexpr auto API = libremidi::API::DUMMY;
static const constexpr std::string_view name = "dummy";
static const constexpr std::string_view display_name = "Dummy";
static const constexpr auto name = "dummy";
static const constexpr auto display_name = "Dummy";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/emscripten.hpp
+2 -4
View File
@@ -7,8 +7,6 @@
#include <libremidi/backends/emscripten/midi_out.hpp>
#include <libremidi/backends/emscripten/observer.hpp>
#include <string_view>
namespace libremidi
{
@@ -21,8 +19,8 @@ struct emscripten_backend
using midi_out_configuration = emscripten_output_configuration;
using midi_observer_configuration = emscripten_observer_configuration;
static const constexpr auto API = libremidi::API::WEBMIDI;
static const constexpr std::string_view name = "webmidi";
static const constexpr std::string_view display_name = "WebMIDI";
static const constexpr auto name = "webmidi";
static const constexpr auto display_name = "WebMIDI";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/emscripten/midi_in.cpp
+2 -2
View File
@@ -38,7 +38,7 @@ LIBREMIDI_INLINE stdx::error midi_in_emscripten::open_port(int portNumber, std::
}
midi.open_input(portNumber, *this);
m_portNumber = portNumber;
portNumber_ = portNumber;
return stdx::error{};
}
@@ -52,7 +52,7 @@ LIBREMIDI_INLINE stdx::error midi_in_emscripten::close_port()
{
auto& midi = webmidi_helpers::midi_access_emscripten::instance();
midi.close_input(m_portNumber, *this);
midi.close_input(portNumber_, *this);
return stdx::error{};
}
include/libremidi/backends/emscripten/midi_in.hpp
+1 -1
View File
@@ -31,7 +31,7 @@ public:
void on_input(double ts, unsigned char* begin, unsigned char* end);
private:
int m_portNumber{};
int portNumber_{};
midi1::input_state_machine m_processing{this->configuration};
};
include/libremidi/backends/emscripten/midi_out.cpp
+3 -3
View File
@@ -34,7 +34,7 @@ LIBREMIDI_INLINE stdx::error midi_out_emscripten::open_port(int portNumber, std:
return std::errc::invalid_argument;
}
m_portNumber = portNumber;
portNumber_ = portNumber;
return stdx::error{};
}
@@ -49,14 +49,14 @@ LIBREMIDI_INLINE stdx::error midi_out_emscripten::close_port() {
LIBREMIDI_INLINE stdx::error midi_out_emscripten::send_message(const unsigned char* message, size_t size)
{
if (m_portNumber < 0)
if (portNumber_ < 0)
libremidi_handle_error(
this->configuration,
"trying to send a message without an open "
"port.");
webmidi_helpers::midi_access_emscripten::instance().send_message(
m_portNumber, reinterpret_cast<const char*>(message), size);
portNumber_, reinterpret_cast<const char*>(message), size);
return stdx::error{};
}
}
include/libremidi/backends/emscripten/midi_out.hpp
+1 -1
View File
@@ -28,6 +28,6 @@ public:
stdx::error send_message(const unsigned char* message, size_t size) override;
private:
int m_portNumber{-1};
int portNumber_{-1};
};
}
include/libremidi/backends/jack.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/jack/midi_out.hpp>
#include <libremidi/backends/jack/observer.hpp>
#include <string_view>
//*********************************************************************//
// API: UNIX JACK
//
@@ -24,8 +22,8 @@ struct jack_backend
using midi_out_configuration = jack_output_configuration;
using midi_observer_configuration = jack_observer_configuration;
static const constexpr auto API = libremidi::API::JACK_MIDI;
static const constexpr std::string_view name = "jack";
static const constexpr std::string_view display_name = "JACK";
static const constexpr auto name = "jack";
static const constexpr auto display_name = "JACK";
static inline bool available() noexcept
{
include/libremidi/backends/jack/helpers.hpp
+11 -89
View File
@@ -5,9 +5,7 @@
#include <libremidi/detail/semaphore.hpp>
#include <atomic>
#include <cstdint>
#include <cstring>
#include <memory>
#include <semaphore>
namespace libremidi
{
@@ -56,16 +54,16 @@ struct jack_client
}
template <bool Input>
static auto get_ports(
jack_client_t* client, const char* pattern, const char* type, const JackPortFlags flags,
bool midi2) noexcept -> std::vector<std::conditional_t<Input, input_port, output_port>>
static auto
get_ports(jack_client_t* client, const char* pattern, const JackPortFlags flags) noexcept
-> std::vector<std::conditional_t<Input, input_port, output_port>>
{
std::vector<std::conditional_t<Input, input_port, output_port>> ret;
if (!client)
return {};
const char** ports = jack_get_ports(client, pattern, type, flags);
const char** ports = jack_get_ports(client, pattern, JACK_DEFAULT_MIDI_TYPE, flags);
if (ports == nullptr)
return {};
@@ -75,11 +73,7 @@ struct jack_client
{
// FIXME this does not take into account filtering sw / hw ports
auto port = jack_port_by_name(client, ports[i]);
if (port)
{
if (bool(midi2) == bool(jack_port_flags(port) & 0x20))
ret.push_back(to_port_info<Input>(client, port));
}
ret.push_back(to_port_info<Input>(client, port));
i++;
}
@@ -138,7 +132,7 @@ struct jack_helpers : jack_client
{.token = this_instance,
.callback = [&self, p = std::weak_ptr{this->port.impl}](jack_nframes_t nf) -> int {
if (auto pt = p.lock())
if (pt->load())
if (auto ppt = pt->load())
self.process(nf);
self.thread_lock.check_client_released();
@@ -198,8 +192,8 @@ struct jack_helpers : jack_client
self.client_open_ = std::errc::not_connected;
}
stdx::error create_local_port(
const auto& self, std::string_view portName, const char* type, JackPortFlags flags)
stdx::error
create_local_port(const auto& self, std::string_view portName, JackPortFlags flags)
{
// full name: "client_name:port_name\0"
if (portName.empty())
@@ -215,7 +209,8 @@ struct jack_helpers : jack_client
if (!this->port)
{
this->port = jack_port_register(this->client, portName.data(), type, flags, 0);
this->port
= jack_port_register(this->client, portName.data(), JACK_DEFAULT_MIDI_TYPE, flags, 0);
}
if (!this->port)
@@ -243,77 +238,4 @@ struct jack_helpers : jack_client
return from_errc(err);
}
};
struct jack_queue
{
public:
static constexpr auto size_sz = sizeof(int32_t);
jack_queue() = default;
jack_queue(const jack_queue&) = delete;
jack_queue(jack_queue&&) = delete;
jack_queue& operator=(const jack_queue&) = delete;
jack_queue& operator=(jack_queue&& other) noexcept
{
ringbuffer = other.ringbuffer;
ringbuffer_space = other.ringbuffer_space;
other.ringbuffer = nullptr;
return *this;
}
explicit jack_queue(int64_t sz) noexcept
{
ringbuffer = jack_ringbuffer_create(sz);
ringbuffer_space = jack_ringbuffer_write_space(ringbuffer);
}
~jack_queue() noexcept
{
if (ringbuffer)
jack_ringbuffer_free(ringbuffer);
}
stdx::error write(const unsigned char* data, int64_t sz) const noexcept
{
if (static_cast<std::size_t>(sz + size_sz) > ringbuffer_space)
return std::errc::no_buffer_space;
while (jack_ringbuffer_write_space(ringbuffer) < sz + size_sz)
sched_yield();
jack_ringbuffer_write(ringbuffer, reinterpret_cast<char*>(&sz), size_sz);
jack_ringbuffer_write(ringbuffer, reinterpret_cast<const char*>(data), sz);
return stdx::error{};
}
void read(void* jack_events) const noexcept
{
int32_t sz;
while (jack_ringbuffer_peek(ringbuffer, reinterpret_cast<char*>(&sz), size_sz) == size_sz
&& jack_ringbuffer_read_space(ringbuffer) >= size_sz + sz)
{
jack_ringbuffer_read_advance(ringbuffer, size_sz);
if (auto midi = jack_midi_event_reserve(jack_events, 0, sz))
jack_ringbuffer_read(ringbuffer, reinterpret_cast<char*>(midi), sz);
else
jack_ringbuffer_read_advance(ringbuffer, sz);
}
}
jack_ringbuffer_t* ringbuffer{};
std::size_t ringbuffer_space{}; // actual writable size, usually 1 less than ringbuffer
};
struct jack_midi1
{
static constexpr const char* port_type = "8 bit raw midi";
};
struct jack_midi2
{
static constexpr const char* port_type = "32 bit raw UMP";
};
}
include/libremidi/backends/jack/midi_in.hpp
+6 -6
View File
@@ -4,12 +4,13 @@
#include <libremidi/detail/midi_in.hpp>
#include <libremidi/detail/midi_stream_decoder.hpp>
#include <chrono>
namespace libremidi
{
class midi_in_jack final
: public midi1::in_api
, public jack_helpers
, public jack_midi1
, public error_handler
{
public:
@@ -45,8 +46,7 @@ public:
stdx::error open_port(const input_port& port, std::string_view portName) override
{
if (auto err = create_local_port(*this, portName, port_type, JackPortIsInput);
err != stdx::error{})
if (auto err = create_local_port(*this, portName, JackPortIsInput); err != stdx::error{})
return err;
if (int err = jack_connect(this->client, port.port_name.c_str(), jack_port_name(this->port));
@@ -62,7 +62,7 @@ public:
stdx::error open_virtual_port(std::string_view portName) override
{
return create_local_port(*this, portName, port_type, JackPortIsInput);
return create_local_port(*this, portName, JackPortIsInput);
}
stdx::error close_port() override { return do_close_port(); }
@@ -96,8 +96,8 @@ public:
this->client, &current_frames, &current_usecs, &next_usecs, &period_usecs);
// We have midi events in buffer
uint32_t ev_count = jack_midi_get_event_count(buff);
for (uint32_t j = 0; j < ev_count; j++)
uint32_t evCount = jack_midi_get_event_count(buff);
for (uint32_t j = 0; j < evCount; j++)
{
jack_midi_event_t event{};
jack_midi_event_get(&event, buff, j);
include/libremidi/backends/jack/midi_out.hpp
+71 -8
View File
@@ -3,12 +3,76 @@
#include <libremidi/backends/jack/helpers.hpp>
#include <libremidi/detail/midi_out.hpp>
#include <semaphore>
namespace libremidi
{
struct jack_queue
{
public:
static constexpr auto size_sz = sizeof(int32_t);
jack_queue() = default;
jack_queue(const jack_queue&) = delete;
jack_queue(jack_queue&&) = delete;
jack_queue& operator=(const jack_queue&) = delete;
jack_queue& operator=(jack_queue&& other) noexcept
{
ringbuffer = other.ringbuffer;
ringbuffer_space = other.ringbuffer_space;
other.ringbuffer = nullptr;
return *this;
}
explicit jack_queue(int64_t sz) noexcept
{
ringbuffer = jack_ringbuffer_create(sz);
ringbuffer_space = jack_ringbuffer_write_space(ringbuffer);
}
~jack_queue() noexcept
{
if (ringbuffer)
jack_ringbuffer_free(ringbuffer);
}
stdx::error write(const unsigned char* data, int64_t sz) const noexcept
{
if (static_cast<std::size_t>(sz + size_sz) > ringbuffer_space)
return std::errc::no_buffer_space;
while (jack_ringbuffer_write_space(ringbuffer) < sz + size_sz)
sched_yield();
jack_ringbuffer_write(ringbuffer, reinterpret_cast<char*>(&sz), size_sz);
jack_ringbuffer_write(ringbuffer, reinterpret_cast<const char*>(data), sz);
return stdx::error{};
}
void read(void* jack_events) const noexcept
{
int32_t sz;
while (jack_ringbuffer_peek(ringbuffer, reinterpret_cast<char*>(&sz), size_sz) == size_sz
&& jack_ringbuffer_read_space(ringbuffer) >= size_sz + sz)
{
jack_ringbuffer_read_advance(ringbuffer, size_sz);
if (auto midi = jack_midi_event_reserve(jack_events, 0, sz))
jack_ringbuffer_read(ringbuffer, reinterpret_cast<char*>(midi), sz);
else
jack_ringbuffer_read_advance(ringbuffer, sz);
}
}
jack_ringbuffer_t* ringbuffer{};
std::size_t ringbuffer_space{}; // actual writable size, usually 1 less than ringbuffer
};
class midi_out_jack
: public midi1::out_api
, public jack_helpers
, public jack_midi1
, public error_handler
{
public:
@@ -30,8 +94,7 @@ public:
stdx::error open_port(const output_port& port, std::string_view portName) override
{
if (auto err = create_local_port(*this, portName, port_type, JackPortIsOutput);
err != stdx::error{})
if (auto err = create_local_port(*this, portName, JackPortIsOutput); err != stdx::error{})
return err;
// Connecting to the output
@@ -48,7 +111,7 @@ public:
stdx::error open_virtual_port(std::string_view portName) override
{
return create_local_port(*this, portName, port_type, JackPortIsOutput);
return create_local_port(*this, portName, JackPortIsOutput);
}
stdx::error close_port() override { return do_close_port(); }
@@ -65,7 +128,7 @@ class midi_out_jack_queued final : public midi_out_jack
public:
midi_out_jack_queued(output_configuration&& conf, jack_output_configuration&& apiconf)
: midi_out_jack{std::move(conf), std::move(apiconf)}
, m_queue{configuration.ringbuffer_size}
, queue{configuration.ringbuffer_size}
{
auto status = connect(*this);
if (!this->client)
@@ -87,7 +150,7 @@ public:
stdx::error send_message(const unsigned char* message, std::size_t size) override
{
return m_queue.write(message, size);
return queue.write(message, size);
}
int process(jack_nframes_t nframes)
@@ -95,13 +158,13 @@ public:
void* buff = jack_port_get_buffer(this->port, nframes);
jack_midi_clear_buffer(buff);
this->m_queue.read(buff);
this->queue.read(buff);
return 0;
}
private:
jack_queue m_queue;
jack_queue queue;
};
class midi_out_jack_direct final : public midi_out_jack
include/libremidi/backends/jack/observer.hpp
+7 -6
View File
@@ -10,7 +10,6 @@ namespace libremidi
class observer_jack final
: public observer_api
, private jack_client
, public jack_midi1
, private error_handler
{
public:
@@ -49,7 +48,8 @@ public:
void initial_callback()
{
{
const char** ports = jack_get_ports(client, nullptr, port_type, JackPortIsOutput);
const char** ports
= jack_get_ports(client, nullptr, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput);
if (ports != nullptr)
{
@@ -80,7 +80,8 @@ public:
}
{
const char** ports = jack_get_ports(client, nullptr, port_type, JackPortIsInput);
const char** ports
= jack_get_ports(client, nullptr, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput);
if (ports != nullptr)
{
@@ -118,7 +119,7 @@ public:
if (reg)
{
std::string_view type = jack_port_type(port);
if (type != port_type)
if (type != JACK_DEFAULT_MIDI_TYPE)
return;
bool physical = flags & JackPortIsPhysical;
@@ -198,12 +199,12 @@ public:
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
return get_ports<true>(this->client, nullptr, port_type, JackPortIsOutput, false);
return get_ports<true>(this->client, nullptr, JackPortIsOutput);
}
std::vector<libremidi::output_port> get_output_ports() const noexcept override
{
return get_ports<false>(this->client, nullptr, port_type, JackPortIsInput, false);
return get_ports<false>(this->client, nullptr, JackPortIsInput);
}
~observer_jack()
include/libremidi/backends/jack_ump.hpp
-34
View File
@@ -1,34 +0,0 @@
#pragma once
#include <libremidi/backends/jack_ump/midi_in.hpp>
#include <libremidi/backends/jack_ump/midi_out.hpp>
#include <libremidi/backends/jack_ump/observer.hpp>
#include <string_view>
namespace libremidi::jack_ump
{
struct backend
{
using midi_in = midi_in_jack;
using midi_out = midi_out_jack;
using midi_observer = observer_jack;
using midi_in_configuration = jack_ump::input_configuration;
using midi_out_configuration = jack_ump::output_configuration;
using midi_observer_configuration = jack_ump::observer_configuration;
static const constexpr auto API = libremidi::API::JACK_UMP;
static const constexpr std::string_view name = "jack_ump";
static const constexpr std::string_view display_name = "JACK (UMP)";
static inline bool available() noexcept
{
#if LIBREMIDI_WEAKJACK
if (WeakJack::instance().available() != 0)
return false;
#endif
int major, minor, micro, patch;
jack_get_version(&major, &minor, &micro, &patch);
return (major >= 3 && minor >= 1 && micro >= 4);
}
};
}
include/libremidi/backends/jack_ump/config.hpp
-33
View File
@@ -1,33 +0,0 @@
#pragma once
#include <libremidi/backends/jack/config.hpp>
namespace libremidi::jack_ump
{
struct input_configuration
{
std::string client_name = "libremidi client";
jack_client_t* context{};
std::function<void(libremidi::jack_callback)> set_process_func{};
std::function<void(int64_t)> clear_process_func{};
};
struct output_configuration
{
std::string client_name = "libremidi client";
jack_client_t* context{};
std::function<void(libremidi::jack_callback)> set_process_func{};
std::function<void(int64_t)> clear_process_func{};
int32_t ringbuffer_size = 16384;
bool direct = false;
};
struct observer_configuration
{
std::string client_name = "libremidi client";
jack_client_t* context{};
};
}
include/libremidi/backends/jack_ump/midi_in.hpp
-119
View File
@@ -1,119 +0,0 @@
#pragma once
#include <libremidi/backends/jack/helpers.hpp>
#include <libremidi/backends/jack_ump/config.hpp>
#include <libremidi/detail/midi_in.hpp>
#include <libremidi/detail/midi_stream_decoder.hpp>
namespace libremidi::jack_ump
{
class midi_in_jack final
: public midi2::in_api
, public jack_helpers
, private jack_midi1
, public error_handler
{
public:
using midi_api::client_open_;
struct
: libremidi::ump_input_configuration
, jack_ump::input_configuration
{
} configuration;
explicit midi_in_jack(
libremidi::ump_input_configuration&& conf, jack_ump::input_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
auto status = connect(*this);
if (!this->client)
{
libremidi_handle_error(configuration, "Could not create JACK client");
client_open_ = from_jack_status(status);
return;
}
client_open_ = stdx::error{};
}
~midi_in_jack() override
{
midi_in_jack::close_port();
disconnect(*this);
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::JACK_UMP; }
stdx::error open_port(const input_port& port, std::string_view portName) override
{
if (auto err
= create_local_port(*this, portName, port_type, JackPortFlags(JackPortIsInput | 0x20));
err != stdx::error{})
return err;
if (int err = jack_connect(this->client, port.port_name.c_str(), jack_port_name(this->port));
err != 0 && err != EEXIST)
{
libremidi_handle_error(
configuration,
"could not connect to port: " + port.port_name + " -> " + jack_port_name(this->port));
return from_errc(err);
}
return stdx::error{};
}
stdx::error open_virtual_port(std::string_view portName) override
{
return create_local_port(*this, portName, port_type, JackPortFlags(JackPortIsInput | 0x20));
}
stdx::error close_port() override { return do_close_port(); }
stdx::error set_port_name(std::string_view portName) override
{
int ret = jack_port_rename(this->client, this->port, portName.data());
return from_errc(ret);
}
timestamp absolute_timestamp() const noexcept override
{
return 1000 * jack_frames_to_time(client, jack_frame_time(client));
}
int process(jack_nframes_t nframes)
{
static constexpr timestamp_backend_info timestamp_info{
.has_absolute_timestamps = true,
.absolute_is_monotonic = true,
.has_samples = true,
};
void* buff = jack_port_get_buffer(this->port, nframes);
// Timing
jack_nframes_t current_frames{};
jack_time_t current_usecs{}; // roughly CLOCK_MONOTONIC
jack_time_t next_usecs{};
float period_usecs{};
jack_get_cycle_times(
this->client, &current_frames, &current_usecs, &next_usecs, &period_usecs);
// We have midi events in buffer
uint32_t ev_count = jack_midi_get_event_count(buff);
for (uint32_t j = 0; j < ev_count; j++)
{
jack_midi_event_t event{};
jack_midi_event_get(&event, buff, j);
const auto to_ns
= [=, this] { return 1000 * jack_frames_to_time(client, current_frames + event.time); };
m_processing.on_bytes(
{(uint32_t*)event.buffer, (uint32_t*)(event.buffer + event.size)},
m_processing.timestamp<timestamp_info>(to_ns, event.time));
}
return 0;
}
midi2::input_state_machine m_processing{this->configuration};
};
}
include/libremidi/backends/jack_ump/midi_out.hpp
-184
View File
@@ -1,184 +0,0 @@
#pragma once
#include <libremidi/backends/jack/helpers.hpp>
#include <libremidi/backends/jack_ump/config.hpp>
#include <libremidi/detail/midi_out.hpp>
namespace libremidi::jack_ump
{
class midi_out_jack
: public midi2::out_api
, public jack_helpers
, private jack_midi1
, public error_handler
{
public:
using midi_api::client_open_;
struct
: libremidi::output_configuration
, jack_ump::output_configuration
{
} configuration;
midi_out_jack(libremidi::output_configuration&& conf, jack_ump::output_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
}
~midi_out_jack() override { }
libremidi::API get_current_api() const noexcept override { return libremidi::API::JACK_UMP; }
stdx::error open_port(const output_port& port, std::string_view portName) override
{
if (auto err
= create_local_port(*this, portName, port_type, JackPortFlags(JackPortIsOutput | 0x20));
err != stdx::error{})
return err;
// Connecting to the output
if (int err = jack_connect(this->client, jack_port_name(this->port), port.port_name.c_str());
err != 0 && err != EEXIST)
{
libremidi_handle_error(configuration, "could not connect to port" + port.port_name);
return from_errc(err);
}
return stdx::error{};
}
stdx::error open_virtual_port(std::string_view portName) override
{
return create_local_port(*this, portName, port_type, JackPortFlags(JackPortIsOutput | 0x20));
}
stdx::error close_port() override { return do_close_port(); }
stdx::error set_port_name(std::string_view portName) override
{
int ret = jack_port_rename(this->client, this->port, portName.data());
return from_errc(ret);
}
};
class midi_out_jack_queued final : public midi_out_jack
{
public:
midi_out_jack_queued(
libremidi::output_configuration&& conf, jack_ump::output_configuration&& apiconf)
: midi_out_jack{std::move(conf), std::move(apiconf)}
, m_queue{configuration.ringbuffer_size}
{
auto status = connect(*this);
if (!this->client)
{
libremidi_handle_error(configuration, "Could not create JACK client");
client_open_ = from_jack_status(status);
return;
}
client_open_ = stdx::error{};
}
~midi_out_jack_queued() override
{
midi_out_jack::close_port();
disconnect(*this);
}
stdx::error send_ump(const uint32_t* message, std::size_t size) override
{
return m_queue.write((unsigned char*)message, size * sizeof(uint32_t));
}
int process(jack_nframes_t nframes)
{
void* buff = jack_port_get_buffer(this->port, nframes);
jack_midi_clear_buffer(buff);
this->m_queue.read(buff);
return 0;
}
private:
libremidi::jack_queue m_queue;
};
class midi_out_jack_direct final : public midi_out_jack
{
public:
midi_out_jack_direct(
libremidi::output_configuration&& conf, jack_ump::output_configuration&& apiconf)
: midi_out_jack{std::move(conf), std::move(apiconf)}
{
auto status = connect(*this);
if (!this->client)
{
libremidi_handle_error(configuration, "Could not create JACK client");
client_open_ = from_jack_status(status);
return;
}
buffer_size = jack_get_buffer_size(this->client);
client_open_ = stdx::error{};
}
~midi_out_jack_direct() override
{
midi_out_jack::close_port();
disconnect(*this);
}
int process(jack_nframes_t nframes)
{
void* buff = jack_port_get_buffer(this->port, nframes);
jack_midi_clear_buffer(buff);
return 0;
}
stdx::error send_ump(const uint32_t* message, std::size_t size) override
{
void* buff = jack_port_get_buffer(this->port, buffer_size);
int ret = jack_midi_event_write(buff, 0, (unsigned char*)message, size * sizeof(uint32_t));
return from_errc(ret);
}
int convert_timestamp(int64_t user) const noexcept
{
switch (configuration.timestamps)
{
case timestamp_mode::AudioFrame:
return static_cast<int>(user);
default:
// TODO
return 0;
}
}
stdx::error schedule_ump(int64_t ts, const uint32_t* message, size_t size) override
{
void* buff = jack_port_get_buffer(this->port, buffer_size);
int ret = jack_midi_event_write(
buff, convert_timestamp(ts), (unsigned char*)message, size * sizeof(uint32_t));
return from_errc(ret);
}
int buffer_size{};
};
}
namespace libremidi
{
template <>
inline std::unique_ptr<midi_out_api>
make<jack_ump::midi_out_jack>(output_configuration&& conf, jack_ump::output_configuration&& api)
{
if (api.direct)
return std::make_unique<jack_ump::midi_out_jack_direct>(std::move(conf), std::move(api));
else
return std::make_unique<jack_ump::midi_out_jack_queued>(std::move(conf), std::move(api));
}
}
include/libremidi/backends/jack_ump/observer.hpp
-235
View File
@@ -1,235 +0,0 @@
#pragma once
#include <libremidi/backends/jack/helpers.hpp>
#include <libremidi/backends/jack_ump/config.hpp>
#include <libremidi/detail/observer.hpp>
#include <unordered_set>
namespace libremidi::jack_ump
{
class observer_jack final
: public observer_api
, private jack_client
, private jack_midi1 // seems like a bug in PipeWire? MIDI 2 flag is set but the MIDI 1 type string is used
, private error_handler
{
public:
struct
: libremidi::observer_configuration
, jack_ump::observer_configuration
{
} configuration;
explicit observer_jack(
libremidi::observer_configuration&& conf, jack_ump::observer_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
// Initialize JACK client
if (configuration.context)
{
this->client = configuration.context;
set_callbacks();
}
else
{
jack_status_t status{};
this->client
= jack_client_open(configuration.client_name.c_str(), JackNoStartServer, &status);
if (status != jack_status_t{})
libremidi_handle_error(configuration, std::to_string((int)status));
if (this->client != nullptr)
{
set_callbacks();
jack_activate(this->client);
}
}
}
void initial_callback()
{
{
const char** ports = jack_get_ports(client, nullptr, port_type, JackPortIsOutput);
if (ports != nullptr)
{
int i = 0;
while (ports[i] != nullptr)
{
const auto port = jack_port_by_name(client, ports[i]);
const auto flags = jack_port_flags(port);
if (!(flags & 0x20)) // midi 2 check
{
i++;
continue;
}
bool physical = flags & JackPortIsPhysical;
bool ok = configuration.track_any;
if (configuration.track_hardware)
ok |= physical;
if (configuration.track_virtual)
ok |= !physical;
if (ok)
{
seen_input_ports.insert(ports[i]);
if (this->configuration.input_added && configuration.notify_in_constructor)
this->configuration.input_added(to_port_info<true>(client, port));
}
i++;
}
}
jack_free(ports);
}
{
const char** ports = jack_get_ports(client, nullptr, port_type, JackPortIsInput);
if (ports != nullptr)
{
int i = 0;
while (ports[i] != nullptr)
{
const auto port = jack_port_by_name(client, ports[i]);
const auto flags = jack_port_flags(port);
if (!(flags & 0x20)) // midi 2 check
{
i++;
continue;
}
bool physical = flags & JackPortIsPhysical;
bool ok = configuration.track_any;
if (configuration.track_hardware)
ok |= physical;
if (configuration.track_virtual)
ok |= !physical;
if (ok)
{
seen_output_ports.insert(ports[i]);
if (this->configuration.output_added && configuration.notify_in_constructor)
this->configuration.output_added(to_port_info<false>(client, port));
}
i++;
}
}
jack_free(ports);
}
}
void on_port_callback(jack_port_t* port, bool reg)
{
auto flags = jack_port_flags(port);
std::string name = jack_port_name(port);
if (reg)
{
std::string_view type = jack_port_type(port);
if (type != port_type)
return;
if (!(flags & 0x20)) // midi 2 check
return;
bool physical = flags & JackPortIsPhysical;
bool ok = configuration.track_any;
if (configuration.track_hardware)
ok |= physical;
if (configuration.track_virtual)
ok |= !physical;
if (!ok)
return;
// Note: we keep track of the ports as
// when disconnecting, jack_port_type and jack_port_flags aren't correctly
// set anymore.
if (flags & JackPortIsOutput)
{
seen_input_ports.insert(name);
if (this->configuration.input_added)
this->configuration.input_added(to_port_info<true>(client, port));
}
else if (flags & JackPortIsInput)
{
seen_output_ports.insert(name);
if (this->configuration.output_added)
this->configuration.output_added(to_port_info<false>(client, port));
}
}
else
{
if (auto it = seen_input_ports.find(name); it != seen_input_ports.end())
{
if (this->configuration.input_removed)
this->configuration.input_removed(to_port_info<true>(client, port));
seen_input_ports.erase(it);
}
if (auto it = seen_output_ports.find(name); it != seen_output_ports.end())
{
if (this->configuration.output_removed)
this->configuration.output_removed(to_port_info<false>(client, port));
seen_output_ports.erase(it);
}
}
}
void set_callbacks()
{
initial_callback();
if (!configuration.has_callbacks())
return;
jack_set_port_registration_callback(this->client, +[](jack_port_id_t p, int r, void* arg) {
auto& self = *(observer_jack*)arg;
if (auto port = jack_port_by_id(self.client, p))
{
self.on_port_callback(port, r != 0);
}
}, this);
jack_set_port_rename_callback(
this->client,
+[](jack_port_id_t p, const char* /*old_name*/, const char* /*new_name*/, void* arg) {
const auto& self = *static_cast<observer_jack*>(arg);
auto port = jack_port_by_id(self.client, p);
if (!port)
return;
}, this);
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::JACK_UMP; }
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
return get_ports<true>(this->client, nullptr, port_type, JackPortIsOutput, true);
}
std::vector<libremidi::output_port> get_output_ports() const noexcept override
{
return get_ports<false>(this->client, nullptr, port_type, JackPortIsInput, true);
}
~observer_jack()
{
if (client && !configuration.context)
{
// If we own the client, deactivate it
jack_deactivate(this->client);
jack_client_close(this->client);
this->client = nullptr;
}
}
std::unordered_set<std::string> seen_input_ports;
std::unordered_set<std::string> seen_output_ports;
};
}
include/libremidi/backends/jack_ump/shared_handler.hpp
View File
include/libremidi/backends/keyboard.hpp
+2 -4
View File
@@ -2,8 +2,6 @@
#include <libremidi/backends/dummy.hpp>
#include <libremidi/backends/keyboard/midi_in.hpp>
#include <string_view>
namespace libremidi
{
struct kbd_backend
@@ -15,8 +13,8 @@ struct kbd_backend
using midi_out_configuration = dummy_configuration;
using midi_observer_configuration = dummy_configuration;
static const constexpr auto API = libremidi::API::KEYBOARD;
static const constexpr std::string_view name = "keyboard";
static const constexpr std::string_view display_name = "Computer keyboard";
static const constexpr auto name = "keyboard";
static const constexpr auto display_name = "Computer keyboard";
static inline bool available() noexcept { return true; }
};
include/libremidi/backends/keyboard/config.hpp
+71 -133
View File
@@ -6,128 +6,6 @@
namespace libremidi
{
enum kbd_event
{
NOTE_0 = 0x0, // C
VEL_0 = NOTE_0 + 128, // Set velocity to 0
OCT_0 = VEL_0 + 128, // Set octave to 0
OCTAVE_PLUS = OCT_0 + 128,
OCTAVE_MINUS,
VELOCITY_PLUS,
VELOCITY_MINUS,
};
// Default map
//
// ,---,---,---,---,---,---,---,---,---,---,---,---,---,-------,
// | V0| V1| V2| V3| V4| V5| V6| V7| V8| V9|V10|V11|V12| <- |
// |---'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-----|
// | ->| | | C#| D#| | F#| G#| A#| | C#| D#| | F#| |
// |-----',--',--',--',--',--',--',--',--',--',--',--',--'| |
// | Caps | C | D | E | F | G | A | B | C | D | E | F | G | |
// |----,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'---'----|
// | -^ | | O-| O+| V-| V+| | | | | | | ----^ |
// |----'-,-',--'--,'---'---'---'---'---'---'-,-'---',--,------|
// | ctrl | | alt | |altgr | | ctrl |
// '------' '-----'--------------------------'------' '------'
// clang-format off
// actually based on macOS virtual codes as it seems
// impossible to get raw scan codes.
// https://eastmanreference.com/complete-list-of-applescript-key-codes
static inline const std::map<int, int>& scancode_map_macos(){
static const std::map<int, int> ret{
{ 0, NOTE_0}, // C0
{ 13, NOTE_0 + 1},
{ 1, NOTE_0 + 2},
{ 14, NOTE_0 + 3},
{ 2, NOTE_0 + 4},
{ 3, NOTE_0 + 5},
{ 17, NOTE_0 + 6},
{ 5, NOTE_0 + 7},
{ 16, NOTE_0 + 8},
{ 4, NOTE_0 + 9},
{ 32, NOTE_0 + 10},
{ 38, NOTE_0 + 11},
{ 40, NOTE_0 + 12}, // C1
{ 31, NOTE_0 + 13},
{ 37, NOTE_0 + 14},
{ 35, NOTE_0 + 15},
{ 41, NOTE_0 + 16},
{ 39, NOTE_0 + 17},
{ 30, NOTE_0 + 18},
{ 42, NOTE_0 + 19},
{ 50, VEL_0 + int(0)},
{ 18, VEL_0 + int(1 * 127 / 12)},
{ 19, VEL_0 + int(2 * 127 / 12)},
{ 20, VEL_0 + int(3 * 127 / 12)},
{ 21, VEL_0 + int(4 * 127 / 12)},
{ 23, VEL_0 + int(5 * 127 / 12)},
{ 22, VEL_0 + int(6 * 127 / 12)},
{ 26, VEL_0 + int(7 * 127 / 12)},
{ 28, VEL_0 + int(8 * 127 / 12)},
{ 25, VEL_0 + int(9 * 127 / 12)},
{ 29, VEL_0 + int(10 * 127 / 12)},
{ 27, VEL_0 + int(11 * 127 / 12)},
{ 24, VEL_0 + int(127)},
{ 6, OCTAVE_MINUS },
{ 7, OCTAVE_PLUS },
{ 8, VELOCITY_MINUS },
{ 9, VELOCITY_PLUS},
};
return ret;
}
// Use: https://kbdlayout.info/KBDUSX/scancodes
// Also valid for windows
static inline const std::map<int, int>& scancode_map_linux() {
static const std::map<int, int> ret{
{ 0x1E, NOTE_0}, // C0
{ 0x11, NOTE_0 + 1},
{ 0x1F, NOTE_0 + 2},
{ 0x12, NOTE_0 + 3},
{ 0x20, NOTE_0 + 4},
{ 0x21, NOTE_0 + 5},
{ 0x14, NOTE_0 + 6},
{ 0x22, NOTE_0 + 7},
{ 0x15, NOTE_0 + 8},
{ 0x23, NOTE_0 + 9},
{ 0x16, NOTE_0 + 10},
{ 0x24, NOTE_0 + 11},
{ 0x25, NOTE_0 + 12}, // C1
{ 0x18, NOTE_0 + 13},
{ 0x26, NOTE_0 + 14},
{ 0x19, NOTE_0 + 15},
{ 0x27, NOTE_0 + 16},
{ 0x28, NOTE_0 + 17},
{ 0x1B, NOTE_0 + 18},
{ 0x2B, NOTE_0 + 19},
{ 0x29, VEL_0 + int(0)},
{ 0x02, VEL_0 + int(1 * 127 / 12)},
{ 0x03, VEL_0 + int(2 * 127 / 12)},
{ 0x04, VEL_0 + int(3 * 127 / 12)},
{ 0x05, VEL_0 + int(4 * 127 / 12)},
{ 0x06, VEL_0 + int(5 * 127 / 12)},
{ 0x07, VEL_0 + int(6 * 127 / 12)},
{ 0x08, VEL_0 + int(7 * 127 / 12)},
{ 0x09, VEL_0 + int(8 * 127 / 12)},
{ 0x0A, VEL_0 + int(9 * 127 / 12)},
{ 0x0B, VEL_0 + int(10 * 127 / 12)},
{ 0x0C, VEL_0 + int(11 * 127 / 12)},
{ 0x0D, VEL_0 + int(127)},
{ 0x2C, OCTAVE_MINUS },
{ 0x2D, OCTAVE_PLUS },
{ 0x2E, VELOCITY_MINUS },
{ 0x2F, VELOCITY_PLUS},
};
return ret;
}
// clang-format on
/**
* Used to set up keyboard input.
* Your app should pass a function that will give you a callback
@@ -135,20 +13,80 @@ static inline const std::map<int, int>& scancode_map_linux() {
*/
struct kbd_input_configuration
{
// Note that on Linux with X11 scancodes should be offset by 8 (an X11 legacy quirk)
// ex.: pass QKeyEvent::nativeScanCode() - 8 to this API
using scancode_callback = std::function<void(int)>;
// First argument is on key press, second on key release
std::function<void(scancode_callback, scancode_callback)> set_input_scancode_callbacks
= [](const scancode_callback&, const scancode_callback&) { };
= [](scancode_callback, scancode_callback) {};
std::map<int, int> scancode_map
#if defined(__APPLE__)
= scancode_map_macos()
#else
= scancode_map_linux()
#endif
;
enum kbd_event
{
NOTE_0 = 0x0, // C
VEL_0 = NOTE_0 + 128, // Set velocity to 0
OCT_0 = VEL_0 + 128, // Set octave to 0
OCTAVE_PLUS = OCT_0 + 128,
OCTAVE_MINUS,
VELOCITY_PLUS,
VELOCITY_MINUS,
};
// Default map
//
// ,---,---,---,---,---,---,---,---,---,---,---,---,---,-------,
// | V0| V1| V2| V3| V4| V5| V6| V7| V8| V9|V10|V11|V12| <- |
// |---'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-----|
// | ->| | | C#| D#| | F#| G#| A#| | C#| D#| | F#| |
// |-----',--',--',--',--',--',--',--',--',--',--',--',--'| |
// | Caps | C | D | E | F | G | A | B | C | D | E | F | G | |
// |----,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'-,-'---'----|
// | -^ | | O-| O+| V-| V+| | | | | | | ----^ |
// |----'-,-',--'--,'---'---'---'---'---'---'-,-'---',--,------|
// | ctrl | | alt | |altgr | | ctrl |
// '------' '-----'--------------------------'------' '------'
// clang-format off
// Use: https://kbdlayout.info/KBDUSX/scancodes
std::map<int, int> scancode_map{
{ 0x1E, NOTE_0}, // C0
{ 0x11, NOTE_0 + 1},
{ 0x1F, NOTE_0 + 2},
{ 0x12, NOTE_0 + 3},
{ 0x20, NOTE_0 + 4},
{ 0x21, NOTE_0 + 5},
{ 0x14, NOTE_0 + 6},
{ 0x22, NOTE_0 + 7},
{ 0x15, NOTE_0 + 8},
{ 0x23, NOTE_0 + 9},
{ 0x16, NOTE_0 + 10},
{ 0x24, NOTE_0 + 11},
{ 0x25, NOTE_0 + 12}, // C1
{ 0x18, NOTE_0 + 13},
{ 0x26, NOTE_0 + 14},
{ 0x19, NOTE_0 + 15},
{ 0x27, NOTE_0 + 16},
{ 0x28, NOTE_0 + 17},
{ 0x1B, NOTE_0 + 18},
{ 0x2B, NOTE_0 + 19},
{ 0x29, VEL_0 + int(0)},
{ 0x02, VEL_0 + int(1 * 127 / 12)},
{ 0x03, VEL_0 + int(2 * 127 / 12)},
{ 0x04, VEL_0 + int(3 * 127 / 12)},
{ 0x05, VEL_0 + int(4 * 127 / 12)},
{ 0x06, VEL_0 + int(5 * 127 / 12)},
{ 0x07, VEL_0 + int(6 * 127 / 12)},
{ 0x08, VEL_0 + int(7 * 127 / 12)},
{ 0x09, VEL_0 + int(8 * 127 / 12)},
{ 0x0A, VEL_0 + int(9 * 127 / 12)},
{ 0x0B, VEL_0 + int(10 * 127 / 12)},
{ 0x0C, VEL_0 + int(11 * 127 / 12)},
{ 0x0D, VEL_0 + int(127)},
{ 0x2C, OCTAVE_MINUS },
{ 0x2D, OCTAVE_PLUS },
{ 0x2E, VELOCITY_MINUS },
{ 0x2F, VELOCITY_PLUS},
};
// clang-format on
};
}
include/libremidi/backends/keyboard/midi_in.hpp
+8 -8
View File
@@ -22,22 +22,22 @@ public:
explicit midi_in_kbd(input_configuration&& conf, kbd_input_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
configuration.set_input_scancode_callbacks(
[this](int v) { on_keypress(v); }, [this](int v) { on_keyrelease(v); });
}
~midi_in_kbd() override { }
libremidi::API get_current_api() const noexcept override { return libremidi::API::KEYBOARD; }
stdx::error open_port(const input_port&, std::string_view) override
{
configuration.set_input_scancode_callbacks(
[this](int v) { on_keypress(v); }, [this](int v) { on_keyrelease(v); });
stdx::error open_port(const input_port&, std::string_view) override { return stdx::error{}; }
return stdx::error{};
}
stdx::error open_virtual_port(std::string_view) override { return stdx::error{}; }
stdx::error close_port() override { return stdx::error{}; }
stdx::error set_port_name(std::string_view) override { return stdx::error{}; }
timestamp absolute_timestamp() const noexcept override
{
return std::chrono::steady_clock::now().time_since_epoch().count();
@@ -45,7 +45,7 @@ public:
void on_keypress(int scancode)
{
using kevent = libremidi::kbd_event;
using kevent = kbd_input_configuration::kbd_event;
auto it = configuration.scancode_map.find(scancode);
if (it == configuration.scancode_map.end())
@@ -88,7 +88,7 @@ public:
void on_keyrelease(int scancode)
{
using kevent = libremidi::kbd_event;
using kevent = kbd_input_configuration::kbd_event;
auto it = configuration.scancode_map.find(scancode);
if (it == configuration.scancode_map.end())
include/libremidi/backends/linux/alsa.hpp
+1 -3
View File
@@ -2,7 +2,7 @@
#include <libremidi/backends/linux/dylib_loader.hpp>
#include <alsa/asoundlib.h> // IWYU pragma: export
#include <alsa/asoundlib.h>
#if defined(SND_LIB_VERSION)
#if __has_include(<alsa/rawmidi.h>) && SND_LIB_VERSION >= ((1 << 16) | (2 << 8) | 6)
@@ -241,7 +241,6 @@ struct libasound
LIBREMIDI_SYMBOL_INIT(snd_seq, client_id)
LIBREMIDI_SYMBOL_INIT(snd_seq, client_info_get_client)
LIBREMIDI_SYMBOL_INIT(snd_seq, client_info_get_name)
LIBREMIDI_SYMBOL_INIT(snd_seq, client_info_get_card)
LIBREMIDI_SYMBOL_INIT(snd_seq, client_info_set_client)
LIBREMIDI_SYMBOL_INIT(snd_seq, client_info_sizeof)
LIBREMIDI_SYMBOL_INIT(snd_seq, close)
@@ -299,7 +298,6 @@ struct libasound
LIBREMIDI_SYMBOL_DEF(snd_seq, client_id)
LIBREMIDI_SYMBOL_DEF(snd_seq, client_info_get_client)
LIBREMIDI_SYMBOL_DEF(snd_seq, client_info_get_name)
LIBREMIDI_SYMBOL_DEF(snd_seq, client_info_get_card)
LIBREMIDI_SYMBOL_DEF(snd_seq, client_info_set_client)
LIBREMIDI_SYMBOL_DEF(snd_seq, client_info_sizeof)
LIBREMIDI_SYMBOL_DEF(snd_seq, close)
include/libremidi/backends/linux/pipewire.hpp
+34 -43
View File
@@ -12,8 +12,6 @@ namespace libremidi
class libpipewire
{
public:
decltype(&::pw_get_library_version) get_library_version{};
decltype(&::pw_init) init{};
decltype(&::pw_deinit) deinit{};
@@ -69,12 +67,12 @@ public:
bool available{true};
private:
dylib_loader m_library;
dylib_loader library;
libpipewire()
: m_library("libpipewire-0.3.so.0")
: library("libpipewire-0.3.so.0")
{
if (!m_library)
if (!library)
{
available = false;
return;
@@ -83,59 +81,52 @@ private:
// in terms of regex:
// decltype\(&::([a-z_]+)\) [a-z_]+{};
// \1 = library.symbol<decltype(&::\1)>("\1");
get_library_version
= m_library.symbol<decltype(&::pw_get_library_version)>("pw_get_library_version");
init = library.symbol<decltype(&::pw_init)>("pw_init");
deinit = library.symbol<decltype(&::pw_deinit)>("pw_deinit");
init = m_library.symbol<decltype(&::pw_init)>("pw_init");
deinit = m_library.symbol<decltype(&::pw_deinit)>("pw_deinit");
context_new = library.symbol<decltype(&::pw_context_new)>("pw_context_new");
context_connect = library.symbol<decltype(&::pw_context_connect)>("pw_context_connect");
context_destroy = library.symbol<decltype(&::pw_context_destroy)>("pw_context_destroy");
context_new = m_library.symbol<decltype(&::pw_context_new)>("pw_context_new");
context_connect = m_library.symbol<decltype(&::pw_context_connect)>("pw_context_connect");
context_destroy = m_library.symbol<decltype(&::pw_context_destroy)>("pw_context_destroy");
core_disconnect = m_library.symbol<decltype(&::pw_core_disconnect)>("pw_core_disconnect");
core_disconnect = library.symbol<decltype(&::pw_core_disconnect)>("pw_core_disconnect");
proxy_add_listener
= m_library.symbol<decltype(&::pw_proxy_add_listener)>("pw_proxy_add_listener");
proxy_destroy = m_library.symbol<decltype(&::pw_proxy_destroy)>("pw_proxy_destroy");
= library.symbol<decltype(&::pw_proxy_add_listener)>("pw_proxy_add_listener");
proxy_destroy = library.symbol<decltype(&::pw_proxy_destroy)>("pw_proxy_destroy");
main_loop_new = m_library.symbol<decltype(&::pw_main_loop_new)>("pw_main_loop_new");
main_loop_destroy
= m_library.symbol<decltype(&::pw_main_loop_destroy)>("pw_main_loop_destroy");
main_loop_quit = m_library.symbol<decltype(&::pw_main_loop_quit)>("pw_main_loop_quit");
main_loop_run = m_library.symbol<decltype(&::pw_main_loop_run)>("pw_main_loop_run");
main_loop_new = library.symbol<decltype(&::pw_main_loop_new)>("pw_main_loop_new");
main_loop_destroy = library.symbol<decltype(&::pw_main_loop_destroy)>("pw_main_loop_destroy");
main_loop_quit = library.symbol<decltype(&::pw_main_loop_quit)>("pw_main_loop_quit");
main_loop_run = library.symbol<decltype(&::pw_main_loop_run)>("pw_main_loop_run");
main_loop_get_loop
= m_library.symbol<decltype(&::pw_main_loop_get_loop)>("pw_main_loop_get_loop");
= library.symbol<decltype(&::pw_main_loop_get_loop)>("pw_main_loop_get_loop");
properties_new = m_library.symbol<decltype(&::pw_properties_new)>("pw_properties_new");
properties_free = m_library.symbol<decltype(&::pw_properties_free)>("pw_properties_free");
properties_get = m_library.symbol<decltype(&::pw_properties_get)>("pw_properties_get");
properties_new = library.symbol<decltype(&::pw_properties_new)>("pw_properties_new");
properties_free = library.symbol<decltype(&::pw_properties_free)>("pw_properties_free");
properties_get = library.symbol<decltype(&::pw_properties_get)>("pw_properties_get");
filter_new_simple
= m_library.symbol<decltype(&::pw_filter_new_simple)>("pw_filter_new_simple");
filter_new_simple = library.symbol<decltype(&::pw_filter_new_simple)>("pw_filter_new_simple");
filter_get_node_id
= m_library.symbol<decltype(&::pw_filter_get_node_id)>("pw_filter_get_node_id");
= library.symbol<decltype(&::pw_filter_get_node_id)>("pw_filter_get_node_id");
filter_get_properties
= m_library.symbol<decltype(&::pw_filter_get_properties)>("pw_filter_get_properties");
filter_add_port = m_library.symbol<decltype(&::pw_filter_add_port)>("pw_filter_add_port");
= library.symbol<decltype(&::pw_filter_get_properties)>("pw_filter_get_properties");
filter_add_port = library.symbol<decltype(&::pw_filter_add_port)>("pw_filter_add_port");
filter_remove_port
= m_library.symbol<decltype(&::pw_filter_remove_port)>("pw_filter_remove_port");
filter_update_properties = m_library.symbol<decltype(&::pw_filter_update_properties)>(
"pw_filter_update_properties");
= library.symbol<decltype(&::pw_filter_remove_port)>("pw_filter_remove_port");
filter_update_properties
= library.symbol<decltype(&::pw_filter_update_properties)>("pw_filter_update_properties");
filter_update_params
= m_library.symbol<decltype(&::pw_filter_update_params)>("pw_filter_update_params");
filter_get_time = m_library.symbol<decltype(&::pw_filter_get_time)>("pw_filter_get_time");
filter_destroy = m_library.symbol<decltype(&::pw_filter_destroy)>("pw_filter_destroy");
filter_connect = m_library.symbol<decltype(&::pw_filter_connect)>("pw_filter_connect");
= library.symbol<decltype(&::pw_filter_update_params)>("pw_filter_update_params");
filter_get_time = library.symbol<decltype(&::pw_filter_get_time)>("pw_filter_get_time");
filter_destroy = library.symbol<decltype(&::pw_filter_destroy)>("pw_filter_destroy");
filter_connect = library.symbol<decltype(&::pw_filter_connect)>("pw_filter_connect");
filter_get_dsp_buffer
= m_library.symbol<decltype(&::pw_filter_get_dsp_buffer)>("pw_filter_get_dsp_buffer");
= library.symbol<decltype(&::pw_filter_get_dsp_buffer)>("pw_filter_get_dsp_buffer");
filter_dequeue_buffer
= m_library.symbol<decltype(&::pw_filter_dequeue_buffer)>("pw_filter_dequeue_buffer");
= library.symbol<decltype(&::pw_filter_dequeue_buffer)>("pw_filter_dequeue_buffer");
filter_queue_buffer
= m_library.symbol<decltype(&::pw_filter_queue_buffer)>("pw_filter_queue_buffer");
filter_flush = m_library.symbol<decltype(&::pw_filter_flush)>("pw_filter_flush");
assert(get_library_version);
= library.symbol<decltype(&::pw_filter_queue_buffer)>("pw_filter_queue_buffer");
filter_flush = library.symbol<decltype(&::pw_filter_flush)>("pw_filter_flush");
assert(init);
assert(deinit);
include/libremidi/backends/linux/udev.hpp
-102
View File
@@ -1,12 +1,10 @@
#pragma once
#include <libremidi/backends/linux/dylib_loader.hpp>
#include <libremidi/backends/linux/helpers.hpp>
#include <libremidi/observer_configuration.hpp>
#include <libudev.h>
#include <cassert>
#include <optional>
namespace libremidi
{
@@ -27,28 +25,12 @@ struct libudev
LIBREMIDI_SYMBOL_INIT(udev, device_get_action)
LIBREMIDI_SYMBOL_INIT(udev, device_get_subsystem)
LIBREMIDI_SYMBOL_INIT(udev, device_get_property_value)
LIBREMIDI_SYMBOL_INIT(udev, device_new_from_syspath)
LIBREMIDI_SYMBOL_INIT(udev, device_get_parent_with_subsystem_devtype)
LIBREMIDI_SYMBOL_INIT(udev, device_unref)
LIBREMIDI_SYMBOL_INIT(udev, monitor_enable_receiving)
LIBREMIDI_SYMBOL_INIT(udev, monitor_get_fd)
LIBREMIDI_SYMBOL_INIT(udev, monitor_new_from_netlink)
LIBREMIDI_SYMBOL_INIT(udev, monitor_receive_device)
LIBREMIDI_SYMBOL_INIT(udev, monitor_unref)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_new)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_unref)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_add_match_is_initialized)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_add_match_subsystem)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_add_match_sysname)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_scan_devices)
LIBREMIDI_SYMBOL_INIT(udev, enumerate_get_list_entry)
LIBREMIDI_SYMBOL_INIT(udev, list_entry_get_name)
LIBREMIDI_SYMBOL_INIT(udev, list_entry_get_next)
LIBREMIDI_SYMBOL_INIT2(udev, new, create)
LIBREMIDI_SYMBOL_INIT(udev, unref)
}
@@ -64,28 +46,12 @@ struct libudev
LIBREMIDI_SYMBOL_DEF(udev, device_get_action)
LIBREMIDI_SYMBOL_DEF(udev, device_get_subsystem)
LIBREMIDI_SYMBOL_DEF(udev, device_new_from_syspath)
LIBREMIDI_SYMBOL_DEF(udev, device_get_property_value)
LIBREMIDI_SYMBOL_DEF(udev, device_get_parent_with_subsystem_devtype)
LIBREMIDI_SYMBOL_DEF(udev, device_unref)
LIBREMIDI_SYMBOL_DEF(udev, monitor_enable_receiving)
LIBREMIDI_SYMBOL_DEF(udev, monitor_get_fd)
LIBREMIDI_SYMBOL_DEF(udev, monitor_new_from_netlink)
LIBREMIDI_SYMBOL_DEF(udev, monitor_receive_device)
LIBREMIDI_SYMBOL_DEF(udev, monitor_unref)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_new)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_unref)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_add_match_is_initialized)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_add_match_subsystem)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_add_match_sysname)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_scan_devices)
LIBREMIDI_SYMBOL_DEF(udev, enumerate_get_list_entry)
LIBREMIDI_SYMBOL_DEF(udev, list_entry_get_name)
LIBREMIDI_SYMBOL_DEF(udev, list_entry_get_next)
LIBREMIDI_SYMBOL_DEF2(udev, new, create)
LIBREMIDI_SYMBOL_DEF(udev, unref)
};
@@ -123,72 +89,4 @@ struct udev_helper
udev_monitor* monitor{};
};
struct udev_enumerator
{
explicit udev_enumerator(const udev_helper& h)
: helper{h}
{
auto& udev = helper.udev;
auto& instance = helper.instance;
enumerator = udev.enumerate_new(instance);
assert(enumerator);
}
~udev_enumerator()
{
auto& udev = helper.udev;
udev.enumerate_unref(enumerator);
}
const udev_helper& helper;
udev_enumerate* enumerator{};
operator udev_enumerate*() const noexcept { return enumerator; }
};
struct udev_soundcard_info
{
container_identifier container;
device_identifier path;
port_information::port_type type{};
};
inline udev_soundcard_info get_udev_soundcard_info(const udev_helper& helper, int card)
{
auto& udev = helper.udev;
udev_enumerator e{helper};
udev.enumerate_add_match_subsystem(e, "sound");
udev.enumerate_add_match_sysname(e, ("controlC" + std::to_string(card)).c_str());
if (udev.enumerate_scan_devices(e) != 0)
return {};
for (auto entry = udev.enumerate_get_list_entry(e); entry;
entry = udev.list_entry_get_next(entry))
{
auto path = udev.list_entry_get_name(entry);
if (!path)
continue;
auto dev = udev.device_new_from_syspath(helper.instance, path);
if (!dev)
continue;
const auto usb_device
= udev.device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");
port_information::port_type type = port_information::port_type::hardware;
if (usb_device)
type = (port_information::port_type)(type | port_information::port_type::usb);
else
type = (port_information::port_type)(type | port_information::port_type::pci);
auto id_path = udev.device_get_property_value(dev, "ID_PATH");
if (!id_path)
id_path = "";
auto ret = udev_soundcard_info{.container = id_path, .path = path, .type = type};
udev.device_unref(dev);
return ret;
}
return {};
}
}
include/libremidi/backends/net/helpers.hpp
+12 -15
View File
@@ -42,34 +42,31 @@ struct optionally_owned
{
public:
explicit optionally_owned(T* maybe_existing)
: m_storage{.ref = maybe_existing}
: storage{.ref = maybe_existing}
{
if (m_storage.ref)
if (storage.ref)
{
m_ownership = unowned;
ownership = unowned;
return;
}
else
{
std::destroy_at(&m_storage.ref);
std::construct_at<T>(reinterpret_cast<T*>(m_storage.object));
m_ownership = owned;
std::destroy_at(&storage.ref);
std::construct_at<T>(reinterpret_cast<T*>(storage.object));
ownership = owned;
}
}
~optionally_owned()
{
if (is_owned())
std::destroy_at(reinterpret_cast<T*>(m_storage.object));
std::destroy_at(reinterpret_cast<T*>(storage.object));
}
T& get() noexcept
{
return *(is_owned() ? reinterpret_cast<T*>(&m_storage.object) : m_storage.ref);
}
T& get() noexcept { return *(is_owned() ? reinterpret_cast<T*>(&storage.object) : storage.ref); }
const T& get() const noexcept
{
return *(is_owned() ? reinterpret_cast<T*>(&m_storage.object) : m_storage.ref);
return *(is_owned() ? reinterpret_cast<T*>(&storage.object) : storage.ref);
}
optionally_owned(const optionally_owned&) = delete;
@@ -77,18 +74,18 @@ public:
optionally_owned& operator=(const optionally_owned&) = delete;
optionally_owned& operator=(optionally_owned&&) noexcept = delete;
bool is_owned() const noexcept { return m_ownership == owned; }
bool is_owned() const noexcept { return ownership == owned; }
private:
union
{
alignas(T) unsigned char object[sizeof(T)];
T* ref;
} m_storage;
} storage;
enum
{
owned,
unowned
} m_ownership{};
} ownership{};
};
}
include/libremidi/backends/net/midi_in.hpp
+4 -1
View File
@@ -4,7 +4,6 @@
#include <libremidi/detail/midi_in.hpp>
#include <libremidi/detail/midi_stream_decoder.hpp>
#include <thread>
namespace libremidi
{
template <typename Impl, typename F>
@@ -220,6 +219,8 @@ public:
return {};
}
stdx::error set_port_name(std::string_view) override { return stdx::error{}; }
timestamp absolute_timestamp() const noexcept override
{
return std::chrono::steady_clock::now().time_since_epoch().count();
@@ -393,6 +394,8 @@ public:
return {};
}
stdx::error set_port_name(std::string_view) override { return stdx::error{}; }
timestamp absolute_timestamp() const noexcept override
{
return std::chrono::steady_clock::now().time_since_epoch().count();
include/libremidi/backends/network.hpp
+2 -4
View File
@@ -5,8 +5,6 @@
#include <libremidi/backends/net/midi_out.hpp>
#include <libremidi/backends/net/observer.hpp>
#include <string_view>
namespace libremidi::net
{
struct backend
@@ -18,8 +16,8 @@ struct backend
using midi_out_configuration = libremidi::net::dgram_output_configuration;
using midi_observer_configuration = libremidi::net::net_observer_configuration;
static const constexpr auto API = libremidi::API::NETWORK;
static const constexpr std::string_view name = "network";
static const constexpr std::string_view display_name = "Network";
static const constexpr auto name = "network";
static const constexpr auto display_name = "Network";
static inline bool available() noexcept { return true; }
};
include/libremidi/backends/network_ump.hpp
+2 -4
View File
@@ -4,8 +4,6 @@
#include <libremidi/backends/net/midi_out.hpp>
#include <libremidi/backends/net/observer.hpp>
#include <string_view>
namespace libremidi::net_ump
{
struct backend
@@ -17,8 +15,8 @@ struct backend
using midi_out_configuration = libremidi::net_ump::dgram_output_configuration;
using midi_observer_configuration = libremidi::net_ump::net_observer_configuration;
static const constexpr auto API = libremidi::API::NETWORK_UMP;
static const constexpr std::string_view name = "network (UMP)";
static const constexpr std::string_view display_name = "Network (UMP)";
static const constexpr auto name = "network (UMP)";
static const constexpr auto display_name = "Network (UMP)";
static inline bool available() noexcept { return true; }
};
include/libremidi/backends/pipewire.hpp
+2 -4
View File
@@ -7,8 +7,6 @@
#include <libremidi/backends/pipewire/midi_out.hpp>
#include <libremidi/backends/pipewire/observer.hpp>
#include <string_view>
namespace libremidi::pipewire
{
struct backend
@@ -20,8 +18,8 @@ struct backend
using midi_out_configuration = pipewire_output_configuration;
using midi_observer_configuration = pipewire_observer_configuration;
static const constexpr auto API = libremidi::API::PIPEWIRE;
static const constexpr std::string_view name = "pipewire";
static const constexpr std::string_view display_name = "PipeWire";
static const constexpr auto name = "pipewire";
static const constexpr auto display_name = "PipeWire";
static inline bool available() noexcept
{
include/libremidi/backends/pipewire/context.hpp
+12 -18
View File
@@ -18,7 +18,6 @@
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include <spa/param/audio/format-utils.h>
@@ -80,11 +79,11 @@ struct pipewire_context
struct graph
{
mutable std::mutex mtx;
libremidi::hash_map<uint64_t, node> physical_audio;
libremidi::hash_map<uint64_t, node> physical_midi;
libremidi::hash_map<uint64_t, node> software_audio;
libremidi::hash_map<uint64_t, node> software_midi;
libremidi::hash_map<uint64_t, port_info> port_cache;
libremidi::hash_map<uint32_t, node> physical_audio;
libremidi::hash_map<uint32_t, node> physical_midi;
libremidi::hash_map<uint32_t, node> software_audio;
libremidi::hash_map<uint32_t, node> software_midi;
libremidi::hash_map<uint32_t, port_info> port_cache;
void for_each_port(auto func)
{
@@ -124,7 +123,7 @@ struct pipewire_context
}
explicit pipewire_context(std::shared_ptr<pipewire_instance> inst)
: global_instance{std::move(inst)}
: global_instance{inst}
, owns_main_loop{true}
{
this->main_loop = pw.main_loop_new(nullptr);
@@ -288,7 +287,7 @@ struct pipewire_context
spa_hook_remove(&core_listener);
}
[[nodiscard]] pw_proxy* link_ports(uint64_t out_port, uint64_t in_port)
[[nodiscard]] pw_proxy* link_ports(uint32_t out_port, uint32_t in_port)
{
auto props = pw.properties_new(
PW_KEY_LINK_OUTPUT_PORT, std::to_string(out_port).c_str(), PW_KEY_LINK_INPUT_PORT,
@@ -362,8 +361,6 @@ struct pipewire_context
return &this->current_graph.physical_audio[nid];
else if (p.format.find("midi") != p.format.npos)
return &this->current_graph.physical_midi[nid];
else if (p.format.find("UMP") != p.format.npos)
return &this->current_graph.physical_midi[nid];
}
else
{
@@ -371,8 +368,6 @@ struct pipewire_context
return &this->current_graph.software_audio[nid];
else if (p.format.find("midi") != p.format.npos)
return &this->current_graph.software_midi[nid];
else if (p.format.find("UMP") != p.format.npos)
return &this->current_graph.software_midi[nid];
}
return nullptr;
};
@@ -458,12 +453,12 @@ struct pipewire_filter
}* port{};
explicit pipewire_filter(std::shared_ptr<pipewire_context> loop)
: loop{std::move(loop)}
: loop{loop}
{
}
explicit pipewire_filter(std::shared_ptr<pipewire_context> loop, pw_filter* filter)
: loop{std::move(loop)}
: loop{loop}
, filter{filter}
{
}
@@ -503,8 +498,7 @@ struct pipewire_filter
pw.filter_destroy(this->filter);
}
stdx::error
create_local_port(std::string_view port_name, spa_direction direction, const char* format)
stdx::error create_local_port(std::string_view port_name, spa_direction direction)
{
// clang-format off
this->port = (struct port*)pw.filter_add_port(
@@ -513,7 +507,7 @@ struct pipewire_filter
PW_FILTER_PORT_FLAG_MAP_BUFFERS,
sizeof(struct port),
pw.properties_new(
PW_KEY_FORMAT_DSP, format,
PW_KEY_FORMAT_DSP, "8 bit raw midi",
PW_KEY_PORT_NAME, port_name.data(),
nullptr),
nullptr, 0);
@@ -523,7 +517,7 @@ struct pipewire_filter
return stdx::error{};
}
void set_port_buffer(int64_t bytes)
void set_port_buffer(int bytes)
{
uint8_t buffer[1024];
struct spa_pod_builder builder;
include/libremidi/backends/pipewire/helpers.hpp
+17 -20
View File
@@ -9,6 +9,8 @@
#include <libremidi/detail/semaphore.hpp>
#include <atomic>
#include <semaphore>
#include <stop_token>
#include <thread>
namespace libremidi
@@ -64,14 +66,14 @@ struct pipewire_helpers
{
this->filter = std::make_unique<pipewire_filter>(this->global_context, configuration.filter);
libremidi::pipewire_callback cbs{
pipewire_callback cbs{
.token = this_instance,
.callback = [&self, p = std::weak_ptr{canary}](spa_io_position* nf) -> void {
if (auto pt = p.lock())
self.process(nf);
if (auto pt = p.lock())
self.process(nf);
self.thread_lock.check_client_released();
}};
self.thread_lock.check_client_released();
}};
configuration.set_process_func(cbs);
}
else
@@ -195,8 +197,7 @@ struct pipewire_helpers
}
template <typename Self>
stdx::error create_local_port(
Self& self, std::string_view portName, spa_direction direction, const char* format)
stdx::error create_local_port(Self& self, std::string_view portName, spa_direction direction)
{
assert(this->global_context);
assert(this->filter);
@@ -206,7 +207,7 @@ struct pipewire_helpers
if (!this->filter->port)
{
auto ret = this->filter->create_local_port(portName.data(), direction, format);
auto ret = this->filter->create_local_port(portName.data(), direction);
if (ret != stdx::error{})
{
self.libremidi_handle_error(self.configuration, "error creating port");
@@ -217,11 +218,11 @@ struct pipewire_helpers
return stdx::error{};
}
void add_callbacks(std::string format, const observer_configuration& conf)
void add_callbacks(const observer_configuration& conf)
{
assert(global_context);
global_context->on_port_added = [format, &conf](const pipewire_context::port_info& port) {
if (port.format.find(format) == std::string::npos)
global_context->on_port_added = [&conf](const pipewire_context::port_info& port) {
if (port.format.find("midi") == std::string::npos)
return;
bool unfiltered = conf.track_any;
@@ -242,8 +243,8 @@ struct pipewire_helpers
}
};
global_context->on_port_removed = [format, &conf](const pipewire_context::port_info& port) {
if (port.format.find(format) == std::string::npos)
global_context->on_port_removed = [&conf](const pipewire_context::port_info& port) {
if (port.format.find("midi") == std::string::npos)
return;
bool unfiltered = conf.track_any;
@@ -436,9 +437,7 @@ struct pipewire_helpers
// Note: keep in mind that an "input" port for us (e.g. a keyboard that goes to the computer)
// is an "output" port from the point of view of pipewire as data will come out of it
template <spa_direction Direction>
static auto get_ports(
std::string_view format, const observer_configuration& conf,
const pipewire_context& ctx) noexcept
static auto get_ports(const observer_configuration& conf, const pipewire_context& ctx) noexcept
-> std::vector<
std::conditional_t<Direction == SPA_DIRECTION_OUTPUT, input_port, output_port>>
{
@@ -453,8 +452,7 @@ struct pipewire_helpers
for (auto& port :
(Direction == SPA_DIRECTION_INPUT ? node.second.inputs : node.second.outputs))
{
if (port.format.find(format) != std::string::npos)
ret.push_back(to_port_info<Direction>(port));
ret.push_back(to_port_info<Direction>(port));
}
}
@@ -464,8 +462,7 @@ struct pipewire_helpers
for (auto& port :
(Direction == SPA_DIRECTION_INPUT ? node.second.inputs : node.second.outputs))
{
if (port.format.find(format) != std::string::npos)
ret.push_back(to_port_info<Direction>(port));
ret.push_back(to_port_info<Direction>(port));
}
}
}
include/libremidi/backends/pipewire/midi_in.hpp
+2 -4
View File
@@ -47,8 +47,7 @@ public:
stdx::error open_port(const input_port& in_port, std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT, "8 bit raw midi");
err != stdx::error{})
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT); err != stdx::error{})
return err;
if (auto err = link_ports(*this, in_port); err != stdx::error{})
@@ -60,8 +59,7 @@ public:
stdx::error open_virtual_port(std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT, "8 bit raw midi");
err != stdx::error{})
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT); err != stdx::error{})
return err;
start_thread();
include/libremidi/backends/pipewire/midi_out.hpp
+6 -7
View File
@@ -5,6 +5,8 @@
#include <readerwriterqueue.h>
#include <semaphore>
namespace libremidi
{
class midi_out_pipewire
@@ -48,8 +50,7 @@ public:
stdx::error open_port(const output_port& out_port, std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT, "8 bit raw midi");
err != stdx::error{})
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT); err != stdx::error{})
return err;
this->filter->set_port_buffer(configuration.output_buffer_size);
@@ -63,8 +64,7 @@ public:
stdx::error open_virtual_port(std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT, "8 bit raw midi");
err != stdx::error{})
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT); err != stdx::error{})
return err;
this->filter->set_port_buffer(configuration.output_buffer_size);
@@ -121,9 +121,8 @@ public:
continue;
}
spa_pod_builder_control(&build, static_cast<int32_t>(m.timestamp), SPA_CONTROL_Midi);
int res
= spa_pod_builder_bytes(&build, m.bytes.data(), static_cast<uint32_t>(m.bytes.size()));
spa_pod_builder_control(&build, m.timestamp, SPA_CONTROL_Midi);
int res = spa_pod_builder_bytes(&build, m.bytes.data(), m.bytes.size());
// Try again next buffer
if (res == -ENOSPC)
include/libremidi/backends/pipewire/observer.hpp
+22 -3
View File
@@ -24,9 +24,19 @@ public:
{
create_context(*this);
// FIXME notify_in_constructor
// FIXME port rename callback
#if 0
// Initialize PipeWire client
if (configuration.context)
{
this->add_callbacks("midi", configuration);
this->client = configuration.context;
set_callbacks();
}
else
#endif
{
this->add_callbacks(configuration);
this->start_thread();
}
@@ -46,18 +56,27 @@ public:
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
return get_ports<SPA_DIRECTION_OUTPUT>("midi", this->configuration, *this->global_context);
return get_ports<SPA_DIRECTION_OUTPUT>(this->configuration, *this->global_context);
}
std::vector<libremidi::output_port> get_output_ports() const noexcept override
{
return get_ports<SPA_DIRECTION_INPUT>("midi", this->configuration, *this->global_context);
return get_ports<SPA_DIRECTION_INPUT>(this->configuration, *this->global_context);
}
~observer_pipewire()
{
stop_thread();
destroy_context();
#if 0
if (client && !configuration.context)
{
// If we own the client, deactivate it
pipewire_deactivate(this->client);
pipewire_client_close(this->client);
this->client = nullptr;
}
#endif
}
std::unordered_set<std::string> seen_input_ports;
include/libremidi/backends/pipewire_ump.hpp
-39
View File
@@ -1,39 +0,0 @@
#pragma once
#include <libremidi/backends/dummy.hpp>
#include <libremidi/backends/linux/pipewire.hpp>
#include <libremidi/backends/pipewire_ump/config.hpp>
#include <libremidi/backends/pipewire_ump/midi_in.hpp>
#include <libremidi/backends/pipewire_ump/midi_out.hpp>
#include <libremidi/backends/pipewire_ump/observer.hpp>
#include <string_view>
namespace libremidi::pipewire_ump
{
struct backend
{
using midi_in = libremidi::pipewire_ump::midi_in_pipewire;
using midi_out = libremidi::pipewire_ump::midi_out_pipewire;
using midi_observer = libremidi::pipewire_ump::observer_pipewire;
using midi_in_configuration = libremidi::pipewire_ump::input_configuration;
using midi_out_configuration = libremidi::pipewire_ump::output_configuration;
using midi_observer_configuration = libremidi::pipewire_ump::observer_configuration;
static const constexpr auto API = libremidi::API::PIPEWIRE_UMP;
static const constexpr std::string_view name = "pipewire_ump";
static const constexpr std::string_view display_name = "PipeWire (UMP)";
static inline bool available() noexcept
{
static const libpipewire& pw = libpipewire::instance();
if (!pw.available)
return false;
const std::string_view version = pw.get_library_version();
if (version.size() >= 3)
{
if (version[0] > '1' || version[2] >= '4')
return true;
}
return false;
}
};
}
include/libremidi/backends/pipewire_ump/config.hpp
-36
View File
@@ -1,36 +0,0 @@
#pragma once
#include <libremidi/backends/pipewire/config.hpp>
#include <libremidi/config.hpp>
namespace libremidi::pipewire_ump
{
struct input_configuration
{
std::string client_name = "libremidi client";
pw_main_loop* context{};
pw_filter* filter{};
std::function<void(libremidi::pipewire_callback)> set_process_func{};
std::function<void(int64_t)> clear_process_func{};
};
struct output_configuration
{
std::string client_name = "libremidi client";
pw_main_loop* context{};
pw_filter* filter{};
std::function<void(libremidi::pipewire_callback)> set_process_func{};
std::function<void(int64_t)> clear_process_func{};
int64_t output_buffer_size{65536};
};
struct observer_configuration
{
std::string client_name = "libremidi client";
pw_main_loop* context{};
};
}
include/libremidi/backends/pipewire_ump/midi_in.hpp
-135
View File
@@ -1,135 +0,0 @@
#pragma once
#include <libremidi/backends/pipewire/helpers.hpp>
#include <libremidi/backends/pipewire_ump/config.hpp>
#include <libremidi/detail/midi_in.hpp>
#include <libremidi/detail/midi_stream_decoder.hpp>
namespace libremidi::pipewire_ump
{
class midi_in_pipewire final
: public midi2::in_api
, public pipewire_helpers
, public error_handler
{
public:
struct
: ump_input_configuration
, libremidi::pipewire_ump::input_configuration
{
} configuration;
explicit midi_in_pipewire(
ump_input_configuration&& conf, libremidi::pipewire_ump::input_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
if (auto ret = create_context(*this); ret != stdx::error{})
{
client_open_ = ret;
return;
}
if (auto ret = create_filter(*this); ret != stdx::error{})
{
client_open_ = ret;
return;
}
client_open_ = stdx::error{};
}
~midi_in_pipewire() override
{
stop_thread();
do_close_port();
destroy_filter(*this);
destroy_context();
client_open_ = std::errc::not_connected;
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::PIPEWIRE_UMP; }
stdx::error open_port(const input_port& in_port, std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT, "32 bit raw UMP");
err != stdx::error{})
return err;
if (auto err = link_ports(*this, in_port); err != stdx::error{})
return err;
start_thread();
return stdx::error{};
}
stdx::error open_virtual_port(std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_INPUT, "32 bit raw UMP");
err != stdx::error{})
return err;
start_thread();
return stdx::error{};
}
stdx::error close_port() override
{
stop_thread();
return do_close_port();
}
stdx::error set_port_name(std::string_view port_name) override
{
return rename_port(port_name);
}
timestamp absolute_timestamp() const noexcept override { return system_ns(); }
void process(struct spa_io_position* position)
{
static constexpr timestamp_backend_info timestamp_info{
.has_absolute_timestamps = true,
.absolute_is_monotonic = true,
.has_samples = true,
};
assert(this->filter);
assert(this->filter->port);
const auto b = pw.filter_dequeue_buffer(this->filter->port);
if (!b)
return;
const auto buf = b->buffer;
const auto d = &buf->datas[0];
if (d->data == nullptr)
return;
const auto pod
= (spa_pod*)spa_pod_from_data(d->data, d->maxsize, d->chunk->offset, d->chunk->size);
if (!pod)
return;
if (!spa_pod_is_sequence(pod))
return;
struct spa_pod_control* c{};
SPA_POD_SEQUENCE_FOREACH((struct spa_pod_sequence*)pod, c)
{
if (c->type != SPA_CONTROL_UMP)
continue;
auto data = (uint8_t*)SPA_POD_BODY(&c->value);
auto size = SPA_POD_BODY_SIZE(&c->value);
const auto to_ns = [=, clk = position->clock] {
return 1e9 * ((clk.position + c->offset) / (double)clk.rate.denom);
};
m_processing.on_bytes(
{(uint32_t*)data, (uint32_t*)(data + size)},
m_processing.timestamp<timestamp_info>(to_ns, c->offset));
}
pw.filter_queue_buffer(this->filter->port, b);
}
midi2::input_state_machine m_processing{this->configuration};
};
}
include/libremidi/backends/pipewire_ump/midi_out.hpp
-185
View File
@@ -1,185 +0,0 @@
#pragma once
#include <libremidi/backends/pipewire/helpers.hpp>
#include <libremidi/backends/pipewire_ump/config.hpp>
#include <libremidi/detail/midi_out.hpp>
#include <readerwriterqueue.h>
namespace libremidi::pipewire_ump
{
class midi_out_pipewire
: public midi2::out_api
, public pipewire_helpers
, public error_handler
{
public:
struct
: libremidi::output_configuration
, libremidi::pipewire_ump::output_configuration
{
} configuration;
midi_out_pipewire(
libremidi::output_configuration&& conf,
libremidi::pipewire_ump::output_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
if (auto ret = create_context(*this); ret != stdx::error{})
{
client_open_ = ret;
return;
}
if (auto ret = create_filter(*this); ret != stdx::error{})
{
client_open_ = ret;
return;
}
client_open_ = stdx::error{};
}
~midi_out_pipewire() override
{
stop_thread();
do_close_port();
destroy_filter(*this);
destroy_context();
client_open_ = std::errc::not_connected;
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::PIPEWIRE_UMP; }
stdx::error open_port(const output_port& out_port, std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT, "32 bit raw UMP");
err != stdx::error{})
return err;
this->filter->set_port_buffer(configuration.output_buffer_size);
if (auto err = link_ports(*this, out_port); err != stdx::error{})
return err;
start_thread();
return stdx::error{};
}
stdx::error open_virtual_port(std::string_view name) override
{
if (auto err = create_local_port(*this, name, SPA_DIRECTION_OUTPUT, "32 bit raw UMP");
err != stdx::error{})
return err;
this->filter->set_port_buffer(configuration.output_buffer_size);
start_thread();
return stdx::error{};
}
stdx::error close_port() override
{
stop_thread();
return do_close_port();
}
stdx::error set_port_name(std::string_view port_name) override
{
return rename_port(port_name);
}
int process(spa_io_position* pos)
{
m_process_clock.store(pos->clock.nsec, std::memory_order_relaxed);
const auto b = pw.filter_dequeue_buffer(this->filter->port);
if (!b)
return 1;
const auto buf = b->buffer;
const auto d = &buf->datas[0];
if (d->data == nullptr)
return 1;
spa_pod_builder build;
spa_zero(build);
spa_pod_builder_init(&build, d->data, d->maxsize);
spa_pod_frame f;
spa_pod_builder_push_sequence(&build, &f, 0);
// for all events
while (auto m_ptr = m_queue.peek())
{
auto& m = *m_ptr;
spa_pod_builder_control(&build, static_cast<int32_t>(m.timestamp), SPA_CONTROL_UMP);
int res = spa_pod_builder_bytes(&build, m.data, cmidi2_ump_get_message_size_bytes(m.data));
// Try again next buffer
if (res == -ENOSPC)
break;
// Recycle the memory
m_queue.pop();
}
spa_pod_builder_pop(&build, &f);
int n_fill_frames = build.state.offset;
if (n_fill_frames > 0)
{
d->chunk->offset = 0;
d->chunk->stride = 1;
d->chunk->size = n_fill_frames;
b->size = n_fill_frames;
pw.filter_queue_buffer(this->filter->port, b);
return 0;
}
pw.filter_flush(this->filter->filter, true);
return 0;
}
stdx::error send_ump(const uint32_t* message, size_t size) override
{
// FIXME
if (size > 4)
return std::errc::message_size;
libremidi::ump m;
std::copy_n(message, size, m.data);
m.timestamp = 0;
m_queue.enqueue(std::move(m));
return stdx::error{};
}
int convert_timestamp(int64_t user) const noexcept
{
switch (configuration.timestamps)
{
case timestamp_mode::AudioFrame:
return static_cast<int>(user);
default:
// TODO
return 0;
}
}
stdx::error schedule_ump(int64_t ts, const uint32_t* message, size_t size) override
{
// FIXME
if (size > 4)
return std::errc::message_size;
libremidi::ump m;
std::copy_n(message, size, m.data);
m.timestamp = convert_timestamp(ts);
m_queue.enqueue(std::move(m)); // FIXME actually send them scheudled
return stdx::error{};
}
moodycamel::ReaderWriterQueue<libremidi::ump> m_queue;
std::atomic_int64_t m_process_clock = 0;
};
}
include/libremidi/backends/pipewire_ump/observer.hpp
-68
View File
@@ -1,68 +0,0 @@
#pragma once
#include <libremidi/backends/pipewire/helpers.hpp>
#include <libremidi/backends/pipewire_ump/config.hpp>
#include <libremidi/detail/observer.hpp>
#include <unordered_set>
namespace libremidi::pipewire_ump
{
class observer_pipewire final
: public observer_api
, private pipewire_helpers
, private error_handler
{
public:
struct
: libremidi::observer_configuration
, libremidi::pipewire_ump::observer_configuration
{
} configuration;
explicit observer_pipewire(
libremidi::observer_configuration&& conf,
libremidi::pipewire_ump::observer_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
{
create_context(*this);
// FIXME port rename callback
{
this->add_callbacks("UMP", configuration);
this->start_thread();
}
if (configuration.notify_in_constructor)
{
if (configuration.input_added)
for (const auto& p : get_input_ports())
configuration.input_added(p);
if (configuration.output_added)
for (const auto& p : get_output_ports())
configuration.output_added(p);
}
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::PIPEWIRE_UMP; }
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
return get_ports<SPA_DIRECTION_OUTPUT>("UMP", this->configuration, *this->global_context);
}
std::vector<libremidi::output_port> get_output_ports() const noexcept override
{
return get_ports<SPA_DIRECTION_INPUT>("UMP", this->configuration, *this->global_context);
}
~observer_pipewire()
{
stop_thread();
destroy_context();
}
std::unordered_set<std::string> seen_input_ports;
std::unordered_set<std::string> seen_output_ports;
};
}
include/libremidi/backends/winmidi.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/winmidi/midi_out.hpp>
#include <libremidi/backends/winmidi/observer.hpp>
#include <string_view>
namespace libremidi::winmidi
{
struct backend
@@ -16,8 +14,8 @@ struct backend
using midi_out_configuration = winmidi::output_configuration;
using midi_observer_configuration = winmidi::observer_configuration;
static const constexpr auto API = libremidi::API::WINDOWS_MIDI_SERVICES;
static const constexpr std::string_view name = "winmidi";
static const constexpr std::string_view display_name = "Windows MIDI Services";
static const constexpr auto name = "winmidi";
static const constexpr auto display_name = "Windows MIDI Services";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/winmidi/config.hpp
-15
View File
@@ -1,34 +1,19 @@
#pragma once
#include <libremidi/config.hpp>
#include <string>
namespace winrt::Microsoft::Windows::Devices::Midi2
{
class MidiSession;
class MidiEndpointDeviceInformation;
class MidiEndpointConnection;
}
// TODO allow to share midi session and endpoints
namespace libremidi::winmidi
{
struct input_configuration
{
std::string client_name = "libremidi input";
winrt::Microsoft::Windows::Devices::Midi2::MidiSession* context{};
};
struct output_configuration
{
std::string client_name = "libremidi output";
winrt::Microsoft::Windows::Devices::Midi2::MidiSession* context{};
};
struct observer_configuration
{
std::string client_name = "libremidi observer";
};
}
include/libremidi/backends/winmidi/helpers.hpp
+16 -52
View File
@@ -3,37 +3,26 @@
#define NOMINMAX 1
#define WIN32_LEAN_AND_MEAN 1
#include <libremidi/detail/midi_api.hpp>
#include <libremidi/detail/memory.hpp>
#include <mutex>
#include <cctype>
#include <string>
#include <thread>
#include <vector>
#include <guiddef.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Foundation.Collections.h>
#include <winrt/Windows.Devices.Enumeration.h>
#include <winrt/Microsoft.Windows.Devices.Midi2.h>
#include <libremidi/cmidi2.hpp>
#include <winrt/Windows.Devices.Midi2.h>
// MinGW support
#if !defined(_MSC_VER)
namespace Microsoft::Windows::Devices::Midi2::Initialization
{
struct IMidiClientInitializer;
struct MidiClientInitializerUuid;
}
__CRT_UUID_DECL(Microsoft::Windows::Devices::Midi2::Initialization::IMidiClientInitializer,
0x8087b303, 0xd551, 0xbce2, 0x1e, 0xad, 0xa2, 0x50, 0x0d, 0x50, 0xc5, 0x80);
__CRT_UUID_DECL(Microsoft::Windows::Devices::Midi2::Initialization::MidiClientInitializerUuid,
0xc3263827, 0xc3b0, 0xbdbd, 0x25, 0x00, 0xce, 0x63, 0xa3, 0xf3, 0xf2, 0xc3);
#endif
#include <init/Microsoft.Windows.Devices.Midi2.Initialization.hpp>
// clang-format on
namespace midi2 = winrt::Microsoft::Windows::Devices::Midi2;
namespace midi2 = winrt::Windows::Devices::Midi2;
namespace foundation = winrt::Windows::Foundation;
namespace collections = winrt::Windows::Foundation::Collections;
// clang-format on
namespace libremidi::winmidi
{
@@ -41,56 +30,31 @@ using namespace winrt;
using namespace winrt::Windows::Foundation;
using namespace winrt::Windows::Devices::Enumeration;
using namespace winrt::Windows::Storage::Streams;
using namespace winrt::Microsoft::Windows::Devices::Midi2;
using namespace winrt::Windows::Devices::Midi2;
using namespace Windows::Devices::Enumeration;
using namespace ::Microsoft::Windows::Devices::Midi2::Initialization;
inline bool ichar_equals(char a, char b)
{
return std::tolower(static_cast<unsigned char>(a)) ==
std::tolower(static_cast<unsigned char>(b));
}
inline bool iequals(std::string_view lhs, std::string_view rhs)
{
return std::ranges::equal(lhs, rhs, ichar_equals);
}
inline std::pair<
winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointDeviceInformation,
winrt::Microsoft::Windows::Devices::Midi2::MidiGroupTerminalBlock>
get_port(const std::string& device_name, int group_terminal_block)
{
inline winrt::Windows::Devices::Midi2::MidiEndpointDeviceInformation
get_port_by_name(const std::string& port) {
auto eps = MidiEndpointDeviceInformation::FindAll();
for (const auto& ep : eps)
{
auto str = to_string(ep.EndpointDeviceId());
auto str = to_string(ep.Id());
if (str.empty())
continue;
if (iequals(str, device_name))
{
for (const auto& gp : ep.GetGroupTerminalBlocks())
{
if (gp.Number() == group_terminal_block)
{
return std::make_pair(ep, gp);
}
}
}
if (iequals(str, port))
return ep;
}
return {nullptr, nullptr};
return {nullptr};
}
struct winmidi_shared_data
{
std::shared_ptr<MidiDesktopAppSdkInitializer> initializer;
bool m_ready{false};
winmidi_shared_data()
: initializer{libremidi::instance<MidiDesktopAppSdkInitializer>()}
, m_ready{
initializer && initializer->InitializeSdkRuntime()
&& initializer->EnsureServiceAvailable()}
{
}
};
}
include/libremidi/backends/winmidi/midi_in.hpp
+11 -28
View File
@@ -5,12 +5,14 @@
#include <libremidi/detail/midi_in.hpp>
#include <libremidi/detail/midi_stream_decoder.hpp>
#include <iostream>
namespace libremidi::winmidi
{
class midi_in_impl final
: public midi2::in_api
, public error_handler
, public winmidi_shared_data
{
public:
struct
@@ -22,9 +24,7 @@ public:
explicit midi_in_impl(
libremidi::ump_input_configuration&& conf, winmidi::input_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
, m_session{
configuration.context ? *configuration.context
: MidiSession::Create(to_hstring(configuration.client_name))}
, m_session{MidiSession::CreateSession(L"libremidi session")}
{
this->client_open_ = stdx::error{};
}
@@ -42,23 +42,15 @@ public:
stdx::error open_port(const input_port& port, std::string_view) override
{
auto device_id = std::get_if<std::string>(&port.device);
if (!device_id)
return std::errc::invalid_argument;
auto [ep, gp] = get_port(*device_id, port.port);
if (!ep || !gp)
auto ep = get_port_by_name(port.port_name);
if (!ep)
return std::errc::address_not_available;
m_group_filter = port.port - 1;
// TODO use a MidiGroupEndpointListener for the filtering
m_endpoint = m_session.CreateEndpointConnection(ep.EndpointDeviceId());
m_endpoint = m_session.CreateEndpointConnection(ep.Id());
m_revoke_token = m_endpoint.MessageReceived(
[this](
const winrt::Microsoft::Windows::Devices::Midi2::IMidiMessageReceivedEventSource&,
const winrt::Microsoft::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& args) {
[&](const foundation::IInspectable& sender,
const winrt::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& args) {
process_message(args);
});
@@ -67,7 +59,7 @@ public:
return stdx::error{};
}
void process_message(const winrt::Microsoft::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& msg)
void process_message(const winrt::Windows::Devices::Midi2::MidiMessageReceivedEventArgs& msg)
{
static constexpr timestamp_backend_info timestamp_info{
.has_absolute_timestamps = true,
@@ -76,14 +68,6 @@ public:
};
const auto& ump = msg.GetMessagePacket();
auto pk = msg.PeekFirstWord();
if (m_group_filter >= 0)
{
int group = cmidi2_ump_get_group(&pk);
if (group != m_group_filter)
return;
}
const auto& b = ump.GetAllWords();
uint32_t ump_space[64];
@@ -107,8 +91,7 @@ public:
private:
MidiSession m_session;
winrt::event_token m_revoke_token{};
winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
winrt::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
midi2::input_state_machine m_processing{this->configuration};
int m_group_filter = -1;
};
}
include/libremidi/backends/winmidi/midi_out.hpp
+5 -12
View File
@@ -11,7 +11,6 @@ namespace libremidi::winmidi
class midi_out_impl final
: public midi2::out_api
, public error_handler
, public winmidi_shared_data
{
public:
struct
@@ -22,9 +21,7 @@ public:
midi_out_impl(libremidi::output_configuration&& conf, winmidi::output_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
, m_session{
configuration.context ? *configuration.context
: MidiSession::Create(to_hstring(configuration.client_name))}
, m_session{MidiSession::CreateSession(L"libremidi session")}
{
this->client_open_ = stdx::error{};
}
@@ -38,15 +35,11 @@ public:
stdx::error open_port(const output_port& port, std::string_view) override
{
auto device_id = std::get_if<std::string>(&port.device);
if (!device_id)
return std::errc::invalid_argument;
auto [ep, gp] = get_port(*device_id, port.port);
if (!ep || !gp)
auto ep = get_port_by_name(port.port_name);
if (!ep)
return std::errc::address_not_available;
m_endpoint = m_session.CreateEndpointConnection(ep.EndpointDeviceId());
m_endpoint = m_session.CreateEndpointConnection(ep.Id());
m_endpoint.Open();
return stdx::error{};
@@ -90,7 +83,7 @@ public:
private:
MidiSession m_session;
winrt::Microsoft::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
winrt::Windows::Devices::Midi2::MidiEndpointConnection m_endpoint{nullptr};
};
}
include/libremidi/backends/winmidi/observer.hpp
+54 -180
View File
@@ -2,7 +2,7 @@
#include <libremidi/backends/winmidi/config.hpp>
#include <libremidi/backends/winmidi/helpers.hpp>
#include <libremidi/detail/observer.hpp>
;
namespace libremidi::winmidi
{
struct port_info
@@ -11,9 +11,7 @@ struct port_info
hstring name;
};
class observer_impl final
: public observer_api
, public winmidi_shared_data
class observer_impl final : public observer_api
{
public:
struct
@@ -22,17 +20,11 @@ public:
{
} configuration;
MidiEndpointDeviceWatcher watcher = nullptr;
MidiEndpointDeviceWatcher::Added_revoker m_addHandler;
MidiEndpointDeviceWatcher::Updated_revoker m_updHandler;
MidiEndpointDeviceWatcher::Removed_revoker m_delHandler;
std::map<hstring, std::vector<input_port>> m_known_input_devices;
std::map<hstring, std::vector<output_port>> m_known_output_devices;
std::mutex m_devices_mtx;
explicit observer_impl(
libremidi::observer_configuration&& conf, winmidi::observer_configuration&& apiconf)
: configuration{std::move(conf), std::move(apiconf)}
, session{MidiSession::CreateSession(L"libremidi session")}
{
if (!configuration.has_callbacks())
return;
@@ -48,35 +40,26 @@ public:
configuration.output_added(p);
}
if ((watcher = MidiEndpointDeviceWatcher::Create()))
{
namespace enumeration = winrt::Windows::Devices::Enumeration;
auto addHandler = foundation::TypedEventHandler<
MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationAddedEventArgs>(
this, &observer_impl::on_device_added);
auto updHandler = foundation::TypedEventHandler<
MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationUpdatedEventArgs>(
this, &observer_impl::on_device_updated);
auto delHandler = foundation::TypedEventHandler<
MidiEndpointDeviceWatcher, MidiEndpointDeviceInformationRemovedEventArgs>(
this, &observer_impl::on_device_removed);
m_addHandler = watcher.Added(winrt::auto_revoke, addHandler);
m_updHandler = watcher.Updated(winrt::auto_revoke, updHandler);
m_delHandler = watcher.Removed(winrt::auto_revoke, delHandler);
watcher.Start();
}
/*
evTokenOnInputAdded_
= internalInPortObserver_.PortAdded([this](const port_info& p) { on_input_added(p); });
evTokenOnInputRemoved_
= internalInPortObserver_.PortRemoved([this](const port_info& p) { on_input_removed(p); });
evTokenOnOutputAdded_
= internalOutPortObserver_.PortAdded([this](const port_info& p) { on_output_added(p); });
evTokenOnOutputRemoved_ = internalOutPortObserver_.PortRemoved(
[this](const port_info& p) { on_output_removed(p); });
*/
}
~observer_impl()
{
if (!configuration.has_callbacks())
return;
m_addHandler.revoke();
m_updHandler.revoke();
m_delHandler.revoke();
// internalInPortObserver_.PortAdded(evTokenOnInputAdded_);
// internalInPortObserver_.PortRemoved(evTokenOnInputRemoved_);
// internalOutPortObserver_.PortAdded(evTokenOnOutputAdded_);
// internalOutPortObserver_.PortRemoved(evTokenOnOutputRemoved_);
}
libremidi::API get_current_api() const noexcept override
@@ -84,56 +67,33 @@ public:
return libremidi::API::WINDOWS_MIDI_SERVICES;
}
static port_information::port_type code_to_type(std::string_view str) noexcept
{
using enum port_information::port_type;
if (str.starts_with("KS"))
return hardware;
if (str == "BLE")
return port_information::port_type(hardware | bluetooth);
if (str == "VPB" || str == "APP")
return software;
if (str == "LOOP")
return port_information::port_type(software | loopback);
if (str.starts_with("NET"))
return network;
return unknown;
}
template <bool Input>
auto to_port_info(const MidiEndpointDeviceInformation& p, const MidiGroupTerminalBlock& gp)
const noexcept -> std::conditional_t<Input, input_port, output_port>
auto to_port_info(const DeviceInformation& p) const noexcept
-> std::conditional_t<Input, input_port, output_port>
{
const auto& tinfo = p.GetTransportSuppliedInfo();
return {
{.client = 0,
.container = std::bit_cast<libremidi::uuid>(p.ContainerId()),
.device = to_string(p.EndpointDeviceId()),
.port = gp.Number(),
.manufacturer = to_string(tinfo.ManufacturerName),
.device_name = to_string(p.Name()),
.port_name = to_string(gp.Name()),
.display_name = to_string(gp.Name()) + " " + std::to_string(gp.Number()),
.type = code_to_type(to_string(p.GetTransportSuppliedInfo().TransportCode))}};
.port = 0,
.manufacturer = "",
.device_name = "",
.port_name = to_string(p.Id()),
.display_name = to_string(p.Name())}};
}
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
std::vector<libremidi::input_port> ret;
for (const auto& ep : MidiEndpointDeviceInformation::FindAll())
auto deviceSelector = MidiEndpointConnection::GetDeviceSelector();
auto endpointDevices = DeviceInformation::FindAllAsync(deviceSelector).get();
for (const auto& ep : endpointDevices)
{
if(ep.Name().starts_with(L"Diagnostics")) {
continue;
}
// FIXME if(has input...)
for (const auto& gp : ep.GetGroupTerminalBlocks())
{
if (gp.Direction() != MidiGroupTerminalBlockDirection::BlockOutput)
ret.emplace_back(to_port_info<true>(ep, gp));
}
ret.emplace_back(to_port_info<true>(ep));
}
return ret;
@@ -143,132 +103,46 @@ public:
{
std::vector<libremidi::output_port> ret;
for (const auto& ep : MidiEndpointDeviceInformation::FindAll())
auto deviceSelector = MidiEndpointConnection::GetDeviceSelector();
auto endpointDevices = DeviceInformation::FindAllAsync(deviceSelector).get();
for (const auto& ep : endpointDevices)
{
if(ep.Name().starts_with(L"Diagnostics")) {
continue;
}
for (const auto& gp : ep.GetGroupTerminalBlocks())
{
if (gp.Direction() != MidiGroupTerminalBlockDirection::BlockInput)
ret.emplace_back(to_port_info<false>(ep, gp));
}
// FIXME if(has output...)
ret.emplace_back(to_port_info<false>(ep));
}
return ret;
}
// Note: these callbacks are called from some random thread!
void on_device_added(
const MidiEndpointDeviceWatcher&, const MidiEndpointDeviceInformationAddedEventArgs& result)
void on_input_added(const DeviceInformation& name)
{
add_device(result.AddedDevice());
if (configuration.input_added)
configuration.input_added(to_port_info<true>(name));
}
void on_device_updated(
const MidiEndpointDeviceWatcher& e,
const MidiEndpointDeviceInformationUpdatedEventArgs& result)
void on_input_removed(const DeviceInformation& name)
{
// OPTIMIZEME
remove_device(result.EndpointDeviceId());
add_device(
MidiEndpointDeviceInformation::CreateFromEndpointDeviceId(result.EndpointDeviceId()));
}
void on_device_removed(
const MidiEndpointDeviceWatcher&,
const MidiEndpointDeviceInformationRemovedEventArgs& result)
{
remove_device(result.EndpointDeviceId());
}
void add_device(const MidiEndpointDeviceInformation& ep)
{
for (const auto& gp : ep.GetGroupTerminalBlocks())
{
MidiGroupTerminalBlockDirection direction = gp.Direction();
switch (direction)
{
case MidiGroupTerminalBlockDirection::Bidirectional: {
if (configuration.input_added)
{
auto ip = to_port_info<true>(ep, gp);
{
std::lock_guard _{m_devices_mtx};
m_known_input_devices[ep.EndpointDeviceId()].push_back(ip);
}
configuration.input_added(std::move(ip));
}
if (configuration.output_added)
{
auto op = to_port_info<false>(ep, gp);
{
std::lock_guard _{m_devices_mtx};
m_known_output_devices[ep.EndpointDeviceId()].push_back(op);
}
configuration.output_added(std::move(op));
}
break;
}
case MidiGroupTerminalBlockDirection::BlockInput:
if (configuration.input_added)
{
auto ip = to_port_info<true>(ep, gp);
{
std::lock_guard _{m_devices_mtx};
m_known_input_devices[ep.EndpointDeviceId()].push_back(ip);
}
configuration.input_added(std::move(ip));
}
break;
case MidiGroupTerminalBlockDirection::BlockOutput:
if (configuration.output_added)
{
auto op = to_port_info<false>(ep, gp);
{
std::lock_guard _{m_devices_mtx};
m_known_output_devices[ep.EndpointDeviceId()].push_back(op);
}
configuration.output_added(std::move(op));
}
break;
}
}
}
void remove_device(hstring eid)
{
std::vector<input_port> to_remove_in;
std::vector<output_port> to_remove_out;
{
std::lock_guard _{m_devices_mtx};
if (auto it = m_known_input_devices.find(eid); it != m_known_input_devices.end())
{
for (auto& ip : it->second)
{
to_remove_in.push_back(ip);
}
m_known_input_devices.erase(it);
}
if (auto it = m_known_output_devices.find(eid); it != m_known_output_devices.end())
{
for (auto& op : it->second)
{
to_remove_out.push_back(op);
}
m_known_output_devices.erase(it);
}
}
if (configuration.input_removed)
for (auto& port : to_remove_in)
configuration.input_removed(port);
if (configuration.output_removed)
for (auto& port : to_remove_out)
configuration.output_removed(port);
configuration.input_removed(to_port_info<true>(name));
}
void on_output_added(const DeviceInformation& name)
{
if (configuration.output_added)
configuration.output_added(to_port_info<false>(name));
}
void on_output_removed(const DeviceInformation& name)
{
if (configuration.output_removed)
configuration.output_removed(to_port_info<false>(name));
}
private:
MidiSession session;
};
}
include/libremidi/backends/winmm.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/winmm/midi_out.hpp>
#include <libremidi/backends/winmm/observer.hpp>
#include <string_view>
// Default for Windows is to add an identifier to the port names; this
// flag can be defined (e.g. in your project file) to disable this behaviour.
// #define LIBREMIDI_DO_NOT_ENSURE_UNIQUE_PORTNAMES
@@ -30,8 +28,8 @@ struct winmm_backend
using midi_out_configuration = winmm_output_configuration;
using midi_observer_configuration = winmm_observer_configuration;
static const constexpr auto API = libremidi::API::WINDOWS_MM;
static const constexpr std::string_view name = "winmm";
static const constexpr std::string_view display_name = "Windows Multimedia";
static const constexpr auto name = "winmm";
static const constexpr auto display_name = "Windows Multimedia";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/winmm/helpers.hpp
+2 -2
View File
@@ -1,8 +1,7 @@
#pragma once
#include <libremidi/backends/winmm/error_domain.hpp>
#include <libremidi/detail/midi_api.hpp>
#include <string>
#include <algorithm>
namespace libremidi
{
@@ -71,4 +70,5 @@ inline void MakeUniqueOutPortName(std::string& deviceName, std::size_t portNumbe
deviceName += " ";
deviceName += std::to_string(x);
}
}
include/libremidi/backends/winmm/observer.hpp
+3
View File
@@ -3,6 +3,9 @@
#include <libremidi/backends/winmm/helpers.hpp>
#include <libremidi/detail/observer.hpp>
#include <condition_variable>
#include <mutex>
#include <ranges>
#include <thread>
namespace libremidi
include/libremidi/backends/winuwp.hpp
+2 -4
View File
@@ -3,8 +3,6 @@
#include <libremidi/backends/winuwp/midi_out.hpp>
#include <libremidi/backends/winuwp/observer.hpp>
#include <string_view>
namespace libremidi
{
struct winuwp_backend
@@ -16,8 +14,8 @@ struct winuwp_backend
using midi_out_configuration = winuwp_output_configuration;
using midi_observer_configuration = winuwp_observer_configuration;
static const constexpr auto API = libremidi::API::WINDOWS_UWP;
static const constexpr std::string_view name = "winuwp";
static const constexpr std::string_view display_name = "Windows UWP";
static const constexpr auto name = "winuwp";
static const constexpr auto display_name = "Windows UWP";
static constexpr inline bool available() noexcept { return true; }
};
include/libremidi/backends/winuwp/observer.hpp
+17 -15
View File
@@ -197,13 +197,13 @@ public:
configuration.output_added(p);
}
evTokenOnInputAdded_ = get_internal_in_port_observer().PortAdded(
[this](const port_info& p) { on_input_added(p); });
evTokenOnInputRemoved_ = get_internal_in_port_observer().PortRemoved(
[this](const port_info& p) { on_input_removed(p); });
evTokenOnOutputAdded_ = get_internal_out_port_observer().PortAdded(
[this](const port_info& p) { on_output_added(p); });
evTokenOnOutputRemoved_ = get_internal_out_port_observer().PortRemoved(
evTokenOnInputAdded_
= internalInPortObserver_.PortAdded([this](const port_info& p) { on_input_added(p); });
evTokenOnInputRemoved_
= internalInPortObserver_.PortRemoved([this](const port_info& p) { on_input_removed(p); });
evTokenOnOutputAdded_
= internalOutPortObserver_.PortAdded([this](const port_info& p) { on_output_added(p); });
evTokenOnOutputRemoved_ = internalOutPortObserver_.PortRemoved(
[this](const port_info& p) { on_output_removed(p); });
}
@@ -211,10 +211,10 @@ public:
{
if (!configuration.has_callbacks())
return;
get_internal_in_port_observer().PortAdded(evTokenOnInputAdded_);
get_internal_in_port_observer().PortRemoved(evTokenOnInputRemoved_);
get_internal_out_port_observer().PortAdded(evTokenOnOutputAdded_);
get_internal_out_port_observer().PortRemoved(evTokenOnOutputRemoved_);
internalInPortObserver_.PortAdded(evTokenOnInputAdded_);
internalInPortObserver_.PortRemoved(evTokenOnInputRemoved_);
internalOutPortObserver_.PortAdded(evTokenOnOutputAdded_);
internalOutPortObserver_.PortRemoved(evTokenOnOutputRemoved_);
}
libremidi::API get_current_api() const noexcept override { return libremidi::API::WINDOWS_UWP; }
@@ -235,7 +235,7 @@ public:
std::vector<libremidi::input_port> get_input_ports() const noexcept override
{
std::vector<libremidi::input_port> ret;
for (auto& port : get_internal_in_port_observer().get_ports())
for (auto& port : internalInPortObserver_.get_ports())
ret.push_back(to_port_info<true>(port));
return ret;
}
@@ -243,20 +243,18 @@ public:
std::vector<libremidi::output_port> get_output_ports() const noexcept override
{
std::vector<libremidi::output_port> ret;
for (auto& port : get_internal_out_port_observer().get_ports())
for (auto& port : internalOutPortObserver_.get_ports())
ret.push_back(to_port_info<false>(port));
return ret;
}
static observer_winuwp_internal& get_internal_in_port_observer()
{
static observer_winuwp_internal internalInPortObserver_{MidiInPort::GetDeviceSelector()};
return internalInPortObserver_;
}
static observer_winuwp_internal& get_internal_out_port_observer()
{
static observer_winuwp_internal internalOutPortObserver_{MidiOutPort::GetDeviceSelector()};
return internalOutPortObserver_;
}
@@ -285,6 +283,10 @@ public:
}
private:
static inline observer_winuwp_internal internalInPortObserver_{MidiInPort::GetDeviceSelector()};
static inline observer_winuwp_internal internalOutPortObserver_{
MidiOutPort::GetDeviceSelector()};
int evTokenOnInputAdded_{-1};
int evTokenOnInputRemoved_{-1};
int evTokenOnOutputAdded_{-1};
include/libremidi/client.hpp
+21 -22
View File
@@ -4,7 +4,6 @@
#include <libremidi/shared_context.hpp>
#include <map>
#include <utility>
namespace libremidi::midi1
{
@@ -67,8 +66,8 @@ public:
}
explicit client(const client_configuration& conf, shared_configurations ctx)
: m_configuration{conf}
, m_context{std::move(ctx)}
: configuration{conf}
, context{ctx}
, m_observer{
observer_configuration{
.on_error = conf.on_error,
@@ -82,10 +81,10 @@ public:
.track_hardware = conf.track_hardware,
.track_virtual = conf.track_virtual,
.notify_in_constructor = false},
m_context.observer}
context.observer}
{
if (m_context.context)
m_context.context->start_processing();
if (context.context)
context.context->start_processing();
}
~client()
@@ -93,8 +92,8 @@ public:
m_inputs.clear();
m_outputs.clear();
if (m_context.context)
m_context.context->stop_processing();
if (context.context)
context.context->stop_processing();
}
std::vector<libremidi::input_port> get_input_ports() const noexcept
@@ -117,19 +116,19 @@ public:
input_configuration{
.on_message
= [this,
port](libremidi::message&& m) { m_configuration.on_message(port, std::move(m)); },
port](libremidi::message&& m) { configuration.on_message(port, std::move(m)); },
.on_raw_data = {},
.get_timestamp = {},
.on_error = m_configuration.on_error,
.on_warning = m_configuration.on_warning,
.on_error = configuration.on_error,
.on_warning = configuration.on_warning,
.ignore_sysex = m_configuration.ignore_sysex,
.ignore_timing = m_configuration.ignore_timing,
.ignore_sensing = m_configuration.ignore_sensing,
.ignore_sysex = configuration.ignore_sysex,
.ignore_timing = configuration.ignore_timing,
.ignore_sensing = configuration.ignore_sensing,
.timestamps = m_configuration.timestamps},
m_context.in);
.timestamps = configuration.timestamps},
context.in);
res.first->second.open_port(port, name);
}
@@ -142,11 +141,11 @@ public:
auto res = m_outputs.try_emplace(
port,
output_configuration{
.on_error = m_configuration.on_error,
.on_warning = m_configuration.on_warning,
.on_error = configuration.on_error,
.on_warning = configuration.on_warning,
.timestamps = m_configuration.timestamps},
m_context.out);
.timestamps = configuration.timestamps},
context.out);
res.first->second.open_port(port, name);
}
@@ -191,8 +190,8 @@ public:
}
private:
client_configuration m_configuration;
shared_configurations m_context;
client_configuration configuration;
shared_configurations context;
std::map<input_port, midi_in> m_inputs;
std::map<output_port, midi_out> m_outputs;
include/libremidi/cmidi2.hpp
+2 -2
View File
@@ -311,7 +311,7 @@ enum cmidi2_ump_chord_name_tonic_note
CMIDI2_UMP_CHORD_NAME_G = 7,
};
enum cmidi2_ump_chord_name_chord_type
enum cmidi2_ump_chor_name_chord_type
{
CMIDI2_UMP_CHORD_TYPE_UNKNOWN = 0,
CMIDI2_UMP_CHORD_TYPE_MAJOR = 1,
@@ -1494,7 +1494,7 @@ static inline uint32_t cmidi2_ump_get_midi2_pnacc_data(const cmidi2_ump* ump)
{
return cmidi2_ump_get_32_to_64(ump);
}
static inline uint8_t cmidi2_ump_get_midi2_pn_management_note(const cmidi2_ump* ump)
static inline uint32_t cmidi2_ump_get_midi2_pn_management_note(const cmidi2_ump* ump)
{
return cmidi2_ump_get_byte_at(ump, 2);
}
include/libremidi/config.hpp
+1 -7
View File
@@ -1,6 +1,6 @@
#pragma once
#if defined(_MSC_VER)
#if defined(MSC_VER)
#define NOMINMAX 1
#define WIN32_LEAN_AND_MEAN
#endif
@@ -62,9 +62,3 @@ using midi_bytes = std::vector<unsigned char>;
#else
#define LIBREMIDI_INLINE
#endif
#if __cpp_contracts >= 202502L
#define LIBREMIDI_PRECONDITION(...) pre(__VA_ARGS__)
#else
#define LIBREMIDI_PRECONDITION(...)
#endif
include/libremidi/configurations.hpp
+1 -45
View File
@@ -1,6 +1,5 @@
#pragma once
#include <libremidi/api.hpp>
#include <libremidi/backends/alsa_raw/config.hpp>
#include <libremidi/backends/alsa_raw_ump/config.hpp>
#include <libremidi/backends/alsa_seq/config.hpp>
@@ -9,60 +8,17 @@
#include <libremidi/backends/coremidi_ump/config.hpp>
#include <libremidi/backends/emscripten/config.hpp>
#include <libremidi/backends/jack/config.hpp>
#include <libremidi/backends/jack_ump/config.hpp>
#include <libremidi/backends/keyboard/config.hpp>
#include <libremidi/backends/net/config.hpp>
#include <libremidi/backends/pipewire/config.hpp>
#include <libremidi/backends/pipewire_ump/config.hpp>
#include <libremidi/backends/winmidi/config.hpp>
#include <libremidi/backends/winmm/config.hpp>
#include <libremidi/backends/winuwp/config.hpp>
#include <libremidi/config.hpp>
#include <variant>
namespace libremidi
{
struct unspecified_configuration
{
};
struct dummy_configuration
{
};
using input_api_configuration = std::variant<
unspecified_configuration, dummy_configuration, alsa_raw_input_configuration,
alsa_raw_ump::input_configuration, alsa_seq::input_configuration,
alsa_seq_ump::input_configuration, coremidi_input_configuration,
coremidi_ump::input_configuration, emscripten_input_configuration, jack_input_configuration,
kbd_input_configuration, libremidi::net::dgram_input_configuration,
libremidi::net_ump::dgram_input_configuration, pipewire_input_configuration,
winmidi::input_configuration, winmm_input_configuration, winuwp_input_configuration,
jack_ump::input_configuration, pipewire_ump::input_configuration, libremidi::API>;
using output_api_configuration = std::variant<
unspecified_configuration, dummy_configuration, alsa_raw_output_configuration,
alsa_raw_ump::output_configuration, alsa_seq::output_configuration,
alsa_seq_ump::output_configuration, coremidi_output_configuration,
coremidi_ump::output_configuration, emscripten_output_configuration, jack_output_configuration,
libremidi::net::dgram_output_configuration, libremidi::net_ump::dgram_output_configuration,
pipewire_output_configuration, winmidi::output_configuration, winmm_output_configuration,
winuwp_output_configuration, jack_ump::output_configuration,
pipewire_ump::output_configuration, libremidi::API>;
using observer_api_configuration = std::variant<
unspecified_configuration, dummy_configuration, alsa_raw_observer_configuration,
alsa_raw_ump::observer_configuration, alsa_seq::observer_configuration,
alsa_seq_ump::observer_configuration, coremidi_observer_configuration,
coremidi_ump::observer_configuration, emscripten_observer_configuration,
jack_observer_configuration, libremidi::net::dgram_observer_configuration,
libremidi::net_ump::dgram_observer_configuration, pipewire_observer_configuration,
winmidi::observer_configuration, winmm_observer_configuration, winuwp_observer_configuration,
jack_ump::observer_configuration, pipewire_ump::observer_configuration, libremidi::API>;
LIBREMIDI_EXPORT
libremidi::API midi_api(const input_api_configuration& conf);
LIBREMIDI_EXPORT
libremidi::API midi_api(const output_api_configuration& conf);
LIBREMIDI_EXPORT
libremidi::API midi_api(const observer_api_configuration& conf);
}
include/libremidi/defaults.hpp
+12 -12
View File
@@ -1,11 +1,11 @@
#pragma once
#include <libremidi/api.hpp>
#include <libremidi/config.hpp>
#include <libremidi/configurations.hpp>
#include <libremidi/input_configuration.hpp>
#include <libremidi/observer_configuration.hpp>
#include <libremidi/output_configuration.hpp>
#include <any>
#include <optional>
namespace libremidi
@@ -16,22 +16,22 @@ class observer;
//! Get the default midi in configuration object for a given API
LIBREMIDI_EXPORT
input_api_configuration midi_in_configuration_for(libremidi::API);
std::any midi_in_configuration_for(libremidi::API);
//! Get the default midi out configuration object for a given API
LIBREMIDI_EXPORT
output_api_configuration midi_out_configuration_for(libremidi::API);
std::any midi_out_configuration_for(libremidi::API);
//! Get the default observer configuration object for a given API
LIBREMIDI_EXPORT
observer_api_configuration observer_configuration_for(libremidi::API);
std::any observer_configuration_for(libremidi::API);
//! Get a matching midi in configuration object for a given observer instance.
LIBREMIDI_EXPORT
input_api_configuration midi_in_configuration_for(const libremidi::observer&);
std::any midi_in_configuration_for(const libremidi::observer&);
//! Get a matching midi out configuration object for a given observer instance.
LIBREMIDI_EXPORT
output_api_configuration midi_out_configuration_for(const libremidi::observer&);
std::any midi_out_configuration_for(const libremidi::observer&);
//! Get the default port for midi input (if any) in a given API.
//! Note that this will only return a hardware / physical port.
@@ -47,15 +47,15 @@ namespace midi1
{
//! Get a default configuration for creating a MIDI 1 input
LIBREMIDI_EXPORT
input_api_configuration in_default_configuration();
std::any in_default_configuration();
//! Get a default configuration for creating a MIDI 1 output
LIBREMIDI_EXPORT
output_api_configuration out_default_configuration();
std::any out_default_configuration();
//! Get a default configuration for creating a MIDI 1 observer
LIBREMIDI_EXPORT
observer_api_configuration observer_default_configuration();
std::any observer_default_configuration();
//! Get a default MIDI 1 input port for the default API of the system
inline std::optional<input_port> in_default_port() noexcept
@@ -74,15 +74,15 @@ namespace midi2
{
//! Get a default configuration for creating a MIDI 2 input
LIBREMIDI_EXPORT
input_api_configuration in_default_configuration();
std::any in_default_configuration();
//! Get a default configuration for creating a MIDI 2 output
LIBREMIDI_EXPORT
output_api_configuration out_default_configuration();
std::any out_default_configuration();
//! Get a default configuration for creating a MIDI 2 observer
LIBREMIDI_EXPORT
observer_api_configuration observer_default_configuration();
std::any observer_default_configuration();
//! Get a default MIDI 2 input port for the default API of the system
inline std::optional<input_port> in_default_port() noexcept
include/libremidi/detail/conversion.hpp
+12 -243
View File
@@ -7,193 +7,8 @@
#include <libremidi/error.hpp>
#include <libremidi/message.hpp>
#include <libremidi/ump.hpp>
#include <cmath>
static inline void cmidi2_reverse(int64_t v, cmidi2_ump* output)
{
union
{
uint32_t u[2];
int64_t i;
} e0, e1;
e0.i = v;
e1.u[0] = e0.u[1];
e1.u[1] = e0.u[0];
memcpy(output, &e1, 8);
}
static inline auto u7_to_u16(uint8_t in) -> uint16_t
{
static constexpr auto ratio = float(std::numeric_limits<uint16_t>::max()) / 127.f;
return std::clamp(std::round(in * ratio), 0.f, float(std::numeric_limits<uint16_t>::max()));
};
static inline auto u7_to_u32(uint8_t in) -> uint32_t
{
static constexpr auto ratio = double(std::numeric_limits<uint32_t>::max()) / 127.;
return std::clamp(std::round(in * ratio), 0., double(std::numeric_limits<uint32_t>::max()));
};
static inline auto u16_to_u32(uint16_t in) -> uint32_t
{
static constexpr auto ratio = double(std::numeric_limits<uint32_t>::max())
/ double(std::numeric_limits<uint16_t>::max());
return std::clamp(std::round(in * ratio), 0., double(std::numeric_limits<uint32_t>::max()));
};
static inline bool
cmidi2_midi1_channel_voice_to_midi2(const uint8_t* bytes, std::size_t sz, cmidi2_ump* output)
{
if (sz < 2)
return false;
if (sz > 3)
return false;
const auto status = libremidi::message_type(bytes[0] & 0xF0);
const int channel = bytes[0] & 0x0F;
const int group = 0;
switch (status)
{
case libremidi::message_type::NOTE_OFF: {
const int64_t msg
= cmidi2_ump_midi2_note_off(group, channel, bytes[1], 0, u7_to_u16(bytes[2]), 0);
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::NOTE_ON: {
const int64_t msg
= cmidi2_ump_midi2_note_on(group, channel, bytes[1], 0, u7_to_u16(bytes[2]), 0);
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::POLY_PRESSURE: {
const int64_t msg = cmidi2_ump_midi2_paf(group, channel, bytes[1], u7_to_u32(bytes[2]));
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::CONTROL_CHANGE: {
const int64_t msg = cmidi2_ump_midi2_cc(group, channel, bytes[1], u7_to_u32(bytes[2]));
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::PROGRAM_CHANGE: {
const int64_t msg = cmidi2_ump_midi2_program(group, channel, 0, bytes[1], 0, 0);
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::AFTERTOUCH: {
const int64_t msg = cmidi2_ump_midi2_caf(group, channel, u7_to_u32(bytes[1]));
cmidi2_reverse(msg, output);
break;
}
case libremidi::message_type::PITCH_BEND: {
const auto pb = bytes[1] + bytes[2] * 0x80;
const int64_t msg = cmidi2_ump_midi2_pitch_bend_direct(group, channel, u16_to_u32(pb));
cmidi2_reverse(msg, output);
break;
}
default:
return false;
}
return true;
}
static inline bool
cmidi2_ump_upgrade_midi1_channel_voice_to_midi2(const cmidi2_ump* input, cmidi2_ump* output)
{
if (cmidi2_ump_get_message_type(input) != CMIDI2_MESSAGE_TYPE_MIDI_1_CHANNEL)
return false;
const auto group = cmidi2_ump_get_group(input);
const auto channel = cmidi2_ump_get_channel(input);
const auto status = cmidi2_ump_get_status_code(input);
const auto b1 = cmidi2_ump_get_midi1_byte2(input);
const auto b2 = cmidi2_ump_get_midi1_byte3(input);
switch (status)
{
// Not in midi 1:
case CMIDI2_STATUS_PER_NOTE_RCC:
case CMIDI2_STATUS_PER_NOTE_ACC:
case CMIDI2_STATUS_RPN:
case CMIDI2_STATUS_NRPN:
case CMIDI2_STATUS_RELATIVE_RPN:
case CMIDI2_STATUS_RELATIVE_NRPN:
case CMIDI2_STATUS_PER_NOTE_PITCH_BEND:
case CMIDI2_STATUS_PER_NOTE_MANAGEMENT:
return false;
case CMIDI2_STATUS_NOTE_OFF: {
const int64_t msg = cmidi2_ump_midi2_note_off(group, channel, b1, 0, u7_to_u16(b2), 0);
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_NOTE_ON: {
const int64_t msg = cmidi2_ump_midi2_note_on(group, channel, b1, 0, u7_to_u16(b2), 0);
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_PAF: {
const int64_t msg = cmidi2_ump_midi2_paf(group, channel, b1, u7_to_u32(b2));
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_CC: {
int64_t msg = cmidi2_ump_midi2_cc(group, channel, b1, u7_to_u32(b2));
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_PROGRAM: {
const int64_t msg = cmidi2_ump_midi2_program(group, channel, 0, b1, 0, 0);
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_CAF: {
const int64_t msg = cmidi2_ump_midi2_caf(group, channel, u7_to_u32(b1));
cmidi2_reverse(msg, output);
break;
}
case CMIDI2_STATUS_PITCH_BEND: {
const auto pb = b1 + b2 * 0x80;
const int64_t msg = cmidi2_ump_midi2_pitch_bend_direct(group, channel, u16_to_u32(pb));
cmidi2_reverse(msg, output);
break;
}
}
return true;
}
namespace libremidi
{
static inline libremidi::message midi1_from_ump(libremidi::ump u)
{
libremidi::message ret;
ret.bytes.resize(4);
if (auto n = cmidi2_convert_single_ump_to_midi1((uint8_t*)ret.bytes.data(), 4, u.data))
{
ret.timestamp = u.timestamp;
ret.bytes.resize(n);
}
else
{
ret.bytes.clear();
}
return ret;
}
static inline libremidi::ump ump_from_midi1(libremidi::message u)
{
libremidi::ump ret;
if (!u.bytes.empty())
{
ret.timestamp = u.timestamp;
cmidi2_midi1_channel_voice_to_midi2(u.bytes.data(), u.bytes.size(), ret.data);
}
return ret;
}
struct midi1_to_midi2
{
stdx::error
@@ -205,31 +20,11 @@ struct midi1_to_midi2
context.ump = ump;
context.ump_num_bytes = sizeof(ump);
context.ump_proceeded_bytes = 0;
context.skip_delta_time = true;
switch (cmidi2_convert_midi1_to_ump(&context))
{
case CMIDI2_CONVERSION_RESULT_OK: {
if (auto n = context.ump_proceeded_bytes; n > 0)
return on_ump(context.ump, context.ump_proceeded_bytes / 4, timestamp);
else
return std::errc::operation_not_supported;
}
case CMIDI2_CONVERSION_RESULT_OUT_OF_SPACE:
return std::errc::no_buffer_space;
case CMIDI2_CONVERSION_RESULT_INVALID_SYSEX:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_DTE_SEQUENCE:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_STATUS:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INCOMPLETE_SYSEX7:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_INPUT:
return std::errc::invalid_argument;
default:
return std::errc::operation_not_supported;
}
if (auto res = cmidi2_convert_midi1_to_ump(&context); res != CMIDI2_CONVERSION_RESULT_OK)
return std::errc::invalid_argument;
return on_ump(context.ump, context.ump_proceeded_bytes / 4, timestamp);
}
cmidi2_midi_conversion_context context = [] {
@@ -237,45 +32,20 @@ struct midi1_to_midi2
cmidi2_midi_conversion_context_initialize(&tmp);
return tmp;
}();
uint32_t ump[65536 / 4];
};
struct midi2_to_midi1
{
stdx::error convert(const uint32_t* message, std::size_t size, int64_t timestamp, auto on_midi)
stdx::error
convert(const uint32_t* message, std::size_t /* size */, int64_t timestamp, auto on_midi)
{
context.midi1 = static_cast<unsigned char*>(midi);
context.midi1_num_bytes = sizeof(midi);
context.midi1_proceeded_bytes = 0;
context.ump = const_cast<uint32_t*>(message);
context.ump_num_bytes = size * sizeof(uint32_t);
context.ump_proceeded_bytes = 0;
context.skip_delta_time = true;
switch (cmidi2_convert_ump_to_midi1(&context))
{
case CMIDI2_CONVERSION_RESULT_OK: {
if (auto n = context.midi1_proceeded_bytes; n > 0)
return on_midi(midi, n, timestamp);
else
return std::errc::operation_not_supported;
}
case CMIDI2_CONVERSION_RESULT_OUT_OF_SPACE:
return std::errc::no_buffer_space;
case CMIDI2_CONVERSION_RESULT_INVALID_SYSEX:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_DTE_SEQUENCE:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_STATUS:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INCOMPLETE_SYSEX7:
return std::errc::invalid_argument;
case CMIDI2_CONVERSION_RESULT_INVALID_INPUT:
return std::errc::invalid_argument;
default:
return std::errc::operation_not_supported;
}
auto n
= cmidi2_convert_single_ump_to_midi1(midi, sizeof(midi), const_cast<uint32_t*>(message));
if (n > 0)
return on_midi(midi, n, timestamp);
else
return std::errc::no_buffer_space;
}
cmidi2_midi_conversion_context context = [] {
@@ -283,7 +53,6 @@ struct midi2_to_midi1
cmidi2_midi_conversion_context_initialize(&tmp);
return tmp;
}();
uint8_t midi[65536];
};
include/libremidi/detail/midi_stream_decoder.hpp
+22 -36
View File
@@ -1,13 +1,11 @@
#pragma once
#include <libremidi/cmidi2.hpp>
#include <libremidi/detail/conversion.hpp>
#include <libremidi/detail/midi_in.hpp>
#include <cmath>
#include <libremidi/cmidi2.hpp>
#include <chrono>
#include <cstdint>
#include <cinttypes>
#include <span>
namespace libremidi
@@ -109,12 +107,12 @@ struct input_state_machine : input_state_machine_base<input_configuration>
{
message.bytes.clear();
message.timestamp = {};
m_state = main;
state = main;
}
bool has_finished_sysex(std::span<const uint8_t> bytes) const noexcept
{
return (((bytes.front() == 0xF0) || (m_state == in_sysex)) && (bytes.back() == 0xF7));
return (((bytes.front() == 0xF0) || (state == in_sysex)) && (bytes.back() == 0xF7));
}
// Function to process a byte stream which may contain multiple successive
@@ -141,22 +139,22 @@ private:
void on_bytes_multi_segmented(
const message_callback& cb, std::span<const uint8_t> bytes, int64_t timestamp)
{
int64_t n_bytes = bytes.size();
int64_t i_byte = 0;
int64_t nBytes = bytes.size();
int64_t iByte = 0;
const bool finished_sysex = has_finished_sysex(bytes);
switch (m_state)
switch (state)
{
case in_sysex: {
return on_continue_sysex(cb, bytes, finished_sysex);
}
case main: {
while (i_byte < n_bytes)
while (iByte < nBytes)
{
int64_t size = 1;
// We are expecting that the next byte in the packet is a status
// byte.
const auto status = bytes[i_byte];
const auto status = bytes[iByte];
if (!(status & 0x80))
break;
@@ -172,17 +170,17 @@ private:
if (configuration.ignore_sysex)
{
size = 0;
i_byte = n_bytes;
iByte = nBytes;
}
else
{
size = n_bytes - i_byte;
size = nBytes - iByte;
}
if (bytes[n_bytes - 1] != 0xF7)
if (bytes[nBytes - 1] != 0xF7)
{
// We know per CoreMIDI API there can't be anything else in this packet
m_state = in_sysex;
state = in_sysex;
message.assign(bytes.begin(), bytes.begin() + size);
message.timestamp = timestamp;
return;
@@ -194,7 +192,7 @@ private:
if (configuration.ignore_timing)
{
size = 0;
i_byte += 2;
iByte += 2;
}
else
{
@@ -211,7 +209,7 @@ private:
if (configuration.ignore_timing)
{
size = 0;
i_byte += 1;
iByte += 1;
}
else
{
@@ -224,7 +222,7 @@ private:
if (configuration.ignore_sensing)
{
size = 0;
i_byte += 1;
iByte += 1;
}
else
{
@@ -240,14 +238,14 @@ private:
// Now process the actual bytes of the message
if (size > 0)
{
auto begin = bytes.begin() + i_byte;
auto begin = bytes.begin() + iByte;
message.assign(begin, begin + size);
message.timestamp = timestamp;
cb(std::move(message));
message.clear();
i_byte += size;
iByte += size;
}
}
}
@@ -258,7 +256,7 @@ private:
const message_callback& cb, std::span<const uint8_t> bytes, bool finished_sysex)
{
if (finished_sysex)
m_state = main;
state = main;
if (configuration.ignore_sysex)
{
@@ -285,7 +283,7 @@ private:
// SYSEX start
case 0xF0: {
if (!finished_sysex)
m_state = in_sysex;
state = in_sysex;
if (!this->configuration.ignore_sysex)
{
@@ -330,7 +328,7 @@ private:
return;
const bool finished_sysex = has_finished_sysex(bytes);
switch (m_state)
switch (state)
{
case in_sysex:
return on_continue_sysex(cb, bytes, finished_sysex);
@@ -348,7 +346,7 @@ private:
{
main,
in_sysex
} m_state{main};
} state{main};
};
}
@@ -455,18 +453,6 @@ private:
return;
break;
}
case CMIDI2_MESSAGE_TYPE_MIDI_1_CHANNEL: {
if (this->configuration.midi1_channel_events_to_midi2)
{
libremidi::ump msg;
cmidi2_ump_upgrade_midi1_channel_voice_to_midi2(bytes.data(), msg.data);
msg.timestamp = timestamp;
cb(std::move(msg));
return;
}
break;
}
}
libremidi::ump msg;
include/libremidi/detail/semaphore.hpp
+1
View File
@@ -1,5 +1,6 @@
#pragma once
#include <chrono>
#include <semaphore>
struct semaphore_pair_lock
include/libremidi/detail/ump_stream.hpp
+1
View File
@@ -2,6 +2,7 @@
#include <libremidi/cmidi2.hpp>
#include <libremidi/error.hpp>
#include <cinttypes>
#include <cstdint>
namespace libremidi
include/libremidi/error.hpp
+1 -1
View File
@@ -28,7 +28,7 @@ struct source_location {
namespace libremidi
{
inline auto from_errc(int64_t ret) noexcept
inline auto from_errc(int ret) noexcept
{
return static_cast<std::errc>(-ret);
}
include/libremidi/input_configuration.hpp
-5
View File
@@ -123,10 +123,5 @@ struct ump_input_configuration
uint32_t ignore_sensing : 1 = true;
uint32_t timestamps : 3 = timestamp_mode::Absolute;
//! Upscale MIDI 1 channel events to MIDI 2 channel events.
//! Note that this only has an effect on Windows with MIDI Services
//! as other platforms already do this by default.
uint32_t midi1_channel_events_to_midi2 : 1 = true;
};
}
include/libremidi/libremidi-c.cpp
+6 -6
View File
@@ -44,14 +44,14 @@ const char* libremidi_get_version(void)
return LIBREMIDI_VERSION;
}
void libremidi_midi1_available_apis(void* ctx, void (*cb)(void* ctx, libremidi_api))
void libremidi_available_midi1_apis(void* ctx, void (*cb)(void* ctx, libremidi_api))
{
if (!cb)
return;
libremidi::midi1::for_all_backends([=](auto b) { cb(ctx, b.API); });
}
void libremidi_midi2_available_apis(void* ctx, void (*cb)(void* ctx, libremidi_api))
void libremidi_available_midi2_apis(void* ctx, void (*cb)(void* ctx, libremidi_api))
{
if (!cb)
return;
@@ -276,11 +276,11 @@ int libremidi_midi_in_new(
= [cb = c->get_timestamp](int64_t msg) { return cb.callback(cb.context, msg); };
}
if (c->version == libremidi_midi_configuration::MIDI1 && c->on_midi1_message.callback)
if (c->on_midi1_message.callback)
conf.on_message = [cb = c->on_midi1_message](const libremidi::message& msg) {
cb.callback(cb.context, msg.timestamp, msg.bytes.data(), msg.size());
};
else if (c->version == libremidi_midi_configuration::MIDI1_RAW && c->on_midi1_raw_data.callback)
else if (c->on_midi1_raw_data.callback)
{
conf.on_raw_data = [cb = c->on_midi1_raw_data](std::span<const uint8_t> msg, int64_t ts) {
cb.callback(cb.context, ts, msg.data(), msg.size());
@@ -319,11 +319,11 @@ int libremidi_midi_in_new(
= [cb = c->get_timestamp](int64_t msg) { return cb.callback(cb.context, msg); };
}
if (c->version == libremidi_midi_configuration::MIDI2 && c->on_midi2_message.callback)
if (c->on_midi2_message.callback)
conf.on_message = [cb = c->on_midi2_message](const libremidi::ump& msg) {
cb.callback(cb.context, msg.timestamp, msg.data, msg.size());
};
else if (c->version == libremidi_midi_configuration::MIDI2_RAW && c->on_midi2_raw_data.callback)
else if (c->on_midi2_raw_data.callback)
{
conf.on_raw_data = [cb = c->on_midi2_raw_data](std::span<const uint32_t> msg, int64_t ts) {
cb.callback(cb.context, ts, msg.data(), msg.size());
include/libremidi/libremidi.cpp
+18 -42
View File
@@ -53,13 +53,14 @@ LIBREMIDI_INLINE libremidi::API get_compiled_api_by_name(std::string_view name)
midi2::for_all_backends([&](auto b) { apis.push_back(b.API); });
return apis;
}
LIBREMIDI_INLINE
libremidi::API midi_api(const input_api_configuration& conf)
libremidi::API midi_api(const std::any& conf)
{
libremidi::API ret = libremidi::API::UNSPECIFIED;
midi_any::for_all_backends([&]<typename T>(T) {
if (std::get_if<typename T::midi_in_configuration>(&conf))
if (std::any_cast<typename T::midi_in_configuration>(&conf)
|| std::any_cast<typename T::midi_out_configuration>(&conf)
|| std::any_cast<typename T::midi_observer_configuration>(&conf))
{
ret = T::API;
}
@@ -67,34 +68,9 @@ libremidi::API midi_api(const input_api_configuration& conf)
return ret;
}
LIBREMIDI_INLINE
libremidi::API midi_api(const output_api_configuration& conf)
std::any midi_in_configuration_for(libremidi::API api)
{
libremidi::API ret = libremidi::API::UNSPECIFIED;
midi_any::for_all_backends([&]<typename T>(T) {
if (std::get_if<typename T::midi_out_configuration>(&conf))
{
ret = T::API;
}
});
return ret;
}
LIBREMIDI_INLINE
libremidi::API midi_api(const observer_api_configuration& conf)
{
libremidi::API ret = libremidi::API::UNSPECIFIED;
midi_any::for_all_backends([&]<typename T>(T) {
if (std::get_if<typename T::midi_observer_configuration>(&conf))
{
ret = T::API;
}
});
return ret;
}
LIBREMIDI_INLINE
input_api_configuration midi_in_configuration_for(libremidi::API api)
{
input_api_configuration ret;
std::any ret;
midi_any::for_backend(api, [&]<typename T>(T) {
using conf_type = typename T::midi_in_configuration;
ret = conf_type{};
@@ -103,9 +79,9 @@ input_api_configuration midi_in_configuration_for(libremidi::API api)
}
LIBREMIDI_INLINE
output_api_configuration midi_out_configuration_for(libremidi::API api)
std::any midi_out_configuration_for(libremidi::API api)
{
output_api_configuration ret;
std::any ret;
midi_any::for_backend(api, [&]<typename T>(T) {
using conf_type = typename T::midi_out_configuration;
ret = conf_type{};
@@ -114,9 +90,9 @@ output_api_configuration midi_out_configuration_for(libremidi::API api)
}
LIBREMIDI_INLINE
observer_api_configuration observer_configuration_for(libremidi::API api)
std::any observer_configuration_for(libremidi::API api)
{
observer_api_configuration ret;
std::any ret;
midi_any::for_backend(api, [&]<typename T>(T) {
using conf_type = typename T::midi_observer_configuration;
ret = conf_type{};
@@ -125,13 +101,13 @@ observer_api_configuration observer_configuration_for(libremidi::API api)
}
LIBREMIDI_INLINE
input_api_configuration midi_in_configuration_for(const libremidi::observer& obs)
std::any midi_in_configuration_for(const libremidi::observer& obs)
{
return midi_in_configuration_for(obs.get_current_api());
}
LIBREMIDI_INLINE
output_api_configuration midi_out_configuration_for(const libremidi::observer& obs)
std::any midi_out_configuration_for(const libremidi::observer& obs)
{
// FIXME reuse context when meaningful, e.g. ALSA, JACK...
return midi_out_configuration_for(obs.get_current_api());
@@ -168,19 +144,19 @@ catch (const std::exception& e)
namespace midi1
{
LIBREMIDI_INLINE
input_api_configuration in_default_configuration()
std::any in_default_configuration()
{
return midi_in_configuration_for(default_api());
}
LIBREMIDI_INLINE
output_api_configuration out_default_configuration()
std::any out_default_configuration()
{
return midi_out_configuration_for(default_api());
}
LIBREMIDI_INLINE
observer_api_configuration observer_default_configuration()
std::any observer_default_configuration()
{
return observer_configuration_for(default_api());
}
@@ -189,19 +165,19 @@ observer_api_configuration observer_default_configuration()
namespace midi2
{
LIBREMIDI_INLINE
input_api_configuration in_default_configuration()
std::any in_default_configuration()
{
return midi_in_configuration_for(default_api());
}
LIBREMIDI_INLINE
output_api_configuration out_default_configuration()
std::any out_default_configuration()
{
return midi_out_configuration_for(default_api());
}
LIBREMIDI_INLINE
observer_api_configuration observer_default_configuration()
std::any observer_default_configuration()
{
return observer_configuration_for(default_api());
}
include/libremidi/libremidi.hpp
+9 -9
View File
@@ -58,7 +58,6 @@
*/
#include <libremidi/api.hpp>
#include <libremidi/configurations.hpp>
#include <libremidi/defaults.hpp>
#include <libremidi/input_configuration.hpp>
#include <libremidi/message.hpp>
@@ -69,6 +68,7 @@
#include <midi/sysex.h>
#include <midi/universal_packet.h>
#endif
#include <any>
namespace libremidi
{
@@ -84,7 +84,7 @@ public:
//! such as jack_observer_configuration, winmm_observer_configuration, etc...
//! * if no callbacks are passed, no secondary thread will be created unless absolutely necessary
explicit observer(const observer_configuration& conf = {}) noexcept;
explicit observer(const observer_configuration& conf, observer_api_configuration api_conf);
explicit observer(observer_configuration conf, std::any api_conf);
observer(const observer&) = delete;
observer(observer&& other) noexcept;
observer& operator=(const observer&) = delete;
@@ -98,7 +98,7 @@ public:
[[nodiscard]] std::vector<libremidi::output_port> get_output_ports() const noexcept;
private:
std::unique_ptr<class observer_api> m_impl;
std::unique_ptr<class observer_api> impl_;
};
//! Main class for receiving MIDI 1.0 and 2.0 messages.
@@ -111,15 +111,15 @@ public:
//! Construct a midi_in object with a configuration object for a specific MIDI 1 back-end
//! see configuration.hpp for the available configuration types.
//! An exception will be thrown if the requested back-end cannot be opened.
explicit midi_in(const input_configuration& conf, const input_api_configuration& api_conf);
explicit midi_in(input_configuration conf, std::any api_conf);
//! Construct a midi_in object with the default MIDI 2 back-end for the platform
explicit midi_in(const ump_input_configuration& conf) noexcept;
explicit midi_in(ump_input_configuration conf) noexcept;
//! Construct a midi_in object with a configuration object for a specific MIDI 2 back-end
//! see configuration.hpp for the available configuration types.
//! An exception will be thrown if the requested back-end cannot be opened.
explicit midi_in(const ump_input_configuration& conf, const input_api_configuration& api_conf);
explicit midi_in(ump_input_configuration conf, std::any api_conf);
midi_in(const midi_in&) = delete;
midi_in(midi_in&& other) noexcept;
@@ -157,7 +157,7 @@ public:
timestamp absolute_timestamp() const noexcept;
private:
std::unique_ptr<class midi_in_api> m_impl;
std::unique_ptr<class midi_in_api> impl_;
};
//! Main class for sending MIDI 1.0 and 2.0 messages.
@@ -170,7 +170,7 @@ public:
//! Construct a midi_out object with a configuration object for a specific back-end
//! see configuration.hpp for the available configuration types.
//! An exception will be thrown if the requested back-end cannot be opened.
explicit midi_out(const output_configuration& conf, const output_api_configuration& api_conf);
explicit midi_out(output_configuration conf, std::any api_conf);
midi_out(const midi_out&) = delete;
midi_out(midi_out&& other) noexcept;
@@ -260,7 +260,7 @@ public:
stdx::error schedule_ump(int64_t timestamp, const uint32_t* message, size_t size) const;
private:
std::unique_ptr<class midi_out_api> m_impl;
std::unique_ptr<class midi_out_api> impl_;
};
}
include/libremidi/message.hpp
+8 -5
View File
@@ -2,7 +2,6 @@
#include <libremidi/config.hpp>
#include <algorithm>
#include <cstdint>
#include <span>
#include <vector>
#if defined(__cpp_exceptions)
@@ -122,8 +121,12 @@ struct message
auto rbegin() noexcept { return bytes.rbegin(); }
auto rend() noexcept { return bytes.rend(); }
bool uses_channel(int channel) const LIBREMIDI_PRECONDITION(channel > 0 && channel <= 16)
bool uses_channel(int channel) const
{
#if defined(__cpp_exceptions)
if (channel <= 0 || channel > 16)
throw std::range_error("out of range");
#endif
return ((bytes[0] & 0xF) == channel - 1) && ((bytes[0] & 0xF0) != 0xF0);
}
@@ -247,12 +250,12 @@ struct meta_events
int notated_32nd_notes_per_beat = 96)
{
int n = 1;
int pow_two = 0;
int powTwo = 0;
while (n < denominator)
{
n <<= 1;
++pow_two;
++powTwo;
}
return {
@@ -260,7 +263,7 @@ struct meta_events
0x58,
0x04,
static_cast<uint8_t>(numerator),
static_cast<uint8_t>(pow_two),
static_cast<uint8_t>(powTwo),
static_cast<uint8_t>(clocks_per_click),
static_cast<uint8_t>(notated_32nd_notes_per_beat)};
}
include/libremidi/midi_in.cpp
+45 -47
View File
@@ -61,14 +61,14 @@ convert_midi2_to_midi1_input_configuration(const ump_input_configuration& base_c
}
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api>
make_midi_in(auto base_conf, input_api_configuration api_conf, auto backends)
make_midi_in(auto base_conf, std::any api_conf, auto backends)
{
std::unique_ptr<midi_in_api> ptr;
assert(base_conf.on_message || base_conf.on_raw_data);
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_in_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_in_configuration>(&api_conf))
{
ptr = libremidi::make<typename T::midi_in>(std::move(base_conf), std::move(*conf));
return true;
@@ -117,9 +117,8 @@ make_midi1_in(const input_configuration& base_conf)
return std::make_unique<midi_in_dummy>(input_configuration{}, dummy_configuration{});
}
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api> make_midi1_in(
const input_configuration& base_conf, const input_api_configuration& api_conf,
libremidi::API api)
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api>
make_midi1_in(const input_configuration& base_conf, const std::any& api_conf, libremidi::API api)
{
if (libremidi::is_midi1(api))
{
@@ -134,13 +133,13 @@ static LIBREMIDI_INLINE std::unique_ptr<midi_in_api> make_midi1_in(
}
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api>
make_midi1_in(const input_configuration& base_conf, const input_api_configuration& api_conf)
make_midi1_in(const input_configuration& base_conf, const std::any& api_conf)
{
if (std::get_if<unspecified_configuration>(&api_conf))
if (!api_conf.has_value())
{
return make_midi1_in(base_conf);
}
else if (auto api_p = std::get_if<libremidi::API>(&api_conf))
else if (auto api_p = std::any_cast<libremidi::API>(&api_conf))
{
if (*api_p == libremidi::API::UNSPECIFIED)
{
@@ -162,19 +161,19 @@ make_midi1_in(const input_configuration& base_conf, const input_api_configuratio
/// MIDI 1 constructors
LIBREMIDI_INLINE midi_in::midi_in(const input_configuration& base_conf) noexcept
: m_impl{make_midi1_in(base_conf)}
: impl_{make_midi1_in(base_conf)}
{
}
LIBREMIDI_INLINE
midi_in::midi_in(const input_configuration& base_conf, const input_api_configuration& api_conf)
: m_impl{make_midi1_in(base_conf, api_conf)}
midi_in::midi_in(input_configuration base_conf, std::any api_conf)
: impl_{make_midi1_in(base_conf, api_conf)}
{
if (!m_impl)
if (!impl_)
{
error_handler e;
e.libremidi_handle_error(base_conf, "Could not open midi in for the given api");
m_impl = std::make_unique<midi_in_dummy>(input_configuration{}, dummy_configuration{});
impl_ = std::make_unique<midi_in_dummy>(input_configuration{}, dummy_configuration{});
}
}
@@ -215,8 +214,7 @@ make_midi2_in(const ump_input_configuration& base_conf)
}
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api> make_midi2_in(
const ump_input_configuration& base_conf, const input_api_configuration& api_conf,
libremidi::API api)
const ump_input_configuration& base_conf, const std::any& api_conf, libremidi::API api)
{
if (is_midi2(api))
{
@@ -232,13 +230,13 @@ static LIBREMIDI_INLINE std::unique_ptr<midi_in_api> make_midi2_in(
}
static LIBREMIDI_INLINE std::unique_ptr<midi_in_api>
make_midi2_in(const ump_input_configuration& base_conf, const input_api_configuration& api_conf)
make_midi2_in(const ump_input_configuration& base_conf, const std::any& api_conf)
{
if (std::get_if<unspecified_configuration>(&api_conf))
if (!api_conf.has_value())
{
return make_midi2_in(base_conf);
}
else if (auto api_p = std::get_if<libremidi::API>(&api_conf))
else if (auto api_p = std::any_cast<libremidi::API>(&api_conf))
{
if (*api_p == libremidi::API::UNSPECIFIED)
{
@@ -259,45 +257,45 @@ make_midi2_in(const ump_input_configuration& base_conf, const input_api_configur
}
/// MIDI 2 constructors
LIBREMIDI_INLINE midi_in::midi_in(const ump_input_configuration& base_conf) noexcept
: m_impl{make_midi2_in(base_conf)}
LIBREMIDI_INLINE midi_in::midi_in(ump_input_configuration base_conf) noexcept
: impl_{make_midi2_in(base_conf)}
{
}
LIBREMIDI_INLINE
midi_in::midi_in(const ump_input_configuration& base_conf, const input_api_configuration& api_conf)
: m_impl{make_midi2_in(base_conf, api_conf)}
midi_in::midi_in(ump_input_configuration base_conf, std::any api_conf)
: impl_{make_midi2_in(base_conf, api_conf)}
{
if (!m_impl)
if (!impl_)
{
error_handler e;
e.libremidi_handle_error(base_conf, "Could not open midi in for the given api");
m_impl = std::make_unique<midi_in_dummy>(input_configuration{}, dummy_configuration{});
impl_ = std::make_unique<midi_in_dummy>(input_configuration{}, dummy_configuration{});
}
}
LIBREMIDI_INLINE midi_in::~midi_in() = default;
LIBREMIDI_INLINE midi_in::midi_in(midi_in&& other) noexcept
: m_impl{std::move(other.m_impl)}
: impl_{std::move(other.impl_)}
{
other.m_impl
other.impl_
= std::make_unique<libremidi::midi_in_dummy>(input_configuration{}, dummy_configuration{});
}
LIBREMIDI_INLINE
stdx::error midi_in::set_port_name(std::string_view portName)
{
if (m_impl->is_port_open())
return m_impl->set_port_name(portName);
if(impl_->is_port_open())
return impl_->set_port_name(portName);
return std::errc::not_connected;
}
LIBREMIDI_INLINE midi_in& midi_in::operator=(midi_in&& other) noexcept
{
this->m_impl = std::move(other.m_impl);
other.m_impl
this->impl_ = std::move(other.impl_);
other.impl_
= std::make_unique<libremidi::midi_in_dummy>(input_configuration{}, dummy_configuration{});
return *this;
}
@@ -305,23 +303,23 @@ LIBREMIDI_INLINE midi_in& midi_in::operator=(midi_in&& other) noexcept
LIBREMIDI_INLINE
libremidi::API midi_in::get_current_api() const noexcept
{
return m_impl->get_current_api();
return impl_->get_current_api();
}
LIBREMIDI_INLINE
stdx::error midi_in::open_port(const input_port& port, std::string_view portName)
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
if (m_impl->is_port_open())
if (impl_->is_port_open())
return std::errc::operation_not_supported;
auto ret = m_impl->open_port(port, portName);
auto ret = impl_->open_port(port, portName);
if (ret == stdx::error{})
{
m_impl->connected_ = true;
m_impl->port_open_ = true;
impl_->connected_ = true;
impl_->port_open_ = true;
}
return ret;
}
@@ -329,28 +327,28 @@ stdx::error midi_in::open_port(const input_port& port, std::string_view portName
LIBREMIDI_INLINE
stdx::error midi_in::open_virtual_port(std::string_view portName)
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
if (m_impl->is_port_open())
if (impl_->is_port_open())
return std::errc::operation_not_supported;
auto ret = m_impl->open_virtual_port(portName);
auto ret = impl_->open_virtual_port(portName);
if (ret == stdx::error{})
m_impl->port_open_ = true;
impl_->port_open_ = true;
return ret;
}
LIBREMIDI_INLINE
stdx::error midi_in::close_port()
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
auto ret = m_impl->close_port();
auto ret = impl_->close_port();
m_impl->connected_ = false;
m_impl->port_open_ = false;
impl_->connected_ = false;
impl_->port_open_ = false;
return ret;
}
@@ -358,18 +356,18 @@ stdx::error midi_in::close_port()
LIBREMIDI_INLINE
bool midi_in::is_port_open() const noexcept
{
return m_impl->is_port_open();
return impl_->is_port_open();
}
LIBREMIDI_INLINE
bool midi_in::is_port_connected() const noexcept
{
return m_impl->is_port_connected();
return impl_->is_port_connected();
}
LIBREMIDI_INLINE
int64_t midi_in::absolute_timestamp() const noexcept
{
return m_impl->absolute_timestamp();
return impl_->absolute_timestamp();
}
}
include/libremidi/midi_out.cpp
+38 -39
View File
@@ -11,11 +11,11 @@
namespace libremidi
{
static LIBREMIDI_INLINE std::unique_ptr<midi_out_api>
make_midi_out_impl(auto base_conf, output_api_configuration api_conf)
make_midi_out_impl(auto base_conf, std::any api_conf)
{
std::unique_ptr<midi_out_api> ptr;
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_out_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_out_configuration>(&api_conf))
{
ptr = libremidi::make<typename T::midi_out>(std::move(base_conf), std::move(*conf));
return true;
@@ -23,8 +23,7 @@ make_midi_out_impl(auto base_conf, output_api_configuration api_conf)
return false;
};
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi1::available_backends);
if (!ptr)
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi2::available_backends);
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi2::available_backends);
return ptr;
}
@@ -59,13 +58,13 @@ make_midi_out(const output_configuration& base_conf)
}
static LIBREMIDI_INLINE std::unique_ptr<midi_out_api>
make_midi_out(const output_configuration& base_conf, const output_api_configuration& api_conf)
make_midi_out(const output_configuration& base_conf, const std::any& api_conf)
{
if (std::get_if<unspecified_configuration>(&api_conf))
if (!api_conf.has_value())
{
return make_midi_out(base_conf);
}
else if (auto api_p = std::get_if<libremidi::API>(&api_conf))
else if (auto api_p = std::any_cast<libremidi::API>(&api_conf))
{
if (*api_p == libremidi::API::UNSPECIFIED)
{
@@ -86,35 +85,35 @@ make_midi_out(const output_configuration& base_conf, const output_api_configurat
}
LIBREMIDI_INLINE midi_out::midi_out(const output_configuration& base_conf) noexcept
: m_impl{make_midi_out(base_conf)}
: impl_{make_midi_out(base_conf)}
{
}
LIBREMIDI_INLINE
midi_out::midi_out(const output_configuration& base_conf, const output_api_configuration& api_conf)
: m_impl{make_midi_out(base_conf, api_conf)}
midi_out::midi_out(output_configuration base_conf, std::any api_conf)
: impl_{make_midi_out(base_conf, api_conf)}
{
if (!m_impl)
if (!impl_)
{
error_handler e;
e.libremidi_handle_error(base_conf, "Could not open midi out for the given api");
m_impl = std::make_unique<midi_out_dummy>(output_configuration{}, dummy_configuration{});
impl_ = std::make_unique<midi_out_dummy>(output_configuration{}, dummy_configuration{});
}
}
LIBREMIDI_INLINE midi_out::~midi_out() = default;
LIBREMIDI_INLINE midi_out::midi_out(midi_out&& other) noexcept
: m_impl{std::move(other.m_impl)}
: impl_{std::move(other.impl_)}
{
other.m_impl
other.impl_
= std::make_unique<libremidi::midi_out_dummy>(output_configuration{}, dummy_configuration{});
}
LIBREMIDI_INLINE midi_out& midi_out::operator=(midi_out&& other) noexcept
{
this->m_impl = std::move(other.m_impl);
other.m_impl
this->impl_ = std::move(other.impl_);
other.impl_
= std::make_unique<libremidi::midi_out_dummy>(output_configuration{}, dummy_configuration{});
return *this;
}
@@ -122,8 +121,8 @@ LIBREMIDI_INLINE midi_out& midi_out::operator=(midi_out&& other) noexcept
LIBREMIDI_INLINE
stdx::error midi_out::set_port_name(std::string_view portName) const
{
if (m_impl->is_port_open())
return m_impl->set_port_name(portName);
if(impl_->is_port_open())
return impl_->set_port_name(portName);
return std::errc::not_connected;
}
@@ -131,23 +130,23 @@ stdx::error midi_out::set_port_name(std::string_view portName) const
LIBREMIDI_INLINE
libremidi::API midi_out::get_current_api() const noexcept
{
return m_impl->get_current_api();
return impl_->get_current_api();
}
LIBREMIDI_INLINE
stdx::error midi_out::open_port(const output_port& port, std::string_view portName) const
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
if (m_impl->is_port_open())
if (impl_->is_port_open())
return std::errc::operation_not_supported;
auto ret = m_impl->open_port(port, portName);
auto ret = impl_->open_port(port, portName);
if (ret == stdx::error{})
{
m_impl->connected_ = true;
m_impl->port_open_ = true;
impl_->connected_ = true;
impl_->port_open_ = true;
}
return ret;
}
@@ -155,40 +154,40 @@ stdx::error midi_out::open_port(const output_port& port, std::string_view portNa
LIBREMIDI_INLINE
stdx::error midi_out::open_virtual_port(std::string_view portName) const
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
if (m_impl->is_port_open())
if (impl_->is_port_open())
return std::errc::operation_not_supported;
auto ret = m_impl->open_virtual_port(portName);
auto ret = impl_->open_virtual_port(portName);
if (ret == stdx::error{})
m_impl->port_open_ = true;
impl_->port_open_ = true;
return ret;
}
LIBREMIDI_INLINE
stdx::error midi_out::close_port() const
{
if (auto err = m_impl->is_client_open(); err != stdx::error{})
if (auto err = impl_->is_client_open(); err != stdx::error{})
return std::errc::not_connected;
auto ret = m_impl->close_port();
m_impl->connected_ = false;
m_impl->port_open_ = false;
auto ret = impl_->close_port();
impl_->connected_ = false;
impl_->port_open_ = false;
return ret;
}
LIBREMIDI_INLINE
bool midi_out::is_port_open() const noexcept
{
return m_impl->is_port_open();
return impl_->is_port_open();
}
LIBREMIDI_INLINE
bool midi_out::is_port_connected() const noexcept
{
return m_impl->is_port_connected();
return impl_->is_port_connected();
}
LIBREMIDI_INLINE
@@ -228,13 +227,13 @@ stdx::error midi_out::send_message(const unsigned char* message, size_t size) co
assert(size > 0);
#endif
return m_impl->send_message(message, size);
return impl_->send_message(message, size);
}
LIBREMIDI_INLINE
int64_t midi_out::current_time()
{
return m_impl->current_time();
return impl_->current_time();
}
LIBREMIDI_INLINE
@@ -244,7 +243,7 @@ stdx::error midi_out::schedule_message(int64_t ts, const unsigned char* message,
assert(size > 0);
#endif
return m_impl->schedule_message(ts, message, size);
return impl_->schedule_message(ts, message, size);
}
LIBREMIDI_INLINE
@@ -255,7 +254,7 @@ stdx::error midi_out::send_ump(const uint32_t* message, size_t size) const
assert(size <= 4);
#endif
return m_impl->send_ump(message, size);
return impl_->send_ump(message, size);
}
LIBREMIDI_INLINE
stdx::error midi_out::send_ump(const libremidi::ump& message) const
@@ -322,6 +321,6 @@ stdx::error midi_out::schedule_ump(int64_t ts, const uint32_t* message, size_t s
assert(size > 0);
#endif
return m_impl->schedule_ump(ts, message, size);
return impl_->schedule_ump(ts, message, size);
}
}
include/libremidi/observer.cpp
+23 -28
View File
@@ -5,19 +5,17 @@
#include <libremidi/backends.hpp>
#include <libremidi/detail/midi_api.hpp>
#include <utility>
namespace libremidi
{
static LIBREMIDI_INLINE std::unique_ptr<observer_api> make_observer(const auto& base_conf)
static LIBREMIDI_INLINE std::unique_ptr<observer_api> make_observer(auto base_conf)
{
for (const auto& api : available_apis())
{
try
{
if (auto impl = make_observer(base_conf, observer_configuration_for(api)))
return impl;
if (auto impl_ = make_observer(base_conf, observer_configuration_for(api)))
return impl_;
}
catch (const std::exception& e)
{
@@ -28,8 +26,8 @@ static LIBREMIDI_INLINE std::unique_ptr<observer_api> make_observer(const auto&
{
try
{
if (auto impl = make_observer(base_conf, observer_configuration_for(api)))
return impl;
if (auto impl_ = make_observer(base_conf, observer_configuration_for(api)))
return impl_;
}
catch (const std::exception& e)
{
@@ -39,11 +37,11 @@ static LIBREMIDI_INLINE std::unique_ptr<observer_api> make_observer(const auto&
return std::make_unique<observer_dummy>(observer_configuration{}, dummy_configuration{});
}
LIBREMIDI_INLINE auto make_observer_impl(auto base_conf, observer_api_configuration api_conf)
LIBREMIDI_INLINE auto make_observer_impl(auto base_conf, std::any api_conf)
{
std::unique_ptr<observer_api> ptr;
auto from_api = [&]<typename T>(T& /*backend*/) mutable {
if (auto conf = std::get_if<typename T::midi_observer_configuration>(&api_conf))
if (auto conf = std::any_cast<typename T::midi_observer_configuration>(&api_conf))
{
ptr = libremidi::make<typename T::midi_observer>(std::move(base_conf), std::move(*conf));
return true;
@@ -51,19 +49,17 @@ LIBREMIDI_INLINE auto make_observer_impl(auto base_conf, observer_api_configurat
return false;
};
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi1::available_backends);
if (!ptr)
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi2::available_backends);
std::apply([&](auto&&... b) { (from_api(b) || ...); }, midi2::available_backends);
return ptr;
}
LIBREMIDI_INLINE std::unique_ptr<observer_api>
make_observer(const auto& base_conf, observer_api_configuration api_conf)
LIBREMIDI_INLINE std::unique_ptr<observer_api> make_observer(auto base_conf, std::any api_conf)
{
if (std::get_if<unspecified_configuration>(&api_conf))
if (!api_conf.has_value())
{
return make_observer(base_conf);
}
else if (auto api_p = std::get_if<libremidi::API>(&api_conf))
else if (auto api_p = std::any_cast<libremidi::API>(&api_conf))
{
if (*api_p == libremidi::API::UNSPECIFIED)
{
@@ -84,33 +80,32 @@ make_observer(const auto& base_conf, observer_api_configuration api_conf)
}
LIBREMIDI_INLINE observer::observer(const observer_configuration& base_conf) noexcept
: m_impl{make_observer(base_conf)}
: impl_{make_observer(base_conf)}
{
}
LIBREMIDI_INLINE
observer::observer(const observer_configuration& base_conf, observer_api_configuration api_conf)
: m_impl{make_observer(base_conf, std::move(api_conf))}
LIBREMIDI_INLINE observer::observer(observer_configuration base_conf, std::any api_conf)
: impl_{make_observer(base_conf, api_conf)}
{
if (!m_impl)
if (!impl_)
{
error_handler e;
e.libremidi_handle_error(base_conf, "Could not open observer for the given api");
m_impl = std::make_unique<observer_dummy>(observer_configuration{}, dummy_configuration{});
impl_ = std::make_unique<observer_dummy>(observer_configuration{}, dummy_configuration{});
}
}
LIBREMIDI_INLINE observer::observer(observer&& other) noexcept
: m_impl{std::move(other.m_impl)}
: impl_{std::move(other.impl_)}
{
other.m_impl = std::make_unique<libremidi::observer_dummy>(
other.impl_ = std::make_unique<libremidi::observer_dummy>(
observer_configuration{}, dummy_configuration{});
}
LIBREMIDI_INLINE observer& observer::operator=(observer&& other) noexcept
{
this->m_impl = std::move(other.m_impl);
other.m_impl = std::make_unique<libremidi::observer_dummy>(
this->impl_ = std::move(other.impl_);
other.impl_ = std::make_unique<libremidi::observer_dummy>(
observer_configuration{}, dummy_configuration{});
return *this;
}
@@ -121,18 +116,18 @@ observer::~observer() = default;
LIBREMIDI_INLINE
libremidi::API observer::get_current_api() const noexcept
{
return m_impl->get_current_api();
return impl_->get_current_api();
}
LIBREMIDI_INLINE
std::vector<libremidi::input_port> observer::get_input_ports() const noexcept
{
return m_impl->get_input_ports();
return impl_->get_input_ports();
}
LIBREMIDI_INLINE
std::vector<libremidi::output_port> observer::get_output_ports() const noexcept
{
return m_impl->get_output_ports();
return impl_->get_output_ports();
}
}
include/libremidi/observer_configuration.hpp
+5 -68
View File
@@ -2,106 +2,43 @@
#include <libremidi/config.hpp>
#include <libremidi/error.hpp>
#include <array>
#include <compare>
#include <string>
#include <variant>
namespace libremidi
{
using client_handle = std::uint64_t;
using port_handle = std::uint64_t;
struct uuid
{
std::array<uint8_t, 16> bytes;
bool operator==(const uuid& other) const noexcept = default;
std::strong_ordering operator<=>(const uuid& other) const noexcept = default;
};
using container_identifier = std::variant<std::monostate, uuid, std::string, std::uint64_t>;
using device_identifier = std::variant<std::monostate, std::string, std::uint64_t>;
struct LIBREMIDI_EXPORT port_information
{
enum port_type : uint8_t
{
unknown = 0,
// Handle to the client object:
software = (1 << 1),
loopback = (1 << 2),
hardware = (1 << 3),
usb = (1 << 4),
bluetooth = (1 << 5),
pci = (1 << 6),
network = (1 << 7),
};
/// Handle to the API client object if the API provides one
// ALSA Raw: unused
// ALSA Seq: snd_seq_t*
// CoreMIDI: MidiClientRef
// WebMIDI: unused
// JACK: jack_client_t*
// PipeWire: unused // FIXME: pw_context? pw_main_loop?
// PipeWire: unused
// WinMM: unused
// WinUWP: unused
client_handle client = static_cast<client_handle>(-1);
/// Container identifier if the API provides one
// WinMIDI: ContainerID GUID (bit_cast to a winapi or winrt::GUID ;
// this is not the string but the binary representation).
// ALSA: device id (std::string), e.g. ID_PATH as returned by udev: "pci-0000:00:14.0-usb-0:12:1.0"
// CoreMIDI: USBLocationID (int32_t)
container_identifier container = std::monostate{};
/// Device identifier if the API provides one
// WinMM: { uint16_t manufacturer_id, uint16_t product_id; }
// WinMIDI: EndpointDeviceId (std::string), e.g. "\\?\swd#midisrv#midiu_ksa..."
// ALSA: sysfs path (std::string), e.g. "/sys/devices/pci0000:00/0000:00:02.2/0000:02:00.0/sound/card0/controlC0"
// CoreMIDI: USBVendorProduct (int32_t)
device_identifier device = std::monostate{};
/// Handle to the port identifier if the API provides one
// ALSA Raw: bit_cast to struct { uint16_t card, device, sub, padding; }.
// ALSA Seq: bit_cast to struct { uint32_t client, port; }
// ALSA Raw: { uint16_t card, device, sub, padding; }
// ALSA Seq: { uint32_t client, uint32_t port; }
// CoreMIDI: MidiObjectRef's kMIDIPropertyUniqueID (uint32_t)
// WebMIDI: unused
// JACK: jack_port_id_t
// PipeWire: port.id
// WinMIDI: uint64_t terminal_block_number; (MidiGroupTerminalBlock::Number(), index is 1-based)
// WinMM: port index between 0 and midi{In,Out}GetNumDevs()
// WinMM: unset, identified by port_name
// WinUWP: unused
port_handle port = static_cast<port_handle>(-1);
/// User-readable information
// CoreMIDI: kMIDIPropertyManufacturer
// WinMIDI: MidiEndpointDeviceInformation::GetTransportSuppliedInfo().ManufacturerName
// WinMM: unavailable
std::string manufacturer{};
// CoreMIDI: kMIDIPropertyModel
// WinMIDI: MidiEndpointDeviceInformation::Name
// WinMM: unavailable
std::string device_name{};
// CoreMIDI: kMIDIPropertyName
// WinMIDI: MidiGroupTerminalBlock::Name
// WinMM: szPname
std::string port_name{};
// CoreMIDI: kMIDIPropertyDisplayName
// Otherwise: the closest to a unique name we can get
std::string display_name{};
/// Port type
// CoreMIDI: available
// WinMM: unavailable
// WinMIDI: available
port_type type = port_type::unknown;
bool operator==(const port_information& other) const noexcept = default;
std::strong_ordering operator<=>(const port_information& other) const noexcept = default;
};
include/libremidi/protocols/remote_control.hpp
-858
View File
@@ -1,858 +0,0 @@
#pragma once
#include <libremidi/error_handler.hpp>
#include <libremidi/message.hpp>
#include <cmath>
#include <array>
#include <cinttypes>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <span>
namespace libremidi
{
static constexpr auto to_underlying(auto e)
{
return static_cast<std::underlying_type_t<decltype(e)>>(e);
}
// A clean-room reverse-engineered remote control protocol compatible with many hardware devices.
// Thanks https://github.com/NicoG60/TouchMCU !
struct remote_control_protocol
{
enum class device_type : uint8_t
{
logic_control = 0x10,
logic_control_xt = 0x11,
mackie_control = 0x14
};
enum class command_to_device : uint8_t
{
device_query = 0x00,
host_connection_reply = 0x02,
transport_click = 0x0A,
lcd_backlight_save = 0x0B,
touchless_movable_fader = 0x0C,
faders_touch_sensitivity = 0x0E,
go_offline = 0x0F,
update_tc_display = 0x10,
update_assignment_display = 0x11,
update_lcd = 0x12,
firmware_version_request = 0x13,
version_reply = 0x14,
firmware_update = 0x18,
channel_meter_mode = 0x20,
global_lcd_meter_mode = 0x21,
faders_to_minimum = 0x61,
all_leds_off = 0x62,
reset = 0x63,
};
enum class command_from_device : uint8_t
{
host_connection_query = 0x01,
host_connection_confirmation = 0x03,
host_connection_error = 0x04,
version_reply = 0x14,
};
enum class lcd_meter_mode : uint8_t
{
horizontal = 0x00,
vertical = 0x01,
};
enum class fader_sensitivity : uint8_t
{
sensitivity_0 = 0x00,
sensitivity_1 = 0x01,
sensitivity_2 = 0x02,
sensitivity_3 = 0x03,
sensitivity_4 = 0x04,
sensitivity_default = sensitivity_3,
};
// CC Message:
// 0b0LMMVVVV
// L: toggle underneath LED
// MM: mode as led_ring_mode
// VVVV: value
enum class led_ring_mode : uint8_t
{
mode_0 = 0b00, // one led only
mode_1 = 0b01, // pan pot
mode_2 = 0b10, // fill leds from left
mode_3 = 0b11, // fill leds from middle
};
enum class pot : uint8_t
{
pot_0 = 0x00,
pot_1 = 0x01,
pot_2 = 0x02,
pot_3 = 0x03,
pot_4 = 0x04,
pot_5 = 0x05,
pot_6 = 0x06,
pot_7 = 0x07,
};
enum class fader : uint8_t
{
fader_0 = 0x00,
fader_1 = 0x01,
fader_2 = 0x02,
fader_3 = 0x03,
fader_4 = 0x04,
fader_5 = 0x05,
fader_6 = 0x06,
fader_7 = 0x07,
fader_master = 0x08,
};
// control changes
enum class mixer_control : uint8_t
{
// rotation: CC
// 0b00000001 : clockwise
// 0b01000001 : counter-clockwise
vpot_rotation_0 = 0x10 + 0x00,
vpot_rotation_1 = 0x10 + 0x01,
vpot_rotation_2 = 0x10 + 0x02,
vpot_rotation_3 = 0x10 + 0x03,
vpot_rotation_4 = 0x10 + 0x04,
vpot_rotation_5 = 0x10 + 0x05,
vpot_rotation_6 = 0x10 + 0x06,
vpot_rotation_7 = 0x10 + 0x07,
external_control = 0x2E,
// led ring: CC
vpot_led_0 = 0x30 + 0x00,
vpot_led_1 = 0x30 + 0x01,
vpot_led_2 = 0x30 + 0x02,
vpot_led_3 = 0x30 + 0x03,
vpot_led_4 = 0x30 + 0x04,
vpot_led_5 = 0x30 + 0x05,
vpot_led_6 = 0x30 + 0x06,
vpot_led_7 = 0x30 + 0x07,
jog_wheel = 0x3C,
timecode_digit_0 = 0x40 + 0x00,
timecode_digit_1 = 0x40 + 0x01,
timecode_digit_2 = 0x40 + 0x02,
timecode_digit_3 = 0x40 + 0x03,
timecode_digit_4 = 0x40 + 0x04,
timecode_digit_5 = 0x40 + 0x05,
timecode_digit_6 = 0x40 + 0x06,
timecode_digit_7 = 0x40 + 0x07,
timecode_digit_8 = 0x40 + 0x08,
timecode_digit_9 = 0x40 + 0x09,
assignment_digit_0 = 0x4A,
assignment_digit_1 = 0x4B,
};
// note events
enum class mixer_command : uint8_t
{
vpot_click_0 = 0x20 + 0x00,
vpot_click_1 = 0x20 + 0x01,
vpot_click_2 = 0x20 + 0x02,
vpot_click_3 = 0x20 + 0x03,
vpot_click_4 = 0x20 + 0x04,
vpot_click_5 = 0x20 + 0x05,
vpot_click_6 = 0x20 + 0x06,
vpot_click_7 = 0x20 + 0x07,
rec_0 = 0x00 + 0x00,
rec_1 = 0x00 + 0x01,
rec_2 = 0x00 + 0x02,
rec_3 = 0x00 + 0x03,
rec_4 = 0x00 + 0x04,
rec_5 = 0x00 + 0x05,
rec_6 = 0x00 + 0x06,
rec_7 = 0x00 + 0x07,
solo_0 = 0x08 + 0x00,
solo_1 = 0x08 + 0x01,
solo_2 = 0x08 + 0x02,
solo_3 = 0x08 + 0x03,
solo_4 = 0x08 + 0x04,
solo_5 = 0x08 + 0x05,
solo_6 = 0x08 + 0x06,
solo_7 = 0x08 + 0x07,
mute_0 = 0x10 + 0x00,
mute_1 = 0x10 + 0x01,
mute_2 = 0x10 + 0x02,
mute_3 = 0x10 + 0x03,
mute_4 = 0x10 + 0x04,
mute_5 = 0x10 + 0x05,
mute_6 = 0x10 + 0x06,
mute_7 = 0x10 + 0x07,
sel_0 = 0x18 + 0x00,
sel_1 = 0x18 + 0x01,
sel_2 = 0x18 + 0x02,
sel_3 = 0x18 + 0x03,
sel_4 = 0x18 + 0x04,
sel_5 = 0x18 + 0x05,
sel_6 = 0x18 + 0x06,
sel_7 = 0x18 + 0x07,
// TODO metering
assign_track = 0x28,
assign_send = 0x29,
assign_pan = 0x2A,
assign_plugin = 0x2B,
assign_eq = 0x2C,
assign_instrument = 0x2D,
bank_left = 0x2E,
bank_right = 0x2F,
channel_left = 0x30,
channel_right = 0x31,
flip = 0x32,
global = 0x33,
name_value_button = 0x34,
smpte_beats_button = 0x35,
f1 = 0x36 + 0x00,
f2 = 0x36 + 0x01,
f3 = 0x36 + 0x02,
f4 = 0x36 + 0x03,
f5 = 0x36 + 0x04,
f6 = 0x36 + 0x05,
f7 = 0x36 + 0x06,
f8 = 0x36 + 0x07,
midi_tracks = 0x3E,
inputs = 0x3F,
audio_tracks = 0x40,
audio_instruments = 0x41,
aux = 0x42,
busses = 0x43,
outputs = 0x44,
user = 0x45,
shift = 0x46,
option = 0x47,
control = 0x48,
alt = 0x49,
save = 0x50,
undo = 0x51,
cancel = 0x52,
enter = 0x53,
markers = 0x54,
nudge = 0x55,
cycle = 0x56,
drop = 0x57,
replace = 0x58,
click = 0x59,
solo = 0x5a,
rewind = 0x5b,
forward = 0x5c,
stop = 0x5d,
play = 0x5e,
record = 0x5f,
up = 0x60,
down = 0x61,
left = 0x62,
right = 0x63,
zoom = 0x64,
scrub = 0x65,
user_switch_1 = 0x66,
user_switch_2 = 0x67,
fader_touched_0 = 0x68,
fader_touched_1 = 0x69,
fader_touched_2 = 0x6a,
fader_touched_3 = 0x6b,
fader_touched_4 = 0x6c,
fader_touched_5 = 0x6d,
fader_touched_6 = 0x6e,
fader_touched_7 = 0x6f,
fader_touched_master = 0x70,
smpte_led = 0x71,
beats_led = 0x72,
rude_solo_led = 0x73,
relay_click = 0x76,
};
template <std::size_t N>
using arr = std::array<uint8_t, N>;
device_type type = device_type::mackie_control;
static libremidi::message make_command_impl(auto&&... data)
{
using namespace std;
libremidi::message m;
m.bytes.reserve((std::ssize(data) + ...));
(m.bytes.insert(m.bytes.end(), begin(data), end(data)), ...);
return m;
}
libremidi::message make_command(command_to_device c, auto&&... data)
{
using namespace std;
const auto type = to_underlying(this->type);
const auto cmd = to_underlying(c);
const uint8_t header[6]{0xF0, 0x00, 0x00, 0x66, type, cmd};
const uint8_t footer[1]{0xF7};
return make_command_impl(header, data..., footer);
}
auto device_query() { return make_command(command_to_device::device_query); }
auto response_to_challenge(arr<4> c)
{
arr<4> r;
r[0] = 0x7F & (c[0] + (c[1] ^ 0x0A) - c[3]);
r[1] = 0x7F & ((c[2] >> 4) ^ (c[0] + c[3]));
r[2] = 0x7F & (c[3] - (c[2] << 2) ^ (c[0] | c[1]));
r[3] = 0x7F & (c[1] - c[2] + (0xF0 ^ (c[3] << 4)));
return r;
}
auto host_connection_reply(arr<7> serial, arr<4> challenge_code)
{
const auto res = response_to_challenge(challenge_code);
return make_command(command_to_device::host_connection_reply, serial, res);
}
auto transport_click(bool enabled)
{
return make_command(
command_to_device::transport_click, arr<1>{uint8_t(enabled ? 0x01 : 0x00)});
}
auto lcd_backlight_save(uint8_t timeout)
{
// 0: instant off otherwise timeout in minutes
return make_command(command_to_device::lcd_backlight_save, arr<1>{timeout});
}
auto touchless_movable_fader(bool enabled)
{
return make_command(
command_to_device::touchless_movable_fader, arr<1>{uint8_t(enabled ? 0x01 : 0x00)});
}
auto faders_touch_sensitivity(uint8_t fader_id, fader_sensitivity sens)
{
return make_command(
command_to_device::faders_touch_sensitivity, arr<2>{fader_id, to_underlying(sens)});
}
auto go_offline() { return make_command(command_to_device::go_offline, arr<1>{0x7F}); }
auto update_tc_display()
{
// FIXME 1 .. 10
return make_command(command_to_device::update_tc_display, arr<10>{});
}
auto update_assignment_display()
{
// FIXME 1 .. 2
return make_command(command_to_device::update_assignment_display, arr<2>{});
}
auto update_lcd(std::string_view txt, int pos)
{
// FIXME
if (pos < 0 || pos >= 112)
return libremidi::message{};
int len = int(std::ssize(txt));
if (len > (112 - pos))
{
txt = txt.substr(0, 112 - pos);
len = 112 - pos;
}
uint8_t buf[128];
const int N = std::min(len, 112 - pos);
for (int i = 0; i < N; i++)
{
buf[i + pos] = charmap_lcd(txt[i]);
}
buf[55] = '\n';
buf[111] = '\n';
uint8_t cmd_pos = pos;
return make_command(command_to_device::update_lcd, arr<1>{cmd_pos}, std::span(buf + pos, len));
}
auto update_lcd(std::string_view txt)
{
uint8_t buf[112] = {};
for (int i = 0; i < std::min(int(std::ssize(txt)), 112); i++)
{
buf[i] = charmap_lcd(txt[i]);
}
buf[55] = '\n';
buf[111] = '\n';
return make_command(command_to_device::update_lcd, arr<1>{0}, std::span(buf, 112));
}
auto firmware_version_request()
{
return make_command(command_to_device::firmware_version_request, arr<1>{0});
}
auto firmware_update(std::span<uint8_t> firmware)
{
return make_command(command_to_device::firmware_update, firmware);
}
auto channel_meter_mode(uint8_t fader_id, bool level_meter, bool peak_hold, bool signal_led)
{
uint8_t mode = 0;
if (signal_led)
mode |= 0b1;
if (peak_hold)
mode |= 0b10;
if (level_meter)
mode |= 0b100;
return make_command(command_to_device::channel_meter_mode, arr<2>{fader_id, mode});
}
auto global_lcd_meter_mode(lcd_meter_mode mode)
{
return make_command(command_to_device::global_lcd_meter_mode, arr<1>{to_underlying(mode)});
}
auto faders_to_minimum() { return make_command(command_to_device::faders_to_minimum); }
auto all_leds_off() { return make_command(command_to_device::all_leds_off); }
auto reset() { return make_command(command_to_device::reset); }
static auto timecode(int hi, int mi, int si, int framei)
{
std::vector<libremidi::message> msg;
auto h = std::to_string(hi);
while (h.size() < 3)
h.insert(h.begin(), '0');
auto m = std::to_string(mi);
while (m.size() < 2)
m.insert(m.begin(), '0');
auto s = std::to_string(si);
while (s.size() < 2)
s.insert(s.begin(), '0');
auto f = std::to_string(framei);
while (f.size() < 3)
f.insert(f.begin(), '0');
using ce = libremidi::channel_events;
msg.push_back(ce::control_change(1, 0x49, charmap_7segment(h[0])));
msg.push_back(ce::control_change(1, 0x48, charmap_7segment(h[1])));
msg.push_back(ce::control_change(1, 0x47, charmap_7segment(h[2])));
msg.push_back(ce::control_change(1, 0x46, charmap_7segment(m[0])));
msg.push_back(ce::control_change(1, 0x45, charmap_7segment(m[1])));
msg.push_back(ce::control_change(1, 0x44, charmap_7segment(s[0])));
msg.push_back(ce::control_change(1, 0x43, charmap_7segment(s[1])));
msg.push_back(ce::control_change(1, 0x42, charmap_7segment(f[0])));
msg.push_back(ce::control_change(1, 0x41, charmap_7segment(f[1])));
msg.push_back(ce::control_change(1, 0x40, charmap_7segment(f[2])));
return msg;
}
static uint8_t charmap_7segment(char c, bool dot)
{
uint8_t res = charmap_7segment(c);
if (dot)
res |= 0b00100000;
return res;
};
static uint8_t charmap_7segment(char c)
{
// FIXME there are some more characters but what to map them to ? :)
if (c >= 'a' && c <= 'z')
return c - 'a' + 1;
else if (c >= 'A' && c <= 'Z')
return c - 'A' + 1;
else if (c >= '0' && c <= '9')
return c - '0' + 0x30;
else
switch (c)
{
case '[':
case '{':
return 0x1B;
case '\\':
case '~': // yen too ?
return 0x1C;
case ']':
case '}':
return 0x1D;
case '^':
return 0x1E;
case '_':
return 0x1F;
case '!':
return 0x21;
case '"':
return 0x22;
case '#':
return 0x23;
case '$':
return 0x24;
case '%':
return 0x25;
case '&':
return 0x26;
case '\'':
return 0x27;
case '(':
return 0x28;
case ')':
return 0x29;
case '*':
return 0x2A;
case '+':
return 0x2B;
case ',':
return 0x2C;
case '-':
return 0x2D;
case '.':
return 0x2E;
case '/':
return 0x2F;
case ':':
return 0x3A;
case ';':
return 0x3B;
case '<':
return 0x3C;
case '=':
return 0x3D;
case '>':
return 0x3E;
case '?':
return 0x3F;
default:
return 0x00;
}
}
static uint8_t charmap_lcd(char c)
{
// FIXME there are some more characters but what to map them to ? :)
if (c >= 'a' && c <= 'z')
return c - 'a' + 0x61;
else if (c >= 'A' && c <= 'Z')
return c - 'A' + 0x41;
else if (c >= '0' && c <= '9')
return c - '0' + 0x30;
else
switch (c)
{
case '!':
return 0x21;
case '"':
return 0x22;
case '#':
return 0x23;
case '$':
return 0x24;
case '%':
return 0x25;
case '&':
return 0x26;
case '\'':
return 0x27;
case '(':
return 0x28;
case ')':
return 0x29;
case '*':
return 0x2A;
case '+':
return 0x2B;
case ',':
return 0x2C;
case '-':
return 0x2D;
case '.':
return 0x2E;
case '/':
return 0x2F;
case ':':
return 0x3A;
case ';':
return 0x3B;
case '<':
return 0x3C;
case '=':
return 0x3D;
case '>':
return 0x3E;
case '?':
return 0x3F;
case '@':
return 0x40;
case '[':
return 0x5B;
case '~': // Yen symbol... builtin mojibake?
return 0x5C;
case ']':
return 0x5D;
case '^':
return 0x5E;
case '_':
return 0x5F;
case '`':
return 0x60;
case '{':
return 0x7B;
case '|':
return 0x7C;
case '}':
return 0x7D;
case '\u000E':
return 0x7E;
case '\u000F':
return 0x7F;
default:
return c; // gives access to the bubble first row 0x00 > 0x0F
}
}
};
struct rcp_configuration
{
//! How to send MIDI messages to the device.
//! Note: this function *will* be called from different thread,
//! thus it has to be thread-safe, for instance
//! by storing the message in an event queue.
std::function<void(libremidi::message&&)> midi_out;
std::function<void(libremidi::remote_control_protocol::device_type)> on_connected;
std::function<void(libremidi::remote_control_protocol::mixer_command, bool)> on_command;
std::function<void(libremidi::remote_control_protocol::mixer_control, int)> on_control;
std::function<void(libremidi::remote_control_protocol::fader, uint16_t)> on_fader;
libremidi::midi_error_callback on_error{};
};
struct remote_control_processor : libremidi::error_handler
{
using rcp = libremidi::remote_control_protocol;
rcp_configuration configuration;
rcp impl;
explicit remote_control_processor(rcp_configuration conf)
: configuration{std::move(conf)}
{
assert(configuration.midi_out);
if (!configuration.on_error)
configuration.on_error = [](std::string_view s, auto&&...) {
std::fprintf(stderr, "libremidi: rcp error: %s\n", s.data());
};
if (!configuration.on_connected)
configuration.on_connected
= [this](auto&&...) { libremidi_handle_error(configuration, "Unhandled on_connected"); };
if (!configuration.on_command)
configuration.on_command
= [this](auto&&...) { libremidi_handle_error(configuration, "Unhandled on_command"); };
if (!configuration.on_control)
configuration.on_control
= [this](auto&&...) { libremidi_handle_error(configuration, "Unhandled on_control"); };
if (!configuration.on_fader)
configuration.on_fader
= [this](auto&&...) { libremidi_handle_error(configuration, "Unhandled on_fader"); };
}
void start()
{
current_state = waiting_for_query;
configuration.midi_out(impl.device_query());
}
void on_midi(const libremidi::message& message)
{
switch (message.get_message_type())
{
case libremidi::message_type::SYSTEM_EXCLUSIVE:
if (auto N = message.size(); N >= 7)
{
const uint8_t* bytes = message.bytes.data();
// strip 0xF0 & 0xF7
bytes += 1;
N -= 2;
// Mackie manufacturer ID check
if (bytes[0] == 0x00 && bytes[1] == 0x00 && bytes[2] == 0x66)
{
impl.type = static_cast<rcp::device_type>(bytes[3]);
// strip header
bytes += 4;
N -= 4;
on_rcp_command(std::span(bytes, N));
}
}
else
{
libremidi_handle_error(configuration, "Invalid sysex");
}
break;
case libremidi::message_type::NOTE_ON:
configuration.on_command(static_cast<rcp::mixer_command>(message[1]), message[2] > 0);
break;
case libremidi::message_type::NOTE_OFF:
break;
case libremidi::message_type::CONTROL_CHANGE:
configuration.on_control(static_cast<rcp::mixer_control>(message[1]), message[2]);
break;
case libremidi::message_type::PITCH_BEND: {
uint16_t value = message.bytes[2] * 128 + message.bytes[1];
configuration.on_fader(static_cast<rcp::fader>(uint8_t(message.get_channel() - 1)), value);
break;
}
default:
break;
}
}
void on_rcp_command(std::span<const uint8_t> cmd)
{
if (cmd.empty())
{
libremidi_handle_error(configuration, "on_rcp_command: empty command");
return;
}
auto command = static_cast<rcp::command_from_device>(cmd[0]);
cmd = cmd.subspan(1);
switch (command)
{
case rcp::command_from_device::host_connection_query: {
if (cmd.size() == 11)
{
current_state = got_query;
std::array<uint8_t, 7> serial;
std::array<uint8_t, 4> challenge;
std::copy_n(cmd.data(), 7, serial.begin());
std::copy_n(cmd.data() + 7, 4, challenge.begin());
configuration.midi_out(impl.host_connection_reply(serial, challenge));
}
else
libremidi_handle_error(configuration, "host_connection_query: invalid size");
break;
}
case rcp::command_from_device::host_connection_confirmation:
current_state = connected;
configuration.on_connected(impl.type);
break;
case rcp::command_from_device::host_connection_error:
current_state = errored;
libremidi_handle_error(configuration, "host_connection_error");
break;
case rcp::command_from_device::version_reply: {
// TODO
break;
}
default:
break;
}
}
void update_timecode(int h, int m, int s, int f)
{
for (auto&& m : rcp::timecode(h, m, s, f))
configuration.midi_out(std::move(m));
}
void update_lcd(std::string_view v)
{
auto res = impl.update_lcd(v);
if (!res.empty())
configuration.midi_out(std::move(res));
}
void update_lcd(std::string_view v, int pos)
{
auto res = impl.update_lcd(v, pos);
if (!res.empty())
configuration.midi_out(std::move(res));
}
void command(remote_control_protocol::mixer_command c, bool press)
{
using ce = libremidi::channel_events;
configuration.midi_out(ce::note_on(1, to_underlying(c), press ? 127 : 0));
configuration.midi_out(ce::note_off(1, to_underlying(c), press ? 127 : 0));
}
void control(remote_control_protocol::mixer_control c, int value)
{
using ce = libremidi::channel_events;
configuration.midi_out(ce::control_change(1, to_underlying(c), value));
}
void fader(remote_control_protocol::fader c, uint16_t value)
{
int idx = to_underlying(c);
using ce = libremidi::channel_events;
configuration.midi_out(ce::pitch_bend(idx + 1, value));
}
// State machine
enum
{
waiting_for_query,
got_query,
connected,
errored
} current_state{waiting_for_query};
};
}
include/libremidi/reader.cpp
+41 -41
View File
@@ -521,7 +521,7 @@ LIBREMIDI_INLINE
reader::reader(bool useAbsolute)
: ticksPerBeat(480)
, startingTempo(120)
, m_useAbsoluteTicks(useAbsolute)
, useAbsoluteTicks(useAbsolute)
{
}
@@ -549,12 +549,12 @@ try
return parse_result::invalid;
}
const uint8_t* const data_end = dataPtr + size;
const uint8_t* const dataEnd = dataPtr + size;
uint32_t header_id = read_checked::read_uint32_be(dataPtr, data_end);
uint32_t header_length = read_checked::read_uint32_be(dataPtr, data_end);
uint32_t headerId = read_checked::read_uint32_be(dataPtr, dataEnd);
uint32_t headerLength = read_checked::read_uint32_be(dataPtr, dataEnd);
if (static_cast<int>(header_id) != str_to_headerid("MThd") || header_length != 6)
if (static_cast<int>(headerId) != str_to_headerid("MThd") || headerLength != 6)
{
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "couldn't parse header" << std::endl;
@@ -563,7 +563,7 @@ try
}
format = read_checked::read_uint16_be(
dataPtr, data_end); //@tofix format type -> save for later eventually
dataPtr, dataEnd); //@tofix format type -> save for later eventually
if (format > 2)
{
#if defined(__LIBREMIDI_DEBUG__)
@@ -571,12 +571,12 @@ try
#endif
return parse_result::invalid;
}
int track_count = read_checked::read_uint16_be(dataPtr, data_end);
uint16_t time_division = read_checked::read_uint16_be(dataPtr, data_end);
int trackCount = read_checked::read_uint16_be(dataPtr, dataEnd);
uint16_t timeDivision = read_checked::read_uint16_be(dataPtr, dataEnd);
// CBB: deal with the SMPTE style time coding
// timeDivision is described here http://www.sonicspot.com/guide/midifiles.html
if (time_division & 0x8000)
if (timeDivision & 0x8000)
{
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "found SMPTE time frames (unsupported)" << std::endl;
@@ -590,18 +590,18 @@ try
}
startingTempo = 120.0f; // midi default
ticksPerBeat = float(time_division); // ticks per beat (a beat is defined as a quarter note)
ticksPerBeat = float(timeDivision); // ticks per beat (a beat is defined as a quarter note)
parse_result result = parse_result::validated;
for (int i = 0; i < track_count; ++i)
for (int i = 0; i < trackCount; ++i)
{
midi_track track;
header_id = read_checked::read_uint32_be(dataPtr, data_end);
header_length = read_checked::read_uint32_be(dataPtr, data_end);
headerId = read_checked::read_uint32_be(dataPtr, dataEnd);
headerLength = read_checked::read_uint32_be(dataPtr, dataEnd);
if (header_id != str_to_headerid("MTrk"))
if (headerId != str_to_headerid("MTrk"))
{
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "couldn't find track header" << std::endl;
@@ -609,8 +609,8 @@ try
return parse_result::incomplete;
}
int64_t available = data_end - dataPtr;
if (available < header_length)
int64_t available = dataEnd - dataPtr;
if (available < headerLength)
{
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "not enough data available" << std::endl;
@@ -618,35 +618,35 @@ try
return parse_result::incomplete;
}
track.reserve(header_length / 3);
track.reserve(headerLength / 3);
const uint8_t* const track_end = dataPtr + header_length;
const uint8_t* const trackEnd = dataPtr + headerLength;
auto running_event = message_type::INVALID;
auto runningEvent = message_type::INVALID;
std::size_t tick_count = 0;
std::size_t tickCount = 0;
while (dataPtr < track_end)
while (dataPtr < trackEnd)
{
const auto tick = read_checked::read_variable_length(dataPtr, track_end);
if (m_useAbsoluteTicks)
const auto tick = read_checked::read_variable_length(dataPtr, trackEnd);
if (useAbsoluteTicks)
{
tick_count += tick;
tickCount += tick;
}
else
{
tick_count = tick;
tickCount = tick;
}
try
{
track_event ev
= parse_event(static_cast<int>(tick_count), i, dataPtr, track_end, running_event);
= parse_event(static_cast<int>(tickCount), i, dataPtr, trackEnd, runningEvent);
if (!ev.m.empty())
{
if (!ev.m.is_meta_event())
{
running_event = static_cast<message_type>(ev.m.bytes[0]);
runningEvent = static_cast<message_type>(ev.m.bytes[0]);
}
}
else
@@ -654,7 +654,7 @@ try
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "could not read event" << std::endl;
#endif
dataPtr = track_end;
dataPtr = trackEnd;
result = parse_result::incomplete;
continue;
}
@@ -666,7 +666,7 @@ try
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "" << e.what() << std::endl;
#endif
dataPtr = track_end;
dataPtr = trackEnd;
result = parse_result::incomplete;
continue;
}
@@ -684,7 +684,7 @@ try
if (result == parse_result::validated)
{
if (dataPtr != data_end)
if (dataPtr != dataEnd)
{
#if defined(__LIBREMIDI_DEBUG__)
std::cerr << "midifile has junk at end: " << std::intptr_t(dataEnd - dataPtr) << std::endl;
@@ -706,33 +706,33 @@ catch (const std::exception& e)
LIBREMIDI_INLINE
double reader::get_end_time() const noexcept
{
if (m_useAbsoluteTicks)
if (useAbsoluteTicks)
{
double total_length = 0.;
double totalLength = 0.;
for (const auto& t : tracks)
{
if (!t.empty())
{
const auto& last_event = t.back();
if (last_event.tick > total_length)
total_length = last_event.tick;
if (last_event.tick > totalLength)
totalLength = last_event.tick;
}
}
return total_length;
return totalLength;
}
else
{
double total_length = 0.;
double totalLength = 0.;
for (const auto& t : tracks)
{
double track_length = 0.;
double trackLength = 0.;
for (const auto& e : t)
track_length += e.tick;
trackLength += e.tick;
if (track_length > total_length)
total_length = track_length;
if (trackLength > totalLength)
totalLength = trackLength;
}
return total_length;
return totalLength;
}
}
include/libremidi/reader.hpp
+1 -1
View File
@@ -66,7 +66,7 @@ public:
std::vector<midi_track> tracks;
private:
bool m_useAbsoluteTicks{};
bool useAbsoluteTicks{};
};
}
include/libremidi/shared_context.hpp
+4 -4
View File
@@ -1,6 +1,8 @@
#pragma once
#include <libremidi/api.hpp>
#include <libremidi/configurations.hpp>
#include <libremidi/config.hpp>
#include <any>
namespace libremidi
{
@@ -22,9 +24,7 @@ public:
struct shared_configurations
{
std::shared_ptr<shared_context> context;
observer_api_configuration observer;
input_api_configuration in;
output_api_configuration out;
std::any observer, in, out;
};
LIBREMIDI_EXPORT

Some files were not shown because too many files have changed in this diff Show More