X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Falsa%2Falsa_rawmidi.cc;h=d1c46f98cf17634e809d462e092891c721a4eb3c;hb=79374df84e79b87d6b2aa600f3512f56772a119d;hp=b3a5720aa27632e2e510f10f188658d1ab2d325d;hpb=bc67e47048d5a9f30088787cef2860d91851a8d9;p=ardour.git diff --git a/libs/backends/alsa/alsa_rawmidi.cc b/libs/backends/alsa/alsa_rawmidi.cc index b3a5720aa2..d1c46f98cf 100644 --- a/libs/backends/alsa/alsa_rawmidi.cc +++ b/libs/backends/alsa/alsa_rawmidi.cc @@ -18,39 +18,27 @@ */ #include - #include +#include "select_sleep.h" #include "alsa_rawmidi.h" -#include "rt_thread.h" #include "pbd/error.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; -/* max bytes per individual midi-event - * events larger than this are ignored */ -#define MaxAlsaRawEventSize (64) - #ifndef NDEBUG #define _DEBUGPRINT(STR) fprintf(stderr, STR); #else #define _DEBUGPRINT(STR) ; #endif -AlsaRawMidiIO::AlsaRawMidiIO (const char *device, const bool input) - : _state (-1) - , _running (false) +AlsaRawMidiIO::AlsaRawMidiIO (const std::string &name, const char *device, const bool input) + : AlsaMidiIO() , _device (0) - , _pfds (0) - , _sample_length_us (1e6 / 48000.0) - , _period_length_us (1.024e6 / 48000.0) - , _samples_per_period (1024) - , _rb (0) { - pthread_mutex_init (&_notify_mutex, 0); - pthread_cond_init (&_notify_ready, 0); + _name = name; init (device, input); } @@ -61,10 +49,6 @@ AlsaRawMidiIO::~AlsaRawMidiIO () snd_rawmidi_close (_device); _device = 0; } - delete _rb; - pthread_mutex_destroy (&_notify_mutex); - pthread_cond_destroy (&_notify_ready); - free (_pfds); } void @@ -87,12 +71,6 @@ AlsaRawMidiIO::init (const char *device_name, const bool input) _pfds = (struct pollfd*) malloc (_npfds * sizeof(struct pollfd)); snd_rawmidi_poll_descriptors (_device, _pfds, _npfds); - // MIDI (hw port) 31.25 kbaud - // worst case here is 8192 SPP and 8KSPS for which we'd need - // 4000 bytes sans MidiEventHeader. - // since we're not always in sync, let's use 4096. - _rb = new RingBuffer(4096 + 4096 * sizeof(MidiEventHeader)); - #if 0 _state = 0; #else @@ -106,7 +84,7 @@ AlsaRawMidiIO::init (const char *device_name, const bool input) if (snd_rawmidi_params_set_avail_min (_device, params, 1)) { goto initerr; } - if ( snd_rawmidi_params_set_buffer_size (_device, params, 64)) { + if (snd_rawmidi_params_set_buffer_size (_device, params, 64)) { goto initerr; } if (snd_rawmidi_params_set_no_active_sensing (_device, params, 1)) { @@ -124,131 +102,24 @@ initerr: return; } -static void * pthread_process (void *arg) -{ - AlsaRawMidiIO *d = static_cast(arg); - d->main_process_thread (); - pthread_exit (0); - return 0; -} - -int -AlsaRawMidiIO::start () -{ - if (_realtime_pthread_create (SCHED_FIFO, -21, 100000, - &_main_thread, pthread_process, this)) - { - if (pthread_create (&_main_thread, NULL, pthread_process, this)) { - PBD::error << _("AlsaRawMidiIO: Failed to create process thread.") << endmsg; - return -1; - } else { - PBD::warning << _("AlsaRawMidiIO: Cannot acquire realtime permissions.") << endmsg; - } - } - int timeout = 5000; - while (!_running && --timeout > 0) { Glib::usleep (1000); } - if (timeout == 0 || !_running) { - return -1; - } - return 0; -} - -int -AlsaRawMidiIO::stop () -{ - void *status; - if (!_running) { - return 0; - } - - _running = false; - - pthread_mutex_lock (&_notify_mutex); - pthread_cond_signal (&_notify_ready); - pthread_mutex_unlock (&_notify_mutex); - - if (pthread_join (_main_thread, &status)) { - PBD::error << _("AlsaRawMidiIO: Failed to terminate.") << endmsg; - return -1; - } - return 0; -} - -void -AlsaRawMidiIO::setup_timing (const size_t samples_per_period, const float samplerate) -{ - _period_length_us = (double) samples_per_period * 1e6 / samplerate; - _sample_length_us = 1e6 / samplerate; - _samples_per_period = samples_per_period; -} - -void -AlsaRawMidiIO::sync_time (const uint64_t tme) -{ - // TODO consider a PLL, if this turns out to be the bottleneck for jitter - // also think about using - // snd_pcm_status_get_tstamp() and snd_rawmidi_status_get_tstamp() - // instead of monotonic clock. -#ifdef DEBUG_TIMING - double tdiff = (_clock_monotonic + _period_length_us - tme) / 1000.0; - if (abs(tdiff) >= .05) { - printf("AlsaRawMidiIO MJ: %.1f ms\n", tdiff); - } -#endif - _clock_monotonic = tme; -} - -/////////////////////////////////////////////////////////////////////////////// - -// select sleeps _at most_ (compared to usleep() which sleeps at least) -static void select_sleep (uint32_t usec) { - if (usec <= 10) return; - fd_set fd; - int max_fd=0; - struct timeval tv; - tv.tv_sec = usec / 1000000; - tv.tv_usec = usec % 1000000; - FD_ZERO (&fd); - select (max_fd, &fd, NULL, NULL, &tv); -} - /////////////////////////////////////////////////////////////////////////////// -AlsaRawMidiOut::AlsaRawMidiOut (const char *device) - : AlsaRawMidiIO (device, false) +AlsaRawMidiOut::AlsaRawMidiOut (const std::string &name, const char *device) + : AlsaRawMidiIO (name, device, false) + , AlsaMidiOut () { } - -int -AlsaRawMidiOut::send_event (const pframes_t time, const uint8_t *data, const size_t size) -{ - const uint32_t buf_size = sizeof (MidiEventHeader) + size; - if (_rb->write_space() < buf_size) { - _DEBUGPRINT("AlsaRawMidiOut: ring buffer overflow\n"); - return -1; - } - struct MidiEventHeader h (_clock_monotonic + time * _sample_length_us, size); - _rb->write ((uint8_t*) &h, sizeof(MidiEventHeader)); - _rb->write (data, size); - - if (pthread_mutex_trylock (&_notify_mutex) == 0) { - pthread_cond_signal (&_notify_ready); - pthread_mutex_unlock (&_notify_mutex); - } - return 0; -} - void * AlsaRawMidiOut::main_process_thread () { _running = true; pthread_mutex_lock (&_notify_mutex); - bool need_drain = false; + unsigned int need_drain = 0; while (_running) { bool have_data = false; struct MidiEventHeader h(0,0); - uint8_t data[MaxAlsaRawEventSize]; + uint8_t data[MaxAlsaMidiEventSize]; const uint32_t read_space = _rb->read_space(); @@ -258,7 +129,7 @@ AlsaRawMidiOut::main_process_thread () break; } assert (read_space >= h.size); - if (h.size > MaxAlsaRawEventSize) { + if (h.size > MaxAlsaMidiEventSize) { _rb->increment_read_idx (h.size); _DEBUGPRINT("AlsaRawMidiOut: MIDI event too large!\n"); continue; @@ -271,9 +142,9 @@ AlsaRawMidiOut::main_process_thread () } if (!have_data) { - if (need_drain) { + if (need_drain > 0) { snd_rawmidi_drain (_device); - need_drain = false; + need_drain = 0; } pthread_cond_wait (&_notify_ready, &_notify_mutex); continue; @@ -281,9 +152,9 @@ AlsaRawMidiOut::main_process_thread () uint64_t now = g_get_monotonic_time(); while (h.time > now + 500) { - if (need_drain) { + if (need_drain > 0) { snd_rawmidi_drain (_device); - need_drain = false; + need_drain = 0; } else { select_sleep(h.time - now); } @@ -320,6 +191,14 @@ retry: ssize_t err = snd_rawmidi_write (_device, data, h.size); +#if 0 // DEBUG -- not rt-safe + printf("TX [%ld | %ld]", h.size, err); + for (size_t i = 0; i < h.size; ++i) { + printf (" %02x", data[i]); + } + printf ("\n"); +#endif + if ((err == -EAGAIN)) { snd_rawmidi_drain (_device); goto retry; @@ -338,7 +217,11 @@ retry: h.size -= err; goto retry; } - need_drain = true; + + if ((need_drain += h.size) >= 64) { + snd_rawmidi_drain (_device); + need_drain = 0; + } } pthread_mutex_unlock (&_notify_mutex); @@ -349,8 +232,9 @@ retry: /////////////////////////////////////////////////////////////////////////////// -AlsaRawMidiIn::AlsaRawMidiIn (const char *device) - : AlsaRawMidiIO (device, true) +AlsaRawMidiIn::AlsaRawMidiIn (const std::string &name, const char *device) + : AlsaRawMidiIO (name, device, true) + , AlsaMidiIn () , _event(0,0) , _first_time(true) , _unbuffered_bytes(0) @@ -360,70 +244,6 @@ AlsaRawMidiIn::AlsaRawMidiIn (const char *device) { } -size_t -AlsaRawMidiIn::recv_event (pframes_t &time, uint8_t *data, size_t &size) -{ - const uint32_t read_space = _rb->read_space(); - struct MidiEventHeader h(0,0); - - if (read_space <= sizeof(MidiEventHeader)) { - return 0; - } - -#if 1 - // check if event is in current cycle - RingBuffer::rw_vector vector; - _rb->get_read_vector(&vector); - if (vector.len[0] >= sizeof(MidiEventHeader)) { - memcpy((uint8_t*)&h, vector.buf[0], sizeof(MidiEventHeader)); - } else { - if (vector.len[0] > 0) { - memcpy ((uint8_t*)&h, vector.buf[0], vector.len[0]); - } - memcpy (((uint8_t*)&h) + vector.len[0], vector.buf[1], sizeof(MidiEventHeader) - vector.len[0]); - } - - if (h.time >= _clock_monotonic + _period_length_us ) { -#ifdef DEBUG_TIMING - printf("AlsaRawMidiIn DEBUG: POSTPONE EVENT TO NEXT CYCLE: %.1f spl\n", ((h.time - _clock_monotonic) / _sample_length_us)); -#endif - return 0; - } - _rb->increment_read_idx (sizeof(MidiEventHeader)); -#else - if (_rb->read ((uint8_t*)&h, sizeof(MidiEventHeader)) != sizeof(MidiEventHeader)) { - _DEBUGPRINT("AlsaRawMidiIn::recv_event Garbled MIDI EVENT HEADER!!\n"); - return 0; - } -#endif - assert (h.size > 0); - if (h.size > size) { - _DEBUGPRINT("AlsaRawMidiIn::recv_event MIDI event too large!\n"); - _rb->increment_read_idx (h.size); - return 0; - } - if (_rb->read (&data[0], h.size) != h.size) { - _DEBUGPRINT("AlsaRawMidiIn::recv_event Garbled MIDI EVENT DATA!!\n"); - return 0; - } - if (h.time < _clock_monotonic) { -#ifdef DEBUG_TIMING - printf("AlsaRawMidiIn DEBUG: MIDI TIME < 0 %.1f spl\n", ((_clock_monotonic - h.time) / -_sample_length_us)); -#endif - time = 0; - } else if (h.time >= _clock_monotonic + _period_length_us ) { -#ifdef DEBUG_TIMING - printf("AlsaRawMidiIn DEBUG: MIDI TIME > PERIOD %.1f spl\n", ((h.time - _clock_monotonic) / _sample_length_us)); -#endif - time = _samples_per_period - 1; - } else { - time = floor ((h.time - _clock_monotonic) / _sample_length_us); - } - assert(time < _samples_per_period); - size = h.size; - return h.size; -} - void * AlsaRawMidiIn::main_process_thread () { @@ -456,12 +276,16 @@ AlsaRawMidiIn::main_process_thread () continue; } - uint8_t data[MaxAlsaRawEventSize]; + uint8_t data[MaxAlsaMidiEventSize]; uint64_t time = g_get_monotonic_time(); ssize_t err = snd_rawmidi_read (_device, data, sizeof(data)); - if ((err == -EAGAIN) || (err == -EWOULDBLOCK)) { - continue; +#if EAGAIN != EWOULDBLOCK + if ((err == -EAGAIN) || (err == -EWOULDBLOCK)) { +#else + if (err == -EAGAIN) { +#endif + continue; } if (err < 0) { PBD::error << _("AlsaRawMidiIn: read error. Terminating Midi") << endmsg; @@ -485,20 +309,8 @@ AlsaRawMidiIn::main_process_thread () int AlsaRawMidiIn::queue_event (const uint64_t time, const uint8_t *data, const size_t size) { - const uint32_t buf_size = sizeof(MidiEventHeader) + size; _event._pending = false; - - if (size == 0) { - return -1; - } - if (_rb->write_space() < buf_size) { - _DEBUGPRINT("AlsaRawMidiIn: ring buffer overflow\n"); - return -1; - } - struct MidiEventHeader h (time, size); - _rb->write ((uint8_t*) &h, sizeof(MidiEventHeader)); - _rb->write (data, size); - return 0; + return AlsaMidiIn::queue_event(time, data, size); } void