Rename all the queues

Except the raw MIDI queues, since they're MIDI specific

common/JackEventAsyncQueue.cpp

@@ -19,14 +19,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 #include <new>
 
-#include "JackMidiAsyncQueue.h"
+#include "JackEventAsyncQueue.h"
 
-using Jack::JackMidiAsyncQueue;
+using Jack::JackEventAsyncQueue;
 
-JackMidiAsyncQueue::JackMidiAsyncQueue(size_t max_bytes, size_t max_messages)
+JackEventAsyncQueue::JackEventAsyncQueue(size_t max_bytes, size_t max_messages)
 {
-    data_buffer = new jack_midi_data_t[max_bytes];
-    byte_ring = jack_ringbuffer_create((max_bytes * sizeof(jack_midi_data_t)) +
+    data_buffer = new jack_event_data_t[max_bytes];
+    byte_ring = jack_ringbuffer_create((max_bytes * sizeof(jack_event_data_t)) +
                                        1);
     if (byte_ring) {
         info_ring = jack_ringbuffer_create((max_messages * INFO_SIZE) + 1);
@@ -42,17 +42,17 @@ JackMidiAsyncQueue::JackMidiAsyncQueue(size_t max_bytes, size_t max_messages)
     throw std::bad_alloc();
 }
 
-JackMidiAsyncQueue::~JackMidiAsyncQueue()
+JackEventAsyncQueue::~JackEventAsyncQueue()
 {
     jack_ringbuffer_free(byte_ring);
     jack_ringbuffer_free(info_ring);
     delete[] data_buffer;
 }
 
-jack_midi_event_t *
-JackMidiAsyncQueue::DequeueEvent()
+jack_event_t *
+JackEventAsyncQueue::DequeueEvent()
 {
-    jack_midi_event_t *event = 0;
+    jack_event_t *event = 0;
     if (jack_ringbuffer_read_space(info_ring) >= INFO_SIZE) {
         size_t size;
         event = &dequeue_event;
@@ -61,27 +61,27 @@ JackMidiAsyncQueue::DequeueEvent()
         jack_ringbuffer_read(info_ring, (char *) &size,
                              sizeof(size_t));
         jack_ringbuffer_read(byte_ring, (char *) data_buffer,
-                             size * sizeof(jack_midi_data_t));
+                             size * sizeof(jack_event_data_t));
         event->buffer = data_buffer;
         event->size = size;
     }
     return event;
 }
 
-Jack::JackMidiWriteQueue::EnqueueResult
-JackMidiAsyncQueue::EnqueueEvent(jack_nframes_t time, size_t size,
-                                 jack_midi_data_t *buffer)
+Jack::JackEventWriteQueue::EnqueueResult
+JackEventAsyncQueue::EnqueueEvent(jack_nframes_t time, size_t size,
+                                 jack_event_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 * sizeof(jack_midi_data_t))))) {
+            (size * sizeof(jack_event_data_t))))) {
         return BUFFER_FULL;
     }
     jack_ringbuffer_write(byte_ring, (const char *) buffer,
-                          size * sizeof(jack_midi_data_t));
+                          size * sizeof(jack_event_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));
@@ -89,7 +89,7 @@ JackMidiAsyncQueue::EnqueueEvent(jack_nframes_t time, size_t size,
 }
 
 size_t
-JackMidiAsyncQueue::GetAvailableSpace()
+JackEventAsyncQueue::GetAvailableSpace()
 {
     return jack_ringbuffer_write_space(info_ring) < INFO_SIZE ? 0 :
         max_bytes - jack_ringbuffer_read_space(byte_ring);

common/JackEventAsyncQueue.h

@@ -17,28 +17,28 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiAsyncQueue__
-#define __JackMidiAsyncQueue__
+#ifndef __JackEventAsyncQueue__
+#define __JackEventAsyncQueue__
 
-#include "JackMidiPort.h"
-#include "JackMidiReadQueue.h"
-#include "JackMidiWriteQueue.h"
+#include "JackEventPort.h"
+#include "JackEventReadQueue.h"
+#include "JackEventWriteQueue.h"
 #include "ringbuffer.h"
 
 namespace Jack {
 
     /**
-     * This is a MIDI message queue designed to allow one thread to pass MIDI
+     * This is a event message queue designed to allow one thread to pass event
      * messages to another thread (though it can also be used to buffer events
-     * internally).  This is especially useful if the MIDI API you're
+     * internally).  This is especially useful if the event API you're
      * attempting to interface with doesn't provide the ability to schedule
-     * MIDI events ahead of time and/or has blocking send/receive calls, as it
+     * events ahead of time and/or has blocking send/receive calls, as it
      * allows a separate thread to handle input/output while the JACK process
-     * thread copies events from a MIDI buffer to this queue, or vice versa.
+     * thread copies events from a buffer to this queue, or vice versa.
      */
 
-    class SERVER_EXPORT JackMidiAsyncQueue:
-        public JackMidiReadQueue, public JackMidiWriteQueue {
+    class SERVER_EXPORT JackEventAsyncQueue:
+        public JackEventReadQueue, public JackEventWriteQueue {
 
     private:
 
@@ -46,43 +46,43 @@ namespace Jack {
             sizeof(jack_nframes_t) + sizeof(size_t);
 
         jack_ringbuffer_t *byte_ring;
-        jack_midi_data_t *data_buffer;
-        jack_midi_event_t dequeue_event;
+        jack_event_data_t *data_buffer;
+        jack_event_t dequeue_event;
         jack_ringbuffer_t *info_ring;
         size_t max_bytes;
 
     public:
 
-        using JackMidiWriteQueue::EnqueueEvent;
+        using JackEventWriteQueue::EnqueueEvent;
 
         /**
-         * Creates a new asynchronous MIDI message queue.  The queue can store
-         * up to `max_messages` MIDI messages and up to `max_bytes` of MIDI
+         * Creates a new asynchronous event message queue.  The queue can store
+         * up to `max_messages` messages and up to `max_bytes` of
          * data before it starts rejecting messages.
          */
 
-        JackMidiAsyncQueue(size_t max_bytes=4096, size_t max_messages=1024);
+        JackEventAsyncQueue(size_t max_bytes=4096, size_t max_messages=1024);
 
         virtual
-        ~JackMidiAsyncQueue();
+        ~JackEventAsyncQueue();
 
         /**
-         * Dequeues and returns a MIDI event.  Returns '0' if there are no MIDI
-         * events available.  This method may be overridden.
+         * Dequeues and returns an event.  Returns '0' if there are none
+         * available.  This method may be overridden.
          */
 
-        virtual jack_midi_event_t *
+        virtual jack_event_t *
         DequeueEvent();
 
         /**
-         * Enqueues the MIDI event specified by the arguments.  The return
+         * Enqueues the event specified by the arguments.  The return
          * value indicates whether or not the event was successfully enqueued.
          * This method may be overridden.
          */
 
         virtual EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
         /**
          * Returns the maximum size event that can be enqueued right *now*.

common/JackEventAsyncWaitQueue.cpp

@@ -19,34 +19,34 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 #include <new>
 
-#include "JackMidiAsyncWaitQueue.h"
+#include "JackEventAsyncWaitQueue.h"
 #include "JackMidiUtil.h"
 #include "JackTime.h"
 
-using Jack::JackMidiAsyncWaitQueue;
+using Jack::JackEventAsyncWaitQueue;
 
-JackMidiAsyncWaitQueue::JackMidiAsyncWaitQueue(size_t max_bytes,
+JackEventAsyncWaitQueue::JackEventAsyncWaitQueue(size_t max_bytes,
                                                size_t max_messages):
-    JackMidiAsyncQueue(max_bytes, max_messages)
+    JackEventAsyncQueue(max_bytes, max_messages)
 {
-    if (semaphore.Allocate("JackMidiAsyncWaitQueue", "midi-thread", 0)) {
+    if (semaphore.Allocate("JackEventAsyncWaitQueue", "event-thread", 0)) {
         throw std::bad_alloc();
     }
 }
 
-JackMidiAsyncWaitQueue::~JackMidiAsyncWaitQueue()
+JackEventAsyncWaitQueue::~JackEventAsyncWaitQueue()
 {
     semaphore.Destroy();
 }
 
-jack_midi_event_t *
-JackMidiAsyncWaitQueue::DequeueEvent()
+jack_event_t *
+JackEventAsyncWaitQueue::DequeueEvent()
 {
     return DequeueEvent((long) 0);
 }
 
-jack_midi_event_t *
-JackMidiAsyncWaitQueue::DequeueEvent(jack_nframes_t frame)
+jack_event_t *
+JackEventAsyncWaitQueue::DequeueEvent(jack_nframes_t frame)
 {
 
     // XXX: I worry about timer resolution on Solaris and Windows.  When the
@@ -65,18 +65,18 @@ JackMidiAsyncWaitQueue::DequeueEvent(jack_nframes_t frame)
                         (long) (frame_time - current_time));
 }
 
-jack_midi_event_t *
-JackMidiAsyncWaitQueue::DequeueEvent(long usec)
+jack_event_t *
+JackEventAsyncWaitQueue::DequeueEvent(long usec)
 {
     return ((usec < 0) ? semaphore.Wait() : semaphore.TimedWait(usec)) ?
-        JackMidiAsyncQueue::DequeueEvent() : 0;
+        JackEventAsyncQueue::DequeueEvent() : 0;
 }
 
-Jack::JackMidiWriteQueue::EnqueueResult
-JackMidiAsyncWaitQueue::EnqueueEvent(jack_nframes_t time, size_t size,
-                                     jack_midi_data_t *buffer)
+Jack::JackEventWriteQueue::EnqueueResult
+JackEventAsyncWaitQueue::EnqueueEvent(jack_nframes_t time, size_t size,
+                                     jack_event_data_t *buffer)
 {
-    EnqueueResult result = JackMidiAsyncQueue::EnqueueEvent(time, size,
+    EnqueueResult result = JackEventAsyncQueue::EnqueueEvent(time, size,
                                                             buffer);
     if (result == OK) {
         semaphore.Signal();

common/JackEventAsyncWaitQueue.h

@@ -17,26 +17,26 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiAsyncWaitQueue__
-#define __JackMidiAsyncWaitQueue__
+#ifndef __JackEventAsyncWaitQueue__
+#define __JackEventAsyncWaitQueue__
 
-#include "JackMidiAsyncQueue.h"
+#include "JackEventAsyncQueue.h"
 
 namespace Jack {
 
     /**
      * This is an asynchronous wait queue that allows a thread to wait for a
      * message, either indefinitely or for a specified time.  This is one
-     * example of a way that the `JackMidiAsyncQueue` class can be extended so
-     * that process threads can interact with non-process threads to send MIDI
+     * example of a way that the `JackEventAsyncQueue` class can be extended so
+     * that process threads can interact with non-process threads to send
      * events.
      *
      * XXX: As of right now, this code hasn't been tested.  Also, note the
-     * warning in the JackMidiAsyncWaitQueue.cpp about semaphore wait
+     * warning in the JackEventAsyncWaitQueue.cpp about semaphore wait
      * resolution.
      */
 
-    class SERVER_EXPORT JackMidiAsyncWaitQueue: public JackMidiAsyncQueue {
+    class SERVER_EXPORT JackEventAsyncWaitQueue: public JackEventAsyncQueue {
 
     private:
 
@@ -44,53 +44,53 @@ namespace Jack {
 
     public:
 
-        using JackMidiAsyncQueue::EnqueueEvent;
+        using JackEventAsyncQueue::EnqueueEvent;
 
         /**
-         * Creates a new asynchronous MIDI wait message queue.  The queue can
-         * store up to `max_messages` MIDI messages and up to `max_bytes` of
-         * MIDI data before it starts rejecting messages.
+         * Creates a new asynchronous wait message queue.  The queue can
+         * store up to `max_messages` messages and up to `max_bytes` of
+         * messagea data before it starts rejecting messages.
          */
 
-        JackMidiAsyncWaitQueue(size_t max_bytes=4096,
+        JackEventAsyncWaitQueue(size_t max_bytes=4096,
                                size_t max_messages=1024);
 
-        ~JackMidiAsyncWaitQueue();
+        ~JackEventAsyncWaitQueue();
 
         /**
          * Dequeues and returns a MIDI event.  Returns '0' if there are no MIDI
          * events available right now.
          */
 
-        jack_midi_event_t *
+        jack_event_t *
         DequeueEvent();
 
         /**
-         * Waits a specified time for a MIDI event to be available, or
-         * indefinitely if the time is negative.  Returns the MIDI event, or
-         * '0' if time runs out and no MIDI event is available.
+         * Waits a specified time for an event to be available, or
+         * indefinitely if the time is negative.  Returns the event, or
+         * '0' if time runs out and no event is available.
          */
 
-        jack_midi_event_t *
+        jack_event_t *
         DequeueEvent(long usecs);
 
         /**
-         * Waits until the specified frame for a MIDI event to be available.
-         * Returns the MIDI event, or '0' if time runs out and no MIDI event is
+         * Waits until the specified frame for an event to be available.
+         * Returns the event, or '0' if time runs out and no event is
          * available.
          */
 
-        jack_midi_event_t *
+        jack_event_t *
         DequeueEvent(jack_nframes_t frame);
 
         /**
-         * Enqueues the MIDI event specified by the arguments.  The return
+         * Enqueues the event specified by the arguments.  The return
          * value indicates whether or not the event was successfully enqueued.
          */
 
         EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
     };
 

common/JackEventBufferReadQueue.cpp

@@ -17,48 +17,48 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#include "JackMidiBufferReadQueue.h"
+#include "JackEventBufferReadQueue.h"
 #include "JackMidiUtil.h"
 #include "JackError.h"
 
-using Jack::JackMidiBufferReadQueue;
+using Jack::JackEventBufferReadQueue;
 
-JackMidiBufferReadQueue::JackMidiBufferReadQueue()
+JackEventBufferReadQueue::JackEventBufferReadQueue()
 {
     event_count = 0;
     index = 0;
 }
 
-jack_midi_event_t *
-JackMidiBufferReadQueue::DequeueEvent()
+jack_event_t *
+JackEventBufferReadQueue::DequeueEvent()
 {
-    jack_midi_event_t *e = 0;
+    jack_event_t *e = 0;
     if (index < event_count) {
-        JackMidiEvent *event = &(buffer->events[index]);
-        midi_event.buffer = event->GetData(buffer);
-        midi_event.size = event->size;
-        midi_event.time = last_frame_time + event->time;
-        e = &midi_event;
+        JackEvent *event = &(buffer->events[index]);
+        event.buffer = event->GetData(buffer);
+        event.size = event->size;
+        event.time = last_frame_time + event->time;
+        e = &event;
         index++;
     }
     return e;
 }
 
 void
-JackMidiBufferReadQueue::ResetMidiBuffer(JackMidiBuffer *buffer)
+JackEventBufferReadQueue::ResetEventBuffer(JackEventBuffer *buffer)
 {
     event_count = 0;
     index = 0;
     if (! buffer) {
-        jack_error("JackMidiBufferReadQueue::ResetMidiBuffer - buffer reset "
+        jack_error("JackEventBufferReadQueue::ResetEventBuffer - buffer reset "
                    "to NULL");
     } else if (! buffer->IsValid()) {
-        jack_error("JackMidiBufferReadQueue::ResetMidiBuffer - buffer reset "
+        jack_error("JackEventBufferReadQueue::ResetEventBuffer - buffer reset "
                    "to invalid buffer");
     } else {
         uint32_t lost_events = buffer->lost_events;
         if (lost_events) {
-            jack_error("JackMidiBufferReadQueue::ResetMidiBuffer - %d events "
+            jack_error("JackEventBufferReadQueue::ResetEventBuffer - %d events "
                        "lost during mixdown", lost_events);
         }
         this->buffer = buffer;

common/JackEventBufferReadQueue.h

@@ -17,41 +17,41 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiBufferReadQueue__
-#define __JackMidiBufferReadQueue__
+#ifndef __JackEventBufferReadQueue__
+#define __JackEventBufferReadQueue__
 
-#include "JackMidiReadQueue.h"
+#include "JackEventReadQueue.h"
 
 namespace Jack {
 
     /**
-     * Wrapper class to present a JackMidiBuffer in a read queue interface.
+     * Wrapper class to present a JackEventBuffer in a read queue interface.
      */
 
-    class SERVER_EXPORT JackMidiBufferReadQueue: public JackMidiReadQueue {
+    class SERVER_EXPORT JackEventBufferReadQueue: public JackEventReadQueue {
 
     private:
 
-        JackMidiBuffer *buffer;
+        JackEventBuffer *buffer;
         jack_nframes_t event_count;
         jack_nframes_t index;
         jack_nframes_t last_frame_time;
-        jack_midi_event_t midi_event;
+        jack_event_t midi_event;
 
     public:
 
-        JackMidiBufferReadQueue();
+        JackEventBufferReadQueue();
 
-        jack_midi_event_t *
+        jack_event_t *
         DequeueEvent();
 
         /**
-         * This method must be called each period to reset the MIDI buffer for
+         * This method must be called each period to reset the buffer for
          * processing.
          */
 
         void
-        ResetMidiBuffer(JackMidiBuffer *buffer);
+        ResetEventBuffer(JackEventBuffer *buffer);
 
     };
 

common/JackEventBufferWriteQueue.cpp

@@ -17,20 +17,20 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#include "JackMidiBufferWriteQueue.h"
+#include "JackEventBufferWriteQueue.h"
 #include "JackMidiUtil.h"
 #include "JackError.h"
 
-using Jack::JackMidiBufferWriteQueue;
+using Jack::JackEventBufferWriteQueue;
 
-JackMidiBufferWriteQueue::JackMidiBufferWriteQueue()
+JackEventBufferWriteQueue::JackEventBufferWriteQueue()
 {
     // Empty
 }
 
-Jack::JackMidiWriteQueue::EnqueueResult
-JackMidiBufferWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
-                                       jack_midi_data_t *data)
+Jack::JackEventWriteQueue::EnqueueResult
+JackEventBufferWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
+                                       jack_evemt_data_t *data)
 {
     if (time >= next_frame_time) {
         return EVENT_EARLY;
@@ -38,7 +38,7 @@ JackMidiBufferWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
     if (time < last_frame_time) {
         time = last_frame_time;
     }
-    jack_midi_data_t *dst = buffer->ReserveEvent(time - last_frame_time, size);
+    jack_evemt_data_t *dst = buffer->ReserveEvent(time - last_frame_time, size);
     if (! dst) {
         return size > max_bytes ? BUFFER_TOO_SMALL : BUFFER_FULL;
     }
@@ -47,14 +47,14 @@ JackMidiBufferWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
 }
 
 void
-JackMidiBufferWriteQueue::ResetMidiBuffer(JackMidiBuffer *buffer,
+JackEventBufferWriteQueue::ResetEventBuffer(JackEventBuffer *buffer,
                                           jack_nframes_t frames)
 {
     if (! buffer) {
-        jack_error("JackMidiBufferWriteQueue::ResetMidiBuffer - buffer reset "
+        jack_error("JackEventBufferWriteQueue::ResetEventBuffer - buffer reset "
                    "to NULL");
     } else if (! buffer->IsValid()) {
-        jack_error("JackMidiBufferWriteQueue::ResetMidiBuffer - buffer reset "
+        jack_error("JackEventBufferWriteQueue::ResetEventBuffer - buffer reset "
                    "to invalid buffer");
     } else {
         this->buffer = buffer;

common/JackEventBufferWriteQueue.h

@@ -17,43 +17,43 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiBufferWriteQueue__
-#define __JackMidiBufferWriteQueue__
+#ifndef __JackEventBufferWriteQueue__
+#define __JackEventBufferWriteQueue__
 
-#include "JackMidiWriteQueue.h"
+#include "JackEventWriteQueue.h"
 
 namespace Jack {
 
     /**
-     * Wrapper class to present a JackMidiBuffer in a write queue interface.
+     * Wrapper class to present a JackEventBuffer in a write queue interface.
      */
 
-    class SERVER_EXPORT JackMidiBufferWriteQueue: public JackMidiWriteQueue {
+    class SERVER_EXPORT JackEventBufferWriteQueue: public JackEventWriteQueue {
 
     private:
 
-        JackMidiBuffer *buffer;
+        JackEventBuffer *buffer;
         jack_nframes_t last_frame_time;
         size_t max_bytes;
         jack_nframes_t next_frame_time;
 
     public:
 
-        using JackMidiWriteQueue::EnqueueEvent;
+        using JackEventWriteQueue::EnqueueEvent;
 
-        JackMidiBufferWriteQueue();
+        JackEventBufferWriteQueue();
 
         EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
         /**
-         * This method must be called each period to reset the MIDI buffer for
+         * This method must be called each period to reset the buffer for
          * processing.
          */
 
         void
-        ResetMidiBuffer(JackMidiBuffer *buffer, jack_nframes_t frames);
+        ResetEventBuffer(JackEventBuffer *buffer, jack_nframes_t frames);
 
     };
 

common/JackEventReadQueue.cpp

@@ -17,11 +17,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#include "JackMidiReadQueue.h"
+#include "JackEventReadQueue.h"
 
-using Jack::JackMidiReadQueue;
+using Jack::JackEventReadQueue;
 
-JackMidiReadQueue::~JackMidiReadQueue()
+JackEventReadQueue::~JackEventReadQueue()
 {
     // Empty
 }

common/JackEventReadQueue.h

@@ -17,23 +17,23 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiReadQueue__
-#define __JackMidiReadQueue__
+#ifndef __JackEventReadQueue__
+#define __JackEventReadQueue__
 
-#include "JackMidiPort.h"
+#include "JackEventPort.h"
 
 namespace Jack {
 
     /**
-     * Interface for objects that MIDI events can be read from.
+     * Interface for objects that events can be read from.
      */
 
-    class SERVER_EXPORT JackMidiReadQueue {
+    class SERVER_EXPORT JackEventReadQueue {
 
     public:
 
         virtual
-        ~JackMidiReadQueue();
+        ~JackEventReadQueue();
 
         /**
          * Dequeues an event from the queue.  Returns the event, or 0 if no
@@ -45,7 +45,7 @@ namespace Jack {
          * next event.
          */
 
-        virtual jack_midi_event_t *
+        virtual jack_event_t *
         DequeueEvent() = 0;
 
     };

common/JackEventReceiveQueue.cpp

@@ -17,11 +17,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#include "JackMidiReceiveQueue.h"
+#include "JackEventReceiveQueue.h"
 
-using Jack::JackMidiReceiveQueue;
+using Jack::JackEventReceiveQueue;
 
-JackMidiReceiveQueue::~JackMidiReceiveQueue()
+JackEventReceiveQueue::~JackEventReceiveQueue()
 {
     // Empty
 }

common/JackEventReceiveQueue.h

@@ -17,10 +17,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiReceiveQueue__
-#define __JackMidiReceiveQueue__
+#ifndef __JackEventReceiveQueue__
+#define __JackEventReceiveQueue__
 
-#include "JackMidiReadQueue.h"
+#include "JackEventReadQueue.h"
 
 namespace Jack {
 
@@ -28,12 +28,12 @@ namespace Jack {
      * Implemented by MIDI input connections.
      */
 
-    class SERVER_EXPORT JackMidiReceiveQueue: public JackMidiReadQueue {
+    class SERVER_EXPORT JackEventReceiveQueue: public JackEventReadQueue {
 
     public:
 
         virtual
-        ~JackMidiReceiveQueue();
+        ~JackEventReceiveQueue();
 
     };
 

common/JackEventSendQueue.cpp

@@ -17,18 +17,18 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#include "JackMidiSendQueue.h"
+#include "JackEventSendQueue.h"
 #include "JackMidiUtil.h"
 
-using Jack::JackMidiSendQueue;
+using Jack::JackEventSendQueue;
 
-JackMidiSendQueue::~JackMidiSendQueue()
+JackEventSendQueue::~JackEventSendQueue()
 {
     // Empty
 }
 
 jack_nframes_t
-JackMidiSendQueue::GetNextScheduleFrame()
+JackEventSendQueue::GetNextScheduleFrame()
 {
     return GetCurrentFrame();
 }

common/JackEventSendQueue.h

@@ -17,28 +17,28 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiSendQueue__
-#define __JackMidiSendQueue__
+#ifndef __JackEventSendQueue__
+#define __JackEventSendQueue__
 
-#include "JackMidiWriteQueue.h"
+#include "JackEventWriteQueue.h"
 
 namespace Jack {
 
     /**
-     * Implemented by MIDI output connections.
+     * Implemented by event output connections.
      */
 
-    class SERVER_EXPORT JackMidiSendQueue: public JackMidiWriteQueue {
+    class SERVER_EXPORT JackEventSendQueue: public JackEventWriteQueue {
 
     public:
 
-        using JackMidiWriteQueue::EnqueueEvent;
+        using JackEventWriteQueue::EnqueueEvent;
 
         virtual
-        ~JackMidiSendQueue();
+        ~JackEventSendQueue();
 
         /**
-         * Returns the next frame that a MIDI message can be sent at.  The
+         * Returns the next frame that a message can be sent at.  The
          * default method returns the current frame.
          */
 

common/JackEventWriteQueue.cpp

@@ -19,9 +19,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 #include "JackMidiWriteQueue.h"
 
-using Jack::JackMidiWriteQueue;
+using Jack::JackEventWriteQueue;
 
-JackMidiWriteQueue::~JackMidiWriteQueue()
+JackEventWriteQueue::~JackEventWriteQueue()
 {
     // Empty
 }

common/JackEventWriteQueue.h

@@ -17,19 +17,19 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiWriteQueue__
-#define __JackMidiWriteQueue__
+#ifndef __JackEventWriteQueue__
+#define __JackEventWriteQueue__
 
-#include "JackMidiPort.h"
+#include "JackEventPort.h"
 
 namespace Jack {
 
     /**
-     * Interface for classes that act as write queues for MIDI messages.  Write
+     * Interface for classes that act as write queues for event messages.  Write
      * queues are used by processors to transfer data to the next processor.
      */
 
-    class SERVER_EXPORT JackMidiWriteQueue {
+    class SERVER_EXPORT JackEventWriteQueue {
 
     public:
 
@@ -41,7 +41,7 @@ namespace Jack {
             OK
         };
 
-        virtual ~JackMidiWriteQueue();
+        virtual ~JackEventWriteQueue();
 
         /**
          * Enqueues a data packet in the write queue of `size` bytes contained
@@ -60,7 +60,7 @@ namespace Jack {
 
         virtual EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer) = 0;
+                     jack_event_data_t *buffer) = 0;
 
         /**
          * A wrapper method for the `EnqueueEvent` method above.  The optional
@@ -69,7 +69,7 @@ namespace Jack {
          */
 
         inline EnqueueResult
-        EnqueueEvent(jack_midi_event_t *event, jack_nframes_t frame_offset=0)
+        EnqueueEvent(jack_event_t *event, jack_nframes_t frame_offset=0)
         {
             return EnqueueEvent(event->time + frame_offset, event->size,
                                 event->buffer);

common/JackEventRawInputWriteQueue.cpp → common/JackMidiRawInputWriteQueue.cpp

@@ -27,12 +27,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 using Jack::JackMidiRawInputWriteQueue;
 
 JackMidiRawInputWriteQueue::
-JackMidiRawInputWriteQueue(JackMidiWriteQueue *write_queue,
+JackMidiRawInputWriteQueue(JackEventWriteQueue *write_queue,
                            size_t max_packet_data, size_t max_packets)
 {
-    packet_queue = new JackMidiAsyncQueue(max_packet_data, max_packets);
-    std::unique_ptr<JackMidiAsyncQueue> packet_queue_ptr(packet_queue);
-    input_buffer = new jack_midi_data_t[max_packet_data];
+    packet_queue = new JackEventAsyncQueue(max_packet_data, max_packets);
+    std::unique_ptr<JackEventAsyncQueue> packet_queue_ptr(packet_queue);
+    input_buffer = new jack_event_data_t[max_packet_data];
     Clear();
     expected_bytes = 0;
     event_pending = false;
@@ -56,9 +56,9 @@ JackMidiRawInputWriteQueue::Clear()
     unbuffered_bytes = 0;
 }
 
-Jack::JackMidiWriteQueue::EnqueueResult
+Jack::JackEventWriteQueue::EnqueueResult
 JackMidiRawInputWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
-                                         jack_midi_data_t *buffer)
+                                         jack_event_data_t *buffer)
 {
     return packet_queue->EnqueueEvent(time, size, buffer);
 }
@@ -79,7 +79,7 @@ JackMidiRawInputWriteQueue::HandleBufferFailure(size_t unbuffered_bytes,
 }
 
 void
-JackMidiRawInputWriteQueue::HandleEventLoss(jack_midi_event_t *event)
+JackMidiRawInputWriteQueue::HandleEventLoss(jack_event_t *event)
 {
     jack_error("JackMidiRawInputWriteQueue::HandleEventLoss - A %d byte MIDI "
                "event scheduled for frame '%d' could not be processed because "
@@ -96,7 +96,7 @@ JackMidiRawInputWriteQueue::HandleIncompleteMessage(size_t total_bytes)
 }
 
 void
-JackMidiRawInputWriteQueue::HandleInvalidStatusByte(jack_midi_data_t byte)
+JackMidiRawInputWriteQueue::HandleInvalidStatusByte(jack_event_data_t byte)
 {
     jack_error("JackMidiRawInputWriteQueue::HandleInvalidStatusByte - "
                "Dropping invalid MIDI status byte '%x'.", (unsigned int) byte);
@@ -130,7 +130,7 @@ JackMidiRawInputWriteQueue::PrepareBufferedEvent(jack_nframes_t time)
 
 bool
 JackMidiRawInputWriteQueue::PrepareByteEvent(jack_nframes_t time,
-                                             jack_midi_data_t byte)
+                                             jack_event_data_t byte)
 {
     event_byte = byte;
     PrepareEvent(time, 1, &event_byte);
@@ -139,7 +139,7 @@ JackMidiRawInputWriteQueue::PrepareByteEvent(jack_nframes_t time,
 
 void
 JackMidiRawInputWriteQueue::PrepareEvent(jack_nframes_t time, size_t size,
-                                         jack_midi_data_t *buffer)
+                                         jack_event_data_t *buffer)
 {
     event.buffer = buffer;
     event.size = size;
@@ -174,7 +174,7 @@ JackMidiRawInputWriteQueue::Process(jack_nframes_t boundary_frame)
 
 bool
 JackMidiRawInputWriteQueue::ProcessByte(jack_nframes_t time,
-                                        jack_midi_data_t byte)
+                                        jack_event_data_t byte)
 {
     if (byte >= 0xf8) {
         // Realtime
@@ -269,7 +269,7 @@ JackMidiRawInputWriteQueue::ProcessByte(jack_nframes_t time,
 }
 
 void
-JackMidiRawInputWriteQueue::RecordByte(jack_midi_data_t byte)
+JackMidiRawInputWriteQueue::RecordByte(jack_event_data_t byte)
 {
     if (total_bytes < input_buffer_size) {
         input_buffer[total_bytes] = byte;

common/JackEventRawInputWriteQueue.h → common/JackMidiRawInputWriteQueue.h

@@ -20,8 +20,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 #ifndef __JackMidiRawInputWriteQueue__
 #define __JackMidiRawInputWriteQueue__
 
-#include "JackMidiAsyncQueue.h"
-#include "JackMidiWriteQueue.h"
+#include "JackEventAsyncQueue.h"
+#include "JackEventWriteQueue.h"
 
 namespace Jack {
 
@@ -33,22 +33,22 @@ namespace Jack {
      * MIDI bytes that must be parsed.
      */
 
-    class SERVER_EXPORT JackMidiRawInputWriteQueue: public JackMidiWriteQueue {
+    class SERVER_EXPORT JackMidiRawInputWriteQueue: public JackEventWriteQueue {
 
     private:
 
-        jack_midi_event_t event;
-        jack_midi_data_t event_byte;
+        jack_event_t event;
+        jack_event_data_t event_byte;
         bool event_pending;
         size_t expected_bytes;
-        jack_midi_data_t *input_buffer;
+        jack_event_data_t *input_buffer;
         size_t input_buffer_size;
-        jack_midi_event_t *packet;
+        jack_event_t *packet;
         JackMidiAsyncQueue *packet_queue;
-        jack_midi_data_t status_byte;
+        jack_event_data_t status_byte;
         size_t total_bytes;
         size_t unbuffered_bytes;
-        JackMidiWriteQueue *write_queue;
+        JackEventWriteQueue *write_queue;
 
         void
         Clear();
@@ -57,17 +57,17 @@ namespace Jack {
         PrepareBufferedEvent(jack_nframes_t time);
 
         bool
-        PrepareByteEvent(jack_nframes_t time, jack_midi_data_t byte);
+        PrepareByteEvent(jack_nframes_t time, jack_event_data_t byte);
 
         void
         PrepareEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
         bool
-        ProcessByte(jack_nframes_t time, jack_midi_data_t byte);
+        ProcessByte(jack_nframes_t time, jack_event_data_t byte);
 
         void
-        RecordByte(jack_midi_data_t byte);
+        RecordByte(jack_event_data_t byte);
 
         bool
         WriteEvent(jack_nframes_t boundary_frame);
@@ -120,7 +120,7 @@ namespace Jack {
 
     public:
 
-        using JackMidiWriteQueue::EnqueueEvent;
+        using JackEventWriteQueue::EnqueueEvent;
 
         /**
          * Called to create a new raw input write queue.  The `write_queue`
@@ -132,7 +132,7 @@ namespace Jack {
          * written to the write queue.
          */
 
-        JackMidiRawInputWriteQueue(JackMidiWriteQueue *write_queue,
+        JackMidiRawInputWriteQueue(JackEventWriteQueue *write_queue,
                                    size_t max_packet_data=4096,
                                    size_t max_packets=1024);
 
@@ -140,7 +140,7 @@ namespace Jack {
 
         EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
         /**
          * Returns the maximum size event that can be enqueued right *now*.

common/JackEventRawOutputWriteQueue.cpp → common/JackMidiRawOutputWriteQueue.cpp

@@ -29,13 +29,13 @@ using Jack::JackMidiRawOutputWriteQueue;
 #define STILL_TIME(c, b) ((! (b)) || ((c) < (b)))
 
 JackMidiRawOutputWriteQueue::
-JackMidiRawOutputWriteQueue(JackMidiSendQueue *send_queue, size_t non_rt_size,
+JackMidiRawOutputWriteQueue(JackEventSendQueue *send_queue, size_t non_rt_size,
                             size_t max_non_rt_messages, size_t max_rt_messages)
 {
-    non_rt_queue = new JackMidiAsyncQueue(non_rt_size, max_non_rt_messages);
-    std::unique_ptr<JackMidiAsyncQueue> non_rt_ptr(non_rt_queue);
-    rt_queue = new JackMidiAsyncQueue(max_rt_messages, max_rt_messages);
-    std::unique_ptr<JackMidiAsyncQueue> rt_ptr(rt_queue);
+    non_rt_queue = new JackEventAsyncQueue(non_rt_size, max_non_rt_messages);
+    std::unique_ptr<JackEventAsyncQueue> non_rt_ptr(non_rt_queue);
+    rt_queue = new JackEventAsyncQueue(max_rt_messages, max_rt_messages);
+    std::unique_ptr<JackEventAsyncQueue> rt_ptr(rt_queue);
     non_rt_event = 0;
     rt_event = 0;
     running_status = 0;
@@ -69,18 +69,18 @@ JackMidiRawOutputWriteQueue::DequeueRealtimeEvent()
     }
 }
 
-Jack::JackMidiWriteQueue::EnqueueResult
+Jack::JackEventWriteQueue::EnqueueResult
 JackMidiRawOutputWriteQueue::EnqueueEvent(jack_nframes_t time, size_t size,
-                                          jack_midi_data_t *buffer)
+                                          jack_event_data_t *buffer)
 {
-    JackMidiAsyncQueue *queue = (size == 1) && (*buffer >= 0xf8) ? rt_queue :
+    JackEventAsyncQueue *queue = (size == 1) && (*buffer >= 0xf8) ? rt_queue :
         non_rt_queue;
     return queue->EnqueueEvent(time, size, buffer);
 }
 
 void
 JackMidiRawOutputWriteQueue::HandleWriteQueueBug(jack_nframes_t time,
-                                                 jack_midi_data_t byte)
+                                                 jack_event_data_t byte)
 {
     jack_error("JackMidiRawOutputWriteQueue::HandleWriteQueueBug - **BUG** "
                "The write queue told us that it couldn't enqueue a 1-byte "
@@ -123,7 +123,7 @@ JackMidiRawOutputWriteQueue::Process(jack_nframes_t boundary_frame)
 
 bool
 JackMidiRawOutputWriteQueue::SendByte(jack_nframes_t time,
-                                      jack_midi_data_t byte)
+                                      jack_event_data_t byte)
 {
     switch (send_queue->EnqueueEvent(time, 1, &byte)) {
     case BUFFER_TOO_SMALL:

common/JackEventRawOutputWriteQueue.h → common/JackMidiRawOutputWriteQueue.h

@@ -20,8 +20,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 #ifndef __JackMidiRawOutputWriteQueue__
 #define __JackMidiRawOutputWriteQueue__
 
-#include "JackMidiAsyncQueue.h"
-#include "JackMidiSendQueue.h"
+#include "JackEventAsyncQueue.h"
+#include "JackEventSendQueue.h"
 
 namespace Jack {
 
@@ -44,18 +44,18 @@ namespace Jack {
      */
 
     class SERVER_EXPORT JackMidiRawOutputWriteQueue:
-        public JackMidiWriteQueue {
+        public JackEventWriteQueue {
 
     private:
 
-        jack_midi_event_t *non_rt_event;
+        jack_event_t *non_rt_event;
         jack_nframes_t non_rt_event_time;
-        JackMidiAsyncQueue *non_rt_queue;
-        jack_midi_event_t *rt_event;
+        JackEventAsyncQueue *non_rt_queue;
+        jack_event_t *rt_event;
         jack_nframes_t rt_event_time;
-        JackMidiAsyncQueue *rt_queue;
-        jack_midi_data_t running_status;
-        JackMidiSendQueue *send_queue;
+        JackEventAsyncQueue *rt_queue;
+        jack_event_data_t running_status;
+        JackEventSendQueue *send_queue;
 
         void
         DequeueNonRealtimeEvent();
@@ -64,7 +64,7 @@ namespace Jack {
         DequeueRealtimeEvent();
 
         bool
-        SendByte(jack_nframes_t time, jack_midi_data_t byte);
+        SendByte(jack_nframes_t time, jack_event_data_t byte);
 
         bool
         SendNonRTBytes(jack_nframes_t boundary_frame);
@@ -78,11 +78,11 @@ namespace Jack {
          */
 
         virtual void
-        HandleWriteQueueBug(jack_nframes_t time, jack_midi_data_t byte);
+        HandleWriteQueueBug(jack_nframes_t time, jack_event_data_t byte);
 
     public:
 
-        using JackMidiWriteQueue::EnqueueEvent;
+        using JackEventWriteQueue::EnqueueEvent;
 
         /**
          * Called to create a new raw write queue.  The `send_queue` argument
@@ -95,7 +95,7 @@ namespace Jack {
          * the non-realtime queue.
          */
 
-        JackMidiRawOutputWriteQueue(JackMidiSendQueue *send_queue,
+        JackMidiRawOutputWriteQueue(JackEventSendQueue *send_queue,
                                     size_t non_rt_size=4096,
                                     size_t max_non_rt_messages=1024,
                                     size_t max_rt_messages=128);
@@ -104,7 +104,7 @@ namespace Jack {
 
         EnqueueResult
         EnqueueEvent(jack_nframes_t time, size_t size,
-                     jack_midi_data_t *buffer);
+                     jack_event_data_t *buffer);
 
         /**
          * The `Process()` method should be called each time the