Rename JackMidiPort to JackEventPort

common/JackEventPort.cpp

@@ -20,15 +20,15 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 
 #include "JackError.h"
-#include "JackPortType.h"
-#include "JackMidiPort.h"
+#include "JackEventType.h"
+#include "JackEventPort.h"
 #include <assert.h>
 #include <string.h>
 
 namespace Jack
 {
 
-SERVER_EXPORT void JackMidiBuffer::Reset(jack_nframes_t nframes)
+SERVER_EXPORT void JackEventBuffer::Reset(jack_nframes_t nframes)
 {
     /* This line ate 1 hour of my life... dsbaikov */
     this->nframes = nframes;
@@ -37,48 +37,48 @@ SERVER_EXPORT void JackMidiBuffer::Reset(jack_nframes_t nframes)
     lost_events = 0;
 }
 
-SERVER_EXPORT jack_shmsize_t JackMidiBuffer::MaxEventSize() const
+SERVER_EXPORT jack_shmsize_t JackEventBuffer::MaxEventSize() const
 {
     assert (((jack_shmsize_t) - 1) < 0); // jack_shmsize_t should be signed
-    jack_shmsize_t left = buffer_size - (sizeof(JackMidiBuffer) + sizeof(JackMidiEvent) * (event_count + 1) + write_pos);
+    jack_shmsize_t left = buffer_size - (sizeof(JackEventBuffer) + sizeof(JackEvent) * (event_count + 1) + write_pos);
     if (left < 0) {
         return 0;
     }
-    if (left <= JackMidiEvent::INLINE_SIZE_MAX) {
-        return JackMidiEvent::INLINE_SIZE_MAX;
+    if (left <= JackEvent::INLINE_SIZE_MAX) {
+        return JackEvent::INLINE_SIZE_MAX;
     }
     return left;
 }
 
-SERVER_EXPORT jack_midi_data_t* JackMidiBuffer::ReserveEvent(jack_nframes_t time, jack_shmsize_t size)
+SERVER_EXPORT jack_event_data_t* JackEventBuffer::ReserveEvent(jack_nframes_t time, jack_shmsize_t size)
 {
     jack_shmsize_t space = MaxEventSize();
     if (space == 0 || size > space) {
-        jack_error("JackMidiBuffer::ReserveEvent - the buffer does not have "
+        jack_error("JackEventBuffer::ReserveEvent - the buffer does not have "
                    "enough room to enqueue a %lu byte event", size);
         lost_events++;
         return 0;
     }
-    JackMidiEvent* event = &events[event_count++];
+    JackEvent* event = &events[event_count++];
     event->time = time;
     event->size = size;
     
-    if (size <= JackMidiEvent::INLINE_SIZE_MAX) {
+    if (size <= JackEvent::INLINE_SIZE_MAX) {
         return event->data;
     }
    
     write_pos += size;
     event->offset = buffer_size - write_pos;
-    return (jack_midi_data_t*)this + event->offset;
+    return (jack_event_data_t*)this + event->offset;
 }
 
-void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes)
+void EventBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes)
 {
-    JackMidiBuffer* midi = (JackMidiBuffer*)buffer;
-    midi->magic = JackMidiBuffer::MAGIC;
+    JackEventBuffer* buffer = (JackEventBuffer*)buffer;
+    buffer->magic = JackEventBuffer::MAGIC;
     /* Since port buffer has actually always BUFFER_SIZE_MAX frames, we can safely use all the size */
-    midi->buffer_size = BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t);
-    midi->Reset(nframes);
+    buffer->buffer_size = BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t);
+    buffer->Reset(nframes);
 }
 
 /*
@@ -91,11 +91,11 @@ void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes)
  * implementation as is, until it is proved to be a bottleneck.
  * Dmitry Baikov.
  */
-static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count, jack_nframes_t nframes)
+static void EventBufferMixdown(void* mixbuffer, void** src_buffers, int src_count, jack_nframes_t nframes)
 {
-    JackMidiBuffer* mix = static_cast<JackMidiBuffer*>(mixbuffer);
+    JackEventBuffer* mix = static_cast<JackEventBuffer*>(mixbuffer);
     if (!mix->IsValid()) {
-        jack_error("Jack::MidiBufferMixdown - invalid mix buffer");
+        jack_error("Jack::EventBufferMixdown - invalid mix buffer");
         return;
     }
     mix->Reset(nframes);
@@ -103,9 +103,9 @@ static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count
     uint32_t mix_index[src_count];
     int event_count = 0;
     for (int i = 0; i < src_count; ++i) {
-        JackMidiBuffer* buf = static_cast<JackMidiBuffer*>(src_buffers[i]);
+        JackEventBuffer* buf = static_cast<JackEventBuffer*>(src_buffers[i]);
         if (!buf->IsValid()) {
-            jack_error("Jack::MidiBufferMixdown - invalid source buffer");
+            jack_error("Jack::EventBufferMixdown - invalid source buffer");
             return;
         }
         mix_index[i] = 0;
@@ -115,16 +115,16 @@ static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count
 
     int events_done;
     for (events_done = 0; events_done < event_count; ++events_done) {
-        JackMidiBuffer* next_buf = 0;
-        JackMidiEvent* next_event = 0;
+        JackEventBuffer* next_buf = 0;
+        JackEvent* next_event = 0;
         uint32_t next_buf_index = 0;
 
         // find the earliest event
         for (int i = 0; i < src_count; ++i) {
-            JackMidiBuffer* buf = static_cast<JackMidiBuffer*>(src_buffers[i]);
+            JackEventBuffer* buf = static_cast<JackEventBuffer*>(src_buffers[i]);
             if (mix_index[i] >= buf->event_count)
                 continue;
-            JackMidiEvent* e = &buf->events[mix_index[i]];
+            JackEvent* e = &buf->events[mix_index[i]];
             if (!next_event || e->time < next_event->time) {
                 next_event = e;
                 next_buf = buf;
@@ -132,12 +132,12 @@ static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count
             }
         }
         if (next_event == 0) {
-            jack_error("Jack::MidiBufferMixdown - got invalid next event");
+            jack_error("Jack::EventBufferMixdown - got invalid next event");
             break;
         }
 
         // write the event
-        jack_midi_data_t* dest = mix->ReserveEvent(next_event->time, next_event->size);
+        jack_event_data_t* dest = mix->ReserveEvent(next_event->time, next_event->size);
         if (!dest) break;
 
         memcpy(dest, next_event->GetData(next_buf), next_event->size);
@@ -146,7 +146,7 @@ static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count
     mix->lost_events += event_count - events_done;
 }
 
-static size_t MidiBufferSize()
+static size_t EventBufferSize()
 {
     return BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t);
 }
@@ -154,9 +154,17 @@ static size_t MidiBufferSize()
 const JackPortType gMidiPortType =
 {
     JACK_DEFAULT_MIDI_TYPE,
-    MidiBufferSize,
-    MidiBufferInit,
-    MidiBufferMixdown
+    EventBufferSize,
+    EventBufferInit,
+    EventBufferMixdown
+};
+
+const JackPortType gOscPortType =
+{
+    JACK_DEFAULT_OSC_TYPE,
+    EventBufferSize,
+    EventBufferInit,
+    EventBufferMixdown
 };
 
 } // namespace Jack

common/JackEventPort.h

@@ -18,49 +18,55 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 */
 
-#ifndef __JackMidiPort__
-#define __JackMidiPort__
+#ifndef __JackEventPort__
+#define __JackEventPort__
 
 #include "types.h"
 #include "JackConstants.h"
 #include "JackPlatformPlug.h"
 #include <stddef.h>
 
-/** Type for raw event data contained in @ref jack_midi_event_t. */
-typedef unsigned char jack_midi_data_t;
+/** Type for raw event data contained in @ref jack_event_t. */
+typedef unsigned char jack_event_data_t;
 
-/** A Jack MIDI event. */
-struct jack_midi_event_t
+/** A Jack event. */
+struct jack_event_t
 {
-    jack_nframes_t    time;   /**< Sample index at which event is valid */
-    size_t            size;   /**< Number of bytes of data in \a buffer */
-    jack_midi_data_t *buffer; /**< Raw MIDI data */
+    jack_nframes_t     time;   /**< Sample index at which event is valid */
+    size_t             size;   /**< Number of bytes of data in \a buffer */
+    jack_event_data_t *buffer; /**< Raw event data */
 };
 
 /** A Jack MIDI port type. */
 #define JACK_DEFAULT_MIDI_TYPE "8 bit raw midi"
+/** A Jack OSC port type. */
+#define JACK_DEFAULT_OSC_TYPE "32 bit OSC"
 
 namespace Jack
 {
 
-struct SERVER_EXPORT JackMidiEvent
+struct SERVER_EXPORT JackEvent
 {
-    // Most MIDI events are < 4 bytes in size, so we can save a lot, storing them inplace.
+    /** Most MIDI events are < 4 bytes in size, so we can save a lot, storing them inplace.
+     * "inplace" means that instead of storing an offset to the actual data we store 4 bytes in that
+     * pointer. This is not relevant for OSC data (and other newer protocols) since most packets are a
+     * lot larger.
+     */
     enum { INLINE_SIZE_MAX = sizeof(jack_shmsize_t) };
 
     uint32_t time;
     jack_shmsize_t size;
     union {
         jack_shmsize_t offset;
-        jack_midi_data_t data[INLINE_SIZE_MAX];
+        jack_event_data_t data[INLINE_SIZE_MAX];
     };
 
-    jack_midi_data_t* GetData(void* buffer)
+    jack_event_data_t* GetData(void* buffer)
     {
         if (size <= INLINE_SIZE_MAX) {
             return data;
         } else {
-            return (jack_midi_data_t*)buffer + offset;
+            return (jack_event_data_t*)buffer + offset;
         }
     }
 };
@@ -72,7 +78,7 @@ struct SERVER_EXPORT JackMidiEvent
  * but their data (if not inlined) is stored from the end of the same buffer.
  */
 
-struct SERVER_EXPORT JackMidiBuffer
+struct SERVER_EXPORT JackEventBuffer
 {
     enum { MAGIC = 0x900df00d };
 
@@ -83,7 +89,7 @@ struct SERVER_EXPORT JackMidiBuffer
     uint32_t event_count;
     uint32_t lost_events;
 
-    JackMidiEvent events[1]; // Using 0 size does not compile with older GCC versions, so use 1 here.
+    JackEvent events[1]; // Using 0 size does not compile with older GCC versions, so use 1 here.
 
     int IsValid() const
     {
@@ -93,10 +99,10 @@ struct SERVER_EXPORT JackMidiBuffer
     jack_shmsize_t MaxEventSize() const;
 
     // checks only size constraints.
-    jack_midi_data_t* ReserveEvent(jack_nframes_t time, jack_shmsize_t size);
+    jack_event_data_t* ReserveEvent(jack_nframes_t time, jack_shmsize_t size);
 };
 
-void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes);
+void EventBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes);
 
 } // namespace Jack