diff --git a/common/JackEventPort.cpp b/common/JackEventPort.cpp index 8731f1e1..7357df68 100644 --- a/common/JackEventPort.cpp +++ b/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 #include 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(mixbuffer); + JackEventBuffer* mix = static_cast(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(src_buffers[i]); + JackEventBuffer* buf = static_cast(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(src_buffers[i]); + JackEventBuffer* buf = static_cast(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 diff --git a/common/JackEventPort.h b/common/JackEventPort.h index d43c95ae..007e2332 100644 --- a/common/JackEventPort.h +++ b/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 -/** 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