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 int err = snd_seq_connect_to(&seq, sourcePort, destClient, destPort);
101 snd_seq_delete_simple_port(&seq, sourcePort);
103 "Failed to connect to ALSA port "
104 "(", destClient,
':', destPort,
")"
105 ": ", snd_strerror(err));
113void MidiOutALSA::disconnect()
115 snd_midi_event_free(event_parser);
116 snd_seq_disconnect_to(&seq, sourcePort, destClient, destPort);
117 snd_seq_delete_simple_port(&seq, sourcePort);
133 const std::vector<uint8_t>& message, EmuTime::param )
136 snd_seq_ev_clear(&ev);
139 snd_seq_ev_set_source(&ev, narrow_cast<uint8_t>(sourcePort));
140 snd_seq_ev_set_subs(&ev);
143 long encodeLen = snd_midi_event_encode(
144 event_parser, message.data(), narrow<long>(message.size()), &ev);
146 std::cerr <<
"Error encoding MIDI message of type "
147 << std::hex << int(message[0]) << std::dec
148 <<
": " << snd_strerror(narrow<int>(encodeLen)) <<
'\n';
151 if (ev.type == SND_SEQ_EVENT_NONE) {
152 std::cerr <<
"Incomplete MIDI message of type "
153 << std::hex << int(message[0]) << std::dec <<
'\n';
158 snd_seq_ev_set_direct(&ev);
159 int err = snd_seq_event_output(&seq, &ev);
161 std::cerr <<
"Error sending MIDI event: "
162 << snd_strerror(err) <<
'\n';
164 snd_seq_drain_output(&seq);
167template<
typename Archive>
170 if constexpr (Archive::IS_LOADER) {
183 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo);
189 [[nodiscard]] std::string_view
getName()
const override;
193 void signal(EmuTime::param time)
override;
195 template<
typename Archive>
196 void serialize(Archive& ar,
unsigned version);
204 int signalEvent(
const Event& event)
override;
211 snd_midi_event_t* event_parser;
212 int destinationPort = -1;
217 bool connected =
false;
227 snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo)
228 : eventDistributor(eventDistributor_)
229 , scheduler(scheduler_)
231 , srcClient(snd_seq_port_info_get_client(&pinfo))
232 , srcPort(snd_seq_port_info_get_port(&pinfo))
233 , name(snd_seq_client_info_get_name(&cinfo))
234 , desc(snd_seq_port_info_get_name(&pinfo))
237 if ((snd_seq_port_info_get_capability(&pinfo) & (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE))) {
238 name.append(
" (input)");
252 auto& midiConnector = checked_cast<MidiInConnector&>(connector_);
269void MidiInALSA::connect()
271 destinationPort = snd_seq_create_simple_port(
272 &seq,
"MIDI in pluggable",
273 SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
274 if (destinationPort < 0) {
276 "Failed to create ALSA port: ", snd_strerror(destinationPort));
279 int err = snd_seq_connect_from(&seq, destinationPort, srcClient, srcPort);
281 snd_seq_delete_simple_port(&seq, destinationPort);
283 "Failed to connect to ALSA port "
284 "(", srcClient,
':', srcPort,
")"
285 ": ", snd_strerror(err));
289 snd_midi_event_no_status(event_parser, 1);
294 thread = std::thread([
this]() { run(); });
297void MidiInALSA::disconnect()
302 snd_midi_event_free(event_parser);
303 snd_seq_disconnect_from(&seq, destinationPort, srcClient, srcPort);
304 snd_seq_delete_simple_port(&seq, destinationPort);
309void MidiInALSA::run()
313 auto npfd = snd_seq_poll_descriptors_count(&seq, POLLIN);
314 std::vector<struct pollfd> pfd(npfd);
315 snd_seq_poll_descriptors(&seq, pfd.data(), npfd, POLLIN);
318 if (poll(pfd.data(), npfd, 1000) > 0) {
319 snd_seq_event_t *ev =
nullptr;
320 if (
auto err = snd_seq_event_input(&seq, &ev); err < 0) {
321 std::cerr <<
"Error receiving MIDI event: "
322 << snd_strerror(err) <<
'\n';
327 if (ev->type == SND_SEQ_EVENT_SYSEX) {
328 std::lock_guard<std::mutex> lock(mutex);
329 for (
auto i :
xrange(ev->data.ext.len)) {
330 queue.
push_back(
static_cast<uint8_t*
>(ev->data.ext.ptr)[i]);
334 std::array<uint8_t, 12> bytes = {};
335 auto size = snd_midi_event_decode(event_parser, bytes.data(), bytes.size(), ev);
337 std::cerr <<
"Error decoding MIDI event: "
338 << snd_strerror(
int(size)) <<
'\n';
339 snd_seq_free_event(ev);
343 std::lock_guard<std::mutex> lock(mutex);
348 snd_seq_free_event(ev);
356 auto* conn = checked_cast<MidiInConnector*>(
getConnector());
357 if (!conn->acceptsData()) {
358 std::lock_guard<std::mutex> lock(mutex);
362 if (!conn->ready())
return;
366 std::lock_guard<std::mutex> lock(mutex);
367 if (queue.
empty())
return;
370 conn->recvByte(data, time);
374int MidiInALSA::signalEvent(
const Event& )
379 std::lock_guard<std::mutex> lock(mutex);
395template<
typename Archive>
398 if constexpr (Archive::IS_LOADER) {
408std::unique_ptr<MidiSessionALSA> MidiSessionALSA::instance;
417 int err = snd_seq_open(&seq,
"default", SND_SEQ_OPEN_DUPLEX, 0);
420 "Could not open sequencer: ", snd_strerror(err));
423 snd_seq_set_client_name(seq,
"openMSX");
426 instance->scanClients(controller, eventDistributor, scheduler);
429MidiSessionALSA::MidiSessionALSA(snd_seq_t& seq_)
441void MidiSessionALSA::scanClients(
447 snd_seq_client_info_t* cInfo;
448 snd_seq_client_info_alloca(&cInfo);
449 snd_seq_client_info_set_client(cInfo, -1);
450 while (snd_seq_query_next_client(&seq, cInfo) >= 0) {
451 int client = snd_seq_client_info_get_client(cInfo);
452 if (client == SND_SEQ_CLIENT_SYSTEM) {
458 snd_seq_port_info_t* pInfo;
459 snd_seq_port_info_alloca(&pInfo);
460 snd_seq_port_info_set_client(pInfo, client);
461 snd_seq_port_info_set_port(pInfo, -1);
462 while (snd_seq_query_next_port(&seq, pInfo) >= 0) {
463 unsigned int type = snd_seq_port_info_get_type(pInfo);
464 if (!(type & SND_SEQ_PORT_TYPE_MIDI_GENERIC)) {
467 constexpr unsigned int wrCaps =
468 SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
469 constexpr unsigned int rdCaps =
470 SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
471 if ((snd_seq_port_info_get_capability(pInfo) & wrCaps) == wrCaps) {
473 seq, *cInfo, *pInfo));
475 if ((snd_seq_port_info_get_capability(pInfo) & rdCaps) == rdCaps) {
477 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)