Fix MIDI queue bugs. Make latency test output unexpected message count even if an error occurs.

common/JackMidiAsyncQueue.cpp

@@ -26,13 +26,13 @@ using Jack::JackMidiAsyncQueue;
 JackMidiAsyncQueue::JackMidiAsyncQueue(size_t max_bytes, size_t max_messages)
 {
     data_buffer = new jack_midi_data_t[max_bytes];
-    byte_ring = jack_ringbuffer_create(max_bytes + 1);
+    byte_ring = jack_ringbuffer_create((max_bytes * sizeof(jack_midi_data_t)) +
+                                       1);
     if (byte_ring) {
         info_ring = jack_ringbuffer_create((max_messages * INFO_SIZE) + 1);
         if (info_ring) {
             jack_ringbuffer_mlock(byte_ring);
             jack_ringbuffer_mlock(info_ring);
-            advance_space = 0;
             this->max_bytes = max_bytes;
             return;
         }
@@ -54,26 +54,23 @@ JackMidiAsyncQueue::DequeueEvent()
 {
     jack_midi_event_t *event = 0;
     if (jack_ringbuffer_read_space(info_ring) >= INFO_SIZE) {
-        if (advance_space) {
-            jack_ringbuffer_read_advance(byte_ring, advance_space);
-        }
         event = &dequeue_event;
         jack_ringbuffer_read(info_ring, (char *) &(event->time),
                              sizeof(jack_nframes_t));
         size_t size;
         jack_ringbuffer_read(info_ring, (char *) &size, sizeof(size_t));
+        event->buffer = data_buffer;
         event->size = size;
         jack_ringbuffer_data_t vector[2];
         jack_ringbuffer_get_read_vector(byte_ring, vector);
         size_t size1 = vector[0].len;
-        if (size1 >= size) {
-            event->buffer = (jack_midi_data_t *) vector[0].buf;
-        } else {
-            event->buffer = data_buffer;
-            memcpy(data_buffer, vector[0].buf, size1);
-            memcpy(data_buffer + size1, vector[1].buf, size - size1);
+        memcpy(data_buffer, vector[0].buf, size1 * sizeof(jack_midi_data_t));
+        if (size1 < size) {
+            memcpy(data_buffer + size1, vector[1].buf,
+                   (size - size1) * sizeof(jack_midi_data_t));
         }
-        advance_space = size;
+        jack_ringbuffer_read_advance(byte_ring,
+                                     size * sizeof(jack_midi_data_t));
     }
     return event;
 }
@@ -82,11 +79,16 @@ Jack::JackMidiWriteQueue::EnqueueResult
 JackMidiAsyncQueue::EnqueueEvent(jack_nframes_t time, size_t size,
                                  jack_midi_data_t *buffer)
 {
+    if (size > max_bytes) {
+        return BUFFER_TOO_SMALL;
+    }
     if (! ((jack_ringbuffer_write_space(info_ring) >= INFO_SIZE) &&
-           (jack_ringbuffer_write_space(byte_ring) >= size))) {
-        return size > max_bytes ? BUFFER_TOO_SMALL : BUFFER_FULL;
+           (jack_ringbuffer_write_space(byte_ring) >=
+            (size * sizeof(jack_midi_data_t))))) {
+        return BUFFER_FULL;
     }
-    jack_ringbuffer_write(byte_ring, (const char *) buffer, size);
+    jack_ringbuffer_write(byte_ring, (const char *) buffer,
+                          size * sizeof(jack_midi_data_t));
     jack_ringbuffer_write(info_ring, (const char *) (&time),
                           sizeof(jack_nframes_t));
     jack_ringbuffer_write(info_ring, (const char *) (&size), sizeof(size_t));

common/JackMidiAsyncQueue.h

@@ -46,7 +46,6 @@ namespace Jack {
         static const size_t INFO_SIZE =
             sizeof(jack_nframes_t) + sizeof(size_t);
 
-        size_t advance_space;
         jack_ringbuffer_t *byte_ring;
         jack_midi_data_t *data_buffer;
         jack_midi_event_t dequeue_event;

example-clients/midi_latency_test.c

@@ -554,10 +554,9 @@ main(int argc, char **argv)
         if (jitter_plot[100]) {
             printf("     > 10 ms: %u\n", jitter_plot[100]);
         }
-        if (unexpected_messages) {
-            printf("\nUnexpected messages received: %d\n",
-                   unexpected_messages);
-        }
+    }
+    if (unexpected_messages) {
+        printf("\nUnexpected messages received: %d\n", unexpected_messages);
     }
  deactivate_client:
     jack_deactivate(client);

linux/firewire/JackFFADOMidiOutputPort.cpp

@@ -33,9 +33,9 @@ JackFFADOMidiOutputPort::JackFFADOMidiOutputPort(size_t non_rt_size,
     std::auto_ptr<JackMidiBufferReadQueue> read_queue_ptr(read_queue);
     send_queue = new JackFFADOMidiSendQueue();
     std::auto_ptr<JackFFADOMidiSendQueue> send_queue_ptr(send_queue);
-    raw_queue = new JackMidiRawOutputWriteQueue(send_queue, max_rt_messages,
+    raw_queue = new JackMidiRawOutputWriteQueue(send_queue, non_rt_size,
                                                 max_non_rt_messages,
-                                                non_rt_size);
+                                                max_rt_messages);
     send_queue_ptr.release();
     read_queue_ptr.release();
 }

linux/firewire/JackFFADOMidiReceiveQueue.cpp

@@ -24,7 +24,7 @@ using Jack::JackFFADOMidiReceiveQueue;
 
 JackFFADOMidiReceiveQueue::JackFFADOMidiReceiveQueue()
 {
-    // Empty
+    bytes_received = 0;
 }
 
 jack_midi_event_t *
@@ -38,6 +38,11 @@ JackFFADOMidiReceiveQueue::DequeueEvent()
             event.size = 1;
             event.time = last_frame + index;
             index += 8;
+            bytes_received++;
+
+            jack_info("Jack::JackFFADOMidiReceiveQueue: %d bytes received",
+                      bytes_received);
+
             return &event;
         }
     }

linux/firewire/JackFFADOMidiReceiveQueue.h

@@ -28,6 +28,8 @@ namespace Jack {
 
     private:
 
+        unsigned long bytes_received;
+
         jack_midi_data_t byte;
         jack_midi_event_t event;
         jack_nframes_t index;

linux/firewire/JackFFADOMidiSendQueue.cpp

@@ -26,7 +26,7 @@ using Jack::JackFFADOMidiSendQueue;
 
 JackFFADOMidiSendQueue::JackFFADOMidiSendQueue()
 {
-    // Empty
+    bytes_sent = 0;
 }
 
 Jack::JackMidiWriteQueue::EnqueueResult
@@ -44,6 +44,10 @@ JackFFADOMidiSendQueue::EnqueueEvent(jack_nframes_t time, size_t size,
     }
     output_buffer[index] = 0x01000000 | ((uint32_t) *buffer);
     index += 8;
+
+    bytes_sent++;
+    jack_info("Jack::JackFFADOMidiSendQueue: %d bytes sent", bytes_sent);
+
     return OK;
 }
 

linux/firewire/JackFFADOMidiSendQueue.h

@@ -28,6 +28,8 @@ namespace Jack {
 
     private:
 
+        unsigned long bytes_sent;
+
         jack_nframes_t index;
         jack_nframes_t last_frame;
         jack_nframes_t length;