From a73a5779809881a86909de4402b5dce99deee5d7 Mon Sep 17 00:00:00 2001 From: piegames Date: Sun, 13 Oct 2019 22:11:23 +0200 Subject: [PATCH] Rename JackMidiPort to JackMessagePort --- .../{JackMidiPort.cpp => JackMessagePort.cpp} | 62 +++++----- common/JackMessagePort.h | 109 ++++++++++++++++++ common/JackMidiPort.h | 80 ++----------- common/wscript | 2 +- 4 files changed, 150 insertions(+), 103 deletions(-) rename common/{JackMidiPort.cpp => JackMessagePort.cpp} (64%) create mode 100644 common/JackMessagePort.h diff --git a/common/JackMidiPort.cpp b/common/JackMessagePort.cpp similarity index 64% rename from common/JackMidiPort.cpp rename to common/JackMessagePort.cpp index 9ce91c9b..1209e465 100644 --- a/common/JackMidiPort.cpp +++ b/common/JackMessagePort.cpp @@ -21,14 +21,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "JackError.h" #include "JackPortType.h" -#include "JackMidiPort.h" +#include "JackMessagePort.h" #include #include namespace Jack { -SERVER_EXPORT void JackMidiBuffer::Reset(jack_nframes_t nframes) +SERVER_EXPORT void JackMessageBuffer::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 JackMessageBuffer::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(JackMessageBuffer) + sizeof(JackMessageEvent) * (event_count + 1) + write_pos); if (left < 0) { return 0; } - if (left <= JackMidiEvent::INLINE_SIZE_MAX) { - return JackMidiEvent::INLINE_SIZE_MAX; + if (left <= JackMessageEvent::INLINE_SIZE_MAX) { + return JackMessageEvent::INLINE_SIZE_MAX; } return left; } -SERVER_EXPORT jack_midi_data_t* JackMidiBuffer::ReserveEvent(jack_nframes_t time, jack_shmsize_t size) +SERVER_EXPORT jack_message_data_t* JackMessageBuffer::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("JackMessageBuffer::ReserveEvent - the buffer does not have " "enough room to enqueue a %lu byte event", size); lost_events++; return 0; } - JackMidiEvent* event = &events[event_count++]; + JackMessageEvent* event = &events[event_count++]; event->time = time; event->size = size; - if (size <= JackMidiEvent::INLINE_SIZE_MAX) { + if (size <= JackMessageEvent::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_message_data_t*)this + event->offset; } -void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes) +void MessageBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes) { - JackMidiBuffer* midi = (JackMidiBuffer*)buffer; - midi->magic = JackMidiBuffer::MAGIC; + JackMessageBuffer* message = (JackMessageBuffer*)buffer; + message->magic = JackMessageBuffer::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); + message->buffer_size = BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t); + message->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 MessageBufferMixdown(void* mixbuffer, void** src_buffers, int src_count, jack_nframes_t nframes) { - JackMidiBuffer* mix = static_cast(mixbuffer); + JackMessageBuffer* mix = static_cast(mixbuffer); if (!mix->IsValid()) { - jack_error("Jack::MidiBufferMixdown - invalid mix buffer"); + jack_error("Jack::MessageBufferMixdown - 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]); + JackMessageBuffer* buf = static_cast(src_buffers[i]); if (!buf->IsValid()) { - jack_error("Jack::MidiBufferMixdown - invalid source buffer"); + jack_error("Jack::MessageBufferMixdown - 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; + JackMessageBuffer* next_buf = 0; + JackMessageEvent* 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]); + JackMessageBuffer* buf = static_cast(src_buffers[i]); if (mix_index[i] >= buf->event_count) continue; - JackMidiEvent* e = &buf->events[mix_index[i]]; + JackMessageEvent* 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::MessageBufferMixdown - got invalid next event"); break; } // write the event - jack_midi_data_t* dest = mix->ReserveEvent(next_event->time, next_event->size); + jack_message_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 MessageBufferSize() { return BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t); } @@ -154,9 +154,9 @@ static size_t MidiBufferSize() const JackPortType gMessagePortType = { JACK_DEFAULT_MESSAGE_TYPE, - MidiBufferSize, - MidiBufferInit, - MidiBufferMixdown + MessageBufferSize, + MessageBufferInit, + MessageBufferMixdown }; const JackPortType gMidiPortType = gMessagePortType; diff --git a/common/JackMessagePort.h b/common/JackMessagePort.h new file mode 100644 index 00000000..db99fb1a --- /dev/null +++ b/common/JackMessagePort.h @@ -0,0 +1,109 @@ +/* +Copyright (C) 2007 Dmitry Baikov +Original JACK MIDI API implementation Copyright (C) 2004 Ian Esten + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +#ifndef __JackMessagePort__ +#define __JackMessagePort__ + +#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_message_data_t; + +/** A Jack MIDI event. */ +struct jack_message_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_message_data_t *buffer; /**< Raw message data */ +}; + +/** @deprecated */ +typedef jack_message_data_t jack_midi_data_t; +/** @deprecated */ +typedef jack_message_event_t jack_midi_event_t; + +/** A Jack MIDI port type. Use @ref JACK_DEFAULT_MESSAGE_TYPE instead if possible */ +#define JACK_DEFAULT_MIDI_TYPE "8 bit raw midi" +#define JACK_DEFAULT_MESSAGE_TYPE "binary message data" + +namespace Jack +{ + +struct SERVER_EXPORT JackMessageEvent +{ + // Most MIDI events are < 4 bytes in size, so we can save a lot, storing them inplace. + enum { INLINE_SIZE_MAX = sizeof(jack_shmsize_t) }; + + uint32_t time; + jack_shmsize_t size; + union { + jack_shmsize_t offset; + jack_message_data_t data[INLINE_SIZE_MAX]; + }; + + jack_message_data_t* GetData(void* buffer) + { + if (size <= INLINE_SIZE_MAX) { + return data; + } else { + return (jack_message_data_t*)buffer + offset; + } + } +}; + +/* + * To store events with arbitrarily sized payload, but still have O(1) indexed access + * we use a trick here: + * Events are stored in an linear array from the beginning of the buffer, + * but their data (if not inlined) is stored from the end of the same buffer. + */ + +struct SERVER_EXPORT JackMessageBuffer +{ + enum { MAGIC = 0x900df00d }; + + uint32_t magic; + jack_shmsize_t buffer_size; + jack_nframes_t nframes; + jack_shmsize_t write_pos; //!< data write position from the end of the buffer. + uint32_t event_count; + uint32_t lost_events; + + JackMessageEvent events[1]; // Using 0 size does not compile with older GCC versions, so use 1 here. + + int IsValid() const + { + return magic == MAGIC; + } + void Reset(jack_nframes_t nframes); + jack_shmsize_t MaxEventSize() const; + + // checks only size constraints. + jack_message_data_t* ReserveEvent(jack_nframes_t time, jack_shmsize_t size); +}; + +void MessageBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes); + +} // namespace Jack + +#endif diff --git a/common/JackMidiPort.h b/common/JackMidiPort.h index 806a03e7..59a9c8a1 100644 --- a/common/JackMidiPort.h +++ b/common/JackMidiPort.h @@ -21,83 +21,21 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #ifndef __JackMidiPort__ #define __JackMidiPort__ -#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; - -/** A Jack MIDI event. */ -struct jack_midi_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 */ -}; - -/** A Jack MIDI port type. Use @ref JACK_DEFAULT_MESSAGE_TYPE instead if possible */ -#define JACK_DEFAULT_MIDI_TYPE "8 bit raw midi" -#define JACK_DEFAULT_MESSAGE_TYPE "binary message data" +#include "JackMessagePort.h" namespace Jack { -struct SERVER_EXPORT JackMidiEvent -{ - // Most MIDI events are < 4 bytes in size, so we can save a lot, storing them inplace. - 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_midi_data_t* GetData(void* buffer) - { - if (size <= INLINE_SIZE_MAX) { - return data; - } else { - return (jack_midi_data_t*)buffer + offset; - } - } -}; - -/* - * To store events with arbitrarily sized payload, but still have O(1) indexed access - * we use a trick here: - * Events are stored in an linear array from the beginning of the buffer, - * but their data (if not inlined) is stored from the end of the same buffer. - */ - -struct SERVER_EXPORT JackMidiBuffer -{ - enum { MAGIC = 0x900df00d }; - - uint32_t magic; - jack_shmsize_t buffer_size; - jack_nframes_t nframes; - jack_shmsize_t write_pos; //!< data write position from the end of the buffer. - 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. - - int IsValid() const - { - return magic == MAGIC; - } - void Reset(jack_nframes_t nframes); - jack_shmsize_t MaxEventSize() const; +/** @deprecated */ +typedef JackMessageEvent JackMidiEvent; +/** @deprecated */ +typedef JackMessageBuffer JackMidiBuffer; - // checks only size constraints. - jack_midi_data_t* ReserveEvent(jack_nframes_t time, jack_shmsize_t size); -}; +/** @deprecated */ +inline void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes) { + MessageBufferInit(buffer, buffer_size, nframes); +} -void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes); } // namespace Jack diff --git a/common/wscript b/common/wscript index aa13edaa..7113cf3b 100644 --- a/common/wscript +++ b/common/wscript @@ -56,7 +56,7 @@ def build(bld): 'JackPort.cpp', 'JackPortType.cpp', 'JackAudioPort.cpp', - 'JackMidiPort.cpp', + 'JackMessagePort.cpp', 'JackMidiAPI.cpp', 'JackMessageAPI.cpp', 'JackEngineControl.cpp',