falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Browse Source

libjack: cleanup midi port code 

Signed-off-by: falkTX <falktx@gmail.com>
tags/v2.1-alpha2
falkTX 6 years ago
parent
2b71a249f4
commit
15f50322f5
Signed by: falkTX <falktx@gmail.com> GPG Key ID: 2D3445A829213837
5 changed files with 101 additions and 85 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +18
    -18
      source/libjack/api.hpp
  2. +13
    -13
      source/libjack/libjack.cpp
  3. +27
    -24
      source/libjack/libjack.hpp
  4. +42
    -29
      source/libjack/libjack_midi.cpp
  5. +1
    -1
      source/libjack/libjack_ports.cpp

+ 18
- 18
source/libjack/api.hpp View File

@@ -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);

// --------------------------------------------------------------------------------------------------------------------



+ 13
- 13
source/libjack/libjack.cpp View File

@@ -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;


+ 27
- 24
source/libjack/libjack.hpp View File

@@ -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 {


+ 42
- 29
source/libjack/libjack_midi.cpp View File

@@ -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;


+ 1
- 1
source/libjack/libjack_ports.cpp View File

@@ -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;



Write Preview
Loading…
Cancel
Save