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

More of the same

tags/1.9.4
falkTX 12 years ago
parent
96ed95705a
commit
e6803e1aec
10 changed files with 1550 additions and 742 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -3
      resources/ui/carla_refresh.ui
  2. +2
    -2
      source/backend/CarlaPlugin.hpp
  3. +617
    -605
      source/backend/plugin/BridgePlugin.cpp
  4. +61
    -51
      source/backend/plugin/DssiPlugin.cpp
  5. +18
    -3
      source/backend/plugin/FluidSynthPlugin.cpp
  6. +25
    -11
      source/backend/plugin/LadspaPlugin.cpp
  7. +15
    -0
      source/backend/plugin/LinuxSamplerPlugin.cpp
  8. +694
    -3
      source/backend/plugin/Lv2Plugin.cpp
  9. +94
    -60
      source/backend/plugin/NativePlugin.cpp
  10. +24
    -4
      source/backend/plugin/VstPlugin.cpp

+ 0
- 3
resources/ui/carla_refresh.ui View File

@@ -59,9 +59,6 @@
</item>
<item>
<widget class="QCheckBox" name="ch_lv2">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>LV2</string>
</property>


+ 2
- 2
source/backend/CarlaPlugin.hpp View File

@@ -409,12 +409,12 @@ public:
void loadSaveState(const SaveState& saveState);

/*!
* TODO
* Save the current plugin state to \a filename.
*/
bool saveStateToFile(const char* const filename);

/*!
* TODO
* Save the plugin state from \a filename.
*/
bool loadStateFromFile(const char* const filename);



+ 617
- 605
source/backend/plugin/BridgePlugin.cpp
File diff suppressed because it is too large
View File


+ 61
- 51
source/backend/plugin/DssiPlugin.cpp View File

@@ -244,7 +244,7 @@ public:
CARLA_ASSERT(fDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fDescriptor->PortCount))
std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);
@@ -252,6 +252,16 @@ public:
CarlaPlugin::getParameterName(parameterId, strBuf);
}

// -------------------------------------------------------------------
// Set data (state)

// nothing

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -259,7 +269,7 @@ public:
{
CARLA_ASSERT(parameterId < kData->param.count);

const float fixedValue = kData->param.fixValue(parameterId, value);
const float fixedValue(kData->param.fixValue(parameterId, value));
fParamBuffers[parameterId] = fixedValue;

CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
@@ -1621,7 +1631,55 @@ public:
}

// -------------------------------------------------------------------
// Post-poned events
// Plugin buffers

void clearBuffers() override
{
carla_debug("DssiPlugin::clearBuffers() - start");

if (fAudioInBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
{
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = nullptr;
}
}

delete[] fAudioInBuffers;
fAudioInBuffers = nullptr;
}

if (fAudioOutBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
{
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = nullptr;
}
}

delete[] fAudioOutBuffers;
fAudioOutBuffers = nullptr;
}

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

CarlaPlugin::clearBuffers();

carla_debug("DssiPlugin::clearBuffers() - end");
}

// -------------------------------------------------------------------
// Post-poned UI Stuff

void uiParameterChange(const uint32_t index, const float value) override
{
@@ -1689,54 +1747,6 @@ public:
osc_send_midi(&kData->osc.data, midiData);
}

// -------------------------------------------------------------------
// Plugin buffers

void clearBuffers() override
{
carla_debug("DssiPlugin::clearBuffers() - start");

if (fAudioInBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
{
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = nullptr;
}
}

delete[] fAudioInBuffers;
fAudioInBuffers = nullptr;
}

if (fAudioOutBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
{
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = nullptr;
}
}

delete[] fAudioOutBuffers;
fAudioOutBuffers = nullptr;
}

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

CarlaPlugin::clearBuffers();

carla_debug("DssiPlugin::clearBuffers() - end");
}

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

const void* getExtraStuff() override


+ 18
- 3
source/backend/plugin/FluidSynthPlugin.cpp View File

@@ -323,6 +323,16 @@ public:
CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);
}

// -------------------------------------------------------------------
// Set data (state)

// nothing

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -330,7 +340,7 @@ public:
{
CARLA_ASSERT(parameterId < kData->param.count);

const float fixedValue = kData->param.fixValue(parameterId, value);
const float fixedValue(kData->param.fixValue(parameterId, value));
fParamBuffers[parameterId] = fixedValue;

{
@@ -388,7 +398,7 @@ public:
else if (index > static_cast<int32_t>(kData->midiprog.count))
return;

if (kData->ctrlChannel < 0 || kData->ctrlChannel >= 16)
if (kData->ctrlChannel < 0 || kData->ctrlChannel >= MAX_MIDI_CHANNELS)
return;

if (index >= 0)
@@ -396,13 +406,18 @@ public:
const uint32_t bank = kData->midiprog.data[index].bank;
const uint32_t program = kData->midiprog.data[index].program;

const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));
//const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));
fluid_synth_program_select(fSynth, kData->ctrlChannel, fSynthId, bank, program);
}

CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback);
}

// -------------------------------------------------------------------
// Set gui stuff

// nothing

// -------------------------------------------------------------------
// Plugin state



+ 25
- 11
source/backend/plugin/LadspaPlugin.cpp View File

@@ -197,16 +197,15 @@ public:
CARLA_ASSERT(parameterId < kData->param.count);
CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex];
const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (scalePointId < port.ScalePointCount)
{
const LADSPA_RDF_ScalePoint& scalePoint = port.ScalePoints[scalePointId];

const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);
return scalePoint.Value;
}
}
@@ -263,7 +262,7 @@ public:
CARLA_ASSERT(fDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fDescriptor->PortCount))
std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX);
@@ -275,7 +274,7 @@ public:
{
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
@@ -295,11 +294,11 @@ public:
{
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex];
const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (LADSPA_PORT_HAS_UNIT(port.Hints))
{
@@ -336,15 +335,15 @@ public:
CARLA_ASSERT(parameterId < kData->param.count);
CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

const int32_t rindex = kData->param.data[parameterId].rindex;
const int32_t rindex(kData->param.data[parameterId].rindex);

if (fRdfDescriptor != nullptr && rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex];
const LADSPA_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (scalePointId < port.ScalePointCount)
{
const LADSPA_RDF_ScalePoint& scalePoint = port.ScalePoints[scalePointId];
const LADSPA_RDF_ScalePoint& scalePoint(port.ScalePoints[scalePointId]);

if (scalePoint.Label != nullptr)
{
@@ -357,6 +356,16 @@ public:
CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);
}

// -------------------------------------------------------------------
// Set data (state)

// nothing

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -370,6 +379,11 @@ public:
CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
}

// -------------------------------------------------------------------
// Set gui stuff

// nothing

// -------------------------------------------------------------------
// Plugin state



+ 15
- 0
source/backend/plugin/LinuxSamplerPlugin.cpp View File

@@ -275,6 +275,16 @@ public:
std::strncpy(strBuf, (const char*)fRealName, STR_MAX);
}

// -------------------------------------------------------------------
// Set data (state)

// nothing

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -901,6 +911,11 @@ public:
return true;
}

// -------------------------------------------------------------------
// Plugin buffers

// nothing

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

const void* getExtraStuff() override


+ 694
- 3
source/backend/plugin/Lv2Plugin.cpp View File

@@ -22,6 +22,17 @@
#include "CarlaPluginGui.hpp"
#include "CarlaLv2Utils.hpp"

extern "C" {
#include "rtmempool/rtmempool.h"
}

// -----------------------------------------------------
// Our LV2 World class object

Lv2WorldClass gLv2World;

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

CARLA_BACKEND_START_NAMESPACE

#if 0
@@ -155,7 +166,7 @@ public:

uint32_t midiInCount() const override
{
uint32_t i, count = 0;
uint32_t /*i,*/ count = 0;

#if 0
for (i=0; i < evIn.count; ++i)
@@ -170,7 +181,7 @@ public:

uint32_t midiOutCount() const override
{
uint32_t i, count = 0;
uint32_t /*i,*/ count = 0;

#if 0
for (i=0; i < evOut.count; ++i)
@@ -242,6 +253,486 @@ public:
return fParamBuffers[parameterId];
}

float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);
CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (scalePointId < port.ScalePointCount)
{
const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);
return portScalePoint.Value;
}
}

return 0.0f;
}

void getLabel(char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(fRdfDescriptor->URI != nullptr);

if (fRdfDescriptor->URI != nullptr)
std::strncpy(strBuf, fRdfDescriptor->URI, STR_MAX);
else
CarlaPlugin::getLabel(strBuf);
}

void getMaker(char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);

if (fRdfDescriptor->Author != nullptr)
std::strncpy(strBuf, fRdfDescriptor->Author, STR_MAX);
else
CarlaPlugin::getMaker(strBuf);
}

void getCopyright(char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);

if (fRdfDescriptor->License != nullptr)
std::strncpy(strBuf, fRdfDescriptor->License, STR_MAX);
else
CarlaPlugin::getCopyright(strBuf);
}

void getRealName(char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);

if (fRdfDescriptor->Name != nullptr)
std::strncpy(strBuf, fRdfDescriptor->Name, STR_MAX);
else
CarlaPlugin::getRealName(strBuf);
}

void getParameterName(const uint32_t parameterId, char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
std::strncpy(strBuf, fRdfDescriptor->Ports[rindex].Name, STR_MAX);
else
CarlaPlugin::getParameterName(parameterId, strBuf);
}

void getParameterSymbol(const uint32_t parameterId, char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
strncpy(strBuf, fRdfDescriptor->Ports[rindex].Symbol, STR_MAX);
else
CarlaPlugin::getParameterSymbol(parameterId, strBuf);
}

void getParameterUnit(const uint32_t parameterId, char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (LV2_HAVE_PORT_UNIT_SYMBOL(port.Unit.Hints) && port.Unit.Symbol)
std::strncpy(strBuf, port.Unit.Symbol, STR_MAX);

else if (LV2_HAVE_PORT_UNIT_UNIT(port.Unit.Hints))
{
switch (port.Unit.Unit)
{
case LV2_PORT_UNIT_BAR:
std::strncpy(strBuf, "bars", STR_MAX);
return;
case LV2_PORT_UNIT_BEAT:
std::strncpy(strBuf, "beats", STR_MAX);
return;
case LV2_PORT_UNIT_BPM:
std::strncpy(strBuf, "BPM", STR_MAX);
return;
case LV2_PORT_UNIT_CENT:
std::strncpy(strBuf, "ct", STR_MAX);
return;
case LV2_PORT_UNIT_CM:
std::strncpy(strBuf, "cm", STR_MAX);
return;
case LV2_PORT_UNIT_COEF:
std::strncpy(strBuf, "(coef)", STR_MAX);
return;
case LV2_PORT_UNIT_DB:
std::strncpy(strBuf, "dB", STR_MAX);
return;
case LV2_PORT_UNIT_DEGREE:
std::strncpy(strBuf, "deg", STR_MAX);
return;
case LV2_PORT_UNIT_FRAME:
std::strncpy(strBuf, "frames", STR_MAX);
return;
case LV2_PORT_UNIT_HZ:
std::strncpy(strBuf, "Hz", STR_MAX);
return;
case LV2_PORT_UNIT_INCH:
std::strncpy(strBuf, "in", STR_MAX);
return;
case LV2_PORT_UNIT_KHZ:
std::strncpy(strBuf, "kHz", STR_MAX);
return;
case LV2_PORT_UNIT_KM:
std::strncpy(strBuf, "km", STR_MAX);
return;
case LV2_PORT_UNIT_M:
std::strncpy(strBuf, "m", STR_MAX);
return;
case LV2_PORT_UNIT_MHZ:
std::strncpy(strBuf, "MHz", STR_MAX);
return;
case LV2_PORT_UNIT_MIDINOTE:
std::strncpy(strBuf, "note", STR_MAX);
return;
case LV2_PORT_UNIT_MILE:
std::strncpy(strBuf, "mi", STR_MAX);
return;
case LV2_PORT_UNIT_MIN:
std::strncpy(strBuf, "min", STR_MAX);
return;
case LV2_PORT_UNIT_MM:
std::strncpy(strBuf, "mm", STR_MAX);
return;
case LV2_PORT_UNIT_MS:
std::strncpy(strBuf, "ms", STR_MAX);
return;
case LV2_PORT_UNIT_OCT:
std::strncpy(strBuf, "oct", STR_MAX);
return;
case LV2_PORT_UNIT_PC:
std::strncpy(strBuf, "%", STR_MAX);
return;
case LV2_PORT_UNIT_S:
std::strncpy(strBuf, "s", STR_MAX);
return;
case LV2_PORT_UNIT_SEMITONE:
std::strncpy(strBuf, "semi", STR_MAX);
return;
}
}
}

CarlaPlugin::getParameterUnit(parameterId, strBuf);
}

void getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) override
{
CARLA_ASSERT(fRdfDescriptor != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);
CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

const int32_t rindex(kData->param.data[parameterId].rindex);

if (rindex < static_cast<int32_t>(fRdfDescriptor->PortCount))
{
const LV2_RDF_Port& port(fRdfDescriptor->Ports[rindex]);

if (scalePointId < port.ScalePointCount)
{
const LV2_RDF_PortScalePoint& portScalePoint(port.ScalePoints[scalePointId]);

if (portScalePoint.Label != nullptr)
{
std::strncpy(strBuf, portScalePoint.Label, STR_MAX);
return;
}
}
}

CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);
}

// -------------------------------------------------------------------
// Set data (state)

void prepareForSave() override
{
CARLA_ASSERT(fHandle != nullptr);

#if 0
if (fExt.state != nullptr && fExt.state->save != nullptr)
{
fExt.state->save(handle, carla_lv2_state_store, this, LV2_STATE_IS_POD, features);

if (fHandle2)
fExt.state->save(h2, carla_lv2_state_store, this, LV2_STATE_IS_POD, features);
}
#endif
}

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) override
{
CARLA_ASSERT(parameterId < kData->param.count);

const float fixedValue(kData->param.fixValue(parameterId, value));
fParamBuffers[parameterId] = fixedValue;

CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
}

// -------------------------------------------------------------------
// Set gui stuff

void showGui(const bool yesNo) override
{
if (true)
{
if (yesNo)
{
kData->osc.thread.start();
}
else
{
if (kData->osc.data.target != nullptr)
{
osc_send_hide(&kData->osc.data);
osc_send_quit(&kData->osc.data);
kData->osc.data.free();
}

if (kData->osc.thread.isRunning() && ! kData->osc.thread.wait(kData->engine->getOptions().oscUiTimeout))
kData->osc.thread.terminate();
}
}
else
{
if (yesNo)
{
if (kData->gui == nullptr)
{
// TODO
CarlaPluginGui::Options guiOptions;
guiOptions.parented = false;
guiOptions.resizable = true;

kData->gui = new CarlaPluginGui(kData->engine, this, guiOptions);
}

//void* const ptr = kData->gui->getContainerWinId();

// open
if (true)
{
kData->gui->setWindowTitle(QString("%1 (GUI)").arg((const char*)fName).toUtf8().constData());
kData->gui->show();
}
else
{
if (kData->gui != nullptr)
{
kData->gui->close();
delete kData->gui;
kData->gui = nullptr;
}

kData->engine->callback(CALLBACK_ERROR, fId, 0, 0, 0.0f, "Plugin refused to open its own UI");
kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);
return;
}
}
else
{
// close here

if (kData->gui != nullptr)
{
kData->gui->close();
delete kData->gui;
kData->gui = nullptr;
}
}
}

//fGui.isVisible = yesNo;
}

void idleGui() override
{
CarlaPlugin::idleGui();
}

// -------------------------------------------------------------------
// Plugin processing

void activate() override
{
CARLA_ASSERT(fDescriptor != nullptr);

if (fDescriptor->activate != nullptr)
{
fDescriptor->activate(fHandle);

if (fHandle2 != nullptr)
fDescriptor->activate(fHandle2);
}
}

void deactivate() override
{
CARLA_ASSERT(fDescriptor != nullptr);

if (fDescriptor->deactivate != nullptr)
{
fDescriptor->deactivate(fHandle);

if (fHandle2 != nullptr)
fDescriptor->deactivate(fHandle2);
}
}

void bufferSizeChanged(const uint32_t newBufferSize) override
{
CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);
carla_debug("Lv2Plugin::bufferSizeChanged(%i) - start", newBufferSize);

for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = new float[newBufferSize];
}

for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = new float[newBufferSize];
}

if (fHandle2 == nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
CARLA_ASSERT(fAudioInBuffers[i] != nullptr);
fDescriptor->connect_port(fHandle, kData->audioIn.ports[i].rindex, fAudioInBuffers[i]);
}

for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
CARLA_ASSERT(fAudioOutBuffers[i] != nullptr);
fDescriptor->connect_port(fHandle, kData->audioOut.ports[i].rindex, fAudioOutBuffers[i]);
}
}
else
{
if (kData->audioIn.count > 0)
{
CARLA_ASSERT(kData->audioIn.count == 2);
CARLA_ASSERT(fAudioInBuffers[0] != nullptr);
CARLA_ASSERT(fAudioInBuffers[1] != nullptr);

fDescriptor->connect_port(fHandle, kData->audioIn.ports[0].rindex, fAudioInBuffers[0]);
fDescriptor->connect_port(fHandle2, kData->audioIn.ports[1].rindex, fAudioInBuffers[1]);
}

if (kData->audioOut.count > 0)
{
CARLA_ASSERT(kData->audioOut.count == 2);
CARLA_ASSERT(fAudioOutBuffers[0] != nullptr);
CARLA_ASSERT(fAudioOutBuffers[1] != nullptr);

fDescriptor->connect_port(fHandle, kData->audioOut.ports[0].rindex, fAudioOutBuffers[0]);
fDescriptor->connect_port(fHandle2, kData->audioOut.ports[1].rindex, fAudioOutBuffers[1]);
}
}

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

void sampleRateChanged(const double newSampleRate) override
{
CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);
carla_debug("Lv2Plugin::sampleRateChanged(%g) - start", newSampleRate);

// TODO
(void)newSampleRate;

carla_debug("Lv2Plugin::sampleRateChanged(%g) - end", newSampleRate);
}

// -------------------------------------------------------------------
// Plugin buffers

void clearBuffers() override
{
carla_debug("Lv2Plugin::clearBuffers() - start");

if (fAudioInBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
{
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = nullptr;
}
}

delete[] fAudioInBuffers;
fAudioInBuffers = nullptr;
}

if (fAudioOutBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
{
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = nullptr;
}
}

delete[] fAudioOutBuffers;
fAudioOutBuffers = nullptr;
}

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

CarlaPlugin::clearBuffers();

carla_debug("Lv2Plugin::clearBuffers() - end");
}

// -------------------------------------------------------------------
// Post-poned UI Stuff

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

protected:
@@ -287,7 +778,207 @@ public:
return false;
}

return false;
// ---------------------------------------------------------------
// get plugin from lv2_rdf (lilv)

gLv2World.init();

fRdfDescriptor = lv2_rdf_new(uri);

if (fRdfDescriptor == nullptr)
{
kData->engine->setLastError("Failed to find the requested plugin in the LV2 Bundle");
return false;
}

// ---------------------------------------------------------------
// open DLL

if (! kData->libOpen(fRdfDescriptor->Binary))
{
kData->engine->setLastError(kData->libError(fRdfDescriptor->Binary));
return false;
}

// ---------------------------------------------------------------
// get DLL main entry

#if 0
const LV2_Lib_Descriptor_Function libDescFn = (LV2_Lib_Descriptor_Function)kData->libSymbol("lv2_lib_descriptor");

if (libDescFn != nullptr)
{
// -----------------------------------------------------------
// get lib descriptor

const LV2_Lib_Descriptor* libFn = nullptr; //descLibFn(fRdfDescriptor->Bundle, features);

if (libFn == nullptr || libFn->get_plugin == nullptr)
{
kData->engine->setLastError("Plugin failed to return library descriptor");
return false;
}

// -----------------------------------------------------------
// get descriptor that matches URI

uint32_t i = 0;
while ((fDescriptor = libFn->get_plugin(libFn->handle, i++)))
{
if (std::strcmp(fDescriptor->URI, uri) == 0)
break;
}

if (fDescriptor == nullptr)
libFn->cleanup(libFn->handle);
else
#endif
{
const LV2_Descriptor_Function descFn = (LV2_Descriptor_Function)kData->libSymbol("lv2_descriptor");

if (descFn == nullptr)
{
kData->engine->setLastError("Could not find the LV2 Descriptor in the plugin library");
return false;
}

// -----------------------------------------------------------
// get descriptor that matches URI

uint32_t i = 0;
while ((fDescriptor = descFn(i++)))
{
if (std::strcmp(fDescriptor->URI, uri) == 0)
break;
}
}

if (fDescriptor == nullptr)
{
kData->engine->setLastError("Could not find the requested plugin URI in the plugin library");
return false;
}

// ---------------------------------------------------------------
// check supported port-types and features

bool canContinue = true;

// Check supported ports
for (uint32_t i=0; i < fRdfDescriptor->PortCount; ++i)
{
const LV2_Property portTypes(fRdfDescriptor->Ports[i].Types);

if (! (LV2_IS_PORT_AUDIO(portTypes) || LV2_IS_PORT_CONTROL(portTypes) || LV2_IS_PORT_ATOM_SEQUENCE(portTypes) || LV2_IS_PORT_EVENT(portTypes) || LV2_IS_PORT_MIDI_LL(portTypes)))
{
if (! LV2_IS_PORT_OPTIONAL(fRdfDescriptor->Ports[i].Properties))
{
kData->engine->setLastError("Plugin requires a port type that is not currently supported");
canContinue = false;
break;
}
}
}

// Check supported features
for (uint32_t i=0; i < fRdfDescriptor->FeatureCount && canContinue; ++i)
{
if (LV2_IS_FEATURE_REQUIRED(fRdfDescriptor->Features[i].Type) && ! is_lv2_feature_supported(fRdfDescriptor->Features[i].URI))
{
QString msg(QString("Plugin requires a feature that is not supported:\n%1").arg(fRdfDescriptor->Features[i].URI));
kData->engine->setLastError(msg.toUtf8().constData());
canContinue = false;
break;
}
}

#if 0
// Check extensions
for (uint32_t i=0; i < fRdfDescriptor->ExtensionCount; ++i)
{
if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_PROGRAMS__Interface) == 0)
fHints |= PLUGIN_HAS_EXTENSION_PROGRAMS;
else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_STATE__interface) == 0)
fHints |= PLUGIN_HAS_EXTENSION_STATE;
else if (std::strcmp(fRdfDescriptor->Extensions[i], LV2_WORKER__interface) == 0)
fHints |= PLUGIN_HAS_EXTENSION_WORKER;
else
carla_stdout("Plugin has non-supported extension: '%s'", fRdfDescriptor->Extensions[i]);
}
#endif

if (! canContinue)
{
// error already set
return false;
}

// ---------------------------------------------------------------
// get info

if (name != nullptr)
fName = kData->engine->getUniquePluginName(name);
else
fName = kData->engine->getUniquePluginName(fRdfDescriptor->Name);

fFilename = bundle;

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

kData->client = kData->engine->addClient(this);

if (kData->client == nullptr || ! kData->client->isOk())
{
kData->engine->setLastError("Failed to register plugin client");
return false;
}

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

fHandle = fDescriptor->instantiate(fDescriptor, kData->engine->getSampleRate(), fRdfDescriptor->Bundle, nullptr); // TODO: features

if (fHandle == nullptr)
{
kData->engine->setLastError("Plugin failed to initialize");
return false;
}

// ---------------------------------------------------------------
// load plugin settings

{
// set default options
fOptions = 0x0;

fOptions |= PLUGIN_OPTION_FIXED_BUFFER;
fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

if (kData->engine->getOptions().forceStereo)
fOptions |= PLUGIN_OPTION_FORCE_STEREO;

//if (fDescriptor->midiIns > 0)
{
fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;
fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
}

// load settings
kData->idStr = "LV2/";
kData->idStr += uri;
fOptions = kData->loadSettings(fOptions, availableOptions());
}

// ---------------------------------------------------------------
// gui stuff

if (fRdfDescriptor->UICount == 0)
return true;

return true;
}

private:


+ 94
- 60
source/backend/plugin/NativePlugin.cpp View File

@@ -222,6 +222,12 @@ public:
fDescriptor = nullptr;
}

if (fHost.ui_name != nullptr)
{
delete[] fHost.ui_name;
fHost.ui_name = nullptr;
}

clearBuffers();
}

@@ -331,8 +337,7 @@ public:
{
if (const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
{
const ParameterScalePoint& scalePoint = param->scalePoints[scalePointId];

const ParameterScalePoint& scalePoint(param->scalePoints[scalePointId]);
return scalePoint.value;
}
}
@@ -388,7 +393,7 @@ public:

if (fDescriptor->get_parameter_info != nullptr && parameterId < kData->param.count)
{
const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId);
const Parameter* const param(fDescriptor->get_parameter_info(fHandle, parameterId));

if (param != nullptr && param->name != nullptr)
{
@@ -426,7 +431,7 @@ public:

if (fDescriptor->get_parameter_info != nullptr && parameterId < kData->param.count)
{
const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId);
const Parameter* const param(fDescriptor->get_parameter_info(fHandle, parameterId));

if (param != nullptr && param->unit != nullptr)
{
@@ -449,7 +454,7 @@ public:
{
if (const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
{
const ParameterScalePoint& scalePoint = param->scalePoints[scalePointId];
const ParameterScalePoint& scalePoint(param->scalePoints[scalePointId]);

if (scalePoint.label != nullptr)
{
@@ -482,6 +487,23 @@ public:
}
}

// -------------------------------------------------------------------
// Set data (internal stuff)

void setName(const char* const newName) override
{
char uiName[std::strlen(newName)+6+1];
std::strcpy(uiName, newName);
std::strcat(uiName, " (GUI)");

if (fHost.ui_name != nullptr)
delete[] fHost.ui_name;

fHost.ui_name = carla_strdup(uiName);

CarlaPlugin::setName(newName);
}

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -491,7 +513,7 @@ public:
CARLA_ASSERT(fHandle != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const float fixedValue = kData->param.fixValue(parameterId, value);
const float fixedValue(kData->param.fixValue(parameterId, value));

if (fDescriptor->set_parameter_value != nullptr && parameterId < kData->param.count)
{
@@ -1750,7 +1772,60 @@ public:
}

// -------------------------------------------------------------------
// Post-poned events
// Plugin buffers

void initBuffers() override
{
fMidiIn.initBuffers(kData->engine);
fMidiOut.initBuffers(kData->engine);

CarlaPlugin::initBuffers();
}

void clearBuffers() override
{
carla_debug("NativePlugin::clearBuffers() - start");

if (fAudioInBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
{
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = nullptr;
}
}

delete[] fAudioInBuffers;
fAudioInBuffers = nullptr;
}

if (fAudioOutBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
{
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = nullptr;
}
}

delete[] fAudioOutBuffers;
fAudioOutBuffers = nullptr;
}

fMidiIn.clear();
fMidiOut.clear();

CarlaPlugin::clearBuffers();

carla_debug("NativePlugin::clearBuffers() - end");
}

// -------------------------------------------------------------------
// Post-poned UI Stuff

void uiParameterChange(const uint32_t index, const float value) override
{
@@ -1828,59 +1903,6 @@ public:
}

// -------------------------------------------------------------------
// Plugin buffers

void initBuffers() override
{
fMidiIn.initBuffers(kData->engine);
fMidiOut.initBuffers(kData->engine);

CarlaPlugin::initBuffers();
}

void clearBuffers() override
{
carla_debug("NativePlugin::clearBuffers() - start");

if (fAudioInBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioIn.count; ++i)
{
if (fAudioInBuffers[i] != nullptr)
{
delete[] fAudioInBuffers[i];
fAudioInBuffers[i] = nullptr;
}
}

delete[] fAudioInBuffers;
fAudioInBuffers = nullptr;
}

if (fAudioOutBuffers != nullptr)
{
for (uint32_t i=0; i < kData->audioOut.count; ++i)
{
if (fAudioOutBuffers[i] != nullptr)
{
delete[] fAudioOutBuffers[i];
fAudioOutBuffers[i] = nullptr;
}
}

delete[] fAudioOutBuffers;
fAudioOutBuffers = nullptr;
}

fMidiIn.clear();
fMidiOut.clear();

CarlaPlugin::clearBuffers();

carla_debug("NativePlugin::clearBuffers() - end");
}

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

protected:
uint32_t handleGetBufferSize()
@@ -1974,6 +1996,8 @@ protected:
return retStr.isNotEmpty() ? (const char*)retStr : nullptr;
}

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

public:
static size_t getPluginCount()
{
@@ -2056,6 +2080,16 @@ public:
else
fName = kData->engine->getUniquePluginName(label);

{
CARLA_ASSERT(fHost.ui_name == nullptr);

char uiName[fName.length()+6+1];
std::strcpy(uiName, (const char*)fName);
std::strcat(uiName, " (GUI)");

fHost.ui_name = carla_strdup(uiName);
}

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



+ 24
- 4
source/backend/plugin/VstPlugin.cpp View File

@@ -222,6 +222,7 @@ public:
{
CARLA_ASSERT(fEffect != nullptr);

strBuf[0] = '\0';
dispatcher(effGetProductString, 0, 0, strBuf, 0.0f);
}

@@ -229,6 +230,7 @@ public:
{
CARLA_ASSERT(fEffect != nullptr);

strBuf[0] = '\0';
dispatcher(effGetVendorString, 0, 0, strBuf, 0.0f);
}

@@ -236,6 +238,7 @@ public:
{
CARLA_ASSERT(fEffect != nullptr);

strBuf[0] = '\0';
dispatcher(effGetVendorString, 0, 0, strBuf, 0.0f);
}

@@ -243,6 +246,7 @@ public:
{
CARLA_ASSERT(fEffect != nullptr);

strBuf[0] = '\0';
dispatcher(effGetEffectName, 0, 0, strBuf, 0.0f);
}

@@ -251,6 +255,7 @@ public:
CARLA_ASSERT(fEffect != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

strBuf[0] = '\0';
dispatcher(effGetParamName, parameterId, 0, strBuf, 0.0f);
}

@@ -260,7 +265,6 @@ public:
CARLA_ASSERT(parameterId < kData->param.count);

strBuf[0] = '\0';

dispatcher(effGetParamDisplay, parameterId, 0, strBuf, 0.0f);

if (strBuf[0] == '\0')
@@ -272,9 +276,20 @@ public:
CARLA_ASSERT(fEffect != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

strBuf[0] = '\0';
dispatcher(effGetParamLabel, parameterId, 0, strBuf, 0.0f);
}

// -------------------------------------------------------------------
// Set data (state)

// nothing

// -------------------------------------------------------------------
// Set data (internal stuff)

// nothing

// -------------------------------------------------------------------
// Set data (plugin-specific stuff)

@@ -283,7 +298,7 @@ public:
CARLA_ASSERT(fEffect != nullptr);
CARLA_ASSERT(parameterId < kData->param.count);

const float fixedValue = kData->param.fixValue(parameterId, value);
const float fixedValue(kData->param.fixValue(parameterId, value));

fEffect->setParameter(fEffect, parameterId, fixedValue);

@@ -373,7 +388,7 @@ public:
{
if (kData->gui == nullptr)
{
struct CarlaPluginGui::Options guiOptions;
CarlaPluginGui::Options guiOptions;
guiOptions.parented = true;
guiOptions.resizable = false;

@@ -1594,7 +1609,12 @@ public:
}

// -------------------------------------------------------------------
// Post-poned events
// Plugin buffers

// nothing

// -------------------------------------------------------------------
// Post-poned UI Stuff

void uiParameterChange(const uint32_t index, const float value) override
{


Write Preview
Loading…
Cancel
Save