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

Start code for carla-plugin without lv2 instance-access

tags/v1.9.11
falkTX 6 years ago
parent
6ab45a86c4
commit
7d55cfe473
9 changed files with 683 additions and 20 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +8
    -1
      data/valgrind.sh
  2. +19
    -1
      data/valgrind.supp
  3. +3
    -3
      source/backend/CarlaStandalone.cpp
  4. +2
    -2
      source/backend/plugin/CarlaPluginInternal.cpp
  5. +2
    -2
      source/backend/plugin/CarlaPluginLV2.cpp
  6. +16
    -0
      source/plugin/Makefile
  7. +515
    -0
      source/plugin/carla-lv2-ui.cpp
  8. +104
    -7
      source/plugin/carla-lv2.cpp
  9. +14
    -4
      source/utils/CarlaLv2Utils.hpp

+ 8
- 1
data/valgrind.sh View File

@@ -7,7 +7,14 @@ export WINEDEBUG=-all
# export PYTHONMALLOC=malloc
# export SKIP_STRIPPING=true

valgrind --tool=memcheck --leak-check=full --show-leak-kinds=all --track-origins=yes --suppressions=./data/valgrind.supp -- ./bin/carla-bridge-native internal "" carlapatchbay &
valgrind \
--tool=memcheck \
--leak-check=full \
--show-leak-kinds=all \
--track-origins=yes \
--gen-suppressions=all \
--suppressions=./data/valgrind.supp \
-- ./bin/carla-bridge-native internal "" carlapatchbay &
PID=$!

while true; do


+ 19
- 1
data/valgrind.supp View File

@@ -18,7 +18,16 @@
obj:/lib/x86_64-linux-gnu/ld-2.27.so
}
{
dlclose
_dl_init-3
Memcheck:Leak
match-leak-kinds: definite
...
fun:call_init
fun:_dl_init
obj:/lib/x86_64-linux-gnu/ld-2.27.so
}
{
dlclose-1
Memcheck:Leak
match-leak-kinds: reachable
fun:calloc
@@ -26,6 +35,15 @@
fun:dlopen@@GLIBC_2.2.5
...
}
{
dlclose-2
Memcheck:Leak
match-leak-kinds: reachable
...
fun:_dl_open
...
}


# XInitThreads
{


+ 3
- 3
source/backend/CarlaStandalone.cpp View File

@@ -385,9 +385,6 @@ bool carla_engine_init(const char* driverName, const char* clientName)
#ifdef CARLA_OS_WIN
carla_setenv("WINEASIO_CLIENT_NAME", clientName);
#endif
#ifdef CARLA_OS_UNIX
sThreadSafeFFTW.init();
#endif

ScopedPointer<CarlaEngine> engine(CarlaEngine::newDriverByName(driverName));

@@ -411,6 +408,9 @@ bool carla_engine_init(const char* driverName, const char* clientName)
#ifndef BUILD_BRIDGE
if (gStandalone.logThreadEnabled && std::getenv("CARLA_LOGS_DISABLED") == nullptr)
gStandalone.logThread.init();
#endif
#ifdef CARLA_OS_UNIX
sThreadSafeFFTW.init();
#endif
gStandalone.lastError = "No error";
gStandalone.engine = engine.release();


+ 2
- 2
source/backend/plugin/CarlaPluginInternal.cpp View File

@@ -714,10 +714,10 @@ CarlaPlugin::ProtectedData::~ProtectedData() noexcept
masterMutex.unlock();
singleMutex.unlock();

CARLA_SAFE_ASSERT(uiLib == nullptr);

if (lib != nullptr)
libClose();

CARLA_SAFE_ASSERT(uiLib == nullptr);
}

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


+ 2
- 2
source/backend/plugin/CarlaPluginLV2.cpp View File

@@ -16,7 +16,7 @@
*/

// testing macros
#define LV2_UIS_ONLY_BRIDGES
// #define LV2_UIS_ONLY_BRIDGES
// #define LV2_UIS_ONLY_INPROCESS

#include "CarlaPluginInternal.hpp"
@@ -6276,7 +6276,7 @@ private:
static void carla_lv2_inline_display_queue_draw(LV2_Inline_Display_Handle handle)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
carla_debug("carla_lv2_inline_display_queue_draw(%p)", handle);
// carla_debug("carla_lv2_inline_display_queue_draw(%p)", handle);

((CarlaPluginLV2*)handle)->handleInlineDisplayQueueRedraw();
}


+ 16
- 0
source/plugin/Makefile View File

@@ -88,10 +88,16 @@ SHARED += -Wl,-exported_symbol,_lv2_descriptor
SHARED += -Wl,-exported_symbol,_lv2ui_descriptor
endif

# ----------------------------------------------------------------------------------------------------------------------------
# ...

LIBS_ui = $(MODULEDIR)/water.a

# ----------------------------------------------------------------------------------------------------------------------------

TARGETS = \
$(BINDIR)/carla.lv2/carla$(LIB_EXT) \
$(BINDIR)/carla.lv2/carla_ui$(LIB_EXT) \
$(BINDIR)/carla.lv2/manifest.ttl

ifeq ($(LINUX),true)
@@ -129,6 +135,11 @@ $(BINDIR)/carla.lv2/carla$(LIB_EXT): $(OBJDIR)/carla-lv2.cpp.o $(LIBS)
@echo "Linking carla.lv2/carla$(LIB_EXT)"
@$(CXX) $< $(LIBS_START) $(LIBS) $(LIBS_END) $(SHARED) $(LINK_FLAGS) -o $@

$(BINDIR)/carla.lv2/carla_ui$(LIB_EXT): $(OBJDIR)/carla-lv2-ui.cpp.o $(LIBS_ui)
-@mkdir -p $(BINDIR)/carla.lv2
@echo "Linking carla.lv2/carla-ui$(LIB_EXT)"
@$(CXX) $< $(LIBS_START) $(LIBS_ui) $(LIBS_END) $(SHARED) $(LINK_FLAGS) -o $@

$(BINDIR)/CarlaRack$(LIB_EXT): $(OBJDIR)/carla-vst.cpp.rack-syn.o $(LIBS)
-@mkdir -p $(BINDIR)
@echo "Linking CarlaRack$(LIB_EXT)"
@@ -166,6 +177,11 @@ $(OBJDIR)/carla-lv2.cpp.o: carla-lv2.cpp
@echo "Compiling $<"
@$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@

$(OBJDIR)/carla-lv2-ui.cpp.o: carla-lv2-ui.cpp
-@mkdir -p $(OBJDIR)
@echo "Compiling $<"
@$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@

$(OBJDIR)/carla-vst.cpp.rack-fx.o: carla-vst.cpp
-@mkdir -p $(OBJDIR)
@echo "Compiling $< (RackFX)"


+ 515
- 0
source/plugin/carla-lv2-ui.cpp View File

@@ -0,0 +1,515 @@
/*
* Carla Native Plugins
* Copyright (C) 2013-2018 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
* published by the Free Software Foundation; either version 2 of
* the License, or 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 General Public License for more details.
*
* For a full copy of the GNU General Public License see the doc/GPL.txt file.
*/

#include "CarlaLv2Utils.hpp"
#include "CarlaPipeUtils.hpp"

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

class NativePluginUI : public LV2_External_UI_Widget_Compat
{
public:
NativePluginUI(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
LV2UI_Widget* widget, const LV2_Feature* const* features, const bool isEmbed)
: fUridMap(nullptr),
fUridUnmap(nullptr),
fUridTranser(0),
fUridTranser2(0),
fUI()
{
run = extui_run;
show = extui_show;
hide = extui_hide;

fUI.writeFunction = writeFunction;
fUI.controller = controller;
fUI.isEmbed = isEmbed;

const LV2_URID_Map* uridMap = nullptr;
const LV2_URID_Unmap* uridUnmap = nullptr;

for (int i=0; features[i] != nullptr; ++i)
{
/**/ if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)
uridMap = (const LV2_URID_Map*)features[i]->data;
else if (std::strcmp(features[i]->URI, LV2_URID__unmap) == 0)
uridUnmap = (const LV2_URID_Unmap*)features[i]->data;
}

if (uridMap == nullptr || uridUnmap == nullptr)
{
carla_stderr("Host doesn't provide urid-map feature");
return;
}

fUridMap = uridMap;
fUridUnmap = uridUnmap;
fUridTranser = uridMap->map(uridMap->handle, LV2_ATOM__eventTransfer);
fUridTranser2 = uridMap->map(uridMap->handle, "urn:carla:transmitEv");

#ifdef CARLA_OS_LINUX
// ---------------------------------------------------------------
// show embed UI if needed

if (isEmbed)
{
intptr_t parentId = 0;
const LV2UI_Resize* uiResize = nullptr;

for (int i=0; features[i] != nullptr; ++i)
{
if (std::strcmp(features[i]->URI, LV2_UI__parent) == 0)
{
parentId = (intptr_t)features[i]->data;
}
else if (std::strcmp(features[i]->URI, LV2_UI__resize) == 0)
{
uiResize = (const LV2UI_Resize*)features[i]->data;
}
}

// -----------------------------------------------------------
// see if the host can really embed the UI

if (parentId != 0)
{
if (uiResize && uiResize->ui_resize != nullptr)
uiResize->ui_resize(uiResize->handle, 740, 512);

fUI.name = carla_strdup("Carla");
fUI.isVisible = true;

char strBuf[0xff+1];
strBuf[0xff] = '\0';
std::snprintf(strBuf, 0xff, P_INTPTR, parentId);

carla_setenv("CARLA_PLUGIN_EMBED_WINID", strBuf);
writeAtomMessage("show");

// FIXME
*widget = nullptr;
return;
}
}
#endif

// ---------------------------------------------------------------
// see if the host supports external-ui

for (int i=0; features[i] != nullptr; ++i)
{
if (std::strcmp(features[i]->URI, LV2_EXTERNAL_UI__Host) == 0 ||
std::strcmp(features[i]->URI, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)
{
fUI.host = (const LV2_External_UI_Host*)features[i]->data;
break;
}
}

if (fUI.host != nullptr)
{
fUI.name = carla_strdup(fUI.host->plugin_human_id);
*widget = (LV2_External_UI_Widget_Compat*)this;
return;
}

// ---------------------------------------------------------------
// no external-ui support, use showInterface

for (int i=0; features[i] != nullptr; ++i)
{
if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) != 0)
continue;

const LV2_Options_Option* const options((const LV2_Options_Option*)features[i]->data);
CARLA_SAFE_ASSERT_BREAK(options != nullptr);

for (int j=0; options[j].key != 0; ++j)
{
if (options[j].key != uridMap->map(uridMap->handle, LV2_UI__windowTitle))
continue;

const char* const title((const char*)options[j].value);
CARLA_SAFE_ASSERT_BREAK(title != nullptr && title[0] != '\0');

fUI.name = carla_strdup(title);
break;
}
break;
}

if (fUI.name == nullptr)
fUI.name = carla_strdup("Carla");

*widget = nullptr;
}

~NativePluginUI()
{
if (fUI.isVisible)
writeAtomMessage("quit");

fUI.host = nullptr;
fUI.writeFunction = nullptr;
fUI.controller = nullptr;
}

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

void lv2ui_port_event(uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)
{
CARLA_SAFE_ASSERT_RETURN(buffer != nullptr,);

if (format == 0)
{
char msg[128];
const float* const valuePtr = (const float*)buffer;

{
const ScopedLocale csl;
std::snprintf(msg, 127, "control %u %f", portIndex, *valuePtr);
}

msg[127] = '\0';

writeAtomMessage(msg);
return;
}

if (format == fUridTranser)
{
CARLA_SAFE_ASSERT_RETURN(bufferSize > sizeof(LV2_Atom),);

const LV2_Atom* const atom = (const LV2_Atom*)buffer;

if (atom->type == fUridTranser2)
{
const char* const msg = (const char*)(atom + 1);

if (std::strcmp(msg, "quit") == 0)
{
handleUiClosed();
}

return;
}
}

carla_stdout("lv2ui_port_event %u %u %u:%s %p", portIndex, bufferSize, format, fUridUnmap->unmap(fUridUnmap->handle, format), buffer);
}

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

void lv2ui_select_program(uint32_t bank, uint32_t program) const
{
char msg[128];
std::snprintf(msg, 127, "program %u %u", bank, program);
msg[127] = '\0';

writeAtomMessage(msg);
}

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

int lv2ui_idle() const
{
if (! fUI.isVisible)
return 1;

handleUiRun();
return 0;
}

int lv2ui_show()
{
handleUiShow();
return 0;
}

int lv2ui_hide()
{
handleUiHide();
return 0;
}

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

protected:
void handleUiShow()
{
writeAtomMessage("show");
fUI.isVisible = true;
}

void handleUiHide()
{
if (fUI.isVisible)
{
fUI.isVisible = false;
writeAtomMessage("hide");
}
}

void handleUiRun() const
{
if (fUI.isVisible)
writeAtomMessage("idle");
}

void handleUiClosed()
{
fUI.isVisible = false;

if (fUI.host != nullptr && fUI.host->ui_closed != nullptr && fUI.controller != nullptr)
fUI.host->ui_closed(fUI.controller);

fUI.host = nullptr;
fUI.writeFunction = nullptr;
fUI.controller = nullptr;
}

bool writeAtomMessage(const char* const msg) const
{
CARLA_SAFE_ASSERT_RETURN(fUI.writeFunction != nullptr, false);
CARLA_SAFE_ASSERT_RETURN(fUridTranser2 != 0, false);
carla_debug("writeAtomMessage(%s)", msg);

const size_t msgSize = std::strlen(msg)+1;
const size_t atomSize = sizeof(LV2_Atom) + msgSize;

if (atomSize <= 128)
{
char atomBuf[atomSize];
carla_zeroChars(atomBuf, atomSize);

LV2_Atom* const atom = (LV2_Atom*)atomBuf;
atom->size = msgSize;
atom->type = fUridTranser2;
std::memcpy(atomBuf+sizeof(LV2_Atom), msg, msgSize);

fUI.writeFunction(fUI.controller, 0, atomSize, fUridTranser, atomBuf);
}
else
{
char* const atomBuf = new char[atomSize];
carla_zeroChars(atomBuf, atomSize);

LV2_Atom* const atom = (LV2_Atom*)atomBuf;
atom->size = msgSize;
atom->type = fUridTranser2;
std::memcpy(atomBuf+sizeof(LV2_Atom), msg, msgSize);

fUI.writeFunction(fUI.controller, 0, atomSize, fUridTranser, atomBuf);

delete[] atomBuf;
}

return true;
}

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

private:
const LV2_URID_Map* fUridMap;
const LV2_URID_Unmap* fUridUnmap;
LV2_URID fUridTranser, fUridTranser2;

struct UI {
const LV2_External_UI_Host* host;
LV2UI_Write_Function writeFunction;
LV2UI_Controller controller;
const char* name;
bool isEmbed;
bool isVisible;

UI()
: host(nullptr),
writeFunction(nullptr),
controller(nullptr),
name(nullptr),
isEmbed(false),
isVisible(false) {}

~UI()
{
if (name != nullptr)
{
delete[] name;
name = nullptr;
}
}
} fUI;

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

#define handlePtr ((NativePluginUI*)handle)

static void extui_run(LV2_External_UI_Widget_Compat* handle)
{
handlePtr->handleUiRun();
}

static void extui_show(LV2_External_UI_Widget_Compat* handle)
{
carla_debug("extui_show(%p)", handle);
handlePtr->handleUiShow();
}

static void extui_hide(LV2_External_UI_Widget_Compat* handle)
{
carla_debug("extui_hide(%p)", handle);
handlePtr->handleUiHide();
}

#undef handlePtr

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

CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePluginUI)
};

// -----------------------------------------------------------------------
// LV2 UI descriptor functions

static LV2UI_Handle lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
LV2UI_Widget* widget, const LV2_Feature* const* features, const bool isEmbed)
{
carla_debug("lv2ui_instantiate(..., %p, %p, %p)", writeFunction, controller, widget, features);
#ifndef CARLA_OS_LINUX
CARLA_SAFE_ASSERT_RETURN(! isEmbed, nullptr);
#endif
carla_debug("writeAtomMessage==========================================================================");

NativePluginUI* const ui = new NativePluginUI(writeFunction, controller, widget, features, isEmbed);

// TODO: check ok

return (LV2UI_Handle)ui;
}

#ifdef CARLA_OS_LINUX
static LV2UI_Handle lv2ui_instantiate_embed(const LV2UI_Descriptor*, const char*, const char*,
LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
LV2UI_Widget* widget, const LV2_Feature* const* features)
{
return lv2ui_instantiate(writeFunction, controller, widget, features, true);
}
#endif

static LV2UI_Handle lv2ui_instantiate_external(const LV2UI_Descriptor*, const char*, const char*,
LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
LV2UI_Widget* widget, const LV2_Feature* const* features)
{
return lv2ui_instantiate(writeFunction, controller, widget, features, false);
}

#define uiPtr ((NativePluginUI*)ui)

static void lv2ui_port_event(LV2UI_Handle ui, uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)
{
carla_debug("lv2ui_port_event(%p, %i, %i, %i, %p)", ui, portIndex, bufferSize, format, buffer);
uiPtr->lv2ui_port_event(portIndex, bufferSize, format, buffer);
}

static void lv2ui_cleanup(LV2UI_Handle ui)
{
carla_debug("lv2ui_cleanup(%p)", ui);
delete uiPtr;
}

static void lv2ui_select_program(LV2UI_Handle ui, uint32_t bank, uint32_t program)
{
carla_debug("lv2ui_select_program(%p, %i, %i)", ui, bank, program);
uiPtr->lv2ui_select_program(bank, program);
}

static int lv2ui_idle(LV2UI_Handle ui)
{
return uiPtr->lv2ui_idle();
}

static int lv2ui_show(LV2UI_Handle ui)
{
carla_debug("lv2ui_show(%p)", ui);
return uiPtr->lv2ui_show();
}

static int lv2ui_hide(LV2UI_Handle ui)
{
carla_debug("lv2ui_hide(%p)", ui);
return uiPtr->lv2ui_hide();
}

static const void* lv2ui_extension_data(const char* uri)
{
carla_stdout("lv2ui_extension_data(\"%s\")", uri);

static const LV2UI_Idle_Interface uiidle = { lv2ui_idle };
static const LV2UI_Show_Interface uishow = { lv2ui_show, lv2ui_hide };
static const LV2_Programs_UI_Interface uiprograms = { lv2ui_select_program };

if (std::strcmp(uri, LV2_UI__idleInterface) == 0)
return &uiidle;
if (std::strcmp(uri, LV2_UI__showInterface) == 0)
return &uishow;
if (std::strcmp(uri, LV2_PROGRAMS__UIInterface) == 0)
return &uiprograms;

return nullptr;
}

#undef uiPtr

// -----------------------------------------------------------------------
// Startup code

CARLA_EXPORT
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
{
carla_debug("lv2ui_descriptor(%i)", index);

#ifdef CARLA_OS_LINUX
static const LV2UI_Descriptor lv2UiEmbedDesc = {
/* URI */ "http://kxstudio.sf.net/carla/ui-bridge-embed",
/* instantiate */ lv2ui_instantiate_embed,
/* cleanup */ lv2ui_cleanup,
/* port_event */ lv2ui_port_event,
/* extension_data */ lv2ui_extension_data
};

if (index == 0)
return &lv2UiEmbedDesc;
else
--index;
#endif

static const LV2UI_Descriptor lv2UiExtDesc = {
/* URI */ "http://kxstudio.sf.net/carla/ui-bridge-ext",
/* instantiate */ lv2ui_instantiate_external,
/* cleanup */ lv2ui_cleanup,
/* port_event */ lv2ui_port_event,
/* extension_data */ lv2ui_extension_data
};

return (index == 0) ? &lv2UiExtDesc : nullptr;
}

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

#include "CarlaPipeUtils.cpp"

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

+ 104
- 7
source/plugin/carla-lv2.cpp View File

@@ -41,7 +41,8 @@ public:
#ifdef CARLA_PROPER_CPP11_SUPPORT
fProgramDesc({0, 0, nullptr}),
#endif
fMidiEventCount(0)
fMidiEventCount(0),
fWorkerUISignal(0)
{
carla_zeroStruct(fHost);

@@ -107,8 +108,8 @@ public:
fPorts.usesTime = fDescriptor->hints & NATIVE_PLUGIN_USES_TIME;
fPorts.numAudioIns = fDescriptor->audioIns;
fPorts.numAudioOuts = fDescriptor->audioOuts;
fPorts.numMidiIns = fDescriptor->midiIns;
fPorts.numMidiOuts = fDescriptor->midiOuts;
fPorts.numMidiIns = std::max(fDescriptor->midiIns, 1U);
fPorts.numMidiOuts = std::max(fDescriptor->midiOuts, 1U);

if (fDescriptor->get_parameter_count != nullptr &&
fDescriptor->get_parameter_info != nullptr &&
@@ -198,6 +199,17 @@ public:
{
if (event == nullptr)
continue;

if (event->body.type == fURIs.uiEvents && fWorkerUISignal != -1)
{
fWorkerUISignal = 1;
const char* const msg((const char*)(event + 1));
const size_t msgSize = std::strlen(msg);
//std::puts(msg);
fWorker->schedule_work(fWorker->handle, msgSize+1, msg);
continue;
}

if (event->body.type != fURIs.midiEvent)
continue;
if (event->body.size > 4)
@@ -230,6 +242,31 @@ public:
const_cast<float**>(fPorts.audioIns), fPorts.audioOuts, frames,
fMidiEvents, fMidiEventCount);

if (fWorkerUISignal == -1 && fPorts.numMidiOuts > 0)
{
const char* const msg = "quit";
const size_t msgSize = 5;

LV2_Atom_Sequence* const seq(fPorts.midiOuts[0]);
Ports::MidiOutData& mData(fPorts.midiOutData[0]);

if (sizeof(LV2_Atom_Event) + msgSize <= mData.capacity - mData.offset)
{
LV2_Atom_Event* const aev = (LV2_Atom_Event*)(LV2_ATOM_CONTENTS(LV2_Atom_Sequence, seq) + mData.offset);

aev->time.frames = 0;
aev->body.size = msgSize;
aev->body.type = fURIs.uiEvents;
std::memcpy(LV2_ATOM_BODY(&aev->body), msg, msgSize);

const uint32_t size = lv2_atom_pad_size(static_cast<uint32_t>(sizeof(LV2_Atom_Event) + msgSize));
mData.offset += size;
seq->atom.size += size;

fWorkerUISignal = 0;
}
}

lv2_post_run(frames);
updateParameterOutputs();
}
@@ -321,6 +358,42 @@ public:

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

LV2_Worker_Status lv2_work(LV2_Worker_Respond_Function, LV2_Worker_Respond_Handle, uint32_t, const void* data)
{
const char* const msg = (const char*)data;

/**/ if (std::strcmp(msg, "show") == 0)
{
handleUiShow();
}
else if (std::strcmp(msg, "hide") == 0)
{
handleUiHide();
}
else if (std::strcmp(msg, "idle") == 0)
{
handleUiRun();
}
else if (std::strcmp(msg, "quit") == 0)
{
handleUiRun();
}
else
{
carla_stdout("lv2_work unknown msg '%s'", msg);
return LV2_WORKER_ERR_UNKNOWN;
}

return LV2_WORKER_SUCCESS;
}

LV2_Worker_Status lv2_work_resp(uint32_t /*size*/, const void* /*body*/)
{
return LV2_WORKER_SUCCESS;
}

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

void lv2ui_instantiate(LV2UI_Write_Function writeFunction, LV2UI_Controller controller,
LV2UI_Widget* widget, const LV2_Feature* const* features, const bool isEmbed)
{
@@ -547,8 +620,11 @@ protected:

void handleUiParameterChanged(const uint32_t index, const float value) const
{
if (fUI.writeFunction != nullptr && fUI.controller != nullptr)
fUI.writeFunction(fUI.controller, index+fPorts.indexOffset, sizeof(float), 0, &value);
if (fWorkerUISignal)
{
}
else if (fUI.writeFunction != nullptr && fUI.controller != nullptr)
fUI.writeFunction(fUI.controller, index+fPorts.indexOffset, sizeof(float), 0, &value);
}

void handleUiCustomDataChanged(const char* const /*key*/, const char* const /*value*/) const
@@ -558,13 +634,17 @@ protected:

void handleUiClosed()
{
fUI.isVisible = false;

if (fWorkerUISignal)
fWorkerUISignal = -1;

if (fUI.host != nullptr && fUI.host->ui_closed != nullptr && fUI.controller != nullptr)
fUI.host->ui_closed(fUI.controller);

fUI.host = nullptr;
fUI.writeFunction = nullptr;
fUI.controller = nullptr;
fUI.isVisible = false;
}

const char* handleUiOpenFile(const bool /*isDir*/, const char* const /*title*/, const char* const /*filter*/) const
@@ -639,6 +719,8 @@ private:
uint32_t fMidiEventCount;
NativeMidiEvent fMidiEvents[kMaxMidiEvents];

int fWorkerUISignal;

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

#define handlePtr ((NativePlugin*)handle)
@@ -823,6 +905,18 @@ static LV2_State_Status lv2_restore(LV2_Handle instance, LV2_State_Retrieve_Func
return instancePtr->lv2_restore(retrieve, handle, flags, features);
}

static LV2_Worker_Status lv2_work(LV2_Handle instance, LV2_Worker_Respond_Function respond, LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)
{
carla_debug("work(%p, %p, %p, %u, %p)", instance, respond, handle, size, data);
return instancePtr->lv2_work(respond, handle, size, data);
}

LV2_Worker_Status lv2_work_resp(LV2_Handle instance, uint32_t size, const void* body)
{
carla_debug("work_resp(%p, %u, %p)", instance, size, body);
return instancePtr->lv2_work_resp(size, body);
}

static const void* lv2_extension_data(const char* uri)
{
carla_debug("lv2_extension_data(\"%s\")", uri);
@@ -830,6 +924,7 @@ static const void* lv2_extension_data(const char* uri)
static const LV2_Options_Interface options = { lv2_get_options, lv2_set_options };
static const LV2_Programs_Interface programs = { lv2_get_program, lv2_select_program };
static const LV2_State_Interface state = { lv2_save, lv2_restore };
static const LV2_Worker_Interface worker = { lv2_work, lv2_work_resp, nullptr };

if (std::strcmp(uri, LV2_OPTIONS__interface) == 0)
return &options;
@@ -837,6 +932,8 @@ static const void* lv2_extension_data(const char* uri)
return &programs;
if (std::strcmp(uri, LV2_STATE__interface) == 0)
return &state;
if (std::strcmp(uri, LV2_WORKER__interface) == 0)
return &worker;

return nullptr;
}
@@ -896,7 +993,7 @@ static LV2UI_Handle lv2ui_instantiate_external(const LV2UI_Descriptor*, const ch

static void lv2ui_port_event(LV2UI_Handle ui, uint32_t portIndex, uint32_t bufferSize, uint32_t format, const void* buffer)
{
carla_debug("lv2ui_port_event(%p, %i, %i, %i, %p)", ui, portIndex, bufferSize, format, buffer);
carla_debug("lv2ui_port_eventxx(%p, %i, %i, %i, %p)", ui, portIndex, bufferSize, format, buffer);
uiPtr->lv2ui_port_event(portIndex, bufferSize, format, buffer);
}



+ 14
- 4
source/utils/CarlaLv2Utils.hpp View File

@@ -554,6 +554,7 @@ public:
fBufferSize(0),
fSampleRate(sampleRate),
fUridMap(nullptr),
fWorker(nullptr),
fTimeInfo(),
fLastPositionData(),
fURIs(),
@@ -572,20 +573,23 @@ public:
const LV2_Options_Option* options = nullptr;
const LV2_URID_Map* uridMap = nullptr;
const LV2_URID_Unmap* uridUnmap = nullptr;
const LV2_Worker_Schedule* worker = nullptr;

for (int i=0; features[i] != nullptr; ++i)
{
if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)
/**/ if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)
options = (const LV2_Options_Option*)features[i]->data;
else if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)
uridMap = (const LV2_URID_Map*)features[i]->data;
else if (std::strcmp(features[i]->URI, LV2_URID__unmap) == 0)
uridUnmap = (const LV2_URID_Unmap*)features[i]->data;
else if (std::strcmp(features[i]->URI, LV2_WORKER__schedule) == 0)
worker = (const LV2_Worker_Schedule*)features[i]->data;
}

if (options == nullptr || uridMap == nullptr)
if (options == nullptr || uridMap == nullptr || worker == nullptr)
{
carla_stderr("Host doesn't provide option or urid-map features");
carla_stderr("Host doesn't provide option, urid-map and worker features");
return;
}

@@ -640,6 +644,8 @@ public:
fUridMap = uridMap;
fURIs.map(uridMap);

fWorker = worker;

carla_zeroStruct(fTimeInfo);
carla_zeroStruct(fLastPositionData);
}
@@ -1140,6 +1146,7 @@ protected:

// LV2 host features
const LV2_URID_Map* fUridMap;
const LV2_Worker_Schedule* fWorker;

// Time info stuff
TimeInfoStruct fTimeInfo;
@@ -1433,6 +1440,7 @@ protected:
LV2_URID timeFrame;
LV2_URID timeSpeed;
LV2_URID timeTicksPerBeat;
LV2_URID uiEvents;

URIDs()
: atomBlank(0),
@@ -1452,7 +1460,8 @@ protected:
timeBeatUnit(0),
timeFrame(0),
timeSpeed(0),
timeTicksPerBeat(0) {}
timeTicksPerBeat(0),
uiEvents(0) {}

void map(const LV2_URID_Map* const uridMap)
{
@@ -1474,6 +1483,7 @@ protected:
timeBeatsPerBar = uridMap->map(uridMap->handle, LV2_TIME__beatsPerBar);
timeBeatsPerMinute = uridMap->map(uridMap->handle, LV2_TIME__beatsPerMinute);
timeTicksPerBeat = uridMap->map(uridMap->handle, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat);
uiEvents = uridMap->map(uridMap->handle, "urn:carla:transmitEv");
}
} fURIs;



Write Preview
Loading…
Cancel
Save