libjack: cleanup midi port code

Signed-off-by: falkTX <falktx@gmail.com>

source/libjack/api.hpp

@@ -27,7 +27,7 @@
 extern "C" {
 
 typedef uint32_t jack_port_type_id_t;
-typedef void *(*JackThreadCallback)(void* arg);
+typedef void*(*JackThreadCallback)(void* arg);
 
 int jack_carla_interposed_action(int, int, void*);
 
@@ -40,9 +40,9 @@ jack_client_t* jack_client_open(const char*, jack_options_t, jack_status_t*, ...
 jack_client_t* jack_client_new(const char*);
 int jack_client_close(jack_client_t*);
 int jack_client_name_size(void);
-char * jack_get_client_name(jack_client_t*);
-char *jack_get_uuid_for_client_name(jack_client_t*, const char*);
-char *jack_get_client_name_by_uuid(jack_client_t*, const char*);
+char* jack_get_client_name(jack_client_t*);
+char* jack_get_uuid_for_client_name(jack_client_t*, const char*);
+char* jack_get_client_name_by_uuid(jack_client_t*, const char*);
 int jack_internal_client_new(const char*, const char*, const char*);
 void jack_internal_client_close(const char*);
 int jack_activate(jack_client_t*);
@@ -62,7 +62,7 @@ int jack_set_freewheel_callback(jack_client_t*, JackFreewheelCallback, void*);
 int jack_set_buffer_size_callback(jack_client_t*, JackBufferSizeCallback, void*);
 int jack_set_sample_rate_callback(jack_client_t*, JackSampleRateCallback, void*);
 int jack_set_client_registration_callback(jack_client_t*, JackClientRegistrationCallback, void*);
- int jack_set_port_registration_callback(jack_client_t*, JackPortRegistrationCallback, void*);
+int jack_set_port_registration_callback(jack_client_t*, JackPortRegistrationCallback, void*);
 int jack_set_port_connect_callback(jack_client_t*, JackPortConnectCallback, void*);
 int jack_set_port_rename_callback(jack_client_t*, JackPortRenameCallback, void*);
 int jack_set_graph_order_callback(jack_client_t*, JackGraphOrderCallback, void*);
@@ -74,14 +74,14 @@ jack_nframes_t jack_get_sample_rate(jack_client_t*);
 jack_nframes_t jack_get_buffer_size(jack_client_t*);
 int jack_engine_takeover_timebase(jack_client_t*);
 float jack_cpu_load(jack_client_t*);
-jack_port_t * jack_port_register(jack_client_t*, const char*, const char*, unsigned long, unsigned long);
+jack_port_t* jack_port_register(jack_client_t*, const char*, const char*, unsigned long, unsigned long);
 int jack_port_unregister(jack_client_t*, jack_port_t*);
-void * jack_port_get_buffer(jack_port_t*, jack_nframes_t);
+void* jack_port_get_buffer(jack_port_t*, jack_nframes_t);
 jack_uuid_t jack_port_uuid(const jack_port_t*);
-const char * jack_port_name(const jack_port_t*);
-const char * jack_port_short_name(const jack_port_t*);
+const char* jack_port_name(const jack_port_t*);
+const char* jack_port_short_name(const jack_port_t*);
 int jack_port_flags(const jack_port_t*);
-const char * jack_port_type(const jack_port_t*);
+const char* jack_port_type(const jack_port_t*);
 jack_port_type_id_t jack_port_type_id(const jack_port_t*);
 int jack_port_is_mine(const jack_client_t*, const jack_port_t*);
 int jack_port_connected(const jack_port_t*);
@@ -124,11 +124,11 @@ jack_nframes_t jack_time_to_frames(const jack_client_t*, jack_time_t);
 jack_time_t jack_get_time(void);
 void jack_free(void*);
 
-extern void(*jack_error_callback)(const char *msg);
-void jack_set_error_function(void (*func)(const char *));
+extern void(*jack_error_callback)(const char*msg);
+void jack_set_error_function(void (*func)(const char*));
 
-extern void (*jack_info_callback)(const char *msg);
-void jack_set_info_function(void (*func)(const char *));
+extern void (*jack_info_callback)(const char*msg);
+void jack_set_info_function(void (*func)(const char*));
 
 // --------------------------------------------------------------------------------------------------------------------
 // medadata.h
@@ -168,7 +168,7 @@ uint32_t jack_midi_get_lost_event_count(void*);
 int jack_client_real_time_priority(jack_client_t*);
 int jack_client_max_real_time_priority(jack_client_t*);
 int jack_acquire_real_time_scheduling(pthread_t, int );
-int jack_client_create_thread(jack_client_t*, pthread_t*, int, int, void *(*start_routine)(void*), void*);
+int jack_client_create_thread(jack_client_t*, pthread_t*, int, int, void*(*start_routine)(void*), void*);
 int jack_drop_real_time_scheduling(pthread_t);
 int jack_client_stop_thread(jack_client_t*, pthread_t);
 int jack_client_kill_thread(jack_client_t*, pthread_t);
@@ -222,12 +222,12 @@ jack_uuid_t jack_client_uuid_generate();
 jack_uuid_t jack_port_uuid_generate(uint32_t port_id);
 uint32_t jack_uuid_to_index(jack_uuid_t);
 
-int  jack_uuid_compare(jack_uuid_t, jack_uuid_t);
+int jack_uuid_compare(jack_uuid_t, jack_uuid_t);
 void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src);
 void jack_uuid_clear(jack_uuid_t*);
-int  jack_uuid_parse(const char *buf, jack_uuid_t*);
+int jack_uuid_parse(const char*buf, jack_uuid_t*);
 void jack_uuid_unparse(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);
-int  jack_uuid_empty(jack_uuid_t);
+int jack_uuid_empty(jack_uuid_t);
 
 // --------------------------------------------------------------------------------------------------------------------
 

source/libjack/libjack.cpp

@@ -121,8 +121,8 @@ public:
           fShmNonRtServerControl(),
           fAudioPoolCopy(nullptr),
           fAudioTmpBuf(nullptr),
-          fDummyMidiInBuffer(true, "ignored"),
-          fDummyMidiOutBuffer(false, "ignored"),
+          fDummyMidiInBuffer(true),
+          fDummyMidiOutBuffer(false),
           fMidiInBuffers(nullptr),
           fMidiOutBuffers(nullptr),
           fIsOffline(false),
@@ -288,10 +288,10 @@ private:
     float* fAudioPoolCopy;
     float* fAudioTmpBuf;
 
-    JackMidiPortBuffer fDummyMidiInBuffer;
-    JackMidiPortBuffer fDummyMidiOutBuffer;
-    JackMidiPortBuffer* fMidiInBuffers;
-    JackMidiPortBuffer* fMidiOutBuffers;
+    JackMidiPortBufferDummy fDummyMidiInBuffer;
+    JackMidiPortBufferDummy fDummyMidiOutBuffer;
+    JackMidiPortBufferOnStack* fMidiInBuffers;
+    JackMidiPortBufferOnStack* fMidiOutBuffers;
 
     char fBaseNameAudioPool[6+1];
     char fBaseNameRtClientControl[6+1];
@@ -561,17 +561,17 @@ bool CarlaJackAppClient::handleRtData()
             const uint8_t  size(fShmRtClientControl.readByte());
             CARLA_SAFE_ASSERT_BREAK(size > 0);
 
-            if (port >= fServer.numMidiIns || size > JackMidiPortBuffer::kMaxEventSize || ! fRealtimeThreadMutex.tryLock())
+            if (port >= fServer.numMidiIns || size > JackMidiPortBufferBase::kMaxEventSize || ! fRealtimeThreadMutex.tryLock())
             {
                 for (uint8_t i=0; i<size; ++i)
                     fShmRtClientControl.readByte();
                 break;
             }
 
-            JackMidiPortBuffer& midiPortBuf(fMidiInBuffers[port]);
+            JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[port]);
 
-            if (midiPortBuf.count < JackMidiPortBuffer::kMaxEventCount &&
-                midiPortBuf.bufferPoolPos + size < JackMidiPortBuffer::kBufferPoolSize)
+            if (midiPortBuf.count < JackMidiPortBufferBase::kMaxEventCount &&
+                midiPortBuf.bufferPoolPos + size < JackMidiPortBufferBase::kBufferPoolSize)
             {
                 jack_midi_event_t& ev(midiPortBuf.events[midiPortBuf.count++]);
 
@@ -822,7 +822,7 @@ bool CarlaJackAppClient::handleRtData()
 
                     for (uint8_t i=0; i<fServer.numMidiOuts; ++i)
                     {
-                        JackMidiPortBuffer& midiPortBuf(fMidiOutBuffers[i]);
+                        JackMidiPortBufferOnStack& midiPortBuf(fMidiOutBuffers[i]);
 
                         for (uint16_t j=0; j<midiPortBuf.count; ++j)
                         {
@@ -1054,7 +1054,7 @@ void CarlaJackAppClient::runNonRealtimeThread()
 
     if (fServer.numMidiIns > 0)
     {
-        fMidiInBuffers = new JackMidiPortBuffer[fServer.numMidiIns];
+        fMidiInBuffers = new JackMidiPortBufferOnStack[fServer.numMidiIns];
 
         for (uint8_t i=0; i<fServer.numMidiIns; ++i)
             fMidiInBuffers[i].isInput = true;
@@ -1062,7 +1062,7 @@ void CarlaJackAppClient::runNonRealtimeThread()
 
     if (fServer.numMidiOuts > 0)
     {
-        fMidiOutBuffers = new JackMidiPortBuffer[fServer.numMidiOuts];
+        fMidiOutBuffers = new JackMidiPortBufferOnStack[fServer.numMidiOuts];
 
         for (uint8_t i=0; i<fServer.numMidiOuts; ++i)
             fMidiOutBuffers[i].isInput = false;

source/libjack/libjack.hpp

@@ -59,40 +59,43 @@ class CarlaJackAppClient;
 struct JackClientState;
 struct JackServerState;
 
-struct JackMidiPortBuffer {
+struct JackMidiPortBufferBase {
     static const uint8_t kMaxEventSize   = 128;
     static const size_t  kMaxEventCount  = 512;
     static const size_t  kBufferPoolSize = kMaxEventCount*8;
 
-    uint16_t count;
     bool isInput;
-    jack_midi_event_t* events;
+    bool isValid;
+};
 
+struct JackMidiPortBufferOnStack : JackMidiPortBufferBase {
     size_t bufferPoolPos;
-    jack_midi_data_t* bufferPool;
-
-    JackMidiPortBuffer()
-        : count(0),
-          isInput(true),
-          events(new jack_midi_event_t[kMaxEventCount]),
-          bufferPoolPos(0),
-          bufferPool(new jack_midi_data_t[kBufferPoolSize]) {}
-
-    // for unused ports
-    JackMidiPortBuffer(const bool input, const char*)
-        : count(0),
-          isInput(input),
-          events(nullptr),
-          bufferPoolPos(kBufferPoolSize),
-          bufferPool(nullptr) {}
-
-    ~JackMidiPortBuffer()
+    uint16_t count;
+
+    jack_midi_event_t events[kMaxEventCount];
+    jack_midi_data_t bufferPool[kBufferPoolSize];
+
+    JackMidiPortBufferOnStack()
+        : bufferPoolPos(0),
+          count(0),
+          events(),
+          bufferPool()
+    {
+        isInput = true;
+        isValid = true;
+    }
+
+    CARLA_DECLARE_NON_COPY_STRUCT(JackMidiPortBufferOnStack)
+};
+
+struct JackMidiPortBufferDummy : JackMidiPortBufferBase {
+    JackMidiPortBufferDummy(const bool input)
     {
-        delete[] events;
-        delete[] bufferPool;
+        isInput = input;
+        isValid = false;
     }
 
-    CARLA_DECLARE_NON_COPY_STRUCT(JackMidiPortBuffer)
+    CARLA_DECLARE_NON_COPY_STRUCT(JackMidiPortBufferDummy)
 };
 
 struct JackPortState {

source/libjack/libjack_midi.cpp

@@ -1,6 +1,6 @@
 /*
  * Carla JACK API for external applications
- * Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com>
+ * Copyright (C) 2016-2019 Filipe Coelho <falktx@falktx.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -24,9 +24,12 @@ CARLA_BACKEND_USE_NAMESPACE
 CARLA_EXPORT
 jack_nframes_t jack_midi_get_event_count(void* buf)
 {
-    JackMidiPortBuffer* const jmidibuf((JackMidiPortBuffer*)buf);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf != nullptr, 0);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf->isInput, 0);
+    const JackMidiPortBufferBase* const jbasebuf((const JackMidiPortBufferBase*)buf);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf != nullptr, 0);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isInput, 0);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isValid, 0);
+
+    const JackMidiPortBufferOnStack* const jmidibuf((const JackMidiPortBufferOnStack*)jbasebuf);
 
     return jmidibuf->count;
 }
@@ -34,9 +37,12 @@ jack_nframes_t jack_midi_get_event_count(void* buf)
 CARLA_EXPORT
 int jack_midi_event_get(jack_midi_event_t* ev, void* buf, uint32_t index)
 {
-    JackMidiPortBuffer* const jmidibuf((JackMidiPortBuffer*)buf);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf != nullptr, EFAULT);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf->isInput, EFAULT);
+    const JackMidiPortBufferBase* const jbasebuf((const JackMidiPortBufferBase*)buf);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf != nullptr, EFAULT);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isInput, EFAULT);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isValid, EFAULT);
+
+    const JackMidiPortBufferOnStack* const jmidibuf((const JackMidiPortBufferOnStack*)jbasebuf);
 
     if (index >= jmidibuf->count)
         return ENODATA;
@@ -48,17 +54,18 @@ int jack_midi_event_get(jack_midi_event_t* ev, void* buf, uint32_t index)
 CARLA_EXPORT
 void jack_midi_clear_buffer(void* buf)
 {
-    JackMidiPortBuffer* const jmidibuf((JackMidiPortBuffer*)buf);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf != nullptr,);
-    CARLA_SAFE_ASSERT_RETURN(! jmidibuf->isInput,);
+    JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf != nullptr,);
+    CARLA_SAFE_ASSERT_RETURN(! jbasebuf->isInput,);
 
-    jmidibuf->count = 0;
+    if (! jbasebuf->isValid)
+        return;
+
+    JackMidiPortBufferOnStack* const jmidibuf((JackMidiPortBufferOnStack*)jbasebuf);
 
-    if (jmidibuf->bufferPool != nullptr)
-    {
-        jmidibuf->bufferPoolPos = 0;
-        std::memset(jmidibuf->bufferPool, 0, JackMidiPortBuffer::kBufferPoolSize);
-    }
+    jmidibuf->count = 0;
+    jmidibuf->bufferPoolPos = 0;
+    std::memset(jmidibuf->bufferPool, 0, JackMidiPortBufferBase::kBufferPoolSize);
 }
 
 CARLA_EXPORT
@@ -70,24 +77,27 @@ void jack_midi_reset_buffer(void* buf)
 CARLA_EXPORT
 size_t jack_midi_max_event_size(void*)
 {
-    return JackMidiPortBuffer::kMaxEventSize;
+    return JackMidiPortBufferBase::kMaxEventSize;
 }
 
 CARLA_EXPORT
 jack_midi_data_t* jack_midi_event_reserve(void* buf, jack_nframes_t frame, size_t size)
 {
-    JackMidiPortBuffer* const jmidibuf((JackMidiPortBuffer*)buf);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf != nullptr, nullptr);
-    CARLA_SAFE_ASSERT_RETURN(! jmidibuf->isInput, nullptr);
-    CARLA_SAFE_ASSERT_RETURN(size < JackMidiPortBuffer::kMaxEventSize, nullptr);
+    JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf != nullptr, nullptr);
+    CARLA_SAFE_ASSERT_RETURN(! jbasebuf->isInput, nullptr);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isValid, nullptr);
+    CARLA_SAFE_ASSERT_RETURN(size < JackMidiPortBufferBase::kMaxEventSize, nullptr);
 
     // broken jack applicatons, wow...
     if (size == 0)
         return nullptr;
 
-    if (jmidibuf->count >= JackMidiPortBuffer::kMaxEventCount)
+    JackMidiPortBufferOnStack* const jmidibuf((JackMidiPortBufferOnStack*)jbasebuf);
+
+    if (jmidibuf->count >= JackMidiPortBufferBase::kMaxEventCount)
         return nullptr;
-    if (jmidibuf->bufferPoolPos + size >= JackMidiPortBuffer::kBufferPoolSize)
+    if (jmidibuf->bufferPoolPos + size >= JackMidiPortBufferBase::kBufferPoolSize)
         return nullptr;
 
     jack_midi_data_t* const jmdata = jmidibuf->bufferPool + jmidibuf->bufferPoolPos;
@@ -101,18 +111,21 @@ jack_midi_data_t* jack_midi_event_reserve(void* buf, jack_nframes_t frame, size_
 CARLA_EXPORT
 int jack_midi_event_write(void* buf, jack_nframes_t frame, const jack_midi_data_t* data, size_t size)
 {
-    JackMidiPortBuffer* const jmidibuf((JackMidiPortBuffer*)buf);
-    CARLA_SAFE_ASSERT_RETURN(jmidibuf != nullptr, EFAULT);
-    CARLA_SAFE_ASSERT_RETURN(! jmidibuf->isInput, EINVAL);
-    CARLA_SAFE_ASSERT_RETURN(size < JackMidiPortBuffer::kMaxEventSize, ENOBUFS);
+    JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf != nullptr, EFAULT);
+    CARLA_SAFE_ASSERT_RETURN(! jbasebuf->isInput, EINVAL);
+    CARLA_SAFE_ASSERT_RETURN(jbasebuf->isValid, EINVAL);
+    CARLA_SAFE_ASSERT_RETURN(size < JackMidiPortBufferBase::kMaxEventSize, ENOBUFS);
 
     // broken jack applicatons, wow...
     if (size == 0)
         return EINVAL;
 
-    if (jmidibuf->count >= JackMidiPortBuffer::kMaxEventCount)
+    JackMidiPortBufferOnStack* const jmidibuf((JackMidiPortBufferOnStack*)jbasebuf);
+
+    if (jmidibuf->count >= JackMidiPortBufferBase::kMaxEventCount)
         return ENOBUFS;
-    if (jmidibuf->bufferPoolPos + size >= JackMidiPortBuffer::kBufferPoolSize)
+    if (jmidibuf->bufferPoolPos + size >= JackMidiPortBufferBase::kBufferPoolSize)
         return ENOBUFS;
 
     jack_midi_data_t* const jmdata = jmidibuf->bufferPool + jmidibuf->bufferPoolPos;

source/libjack/libjack_ports.cpp

@@ -471,7 +471,7 @@ size_t jack_port_type_get_buffer_size(jack_client_t* client, const char* port_ty
     CARLA_SAFE_ASSERT_RETURN(port_type != nullptr && port_type[0] != '\0', 0);
 
     if (std::strcmp(port_type, JACK_DEFAULT_MIDI_TYPE) == 0)
-        return JackMidiPortBuffer::kMaxEventSize;
+        return JackMidiPortBufferBase::kMaxEventSize;
 
     return 0;