28 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo);
36 [[nodiscard]] std::string_view
getName()
const override;
41 const std::vector<uint8_t>& message, EmuTime::param time)
override;
43 template<
typename Archive>
44 void serialize(Archive& ar,
unsigned version);
52 snd_midi_event_t* event_parser;
58 bool connected =
false;
63 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo)
65 , destClient(snd_seq_port_info_get_client(&pinfo))
66 , destPort(snd_seq_port_info_get_port(&pinfo))
67 , name(snd_seq_client_info_get_name(&cinfo))
68 , desc(snd_seq_port_info_get_name(&pinfo))
89void MidiOutALSA::connect()
91 sourcePort = snd_seq_create_simple_port(
92 &seq,
"MIDI out pluggable",
93 0, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
96 "Failed to create ALSA port: ", snd_strerror(sourcePort));
99 if (
int err = snd_seq_connect_to(&seq, sourcePort, destClient, destPort)) {
100 snd_seq_delete_simple_port(&seq, sourcePort);
102 "Failed to connect to ALSA port "
103 "(", destClient,
':', destPort,
")"
104 ": ", snd_strerror(err));
112void MidiOutALSA::disconnect()
114 snd_midi_event_free(event_parser);
115 snd_seq_disconnect_to(&seq, sourcePort, destClient, destPort);
116 snd_seq_delete_simple_port(&seq, sourcePort);
132 const std::vector<uint8_t>& message, EmuTime::param )
135 snd_seq_ev_clear(&ev);
138 snd_seq_ev_set_source(&ev, narrow_cast<uint8_t>(sourcePort));
139 snd_seq_ev_set_subs(&ev);
142 if (
auto encodeLen = snd_midi_event_encode(
143 event_parser, message.data(), narrow<long>(message.size()), &ev);
145 std::cerr <<
"Error encoding MIDI message of type "
146 << std::hex << int(message[0]) << std::dec
147 <<
": " << snd_strerror(narrow<int>(encodeLen)) <<
'\n';
150 if (ev.type == SND_SEQ_EVENT_NONE) {
151 std::cerr <<
"Incomplete MIDI message of type "
152 << std::hex << int(message[0]) << std::dec <<
'\n';
157 snd_seq_ev_set_direct(&ev);
158 if (
int err = snd_seq_event_output(&seq, &ev); err < 0) {
159 std::cerr <<
"Error sending MIDI event: "
160 << snd_strerror(err) <<
'\n';
162 snd_seq_drain_output(&seq);
165template<
typename Archive>
168 if constexpr (Archive::IS_LOADER) {
181 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo);
187 [[nodiscard]] std::string_view
getName()
const override;
191 void signal(EmuTime::param time)
override;
193 template<
typename Archive>
194 void serialize(Archive& ar,
unsigned version);
202 int signalEvent(
const Event& event)
override;
209 snd_midi_event_t* event_parser;
210 int destinationPort = -1;
215 bool connected =
false;
225 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo)
226 : eventDistributor(eventDistributor_)
227 , scheduler(scheduler_)
229 , srcClient(snd_seq_port_info_get_client(&pinfo))
230 , srcPort(snd_seq_port_info_get_port(&pinfo))
231 , name(snd_seq_client_info_get_name(&cinfo))
232 , desc(snd_seq_port_info_get_name(&pinfo))
235 if (snd_seq_port_info_get_capability(&pinfo) & (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) {
236 name.append(
" (input)");
250 auto& midiConnector = checked_cast<MidiInConnector&>(connector_);
267void MidiInALSA::connect()
269 destinationPort = snd_seq_create_simple_port(
270 &seq,
"MIDI in pluggable",
271 SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
272 if (destinationPort < 0) {
274 "Failed to create ALSA port: ", snd_strerror(destinationPort));
277 if (
int err = snd_seq_connect_from(&seq, destinationPort, srcClient, srcPort)) {
278 snd_seq_delete_simple_port(&seq, destinationPort);
280 "Failed to connect to ALSA port "
281 "(", srcClient,
':', srcPort,
")"
282 ": ", snd_strerror(err));
286 snd_midi_event_no_status(event_parser, 1);
291 thread = std::thread([
this]() { run(); });
294void MidiInALSA::disconnect()
299 snd_midi_event_free(event_parser);
300 snd_seq_disconnect_from(&seq, destinationPort, srcClient, srcPort);
301 snd_seq_delete_simple_port(&seq, destinationPort);
306void MidiInALSA::run()
310 auto npfd = snd_seq_poll_descriptors_count(&seq, POLLIN);
311 std::vector<struct pollfd> pfd(npfd);
312 snd_seq_poll_descriptors(&seq, pfd.data(), npfd, POLLIN);
315 if (poll(pfd.data(), npfd, 1000) > 0) {
316 snd_seq_event_t *ev =
nullptr;
317 if (
auto err = snd_seq_event_input(&seq, &ev); err < 0) {
318 std::cerr <<
"Error receiving MIDI event: "
319 << snd_strerror(err) <<
'\n';
324 if (ev->type == SND_SEQ_EVENT_SYSEX) {
325 std::scoped_lock lock(mutex);
326 for (
auto i :
xrange(ev->data.ext.len)) {
327 queue.
push_back(
static_cast<uint8_t*
>(ev->data.ext.ptr)[i]);
331 std::array<uint8_t, 12> bytes = {};
332 auto size = snd_midi_event_decode(event_parser, bytes.data(), bytes.size(), ev);
334 std::cerr <<
"Error decoding MIDI event: "
335 << snd_strerror(
int(size)) <<
'\n';
336 snd_seq_free_event(ev);
340 std::scoped_lock lock(mutex);
345 snd_seq_free_event(ev);
353 auto* conn = checked_cast<MidiInConnector*>(
getConnector());
354 if (!conn->acceptsData()) {
355 std::scoped_lock lock(mutex);
359 if (!conn->ready())
return;
363 std::scoped_lock lock(mutex);
364 if (queue.
empty())
return;
367 conn->recvByte(data, time);
371int MidiInALSA::signalEvent(
const Event& )
376 std::scoped_lock lock(mutex);
392template<
typename Archive>
395 if constexpr (Archive::IS_LOADER) {
405std::unique_ptr<MidiSessionALSA> MidiSessionALSA::instance;
414 if (
int err = snd_seq_open(&seq,
"default", SND_SEQ_OPEN_DUPLEX, 0);
417 "Could not open sequencer: ", snd_strerror(err));
420 snd_seq_set_client_name(seq,
"openMSX");
423 instance->scanClients(controller, eventDistributor, scheduler);
426MidiSessionALSA::MidiSessionALSA(snd_seq_t& seq_)
438void MidiSessionALSA::scanClients(
444 snd_seq_client_info_t* cInfo;
445 snd_seq_client_info_alloca(&cInfo);
446 snd_seq_client_info_set_client(cInfo, -1);
447 while (snd_seq_query_next_client(&seq, cInfo) >= 0) {
448 int client = snd_seq_client_info_get_client(cInfo);
449 if (client == SND_SEQ_CLIENT_SYSTEM) {
455 snd_seq_port_info_t* pInfo;
456 snd_seq_port_info_alloca(&pInfo);
457 snd_seq_port_info_set_client(pInfo, client);
458 snd_seq_port_info_set_port(pInfo, -1);
459 while (snd_seq_query_next_port(&seq, pInfo) >= 0) {
460 if (
unsigned type = snd_seq_port_info_get_type(pInfo);
461 !(type & SND_SEQ_PORT_TYPE_MIDI_GENERIC)) {
464 constexpr unsigned wrCaps =
465 SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
466 constexpr unsigned rdCaps =
467 SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
468 if ((snd_seq_port_info_get_capability(pInfo) & wrCaps) == wrCaps) {
470 seq, *cInfo, *pInfo));
472 if ((snd_seq_port_info_get_capability(pInfo) & rdCaps) == rdCaps) {
474 eventDistributor, scheduler, seq, *cInfo, *pInfo));
This implements a queue on top of circular_buffer (not part of boost).
void printError(std::string_view message)
Represents something you can plug devices into.
void unregisterEventListener(EventType type, EventListener &listener)
Unregisters a previously registered event listener.
void distributeEvent(Event &&event)
Schedule the given event for delivery.
void registerEventListener(EventType type, EventListener &listener, Priority priority=OTHER)
Registers a given object to receive certain events.
std::string_view getDescription() const override
Description for this pluggable.
void serialize(Archive &ar, unsigned version)
std::string_view getName() const override
Name used to identify this pluggable.
void plugHelper(Connector &connector, EmuTime::param time) override
MidiInALSA(EventDistributor &eventDistributor, Scheduler &scheduler, snd_seq_t &seq, snd_seq_client_info_t &cinfo, snd_seq_port_info_t &pinfo)
void unplugHelper(EmuTime::param time) override
void signal(EmuTime::param time) override
MidiOutALSA & operator=(const MidiOutALSA &)=delete
void serialize(Archive &ar, unsigned version)
MidiOutALSA(snd_seq_t &seq, snd_seq_client_info_t &cinfo, snd_seq_port_info_t &pinfo)
MidiOutALSA(const MidiOutALSA &)=delete
void plugHelper(Connector &connector, EmuTime::param time) override
std::string_view getName() const override
Name used to identify this pluggable.
void recvMessage(const std::vector< uint8_t > &message, EmuTime::param time) override
Called when a full MIDI message is ready to be sent.
void unplugHelper(EmuTime::param time) override
std::string_view getDescription() const override
Description for this pluggable.
Pluggable that connects an MSX MIDI out port to a host MIDI device.
static constexpr size_t MAX_MESSAGE_SIZE
The limit for the amount of data we'll put into one MIDI message.
Lists ALSA MIDI ports we can connect to.
static void registerAll(PluggingController &controller, CliComm &cliComm, EventDistributor &eventDistributor, Scheduler &scheduler)
Thrown when a plug action fails.
bool isPluggedIn() const
Returns true if this pluggable is currently plugged into a connector.
void setConnector(Connector *conn)
Connector * getConnector() const
Get the connector this Pluggable is plugged into.
Central administration of Connectors and Pluggables.
void registerPluggable(std::unique_ptr< Pluggable > pluggable)
Add a Pluggable to the registry.
EmuTime::param getCurrentTime() const
Get the current scheduler time.
This file implemented 3 utility functions:
std::variant< KeyUpEvent, KeyDownEvent, MouseMotionEvent, MouseButtonUpEvent, MouseButtonDownEvent, MouseWheelEvent, JoystickAxisMotionEvent, JoystickHatEvent, JoystickButtonUpEvent, JoystickButtonDownEvent, OsdControlReleaseEvent, OsdControlPressEvent, WindowEvent, TextEvent, FileDropEvent, QuitEvent, FinishFrameEvent, CliCommandEvent, GroupEvent, BootEvent, FrameDrawnEvent, BreakEvent, SwitchRendererEvent, TakeReverseSnapshotEvent, AfterTimedEvent, MachineLoadedEvent, MachineActivatedEvent, MachineDeactivatedEvent, MidiInReaderEvent, MidiInWindowsEvent, MidiInCoreMidiEvent, MidiInCoreMidiVirtualEvent, MidiInALSAEvent, Rs232TesterEvent, Rs232NetEvent, ImGuiDelayedActionEvent, ImGuiActiveEvent > Event
size_t size(std::string_view utf8)
#define INSTANTIATE_SERIALIZE_METHODS(CLASS)
constexpr auto xrange(T e)