done data hangling for midi works now

4 files changed, 120 insertions, 41 deletions

diff --git a/apps/midi.c b/apps/midi.c
index 861c95e..5d5fb1a 100644
--- a/apps/midi.c
+++ b/apps/midi.c
@@ -31,11 +31,7 @@
 
 #define NOTE_EN 0x00
 #define NOTE_DE 0x01
-
-#define EN_IDX 0
 u_int8_t done_data_en[] = { 0xB0, NOTE_EN, 0x01, 0xB0, NOTE_DE, 0x00 };
-
-#define DE_IDX 1
 u_int8_t done_data_de[] = { 0xB0, NOTE_EN, 0x00, 0xB0, NOTE_DE, 0x01 };
 
 int midi_init(midi_t* m, const char* device)
@@ -43,18 +39,13 @@ int midi_init(midi_t* m, const char* device)
   assert(m != NULL);
 
   m->input_ = NULL;
+  m->output_ = NULL;
   memset(m->buf_, 0, sizeof(m->buf_));
   m->read_idx_ = 0;
 
-  m->done_data_[EN_IDX].self_ = m;
-  m->done_data_[EN_IDX].buf_ = done_data_en;
-  m->done_data_[EN_IDX].len_ = sizeof(done_data_en);
-
-  m->done_data_[DE_IDX].self_ = m;
-  m->done_data_[DE_IDX].buf_ = done_data_de;
-  m->done_data_[DE_IDX].len_ = sizeof(done_data_de);
+  slist_init(&(m->done_data_), free);
 
-  int ret = snd_rawmidi_open(&(m->input_), NULL, device, SND_RAWMIDI_NONBLOCK);
+  int ret = snd_rawmidi_open(&(m->input_), &(m->output_), device, SND_RAWMIDI_NONBLOCK);
   if(ret < 0) {
     error(0, 0, "MIDI: cannot open port '%s': %s", device, snd_strerror(ret));
     return ret;
@@ -65,34 +56,64 @@ int midi_init(midi_t* m, const char* device)
 
 int midi_get_poll_fd_count(midi_t* m)
 {
-  return snd_rawmidi_poll_descriptors_count(m->input_);
+  assert(m);
+
+  m->in_pfds_cnt_ = snd_rawmidi_poll_descriptors_count(m->input_);
+  assert(m->in_pfds_cnt_ > 0);
+  m->out_pfds_cnt_ = snd_rawmidi_poll_descriptors_count(m->output_);
+  assert(m->out_pfds_cnt_ > 0);
+
+  return (m->in_pfds_cnt_ + m->out_pfds_cnt_);
 }
 
 int midi_get_poll_fds(midi_t* m, struct pollfd *pfds, int npfds)
 {
-  return snd_rawmidi_poll_descriptors(m->input_, pfds, npfds);
+  assert(m && pfds && npfds);
+
+  snd_rawmidi_poll_descriptors(m->input_, pfds, m->in_pfds_cnt_);
+  snd_rawmidi_poll_descriptors(m->output_, &(pfds[m->in_pfds_cnt_]), npfds - m->in_pfds_cnt_);
+
+  int pending_data = 0;
+  if(m->done_data_.first_) {
+    midi_done_data_t* d = (midi_done_data_t*)(m->done_data_.first_->data_);
+    if(d->active_)
+      pending_data = 1;
+  }
+  if(!pending_data) {
+    int i;
+    for(i = m->in_pfds_cnt_; i < npfds; ++i)
+      pfds[i].events = 0;
+  }
+  return (m->in_pfds_cnt_ + m->out_pfds_cnt_);
 }
 
-void midi_switch_lang_done(void* data)
+void midi_lang_switch_done(void* data)
 {
   assert(data);
   midi_done_data_t* d = data;
-  assert(d->self_);
+  d->active_ = 1;
+}
 
-  int i;
-  printf("MIDI done: ");
-  for(i = 0; i < d->len_; ++i) {
-    printf("0x%02X%s", d->buf_[i], (i && !((i+1) % 3)) ? ", " : " ");
-  }
-  printf("\n");
+static int midi_enqueue_lang_switch(midi_t* m, mixer_t* x, const char* lang, const u_int8_t* buf, int len)
+{
+  midi_done_data_t* done_data = malloc(sizeof(midi_done_data_t));
+  assert(done_data);
+  done_data->self_ = m;
+  done_data->active_ = 0;
+  done_data->buf_ = buf;
+  done_data->len_ = len;
+  done_data->write_idx_ = 0;
+  assert(slist_add(&(m->done_data_), done_data));
+
+  return mixer_switch_lang(x, lang, &midi_lang_switch_done, done_data);
 }
 
 static int midi_handle_note_on(midi_t* m, mixer_t* x)
 {
   int ret = 0;
   switch(m->buf_[1]) {
-  case NOTE_EN: ret = mixer_switch_lang(x, "en", &midi_switch_lang_done, &(m->done_data_[EN_IDX])); break;
-  case NOTE_DE: ret = mixer_switch_lang(x, "de", &midi_switch_lang_done, &(m->done_data_[DE_IDX])); break;
+  case NOTE_EN: ret = midi_enqueue_lang_switch(m, x, "en", done_data_en, sizeof(done_data_en)); break;
+  case NOTE_DE: ret = midi_enqueue_lang_switch(m, x, "de", done_data_de, sizeof(done_data_de)); break;
   default: printf("ignoring unknown note\n"); break;
   }
   return ret;
@@ -120,7 +141,7 @@ static int midi_handle_message(midi_t* m, mixer_t* x)
   return ret;
 }
 
-int midi_handle_revents(midi_t* m, struct pollfd *pfds, int npfds, mixer_t* x)
+static int midi_handle_in_revents(midi_t* m, struct pollfd *pfds, int npfds, mixer_t* x)
 {
   int err;
   unsigned short revents;
@@ -152,3 +173,54 @@ int midi_handle_revents(midi_t* m, struct pollfd *pfds, int npfds, mixer_t* x)
 
   return 0;
 }
+
+static int midi_handle_out_revents(midi_t* m, struct pollfd *pfds, int npfds)
+{
+  int err;
+  unsigned short revents;
+  if((err = snd_rawmidi_poll_descriptors_revents(m->output_, pfds, npfds, &revents)) < 0) {
+    error(0, 0, "MIDI: cannot get poll events: %s", snd_strerror(errno));
+    return -1;
+  }
+  if(pfds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+    error(0, 0, "MIDI: got POLLERR, POLLHUP or POLLNVAL");
+    return -1;
+  }
+  if(!(revents & POLLOUT))
+    return 0;
+
+  assert(m->done_data_.first_);
+  midi_done_data_t* done_data = (midi_done_data_t*)(m->done_data_.first_->data_);
+  assert(done_data);
+  assert(done_data->active_);
+  assert(done_data->buf_);
+
+  int ret = snd_rawmidi_write(m->output_, &(done_data->buf_[done_data->write_idx_]), done_data->len_ - done_data->write_idx_);
+  if(ret == -EAGAIN)
+    return 0;
+  if(ret < 0) {
+    error(0, 0, "MIDI: cannot write to port: %s", snd_strerror(ret));
+    return -1;
+  }
+  done_data->write_idx_ += ret;
+  if(done_data->write_idx_ >= done_data->len_) {
+    if((err = snd_rawmidi_drain(m->output_)) < 0) {
+      error(0, 0, "MIDI: cannot drain output: %s", snd_strerror(err));
+      return -1;
+    }
+    slist_remove(&(m->done_data_), done_data);
+  }
+
+  return 0;
+}
+
+int midi_handle_revents(midi_t* m, struct pollfd *pfds, int npfds, mixer_t* x)
+{
+  assert(m && x && pfds);
+
+  int ret = midi_handle_in_revents(m, pfds, m->in_pfds_cnt_, x);
+  if(ret)
+    return ret;
+
+  return midi_handle_out_revents(m, &(pfds[m->in_pfds_cnt_]), m->out_pfds_cnt_);
+}
diff --git a/apps/midi.h b/apps/midi.h
index cb3bd90..537c356 100644
--- a/apps/midi.h
+++ b/apps/midi.h
@@ -26,23 +26,26 @@
 #include <alsa/asoundlib.h>
 #include <poll.h>
 
+#include "slist.h"
 #include "mixer.h"
 
-struct midi_struct;
-
 typedef struct {
-  struct midi_struct* self_;
-  u_int8_t* buf_;
-  int len_;
-} midi_done_data_t;
-
-struct midi_struct {
   snd_rawmidi_t* input_;
+  int in_pfds_cnt_;
+  snd_rawmidi_t* output_;
+  int out_pfds_cnt_;
   u_int8_t buf_[3];
   int read_idx_;
-  midi_done_data_t done_data_[2];
-};
-typedef struct midi_struct midi_t;
+  slist_t done_data_;
+} midi_t;
+
+typedef struct {
+  midi_t* self_;
+  int active_;
+  const u_int8_t* buf_;
+  int len_;
+  int write_idx_;
+} midi_done_data_t;
 
 int midi_init(midi_t* m, const char* device);
 int midi_get_poll_fd_count(midi_t* m);
diff --git a/apps/mixer.c b/apps/mixer.c
index 50684ca..83ac8c7 100644
--- a/apps/mixer.c
+++ b/apps/mixer.c
@@ -198,7 +198,6 @@ int mixer_switch_lang(mixer_t* x, const char* lang, void (*done_cb)(void*), void
   return -1;
 }
 
-
 void mixer_print_tasks(mixer_t* x)
 {
   assert(x);
@@ -222,23 +221,27 @@ void mixer_print_tasks(mixer_t* x)
 
 int mixer_get_poll_fd_count(mixer_t* x)
 {
+	assert(x);
+
   return snd_rawmidi_poll_descriptors_count(x->output_);
 }
 
 int mixer_get_poll_fds(mixer_t* x, struct pollfd *pfds, int npfds)
 {
+	assert(x && pfds && npfds);
+
   int ret = snd_rawmidi_poll_descriptors(x->output_, pfds, npfds);
   if(!slist_length(&(x->tasks_))) {
     int i;
     for(i = 0; i < ret; ++i)
-      pfds[i].fd = -1;
+      pfds[i].events = 0;
   }
   return ret;
 }
 
 int mixer_handle_revents(mixer_t* x, struct pollfd *pfds, int npfds)
 {
-  assert(x);
+	assert(x && pfds && npfds);
 
   int err;
   unsigned short revents;
@@ -273,6 +276,7 @@ int mixer_handle_revents(mixer_t* x, struct pollfd *pfds, int npfds)
     }
     if(task->done_cb_)
       task->done_cb_(task->done_data_);
+
     slist_remove(&(x->tasks_), task);
   }
 
diff --git a/apps/osc.c b/apps/osc.c
index 5d656b9..1dbb53e 100644
--- a/apps/osc.c
+++ b/apps/osc.c
@@ -72,7 +72,7 @@ int osc_get_poll_fd_count(osc_t* o)
 
 int osc_get_poll_fds(osc_t* o, struct pollfd *pfds, int npfds)
 {
-  assert(npfds == 1);
+  assert(o && pfds && npfds == 1);
 
   pfds[0].fd = lo_server_get_socket_fd(o->server_);
   pfds[0].events = POLLIN;
@@ -83,7 +83,7 @@ int osc_get_poll_fds(osc_t* o, struct pollfd *pfds, int npfds)
 
 int osc_handle_revents(osc_t* o, struct pollfd *pfds, int npfds, mixer_t* x)
 {
-  assert(npfds == 1);
+  assert(o && pfds && npfds == 1);
 
   if(pfds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
     error(0, 0, "OSC: got POLLERR, POLLHUP or POLLNVAL");