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

Start importing LV2 code from stable branch, incomplete

tags/1.9.4
falkTX 11 years ago
parent
291791980d
commit
15846e4cfa
7 changed files with 855 additions and 46 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -1
      source/backend/Makefile.mk
  2. +2
    -2
      source/backend/engine/Makefile
  3. +791
    -11
      source/backend/plugin/Lv2Plugin.cpp
  4. +1
    -1
      source/backend/standalone/Makefile
  5. +28
    -13
      source/discovery/Makefile
  6. +29
    -17
      source/utils/CarlaLv2Utils.hpp
  7. +2
    -1
      source/utils/CarlaStateUtils.cpp

+ 2
- 1
source/backend/Makefile.mk View File

@@ -85,7 +85,8 @@ CARLA_LIB_COUNTER_HPP = ../../utils/CarlaLibCounter.hpp $(CARLA_LIB_UTILS_HPP)
CARLA_MATH_UTILS_HPP = ../../utils/CarlaMathUtils.hpp $(CARLA_UTILS_HPP)
CARLA_PIPE_UTILS_HPP = ../../utils/CarlaPipeUtils.hpp $(CARLA_STRING_HPP)
CARLA_SHM_UTILS_HPP = ../../utils/CarlaShmUtils.hpp $(CARLA_UTILS_HPP)
CARLA_STATE_UTILS_HPP = ../../utils/CarlaStateUtils.hpp $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MIDI_H) $(LINKED_LIST_HPP)
CARLA_STATE_UTILS_HPP = ../../utils/CarlaStateUtils.hpp $(LINKED_LIST_HPP)
CARLA_STATE_UTILS_CPP = ../../utils/CarlaStateUtils.cpp $(CARLA_STATE_UTILS_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MATH_UTILS_HPP) $(CARLA_MIDI_H)

CARLA_LADSPA_UTILS_HPP = ../../utils/CarlaLadspaUtils.hpp $(CARLA_UTILS_HPP)
CARLA_DSSI_UTILS_HPP = ../../utils/CarlaDssiUtils.hpp $(CARLA_LADSPA_UTILS_HPP)


+ 2
- 2
source/backend/engine/Makefile View File

@@ -87,10 +87,10 @@ CarlaEngineRtAudio.cpp.o: CarlaEngineRtAudio.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(
CarlaEngineJuce.cpp.o: CarlaEngineJuce.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(CARLA_BACKEND_UTILS_HPP)
$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@

CarlaEngineNative.cpp.o: CarlaEngineNative.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MATH_UTILS_HPP) $(CARLA_PIPE_UTILS_HPP) $(CARLA_STATE_UTILS_HPP) $(CARLA_NATIVE_HPP)
CarlaEngineNative.cpp.o: CarlaEngineNative.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MATH_UTILS_HPP) $(CARLA_PIPE_UTILS_HPP) $(CARLA_STATE_UTILS_HPP) $(CARLA_NATIVE_HPP) $(CARLA_STATE_UTILS_CPP)
$(CXX) $< $(BUILD_CXX_FLAGS) $(QTCORE_FLAGS) $(QTXML_FLAGS) -c -o $@

CarlaEngineNative.cpp.exp.o: CarlaEngineNative.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MATH_UTILS_HPP) $(CARLA_PIPE_UTILS_HPP) $(CARLA_STATE_UTILS_HPP) $(CARLA_NATIVE_HPP)
CarlaEngineNative.cpp.exp.o: CarlaEngineNative.cpp $(CARLA_ENGINE_INTERNAL_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_MATH_UTILS_HPP) $(CARLA_PIPE_UTILS_HPP) $(CARLA_STATE_UTILS_HPP) $(CARLA_NATIVE_HPP) $(CARLA_STATE_UTILS_CPP)
$(CXX) $< $(BUILD_CXX_FLAGS) $(QTCORE_FLAGS) $(QTXML_FLAGS) -DCARLA_PLUGIN_EXPORT -c -o $@

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

+ 791
- 11
source/backend/plugin/Lv2Plugin.cpp View File

@@ -46,8 +46,136 @@ CARLA_BACKEND_START_NAMESPACE
const unsigned int PARAMETER_IS_STRICT_BOUNDS = 0x1000;
const unsigned int PARAMETER_IS_TRIGGER = 0x2000;

// LV2 URI Map Ids
const uint32_t CARLA_URI_MAP_ID_NULL = 0;
const uint32_t CARLA_URI_MAP_ID_ATOM_BLANK = 1;
const uint32_t CARLA_URI_MAP_ID_ATOM_BOOL = 2;
const uint32_t CARLA_URI_MAP_ID_ATOM_CHUNK = 3;
const uint32_t CARLA_URI_MAP_ID_ATOM_DOUBLE = 4;
const uint32_t CARLA_URI_MAP_ID_ATOM_FLOAT = 5;
const uint32_t CARLA_URI_MAP_ID_ATOM_INT = 6;
const uint32_t CARLA_URI_MAP_ID_ATOM_LITERAL = 7;
const uint32_t CARLA_URI_MAP_ID_ATOM_LONG = 8;
const uint32_t CARLA_URI_MAP_ID_ATOM_PATH = 9;
const uint32_t CARLA_URI_MAP_ID_ATOM_PROPERTY = 10;
const uint32_t CARLA_URI_MAP_ID_ATOM_RESOURCE = 11;
const uint32_t CARLA_URI_MAP_ID_ATOM_SEQUENCE = 12;
const uint32_t CARLA_URI_MAP_ID_ATOM_STRING = 13;
const uint32_t CARLA_URI_MAP_ID_ATOM_TUPLE = 14;
const uint32_t CARLA_URI_MAP_ID_ATOM_URI = 15;
const uint32_t CARLA_URI_MAP_ID_ATOM_URID = 16;
const uint32_t CARLA_URI_MAP_ID_ATOM_VECTOR = 17;
const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM = 18;
const uint32_t CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT = 19;
const uint32_t CARLA_URI_MAP_ID_BUF_MAX_LENGTH = 20;
const uint32_t CARLA_URI_MAP_ID_BUF_MIN_LENGTH = 21;
const uint32_t CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE = 22;
const uint32_t CARLA_URI_MAP_ID_LOG_ERROR = 23;
const uint32_t CARLA_URI_MAP_ID_LOG_NOTE = 24;
const uint32_t CARLA_URI_MAP_ID_LOG_TRACE = 25;
const uint32_t CARLA_URI_MAP_ID_LOG_WARNING = 26;
const uint32_t CARLA_URI_MAP_ID_TIME_POSITION = 27; // base type
const uint32_t CARLA_URI_MAP_ID_TIME_BAR = 28; // values
const uint32_t CARLA_URI_MAP_ID_TIME_BAR_BEAT = 29;
const uint32_t CARLA_URI_MAP_ID_TIME_BEAT = 30;
const uint32_t CARLA_URI_MAP_ID_TIME_BEAT_UNIT = 31;
const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR = 32;
const uint32_t CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE = 33;
const uint32_t CARLA_URI_MAP_ID_TIME_FRAME = 34;
const uint32_t CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND = 35;
const uint32_t CARLA_URI_MAP_ID_TIME_SPEED = 36;
const uint32_t CARLA_URI_MAP_ID_MIDI_EVENT = 37;
const uint32_t CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE = 38;
const uint32_t CARLA_URI_MAP_ID_COUNT = 39;

// LV2 Feature Ids
const uint32_t kFeatureCount = 0;
const uint32_t kFeatureIdBufSizeBounded = 0;
const uint32_t kFeatureIdBufSizeFixed = 1;
const uint32_t kFeatureIdBufSizePowerOf2 = 2;
const uint32_t kFeatureIdEvent = 3;
const uint32_t kFeatureIdHardRtCapable = 4;
const uint32_t kFeatureIdInPlaceBroken = 5;
const uint32_t kFeatureIdIsLive = 6;
const uint32_t kFeatureIdLogs = 7;
const uint32_t kFeatureIdOptions = 8;
const uint32_t kFeatureIdPrograms = 9;
const uint32_t kFeatureIdRtMemPool = 10;
const uint32_t kFeatureIdStateMakePath = 11;
const uint32_t kFeatureIdStateMapPath = 12;
const uint32_t kFeatureIdStrictBounds = 13;
const uint32_t kFeatureIdUriMap = 14;
const uint32_t kFeatureIdUridMap = 15;
const uint32_t kFeatureIdUridUnmap = 16;
const uint32_t kFeatureIdWorker = 17;
const uint32_t kFeatureCountPlugin = 18;
const uint32_t kFeatureCountAll = 19;

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

struct Lv2PluginOptions {
enum OptIndex {
MaxBlockLenth = 0,
MinBlockLenth,
//SequenceSize,
SampleRate,
Null
};

int maxBufferSize;
int minBufferSize;
//int sequenceSize;
double sampleRate;
LV2_Options_Option opts[5];

Lv2PluginOptions()
: maxBufferSize(0),
minBufferSize(0),
//sequenceSize(MAX_EVENT_BUFFER),
sampleRate(0.0)
{
LV2_Options_Option& optMaxBlockLenth(opts[MaxBlockLenth]);
optMaxBlockLenth.context = LV2_OPTIONS_INSTANCE;
optMaxBlockLenth.subject = 0;
optMaxBlockLenth.key = CARLA_URI_MAP_ID_BUF_MAX_LENGTH;
optMaxBlockLenth.size = sizeof(int);
optMaxBlockLenth.type = CARLA_URI_MAP_ID_ATOM_INT;
optMaxBlockLenth.value = &maxBufferSize;

LV2_Options_Option& optMinBlockLenth(opts[MinBlockLenth]);
optMinBlockLenth.context = LV2_OPTIONS_INSTANCE;
optMinBlockLenth.subject = 0;
optMinBlockLenth.key = CARLA_URI_MAP_ID_BUF_MIN_LENGTH;
optMinBlockLenth.size = sizeof(int);
optMinBlockLenth.type = CARLA_URI_MAP_ID_ATOM_INT;
optMinBlockLenth.value = &minBufferSize;

#if 0
LV2_Options_Option& optSequenceSize(opts[SequenceSize]);
optSequenceSize.context = LV2_OPTIONS_INSTANCE;
optSequenceSize.subject = 0;
optSequenceSize.key = CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;
optSequenceSize.size = sizeof(int);
optSequenceSize.type = CARLA_URI_MAP_ID_ATOM_INT;
optSequenceSize.value = &sequenceSize;
#endif

LV2_Options_Option& optSampleRate(opts[SampleRate]);
optSampleRate.context = LV2_OPTIONS_INSTANCE;
optSampleRate.subject = 0;
optSampleRate.key = CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;
optSampleRate.size = sizeof(double);
optSampleRate.type = CARLA_URI_MAP_ID_ATOM_DOUBLE;
optSampleRate.value = &sampleRate;

LV2_Options_Option& optNull(opts[Null]);
optNull.context = LV2_OPTIONS_INSTANCE;
optNull.subject = 0;
optNull.key = CARLA_URI_MAP_ID_NULL;
optNull.size = 0;
optNull.type = CARLA_URI_MAP_ID_NULL;
optNull.value = nullptr;
}
};

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

@@ -66,7 +194,10 @@ public:
{
carla_debug("Lv2Plugin::Lv2Plugin(%p, %i)", engine, id);

carla_fill<LV2_Feature*>(fFeatures, kFeatureCount+1, nullptr);
carla_fill<LV2_Feature*>(fFeatures, kFeatureCountAll+1, nullptr);

for (uint32_t i=0; i < CARLA_URI_MAP_ID_COUNT; ++i)
fCustomURIDs.append(nullptr);

pData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_LV2_GUI);
}
@@ -108,6 +239,58 @@ public:
fRdfDescriptor = nullptr;
}

if (fFeatures[kFeatureIdEvent] != nullptr && fFeatures[kFeatureIdEvent]->data != nullptr)
delete (LV2_Event_Feature*)fFeatures[kFeatureIdEvent]->data;

if (fFeatures[kFeatureIdLogs] != nullptr && fFeatures[kFeatureIdLogs]->data != nullptr)
delete (LV2_Log_Log*)fFeatures[kFeatureIdLogs]->data;

if (fFeatures[kFeatureIdStateMakePath] != nullptr && fFeatures[kFeatureIdStateMakePath]->data != nullptr)
delete (LV2_State_Make_Path*)fFeatures[kFeatureIdStateMakePath]->data;

if (fFeatures[kFeatureIdStateMapPath] != nullptr && fFeatures[kFeatureIdStateMapPath]->data != nullptr)
delete (LV2_State_Map_Path*)fFeatures[kFeatureIdStateMapPath]->data;

if (fFeatures[kFeatureIdPrograms] != nullptr && fFeatures[kFeatureIdPrograms]->data != nullptr)
delete (LV2_Programs_Host*)fFeatures[kFeatureIdPrograms]->data;

if (fFeatures[kFeatureIdRtMemPool] != nullptr && fFeatures[kFeatureIdRtMemPool]->data != nullptr)
delete (LV2_RtMemPool_Pool*)fFeatures[kFeatureIdRtMemPool]->data;

if (fFeatures[kFeatureIdUriMap] != nullptr && fFeatures[kFeatureIdUriMap]->data != nullptr)
delete (LV2_URI_Map_Feature*)fFeatures[kFeatureIdUriMap]->data;

if (fFeatures[kFeatureIdUridMap] != nullptr && fFeatures[kFeatureIdUridMap]->data != nullptr)
delete (LV2_URID_Map*)fFeatures[kFeatureIdUridMap]->data;

if (fFeatures[kFeatureIdUridUnmap] != nullptr && fFeatures[kFeatureIdUridUnmap]->data != nullptr)
delete (LV2_URID_Unmap*)fFeatures[kFeatureIdUridUnmap]->data;

if (fFeatures[kFeatureIdWorker] != nullptr && fFeatures[kFeatureIdWorker]->data != nullptr)
delete (LV2_Worker_Schedule*)fFeatures[kFeatureIdWorker]->data;

for (uint32_t i=0; i < kFeatureCountAll; ++i)
{
if (fFeatures[i] != nullptr)
{
delete fFeatures[i];
fFeatures[i] = nullptr;
}
}

for (LinkedList<const char*>::Itenerator it = fCustomURIDs.begin(); it.valid(); it.next())
{
const char*& uri(it.getValue());

if (uri != nullptr)
{
delete[] uri;
uri = nullptr;
}
}

fCustomURIDs.clear();

clearBuffers();
}

@@ -1265,6 +1448,24 @@ public:
}
}

const int newBufferSizeInt(static_cast<int>(newBufferSize));

if (fLv2Options.maxBufferSize != newBufferSizeInt || (fLv2Options.minBufferSize != 1 && fLv2Options.minBufferSize != newBufferSizeInt))
{
fLv2Options.maxBufferSize = newBufferSizeInt;

if (fLv2Options.minBufferSize != 1)
fLv2Options.minBufferSize = newBufferSizeInt;

#if 0
if (fExt.options != nullptr && fExt.options->set != nullptr)
{
fExt.options->set(fHandle, &fLv2Options.opts[Lv2PluginOptions::MaxBlockLenth]);
fExt.options->set(fHandle, &fLv2Options.opts[Lv2PluginOptions::MinBlockLenth]);
}
#endif
}

carla_debug("Lv2Plugin::bufferSizeChanged(%i) - end", newBufferSize);
}

@@ -1273,8 +1474,15 @@ public:
CARLA_ASSERT_INT(newSampleRate > 0.0, (int)newSampleRate);
carla_debug("Lv2Plugin::sampleRateChanged(%g) - start", newSampleRate);

// TODO
(void)newSampleRate;
if (fLv2Options.sampleRate != newSampleRate)
{
fLv2Options.sampleRate = newSampleRate;

#if 0
if (fExt.options != nullptr && fExt.options->set != nullptr)
fExt.options->set(fHandle, &fLv2Options.opts[Lv2PluginOptions::SampleRate]);
#endif
}

carla_debug("Lv2Plugin::sampleRateChanged(%g) - end", newSampleRate);
}
@@ -1370,6 +1578,97 @@ public:

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

LV2_URID getCustomURID(const char* const uri)
{
CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);
carla_debug("Lv2Plugin::getCustomURID(\"%s\")", uri);

for (size_t i=0; i < fCustomURIDs.count(); ++i)
{
const char*& thisUri(fCustomURIDs.getAt(i));
if (thisUri != nullptr && std::strcmp(thisUri, uri) == 0)
return static_cast<LV2_URID>(i);
}

const LV2_URID urid(static_cast<LV2_URID>(fCustomURIDs.count()));

fCustomURIDs.append(carla_strdup(uri));

#if 0
if (fUi.type == PLUGIN_UI_OSC && kData->osc.data.target != nullptr)
osc_send_lv2_urid_map(&kData->osc.data, urid, uri);
#endif

return urid;
}

const char* getCustomURIDString(const LV2_URID urid)
{
CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, nullptr);
CARLA_SAFE_ASSERT_RETURN(urid < fCustomURIDs.count(), nullptr);
carla_debug("Lv2Plugin::getCustomURIString(%i)", urid);

return fCustomURIDs.getAt(urid);
}

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

void handleProgramChanged(const int32_t index)
{
CARLA_SAFE_ASSERT_RETURN(index >= -1,);
carla_debug("Lv2Plugin::handleProgramChanged(%i)", index);

if (index == -1)
{
const ScopedSingleProcessLocker spl(this, true);
return reloadPrograms(false);
}

#if 0
if (index < static_cast<int32_t>(pData->midiprog.count) && fExt.programs != nullptr && fExt.programs->get_program != nullptr)
{
if (const LV2_Program_Descriptor* progDesc = fExt.programs->get_program(fHandle, index))
{
CARLA_ASSERT(progDesc->name != nullptr);

if (kData->midiprog.data[index].name != nullptr)
delete[] kData->midiprog.data[index].name;

kData->midiprog.data[index].name = carla_strdup(progDesc->name ? progDesc->name : "");

if (index == kData->midiprog.current)
kData->engine->callback(CALLBACK_UPDATE, fId, 0, 0, 0.0, nullptr);
else
kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0, nullptr);
}
}
#endif
}

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

LV2_Worker_Status handleWorkerSchedule(const uint32_t size, const void* const data)
{
carla_stdout("Lv2Plugin::handleWorkerSchedule(%i, %p)", size, data);

#if 0
if (fExt.worker == nullptr || fExt.worker->work == nullptr)
{
carla_stderr("Lv2Plugin::handleWorkerSchedule(%i, %p) - plugin has no worker", size, data);
return LV2_WORKER_ERR_UNKNOWN;
}

//if (kData->engine->isOffline())
fExt.worker->work(fHandle, carla_lv2_worker_respond, this, size, data);
//else
// postponeEvent(PluginPostEventCustom, size, 0, 0.0, data);
#endif

return LV2_WORKER_SUCCESS;
}

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

public:
bool init(const char* const bundle, const char* const name, const char* const uri)
{
@@ -1444,7 +1743,6 @@ public:
uint32_t i = 0;
while ((fDescriptor = descFn(i++)))
{
carla_debug("LV2 Init @%i => '%s' vs '%s'", i, fDescriptor->URI, uri);
if (std::strcmp(fDescriptor->URI, uri) == 0)
break;
}
@@ -1479,12 +1777,18 @@ public:
// Check supported features
for (uint32_t j=0; j < fRdfDescriptor->FeatureCount && canContinue; ++j)
{
if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[j].Type) && ! is_lv2_feature_supported(fRdfDescriptor->Features[j].URI))
if (! is_lv2_feature_supported(fRdfDescriptor->Features[j].URI))
{
// QString msg(QString("Plugin requires a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[j].URI));
// pData->engine->setLastError(msg.toUtf8().constData());
canContinue = false;
break;
QString msg(QString("Plugin wants a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[j].URI));

if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[j].Type))
{
canContinue = false;
pData->engine->setLastError(msg.toUtf8().constData());
break;
}
else
carla_stderr("%s", msg.toUtf8().constData());
}
}

@@ -1502,6 +1806,8 @@ public:
else
pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);

pData->filename = carla_strdup(bundle);

// ---------------------------------------------------------------
// register client

@@ -1513,6 +1819,126 @@ public:
return false;
}

// ---------------------------------------------------------------
// initialize options

fLv2Options.minBufferSize = 1;
fLv2Options.maxBufferSize = static_cast<int>(pData->engine->getBufferSize());
fLv2Options.sampleRate = pData->engine->getSampleRate();

// ---------------------------------------------------------------
// initialize features (part 1)

LV2_Event_Feature* const eventFt = new LV2_Event_Feature;
eventFt->callback_data = this;
eventFt->lv2_event_ref = carla_lv2_event_ref;
eventFt->lv2_event_unref = carla_lv2_event_unref;

LV2_Log_Log* const logFt = new LV2_Log_Log;
logFt->handle = this;
logFt->printf = carla_lv2_log_printf;
logFt->vprintf = carla_lv2_log_vprintf;

LV2_State_Make_Path* const stateMakePathFt = new LV2_State_Make_Path;
stateMakePathFt->handle = this;
stateMakePathFt->path = carla_lv2_state_make_path;

LV2_State_Map_Path* const stateMapPathFt = new LV2_State_Map_Path;
stateMapPathFt->handle = this;
stateMapPathFt->abstract_path = carla_lv2_state_map_abstract_path;
stateMapPathFt->absolute_path = carla_lv2_state_map_absolute_path;

LV2_Programs_Host* const programsFt = new LV2_Programs_Host;
programsFt->handle = this;
programsFt->program_changed = carla_lv2_program_changed;

LV2_RtMemPool_Pool* const rtMemPoolFt = new LV2_RtMemPool_Pool;
lv2_rtmempool_init(rtMemPoolFt);

LV2_URI_Map_Feature* const uriMapFt = new LV2_URI_Map_Feature;
uriMapFt->callback_data = this;
uriMapFt->uri_to_id = carla_lv2_uri_to_id;

LV2_URID_Map* const uridMapFt = new LV2_URID_Map;
uridMapFt->handle = this;
uridMapFt->map = carla_lv2_urid_map;

LV2_URID_Unmap* const uridUnmapFt = new LV2_URID_Unmap;
uridUnmapFt->handle = this;
uridUnmapFt->unmap = carla_lv2_urid_unmap;

LV2_Worker_Schedule* const workerFt = new LV2_Worker_Schedule;
workerFt->handle = this;
workerFt->schedule_work = carla_lv2_worker_schedule;

// ---------------------------------------------------------------
// initialize features (part 2)

for (uint32_t j=0; j < kFeatureCountPlugin; ++j)
fFeatures[j] = new LV2_Feature;

fFeatures[kFeatureIdBufSizeBounded]->URI = LV2_BUF_SIZE__boundedBlockLength;
fFeatures[kFeatureIdBufSizeBounded]->data = nullptr;

fFeatures[kFeatureIdBufSizeFixed]->URI = LV2_BUF_SIZE__fixedBlockLength;
fFeatures[kFeatureIdBufSizeFixed]->data = nullptr;

fFeatures[kFeatureIdBufSizePowerOf2]->URI = LV2_BUF_SIZE__powerOf2BlockLength;
fFeatures[kFeatureIdBufSizePowerOf2]->data = nullptr;

fFeatures[kFeatureIdEvent]->URI = LV2_EVENT_URI;
fFeatures[kFeatureIdEvent]->data = eventFt;

fFeatures[kFeatureIdHardRtCapable]->URI = LV2_CORE__hardRTCapable;
fFeatures[kFeatureIdHardRtCapable]->data = nullptr;

fFeatures[kFeatureIdInPlaceBroken]->URI = LV2_CORE__inPlaceBroken;
fFeatures[kFeatureIdInPlaceBroken]->data = nullptr;

fFeatures[kFeatureIdIsLive]->URI = LV2_CORE__isLive;
fFeatures[kFeatureIdIsLive]->data = nullptr;

fFeatures[kFeatureIdLogs]->URI = LV2_LOG__log;
fFeatures[kFeatureIdLogs]->data = logFt;

fFeatures[kFeatureIdOptions]->URI = LV2_OPTIONS__options;
fFeatures[kFeatureIdOptions]->data = fLv2Options.opts;

fFeatures[kFeatureIdPrograms]->URI = LV2_PROGRAMS__Host;
fFeatures[kFeatureIdPrograms]->data = programsFt;

fFeatures[kFeatureIdRtMemPool]->URI = LV2_RTSAFE_MEMORY_POOL__Pool;
fFeatures[kFeatureIdRtMemPool]->data = rtMemPoolFt;

fFeatures[kFeatureIdStateMakePath]->URI = LV2_STATE__makePath;
fFeatures[kFeatureIdStateMakePath]->data = stateMakePathFt;

fFeatures[kFeatureIdStateMapPath]->URI = LV2_STATE__mapPath;
fFeatures[kFeatureIdStateMapPath]->data = stateMapPathFt;

fFeatures[kFeatureIdStrictBounds]->URI = LV2_PORT_PROPS__supportsStrictBounds;
fFeatures[kFeatureIdStrictBounds]->data = nullptr;

fFeatures[kFeatureIdUriMap]->URI = LV2_URI_MAP_URI;
fFeatures[kFeatureIdUriMap]->data = uriMapFt;

fFeatures[kFeatureIdUridMap]->URI = LV2_URID__map;
fFeatures[kFeatureIdUridMap]->data = uridMapFt;

fFeatures[kFeatureIdUridUnmap]->URI = LV2_URID__unmap;
fFeatures[kFeatureIdUridUnmap]->data = uridUnmapFt;

fFeatures[kFeatureIdWorker]->URI = LV2_WORKER__schedule;
fFeatures[kFeatureIdWorker]->data = workerFt;

// if a fixed buffer is not needed, skip its feature
if (! needsFixedBuffer())
fFeatures[kFeatureIdBufSizeFixed]->URI = LV2_BUF_SIZE__boundedBlockLength;

// if power of 2 is not possible, skip its feature FIXME
//if (fLv2Options.maxBufferSize)
// fFeatures[kFeatureIdBufSizePowerOf2]->URI = LV2_BUF_SIZE__boundedBlockLength;

// ---------------------------------------------------------------
// initialize plugin

@@ -1565,6 +1991,8 @@ public:
if (fRdfDescriptor->UICount == 0)
return true;

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

return true;
}

@@ -1573,7 +2001,7 @@ public:
private:
LV2_Handle fHandle;
LV2_Handle fHandle2;
LV2_Feature* fFeatures[kFeatureCount+1];
LV2_Feature* fFeatures[kFeatureCountAll+1];
const LV2_Descriptor* fDescriptor;
const LV2_RDF_Descriptor* fRdfDescriptor;

@@ -1581,6 +2009,358 @@ private:
float** fAudioOutBuffers;
float* fParamBuffers;

Lv2PluginOptions fLv2Options;

LinkedList<const char*> fCustomURIDs;

// -------------------------------------------------------------------
// Event Feature

static uint32_t carla_lv2_event_ref(LV2_Event_Callback_Data callback_data, LV2_Event* event)
{
CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);
CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);
carla_debug("carla_lv2_event_ref(%p, %p)", callback_data, event);

return 0;
}

static uint32_t carla_lv2_event_unref(LV2_Event_Callback_Data callback_data, LV2_Event* event)
{
CARLA_SAFE_ASSERT_RETURN(callback_data != nullptr, 0);
CARLA_SAFE_ASSERT_RETURN(event != nullptr, 0);
carla_debug("carla_lv2_event_unref(%p, %p)", callback_data, event);

return 0;
}

// -------------------------------------------------------------------
// Logs Feature

static int carla_lv2_log_printf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, ...)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);
CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

#ifndef DEBUG
if (type == CARLA_URI_MAP_ID_LOG_TRACE)
return 0;
#endif

va_list args;
va_start(args, fmt);
const int ret(carla_lv2_log_vprintf(handle, type, fmt, args));
va_end(args);

return ret;
}

static int carla_lv2_log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_list ap)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, 0);
CARLA_SAFE_ASSERT_RETURN(type != CARLA_URI_MAP_ID_NULL, 0);

#ifndef DEBUG
if (type == CARLA_URI_MAP_ID_LOG_TRACE)
return 0;
#endif

int ret = 0;

switch (type)
{
case CARLA_URI_MAP_ID_LOG_ERROR:
std::fprintf(stderr, "\x1b[31m");
ret = std::vfprintf(stderr, fmt, ap);
std::fprintf(stderr, "\x1b[0m");
break;

case CARLA_URI_MAP_ID_LOG_NOTE:
ret = std::vfprintf(stdout, fmt, ap);
break;

case CARLA_URI_MAP_ID_LOG_TRACE:
#ifdef DEBUG
std::fprintf(stdout, "\x1b[30;1m");
ret = std::vfprintf(stdout, fmt, ap);
std::fprintf(stdout, "\x1b[0m");
#endif
break;

case CARLA_URI_MAP_ID_LOG_WARNING:
ret = std::vfprintf(stderr, fmt, ap);
break;

default:
break;
}

return ret;
}

// -------------------------------------------------------------------
// Programs Feature

static void carla_lv2_program_changed(LV2_Programs_Handle handle, int32_t index)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
carla_debug("carla_lv2_program_changed(%p, %i)", handle, index);

((Lv2Plugin*)handle)->handleProgramChanged(index);
}

// -------------------------------------------------------------------
// State Feature

static char* carla_lv2_state_make_path(LV2_State_Make_Path_Handle handle, const char* path)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);
CARLA_SAFE_ASSERT_RETURN(path != nullptr && path[0] != '\0', nullptr);
carla_debug("carla_lv2_state_make_path(%p, \"%s\")", handle, path);

QDir dir;
dir.mkpath(path);
return strdup(path);
}

static char* carla_lv2_state_map_abstract_path(LV2_State_Map_Path_Handle handle, const char* absolute_path)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);
CARLA_SAFE_ASSERT_RETURN(absolute_path != nullptr && absolute_path[0] != '\0', nullptr);
carla_debug("carla_lv2_state_map_abstract_path(%p, \"%s\")", handle, absolute_path);

QDir dir(absolute_path);
return strdup(dir.canonicalPath().toUtf8().constData());
}

static char* carla_lv2_state_map_absolute_path(LV2_State_Map_Path_Handle handle, const char* abstract_path)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);
CARLA_SAFE_ASSERT_RETURN(abstract_path != nullptr && abstract_path[0] != '\0', nullptr);
carla_debug("carla_lv2_state_map_absolute_path(%p, \"%s\")", handle, abstract_path);

QDir dir(abstract_path);
return strdup(dir.absolutePath().toUtf8().constData());
}

// -------------------------------------------------------------------
// URI-Map Feature

static uint32_t carla_lv2_uri_to_id(LV2_URI_Map_Callback_Data data, const char* map, const char* uri)
{
carla_debug("carla_lv2_uri_to_id(%p, \"%s\", \"%s\")", data, map, uri);
return carla_lv2_urid_map((LV2_URID_Map_Handle*)data, uri);

// unused
(void)map;
}

// -------------------------------------------------------------------
// URID Feature

static LV2_URID carla_lv2_urid_map(LV2_URID_Map_Handle handle, const char* uri)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, CARLA_URI_MAP_ID_NULL);
CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', CARLA_URI_MAP_ID_NULL);
carla_debug("carla_lv2_urid_map(%p, \"%s\")", handle, uri);

// Atom types
if (std::strcmp(uri, LV2_ATOM__Blank) == 0)
return CARLA_URI_MAP_ID_ATOM_BLANK;
if (std::strcmp(uri, LV2_ATOM__Bool) == 0)
return CARLA_URI_MAP_ID_ATOM_BOOL;
if (std::strcmp(uri, LV2_ATOM__Chunk) == 0)
return CARLA_URI_MAP_ID_ATOM_CHUNK;
if (std::strcmp(uri, LV2_ATOM__Double) == 0)
return CARLA_URI_MAP_ID_ATOM_DOUBLE;
if (std::strcmp(uri, LV2_ATOM__Float) == 0)
return CARLA_URI_MAP_ID_ATOM_FLOAT;
if (std::strcmp(uri, LV2_ATOM__Int) == 0)
return CARLA_URI_MAP_ID_ATOM_INT;
if (std::strcmp(uri, LV2_ATOM__Literal) == 0)
return CARLA_URI_MAP_ID_ATOM_LITERAL;
if (std::strcmp(uri, LV2_ATOM__Long) == 0)
return CARLA_URI_MAP_ID_ATOM_LONG;
if (std::strcmp(uri, LV2_ATOM__Path) == 0)
return CARLA_URI_MAP_ID_ATOM_PATH;
if (std::strcmp(uri, LV2_ATOM__Property) == 0)
return CARLA_URI_MAP_ID_ATOM_PROPERTY;
if (std::strcmp(uri, LV2_ATOM__Resource) == 0)
return CARLA_URI_MAP_ID_ATOM_RESOURCE;
if (std::strcmp(uri, LV2_ATOM__Sequence) == 0)
return CARLA_URI_MAP_ID_ATOM_SEQUENCE;
if (std::strcmp(uri, LV2_ATOM__String) == 0)
return CARLA_URI_MAP_ID_ATOM_STRING;
if (std::strcmp(uri, LV2_ATOM__Tuple) == 0)
return CARLA_URI_MAP_ID_ATOM_TUPLE;
if (std::strcmp(uri, LV2_ATOM__URI) == 0)
return CARLA_URI_MAP_ID_ATOM_URI;
if (std::strcmp(uri, LV2_ATOM__URID) == 0)
return CARLA_URI_MAP_ID_ATOM_URID;
if (std::strcmp(uri, LV2_ATOM__Vector) == 0)
return CARLA_URI_MAP_ID_ATOM_VECTOR;
if (std::strcmp(uri, LV2_ATOM__atomTransfer) == 0)
return CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM;
if (std::strcmp(uri, LV2_ATOM__eventTransfer) == 0)
return CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT;

// BufSize types
if (std::strcmp(uri, LV2_BUF_SIZE__maxBlockLength) == 0)
return CARLA_URI_MAP_ID_BUF_MAX_LENGTH;
if (std::strcmp(uri, LV2_BUF_SIZE__minBlockLength) == 0)
return CARLA_URI_MAP_ID_BUF_MIN_LENGTH;
if (std::strcmp(uri, LV2_BUF_SIZE__sequenceSize) == 0)
return CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE;

// Log types
if (std::strcmp(uri, LV2_LOG__Error) == 0)
return CARLA_URI_MAP_ID_LOG_ERROR;
if (std::strcmp(uri, LV2_LOG__Note) == 0)
return CARLA_URI_MAP_ID_LOG_NOTE;
if (std::strcmp(uri, LV2_LOG__Trace) == 0)
return CARLA_URI_MAP_ID_LOG_TRACE;
if (std::strcmp(uri, LV2_LOG__Warning) == 0)
return CARLA_URI_MAP_ID_LOG_WARNING;

// Time types
if (std::strcmp(uri, LV2_TIME__Position) == 0)
return CARLA_URI_MAP_ID_TIME_POSITION;
if (std::strcmp(uri, LV2_TIME__bar) == 0)
return CARLA_URI_MAP_ID_TIME_BAR;
if (std::strcmp(uri, LV2_TIME__barBeat) == 0)
return CARLA_URI_MAP_ID_TIME_BAR_BEAT;
if (std::strcmp(uri, LV2_TIME__beat) == 0)
return CARLA_URI_MAP_ID_TIME_BEAT;
if (std::strcmp(uri, LV2_TIME__beatUnit) == 0)
return CARLA_URI_MAP_ID_TIME_BEAT_UNIT;
if (std::strcmp(uri, LV2_TIME__beatsPerBar) == 0)
return CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR;
if (std::strcmp(uri, LV2_TIME__beatsPerMinute) == 0)
return CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE;
if (std::strcmp(uri, LV2_TIME__frame) == 0)
return CARLA_URI_MAP_ID_TIME_FRAME;
if (std::strcmp(uri, LV2_TIME__framesPerSecond) == 0)
return CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND;
if (std::strcmp(uri, LV2_TIME__speed) == 0)
return CARLA_URI_MAP_ID_TIME_SPEED;

// Others
if (std::strcmp(uri, LV2_MIDI__MidiEvent) == 0)
return CARLA_URI_MAP_ID_MIDI_EVENT;
if (std::strcmp(uri, LV2_PARAMETERS__sampleRate) == 0)
return CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE;

// Custom types
return ((Lv2Plugin*)handle)->getCustomURID(uri);
}

static const char* carla_lv2_urid_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, nullptr);
CARLA_SAFE_ASSERT_RETURN(urid != CARLA_URI_MAP_ID_NULL, nullptr);
carla_debug("carla_lv2_urid_unmap(%p, %i)", handle, urid);

// Atom types
if (urid == CARLA_URI_MAP_ID_ATOM_BLANK)
return LV2_ATOM__Blank;
if (urid == CARLA_URI_MAP_ID_ATOM_BOOL)
return LV2_ATOM__Bool;
if (urid == CARLA_URI_MAP_ID_ATOM_CHUNK)
return LV2_ATOM__Chunk;
if (urid == CARLA_URI_MAP_ID_ATOM_DOUBLE)
return LV2_ATOM__Double;
if (urid == CARLA_URI_MAP_ID_ATOM_FLOAT)
return LV2_ATOM__Float;
if (urid == CARLA_URI_MAP_ID_ATOM_INT)
return LV2_ATOM__Int;
if (urid == CARLA_URI_MAP_ID_ATOM_LITERAL)
return LV2_ATOM__Literal;
if (urid == CARLA_URI_MAP_ID_ATOM_LONG)
return LV2_ATOM__Long;
if (urid == CARLA_URI_MAP_ID_ATOM_PATH)
return LV2_ATOM__Path;
if (urid == CARLA_URI_MAP_ID_ATOM_PROPERTY)
return LV2_ATOM__Property;
if (urid == CARLA_URI_MAP_ID_ATOM_RESOURCE)
return LV2_ATOM__Resource;
if (urid == CARLA_URI_MAP_ID_ATOM_SEQUENCE)
return LV2_ATOM__Sequence;
if (urid == CARLA_URI_MAP_ID_ATOM_STRING)
return LV2_ATOM__String;
if (urid == CARLA_URI_MAP_ID_ATOM_TUPLE)
return LV2_ATOM__Tuple;
if (urid == CARLA_URI_MAP_ID_ATOM_URI)
return LV2_ATOM__URI;
if (urid == CARLA_URI_MAP_ID_ATOM_URID)
return LV2_ATOM__URID;
if (urid == CARLA_URI_MAP_ID_ATOM_VECTOR)
return LV2_ATOM__Vector;
if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_ATOM)
return LV2_ATOM__atomTransfer;
if (urid == CARLA_URI_MAP_ID_ATOM_TRANSFER_EVENT)
return LV2_ATOM__eventTransfer;

// BufSize types
if (urid == CARLA_URI_MAP_ID_BUF_MAX_LENGTH)
return LV2_BUF_SIZE__maxBlockLength;
if (urid == CARLA_URI_MAP_ID_BUF_MIN_LENGTH)
return LV2_BUF_SIZE__minBlockLength;
if (urid == CARLA_URI_MAP_ID_BUF_SEQUENCE_SIZE)
return LV2_BUF_SIZE__sequenceSize;

// Log types
if (urid == CARLA_URI_MAP_ID_LOG_ERROR)
return LV2_LOG__Error;
if (urid == CARLA_URI_MAP_ID_LOG_NOTE)
return LV2_LOG__Note;
if (urid == CARLA_URI_MAP_ID_LOG_TRACE)
return LV2_LOG__Trace;
if (urid == CARLA_URI_MAP_ID_LOG_WARNING)
return LV2_LOG__Warning;

// Time types
if (urid == CARLA_URI_MAP_ID_TIME_POSITION)
return LV2_TIME__Position;
if (urid == CARLA_URI_MAP_ID_TIME_BAR)
return LV2_TIME__bar;
if (urid == CARLA_URI_MAP_ID_TIME_BAR_BEAT)
return LV2_TIME__barBeat;
if (urid == CARLA_URI_MAP_ID_TIME_BEAT)
return LV2_TIME__beat;
if (urid == CARLA_URI_MAP_ID_TIME_BEAT_UNIT)
return LV2_TIME__beatUnit;
if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_BAR)
return LV2_TIME__beatsPerBar;
if (urid == CARLA_URI_MAP_ID_TIME_BEATS_PER_MINUTE)
return LV2_TIME__beatsPerMinute;
if (urid == CARLA_URI_MAP_ID_TIME_FRAME)
return LV2_TIME__frame;
if (urid == CARLA_URI_MAP_ID_TIME_FRAMES_PER_SECOND)
return LV2_TIME__framesPerSecond;
if (urid == CARLA_URI_MAP_ID_TIME_SPEED)
return LV2_TIME__speed;

// Others
if (urid == CARLA_URI_MAP_ID_MIDI_EVENT)
return LV2_MIDI__MidiEvent;
if (urid == CARLA_URI_MAP_ID_PARAM_SAMPLE_RATE)
return LV2_PARAMETERS__sampleRate;

// Custom types
return ((Lv2Plugin*)handle)->getCustomURIDString(urid);
}

// -------------------------------------------------------------------
// Worker Feature

static LV2_Worker_Status carla_lv2_worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void* data)
{
CARLA_SAFE_ASSERT_RETURN(handle != nullptr, LV2_WORKER_ERR_UNKNOWN);
carla_debug("carla_lv2_worker_schedule(%p, %i, %p)", handle, size, data);

return ((Lv2Plugin*)handle)->handleWorkerSchedule(size, data);
}

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

CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Lv2Plugin)


+ 1
- 1
source/backend/standalone/Makefile View File

@@ -130,7 +130,7 @@ debug:

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

CarlaStandalone.cpp.o: CarlaStandalone.cpp $(CARLA_HOST_H) $(CARLA_MIDI_H) $(CARLA_NATIVE_H) $(CARLA_ENGINE_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_THREAD_HPP)
CarlaStandalone.cpp.o: CarlaStandalone.cpp $(CARLA_HOST_H) $(CARLA_MIDI_H) $(CARLA_NATIVE_H) $(CARLA_ENGINE_HPP) $(CARLA_PLUGIN_HPP) $(CARLA_BACKEND_UTILS_HPP) $(CARLA_THREAD_HPP) $(CARLA_STATE_UTILS_CPP)
$(CXX) $< $(BUILD_CXX_FLAGS) $(QTCORE_FLAGS) -c -o $@

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


+ 28
- 13
source/discovery/Makefile View File

@@ -82,8 +82,23 @@ WIN_32BIT_FLAGS = $(32BIT_FLAGS)
WIN_64BIT_FLAGS = $(64BIT_FLAGS)
WIN_LINK_FLAGS = $(LINK_FLAGS) $(EXTRA_LIBS)

OBJS = carla-discovery.cpp
# --------------------------------------------------------------

DEPS = ../includes/CarlaDefines.h
DEPS += ../includes/CarlaMIDI.h
DEPS += ../backend/CarlaBackend.h
DEPS += ../utils/CarlaString.hpp
DEPS += ../utils/CarlaUtils.hpp
DEPS += ../utils/CarlaBackendUtils.hpp
DEPS += ../utils/CarlaJuceUtils.hpp
DEPS += ../utils/CarlaLibUtils.hpp
DEPS += ../utils/CarlaMathUtils.hpp
DEPS += ../utils/CarlaLadspaUtils.hpp
DEPS += ../utils/CarlaDssiUtils.hpp
DEPS += ../utils/CarlaLv2Utils.hpp
DEPS += ../utils/CarlaVstUtils.hpp

OBJS = carla-discovery.cpp

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

@@ -100,23 +115,23 @@ win64: carla-discovery-win64.exe

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

carla-discovery-native: $(OBJS) $(LIBS)
$(CXX) $^ $(POSIX_BUILD_FLAGS) $(NATIVE_FLAGS) $(POSIX_LINK_FLAGS) -o $@
carla-discovery-native: $(OBJS) $(DEPS) $(LIBS)
$(CXX) $< $(LIBS) $(POSIX_BUILD_FLAGS) $(NATIVE_FLAGS) $(POSIX_LINK_FLAGS) -o $@

carla-discovery-native.exe: $(OBJS) $(LIBS)
$(CXX) $^ $(WIN_BUILD_FLAGS) $(NATIVE_FLAGS) $(WIN_LINK_FLAGS) -o $@
carla-discovery-native.exe: $(OBJS) $(DEPS) $(LIBS)
$(CXX) $< $(LIBS) $(WIN_BUILD_FLAGS) $(NATIVE_FLAGS) $(WIN_LINK_FLAGS) -o $@

carla-discovery-posix32: $(OBJS) $(LIBS_posix32)
$(CXX) $^ $(POSIX_BUILD_FLAGS) $(POSIX_32BIT_FLAGS) $(POSIX_LINK_FLAGS) -o $@
carla-discovery-posix32: $(OBJS) $(DEPS) $(LIBS_posix32)
$(CXX) $< $(LIBS_posix32) $(POSIX_BUILD_FLAGS) $(POSIX_32BIT_FLAGS) $(POSIX_LINK_FLAGS) -o $@

carla-discovery-posix64: $(OBJS) $(LIBS_posix64)
$(CXX) $^ $(POSIX_BUILD_FLAGS) $(POSIX_64BIT_FLAGS) $(POSIX_LINK_FLAGS) -o $@
carla-discovery-posix64: $(OBJS) $(DEPS) $(LIBS_posix64)
$(CXX) $< $(LIBS_posix64) $(POSIX_BUILD_FLAGS) $(POSIX_64BIT_FLAGS) $(POSIX_LINK_FLAGS) -o $@

carla-discovery-win32.exe: $(OBJS) $(LIBS_win32)
$(CXX) $^ $(WIN_BUILD_FLAGS) $(WIN_32BIT_FLAGS) $(WIN_LINK_FLAGS) -o $@
carla-discovery-win32.exe: $(OBJS) $(DEPS) $(LIBS_win32)
$(CXX) $< $(LIBS_win32) $(WIN_BUILD_FLAGS) $(WIN_32BIT_FLAGS) $(WIN_LINK_FLAGS) -o $@

carla-discovery-win64.exe: $(OBJS) $(LIBS_win64)
$(CXX) $^ $(WIN_BUILD_FLAGS) $(WIN_64BIT_FLAGS) $(WIN_LINK_FLAGS) -o $@
carla-discovery-win64.exe: $(OBJS) $(DEPS) $(LIBS_win64)
$(CXX) $< $(LIBS_win64) $(WIN_BUILD_FLAGS) $(WIN_64BIT_FLAGS) $(WIN_LINK_FLAGS) -o $@

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



+ 29
- 17
source/utils/CarlaLv2Utils.hpp View File

@@ -1081,6 +1081,8 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool /*fillPreset

if (const char* const featureURI = lilvFeatureNode.as_uri())
rdfFeature->URI = carla_strdup(featureURI);
else
rdfFeature->URI = nullptr;
}
}
}
@@ -1103,8 +1105,15 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool /*fillPreset
Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it));
LV2_URI* const rdfExtension(&rdfDescriptor->Extensions[h++]);

if (const char* const extURI = lilvExtensionDataNode.as_uri())
*rdfExtension = carla_strdup(extURI);
if (lilvExtensionDataNode.is_uri())
{
if (const char* const extURI = lilvExtensionDataNode.as_uri())
{
*rdfExtension = carla_strdup(extURI);
continue;
}
}
*rdfExtension = nullptr;
}
}
}
@@ -1187,7 +1196,9 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool /*fillPreset
rdfFeature->Type = lilvFeatureNodesR.contains(lilvFeatureNode) ? LV2_FEATURE_REQUIRED : LV2_FEATURE_OPTIONAL;

if (const char* const featureURI = lilvFeatureNode.as_uri())
rdfFeature->URI = carla_strdup(featureURI);
rdfFeature->URI = carla_strdup(featureURI);
else
rdfFeature->URI = nullptr;
}
}
}
@@ -1210,8 +1221,15 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool /*fillPreset
Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it));
LV2_URI* const rdfExtension(&rdfUI->Extensions[h2++]);

if (const char* const extURI = lilvExtensionDataNode.as_uri())
*rdfExtension = carla_strdup(extURI);
if (lilvExtensionDataNode.is_uri())
{
if (const char* const extURI = lilvExtensionDataNode.as_uri())
{
*rdfExtension = carla_strdup(extURI);
continue;
}
}
*rdfExtension = nullptr;
}
}
}
@@ -1251,21 +1269,18 @@ bool is_lv2_feature_supported(const LV2_URI uri)
{
CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);

// TODO
return false;

if (std::strcmp(uri, LV2_CORE__hardRTCapable) == 0)
return true;
if (std::strcmp(uri, LV2_CORE__inPlaceBroken) == 0)
return true;
if (std::strcmp(uri, LV2_CORE__isLive) == 0)
return true;
if (std::strcmp(uri, LV2_BUF_SIZE__boundedBlockLength) == 0)
return true;
if (std::strcmp(uri, LV2_BUF_SIZE__fixedBlockLength) == 0)
return true;
if (std::strcmp(uri, LV2_BUF_SIZE__powerOf2BlockLength) == 0)
return true;
if (std::strcmp(uri, LV2_CORE__hardRTCapable) == 0)
return true;
if (std::strcmp(uri, LV2_CORE__inPlaceBroken) == 0)
return true;
if (std::strcmp(uri, LV2_CORE__isLive) == 0)
return true;
if (std::strcmp(uri, LV2_EVENT_URI) == 0)
return true;
if (std::strcmp(uri, LV2_LOG__log) == 0)
@@ -1301,9 +1316,6 @@ bool is_lv2_ui_feature_supported(const LV2_URI uri)
{
CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);

// TODO
return false;

if (is_lv2_feature_supported(uri))
return true;
#ifndef BRIDGE_LV2


+ 2
- 1
source/utils/CarlaStateUtils.cpp View File

@@ -218,7 +218,7 @@ void fillSaveStateFromXmlNode(SaveState& saveState, const QDomNode& xmlNode)
{
saveState.label = xmlSafeStringCharDup(text, false);
}
else if (tag.compare("binary", Qt::CaseInsensitive) == 0 || tag.compare("filename", Qt::CaseInsensitive) == 0)
else if (tag.compare("binary", Qt::CaseInsensitive) == 0 || tag.compare("bundle", Qt::CaseInsensitive) == 0 || tag.compare("filename", Qt::CaseInsensitive) == 0)
{
saveState.binary = xmlSafeStringCharDup(text, false);
}
@@ -433,6 +433,7 @@ void fillXmlStringFromSaveState(QString& content, const SaveState& saveState)
info += QString(" <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));
break;
case PLUGIN_LV2:
info += QString(" <Bundle>%1</Bundle>\n").arg(xmlSafeString(saveState.binary, true));
info += QString(" <URI>%1</URI>\n").arg(xmlSafeString(saveState.label, true));
break;
case PLUGIN_VST:


Write Preview
Loading…
Cancel
Save