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

Misc fixing

tags/1.9.4
falkTX 11 years ago
parent
10ceab2a47
commit
6cbecccaab
9 changed files with 505 additions and 459 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +5
    -11
      source/backend/plugin/BridgePlugin.cpp
  2. +1
    -1
      source/backend/plugin/CarlaPlugin.cpp
  3. +5
    -8
      source/backend/plugin/DssiPlugin.cpp
  4. +335
    -327
      source/backend/plugin/FluidSynthPlugin.cpp
  5. +4
    -4
      source/backend/plugin/LadspaPlugin.cpp
  6. +137
    -76
      source/backend/plugin/LinuxSamplerPlugin.cpp
  7. +4
    -11
      source/backend/plugin/Lv2Plugin.cpp
  8. +5
    -8
      source/backend/plugin/NativePlugin.cpp
  9. +9
    -13
      source/backend/plugin/VstPlugin.cpp

+ 5
- 11
source/backend/plugin/BridgePlugin.cpp View File

@@ -576,7 +576,7 @@ public:
#endif #endif


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


void showCustomUI(const bool yesNo) override void showCustomUI(const bool yesNo) override
{ {
@@ -1676,17 +1676,11 @@ public:


bool init(const char* const filename, const char* const name, const char* const label, const char* const bridgeBinary) bool init(const char* const filename, const char* const name, const char* const label, const char* const bridgeBinary)
{ {
CARLA_ASSERT(pData->engine != nullptr);
CARLA_ASSERT(pData->client == nullptr);
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);


// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
@@ -1696,7 +1690,7 @@ public:
// --------------------------------------------------------------- // ---------------------------------------------------------------
// set info // set info


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);


pData->filename = filename; pData->filename = filename;
@@ -1823,9 +1817,9 @@ public:


if (pData->name == nullptr) if (pData->name == nullptr)
{ {
if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else if (label != nullptr)
else if (label != nullptr && label[0] != '\0')
pData->name = pData->engine->getUniquePluginName(label); pData->name = pData->engine->getUniquePluginName(label);
else else
pData->name = pData->engine->getUniquePluginName("unknown"); pData->name = pData->engine->getUniquePluginName("unknown");


+ 1
- 1
source/backend/plugin/CarlaPlugin.cpp View File

@@ -1402,7 +1402,7 @@ void CarlaPlugin::setMidiProgramById(const uint32_t bank, const uint32_t program
} }


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


void CarlaPlugin::showCustomUI(const bool yesNo) void CarlaPlugin::showCustomUI(const bool yesNo)
{ {


+ 5
- 8
source/backend/plugin/DssiPlugin.cpp View File

@@ -355,7 +355,7 @@ public:
} }


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


void showCustomUI(const bool yesNo) override void showCustomUI(const bool yesNo) override
{ {
@@ -1756,14 +1756,11 @@ public:


bool init(const char* const filename, const char* const name, const char* const label) bool init(const char* const filename, const char* const name, const char* const label)
{ {
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
@@ -1834,9 +1831,9 @@ public:
// --------------------------------------------------------------- // ---------------------------------------------------------------
// get info // get info


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else if (fDescriptor->Name != nullptr)
else if (fDescriptor->Name != nullptr && fDescriptor->Name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(fDescriptor->Name); pData->name = pData->engine->getUniquePluginName(fDescriptor->Name);
else else
pData->name = pData->engine->getUniquePluginName(fDescriptor->Label); pData->name = pData->engine->getUniquePluginName(fDescriptor->Label);


+ 335
- 327
source/backend/plugin/FluidSynthPlugin.cpp View File

@@ -356,8 +356,6 @@ public:


void prepareForSave() override void prepareForSave() override
{ {
CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

char strBuf[STR_MAX+1]; char strBuf[STR_MAX+1];
std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i", fCurMidiProgs[0], fCurMidiProgs[1], fCurMidiProgs[2], fCurMidiProgs[3], std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i", fCurMidiProgs[0], fCurMidiProgs[1], fCurMidiProgs[2], fCurMidiProgs[3],
fCurMidiProgs[4], fCurMidiProgs[5], fCurMidiProgs[6], fCurMidiProgs[7], fCurMidiProgs[4], fCurMidiProgs[5], fCurMidiProgs[6], fCurMidiProgs[7],
@@ -457,6 +455,8 @@ public:
uint i = 0; uint i = 0;
foreach (const QString& midiProg, midiProgramList) foreach (const QString& midiProg, midiProgramList)
{ {
CARLA_SAFE_ASSERT_BREAK(i < MAX_MIDI_CHANNELS);

bool ok; bool ok;
uint index = midiProg.toUInt(&ok); uint index = midiProg.toUInt(&ok);


@@ -510,7 +510,7 @@ public:
} }


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


// nothing // nothing


@@ -533,7 +533,7 @@ public:


clearBuffers(); clearBuffers();


uint32_t aOuts, params, j;
uint32_t aOuts, params;
aOuts = fUses16Outs ? 32 : 2; aOuts = fUses16Outs ? 32 : 2;
params = FluidSynthParametersMax; params = FluidSynthParametersMax;


@@ -548,7 +548,7 @@ public:


if (fUses16Outs) if (fUses16Outs)
{ {
for (j=0; j < 32; ++j)
for (int i=0; i < 32; ++i)
{ {
portName.clear(); portName.clear();


@@ -560,26 +560,26 @@ public:


portName += "out-"; portName += "out-";


if ((j+2)/2 < 9)
if ((i+2)/2 < 9)
portName += "0"; portName += "0";


portName += CarlaString((j+2)/2);
portName += CarlaString((i+2)/2);


if (j % 2 == 0)
if (i % 2 == 0)
portName += "L"; portName += "L";
else else
portName += "R"; portName += "R";


portName.truncate(portNameSize); portName.truncate(portNameSize);


pData->audioOut.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);
pData->audioOut.ports[j].rindex = j;
pData->audioOut.ports[i].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);
pData->audioOut.ports[i].rindex = i;
} }


fAudio16Buffers = new float*[aOuts]; fAudio16Buffers = new float*[aOuts];


for (j=0; j < aOuts; ++j)
fAudio16Buffers[j] = nullptr;
for (uint32_t i=0; i < aOuts; ++i)
fAudio16Buffers[i] = nullptr;
} }
else else
{ {
@@ -626,7 +626,7 @@ public:
portName += ":"; portName += ":";
} }


portName += "event-in";
portName += "events-in";
portName.truncate(portNameSize); portName.truncate(portNameSize);


pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true); pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true);
@@ -644,235 +644,242 @@ public:
portName += ":"; portName += ":";
} }


portName += "event-out";
portName += "events-out";
portName.truncate(portNameSize); portName.truncate(portNameSize);


pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false); pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false);
} }


// ----------------------
j = FluidSynthReverbOnOff;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/ | PARAMETER_IS_BOOLEAN;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = 1.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbRoomSize;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.2f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_ROOMSIZE;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbDamp;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_DAMP;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbLevel;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = MIDI_CONTROL_REVERB_SEND_LEVEL;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_LEVEL;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbWidth;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 10.0f; // should be 100, but that sounds too much
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_WIDTH;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusOnOff;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_BOOLEAN;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = 1.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusNr;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 99.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_N;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 10.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusLevel;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = 0; //MIDI_CONTROL_CHORUS_SEND_LEVEL;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 10.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_LEVEL;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusSpeedHz;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.29f;
pData->param.ranges[j].max = 5.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_SPEED;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusDepthMs;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = float(2048.0 * 1000.0 / pData->engine->getSampleRate()); // FIXME?
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_DEPTH;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusType;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = FLUID_CHORUS_MOD_SINE;
pData->param.ranges[j].max = FLUID_CHORUS_MOD_TRIANGLE;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_TYPE;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthPolyphony;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 1.0f;
pData->param.ranges[j].max = 512.0f; // max theoric is 65535
pData->param.ranges[j].def = (float)fluid_synth_get_polyphony(fSynth);
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 10.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthInterpolation;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = FLUID_INTERP_NONE;
pData->param.ranges[j].max = FLUID_INTERP_HIGHEST;
pData->param.ranges[j].def = FLUID_INTERP_DEFAULT;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthVoiceCount;
pData->param.data[j].type = PARAMETER_OUTPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 65535.0f;
pData->param.ranges[j].def = 0.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;
// ---------------------------------------
// Parameters

{
int j;

// ----------------------
j = FluidSynthReverbOnOff;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/ | PARAMETER_IS_BOOLEAN;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = 1.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbRoomSize;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.2f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_ROOMSIZE;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbDamp;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_DAMP;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbLevel;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = MIDI_CONTROL_REVERB_SEND_LEVEL;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_LEVEL;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthReverbWidth;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMABLE*/;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 10.0f; // should be 100, but that sounds too much
pData->param.ranges[j].def = FLUID_REVERB_DEFAULT_WIDTH;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusOnOff;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_BOOLEAN;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 1.0f;
pData->param.ranges[j].def = 1.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusNr;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 99.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_N;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 10.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusLevel;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = 0; //MIDI_CONTROL_CHORUS_SEND_LEVEL;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 10.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_LEVEL;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusSpeedHz;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.29f;
pData->param.ranges[j].max = 5.0f;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_SPEED;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusDepthMs;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = float(2048.0 * 1000.0 / pData->engine->getSampleRate()); // FIXME?
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_DEPTH;
pData->param.ranges[j].step = 0.01f;
pData->param.ranges[j].stepSmall = 0.0001f;
pData->param.ranges[j].stepLarge = 0.1f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthChorusType;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = FLUID_CHORUS_MOD_SINE;
pData->param.ranges[j].max = FLUID_CHORUS_MOD_TRIANGLE;
pData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_TYPE;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthPolyphony;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 1.0f;
pData->param.ranges[j].max = 512.0f; // max theoric is 65535
pData->param.ranges[j].def = (float)fluid_synth_get_polyphony(fSynth);
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 10.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthInterpolation;
pData->param.data[j].type = PARAMETER_INPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = FLUID_INTERP_NONE;
pData->param.ranges[j].max = FLUID_INTERP_HIGHEST;
pData->param.ranges[j].def = FLUID_INTERP_DEFAULT;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;

// ----------------------
j = FluidSynthVoiceCount;
pData->param.data[j].type = PARAMETER_OUTPUT;
pData->param.data[j].hints = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE | PARAMETER_IS_INTEGER;
pData->param.data[j].index = j;
pData->param.data[j].rindex = j;
pData->param.data[j].midiChannel = 0;
pData->param.data[j].midiCC = -1;
pData->param.ranges[j].min = 0.0f;
pData->param.ranges[j].max = 65535.0f;
pData->param.ranges[j].def = 0.0f;
pData->param.ranges[j].step = 1.0f;
pData->param.ranges[j].stepSmall = 1.0f;
pData->param.ranges[j].stepLarge = 1.0f;
fParamBuffers[j] = pData->param.ranges[j].def;
}


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


@@ -902,54 +909,58 @@ public:
{ {
carla_debug("FluidSynthPlugin::reloadPrograms(%s)", bool2str(init)); carla_debug("FluidSynthPlugin::reloadPrograms(%s)", bool2str(init));


// save drum info in case we have one program for it
bool hasDrums = false;
uint32_t drumIndex, drumProg;

// Delete old programs // Delete old programs
pData->midiprog.clear(); pData->midiprog.clear();


// Query new programs // Query new programs
uint32_t count = 0; uint32_t count = 0;
fluid_sfont_t* f_sfont;
fluid_preset_t f_preset;


bool hasDrums = false;
uint32_t drumIndex, drumProg;
if (fluid_sfont_t* const f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId))
{
fluid_preset_t f_preset;


f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId);
// initial check to know how many midi-programs we have
f_sfont->iteration_start(f_sfont);
while (f_sfont->iteration_next(f_sfont, &f_preset))
++count;


// initial check to know how much midi-programs we have
f_sfont->iteration_start(f_sfont);
while (f_sfont->iteration_next(f_sfont, &f_preset))
count += 1;
// sound kits must always have at least 1 midi-program
CARLA_SAFE_ASSERT_RETURN(count > 0,);


// soundfonts must always have at least 1 midi-program
CARLA_ASSERT(count > 0);
pData->midiprog.createNew(count);


if (count == 0)
return;
// Update data
uint32_t i = 0;
f_sfont->iteration_start(f_sfont);


pData->midiprog.createNew(count);
while (f_sfont->iteration_next(f_sfont, &f_preset))
{
CARLA_SAFE_ASSERT_BREAK(i < count);


// Update data
uint32_t i = 0;
f_sfont->iteration_start(f_sfont);
pData->midiprog.data[i].bank = f_preset.get_banknum(&f_preset);
pData->midiprog.data[i].program = f_preset.get_num(&f_preset);
pData->midiprog.data[i].name = carla_strdup(f_preset.get_name(&f_preset));


while (f_sfont->iteration_next(f_sfont, &f_preset))
{
CARLA_ASSERT(i < pData->midiprog.count);
pData->midiprog.data[i].bank = f_preset.get_banknum(&f_preset);
pData->midiprog.data[i].program = f_preset.get_num(&f_preset);
pData->midiprog.data[i].name = carla_strdup(f_preset.get_name(&f_preset));
if (pData->midiprog.data[i].bank == 128 && ! hasDrums)
{
hasDrums = true;
drumIndex = i;
drumProg = pData->midiprog.data[i].program;
}


if (pData->midiprog.data[i].bank == 128 && ! hasDrums)
{
hasDrums = true;
drumIndex = i;
drumProg = pData->midiprog.data[i].program;
++i;
} }

++i;
} }

//f_sfont->free(f_sfont);
else
{
// failing means 0 midi-programs, it shouldn't happen!
carla_safe_assert("fluid_sfont_t* const f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId)", __FILE__, __LINE__);
return;
}


#ifndef BUILD_BRIDGE #ifndef BUILD_BRIDGE
// Update OSC Names // Update OSC Names
@@ -957,7 +968,7 @@ public:
{ {
pData->engine->oscSend_control_set_midi_program_count(pData->id, count); pData->engine->oscSend_control_set_midi_program_count(pData->id, count);


for (i=0; i < count; ++i)
for (uint32_t i=0; i < count; ++i)
pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name); pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name);
} }
#endif #endif
@@ -967,7 +978,7 @@ public:
fluid_synth_program_reset(fSynth); fluid_synth_program_reset(fSynth);


// select first program, or 128 for ch10 // select first program, or 128 for ch10
for (i=0; i < MAX_MIDI_CHANNELS && i != 9; ++i)
for (uint32_t i=0; i < MAX_MIDI_CHANNELS && i != 9; ++i)
{ {
#ifdef FLUIDSYNTH_VERSION_NEW_API #ifdef FLUIDSYNTH_VERSION_NEW_API
fluid_synth_set_channel_type(fSynth, i, CHANNEL_TYPE_MELODIC); fluid_synth_set_channel_type(fSynth, i, CHANNEL_TYPE_MELODIC);
@@ -1009,22 +1020,14 @@ public:


void process(float** const, float** const outBuffer, const uint32_t frames) override void process(float** const, float** const outBuffer, const uint32_t frames) override
{ {
uint32_t i, k;

// -------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------
// Check if active // Check if active


if (! pData->active) if (! pData->active)
{ {
// disable any output sound // disable any output sound
for (i=0; i < pData->audioOut.count; ++i)
{
#ifdef HAVE_JUCE
FloatVectorOperations::clear(outBuffer[i], frames);
#else
#endif
}

for (uint32_t i=0; i < pData->audioOut.count; ++i)
FLOAT_CLEAR(outBuffer[i], frames);
return; return;
} }


@@ -1035,21 +1038,21 @@ public:
{ {
if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF) if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
{ {
for (int c=0; c < MAX_MIDI_CHANNELS; ++c)
for (int i=0; i < MAX_MIDI_CHANNELS; ++i)
{ {
#ifdef FLUIDSYNTH_VERSION_NEW_API #ifdef FLUIDSYNTH_VERSION_NEW_API
fluid_synth_all_notes_off(fSynth, c);
fluid_synth_all_sounds_off(fSynth, c);
fluid_synth_all_notes_off(fSynth, i);
fluid_synth_all_sounds_off(fSynth, i);
#else #else
fluid_synth_cc(fSynth, c, MIDI_CONTROL_ALL_SOUND_OFF, 0);
fluid_synth_cc(fSynth, c, MIDI_CONTROL_ALL_NOTES_OFF, 0);
fluid_synth_cc(fSynth, i, MIDI_CONTROL_ALL_SOUND_OFF, 0);
fluid_synth_cc(fSynth, i, MIDI_CONTROL_ALL_NOTES_OFF, 0);
#endif #endif
} }
} }
else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
{ {
for (k=0; k < MAX_MIDI_NOTE; ++k)
fluid_synth_noteoff(fSynth, pData->ctrlChannel, k);
for (int i=0; i < MAX_MIDI_NOTE; ++i)
fluid_synth_noteoff(fSynth, pData->ctrlChannel, i);
} }


pData->needsReset = false; pData->needsReset = false;
@@ -1068,7 +1071,7 @@ public:
{ {
const ExternalMidiNote& note(pData->extNotes.data.getFirst(true)); const ExternalMidiNote& note(pData->extNotes.data.getFirst(true));


CARLA_ASSERT(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);


if (note.velo > 0) if (note.velo > 0)
fluid_synth_noteon(fSynth, note.channel, note.note, note.velo); fluid_synth_noteon(fSynth, note.channel, note.note, note.velo);
@@ -1093,16 +1096,14 @@ public:
if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank; nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;


for (i=0; i < nEvents; ++i)
for (uint32_t i=0; i < nEvents; ++i)
{ {
const EngineEvent& event(pData->event.portIn->getEvent(i)); const EngineEvent& event(pData->event.portIn->getEvent(i));


time = event.time; time = event.time;


if (time >= frames)
continue;

CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);
CARLA_SAFE_ASSERT_CONTINUE(time < frames);
CARLA_SAFE_ASSERT_BREAK(time >= timeOffset);


if (time > timeOffset) if (time > timeOffset)
{ {
@@ -1110,7 +1111,7 @@ public:
{ {
timeOffset = time; timeOffset = time;


if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < 16)
if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank; nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;
} }
} }
@@ -1182,7 +1183,7 @@ public:
#endif #endif


// Control plugin parameters // Control plugin parameters
for (k=0; k < pData->param.count; ++k)
for (uint32_t k=0; k < pData->param.count; ++k)
{ {
if (pData->param.data[k].midiChannel != event.channel) if (pData->param.data[k].midiChannel != event.channel)
continue; continue;
@@ -1230,7 +1231,7 @@ public:
const uint32_t bankId(nextBankIds[event.channel]); const uint32_t bankId(nextBankIds[event.channel]);
const uint32_t progId(ctrlEvent.param); const uint32_t progId(ctrlEvent.param);


for (k=0; k < pData->midiprog.count; ++k)
for (uint32_t k=0; k < pData->midiprog.count; ++k)
{ {
if (pData->midiprog.data[k].bank == bankId && pData->midiprog.data[k].program == progId) if (pData->midiprog.data[k].bank == bankId && pData->midiprog.data[k].program == progId)
{ {
@@ -1328,10 +1329,11 @@ public:
} }
else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) != 0) else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) != 0)
{ {
const uint8_t lsb = midiEvent.data[1];
const uint8_t msb = midiEvent.data[2];
const uint8_t lsb = midiEvent.data[1];
const uint8_t msb = midiEvent.data[2];
const int value = ((msb << 7) | lsb) - 8192;


fluid_synth_pitch_bend(fSynth, channel, (msb << 7) | lsb);
fluid_synth_pitch_bend(fSynth, channel, value);
} }


break; break;
@@ -1352,8 +1354,8 @@ public:
// Control Output // Control Output


{ {
k = FluidSynthVoiceCount;
fParamBuffers[k] = (float)fluid_synth_get_active_voice_count(fSynth);
uint32_t k = FluidSynthVoiceCount;
fParamBuffers[k] = float(fluid_synth_get_active_voice_count(fSynth));
pData->param.ranges[k].fixValue(fParamBuffers[k]); pData->param.ranges[k].fixValue(fParamBuffers[k]);


if (pData->param.data[k].midiCC > 0) if (pData->param.data[k].midiCC > 0)
@@ -1370,8 +1372,6 @@ public:
CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false); CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false);
CARLA_SAFE_ASSERT_RETURN(frames > 0, false); CARLA_SAFE_ASSERT_RETURN(frames > 0, false);


uint32_t i, k;

// -------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------
// Try lock, silence otherwise // Try lock, silence otherwise


@@ -1381,9 +1381,9 @@ public:
} }
else if (! pData->singleMutex.tryLock()) else if (! pData->singleMutex.tryLock())
{ {
for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] = 0.0f; outBuffer[i][k+timeOffset] = 0.0f;
} }


@@ -1395,7 +1395,7 @@ public:


if (fUses16Outs) if (fUses16Outs)
{ {
for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
FLOAT_CLEAR(fAudio16Buffers[i], frames); FLOAT_CLEAR(fAudio16Buffers[i], frames);


fluid_synth_process(fSynth, frames, 0, nullptr, pData->audioOut.count, fAudio16Buffers); fluid_synth_process(fSynth, frames, 0, nullptr, pData->audioOut.count, fAudio16Buffers);
@@ -1414,7 +1414,7 @@ public:


float oldBufLeft[doBalance ? frames : 1]; float oldBufLeft[doBalance ? frames : 1];


for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
{ {
// Balance // Balance
if (doBalance) if (doBalance)
@@ -1425,7 +1425,7 @@ public:
float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f; float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f;
float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f; float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;


for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
{ {
if (i % 2 == 0) if (i % 2 == 0)
{ {
@@ -1445,12 +1445,12 @@ public:
// Volume // Volume
if (fUses16Outs) if (fUses16Outs)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k] * pData->postProc.volume; outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k] * pData->postProc.volume;
} }
else if (doVolume) else if (doVolume)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] *= pData->postProc.volume; outBuffer[i][k+timeOffset] *= pData->postProc.volume;
} }
} }
@@ -1459,9 +1459,9 @@ public:
#else #else
if (fUses16Outs) if (fUses16Outs)
{ {
for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k]; outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k];
} }
} }
@@ -1486,6 +1486,19 @@ public:
} }
} }


void sampleRateChanged(const double newSampleRate) override
{
CARLA_SAFE_ASSERT_RETURN(fSettings != nullptr,);

fluid_settings_setnum(fSettings, "synth.sample-rate", newSampleRate);

#ifdef FLUIDSYNTH_VERSION_NEW_API
CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

fluid_synth_set_sample_rate(fSynth, float(newSampleRate));
#endif
}

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


@@ -1517,23 +1530,18 @@ public:


const void* getExtraStuff() const noexcept override const void* getExtraStuff() const noexcept override
{ {
return fUses16Outs ? (const void*)0x1 : nullptr;
static const char xtrue[] = "true";
static const char xfalse[] = "false";
return fUses16Outs ? xtrue : xfalse;
} }


bool init(const char* const filename, const char* const name, const char* const label) bool init(const char* const filename, const char* const name, const char* const label)
{ {
CARLA_ASSERT(fSynth != nullptr);
CARLA_ASSERT(filename != nullptr);
CARLA_ASSERT(label != nullptr);
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);


// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
@@ -1546,13 +1554,13 @@ public:
return false; return false;
} }


if (filename == nullptr)
if (filename == nullptr || filename[0] == '\0')
{ {
pData->engine->setLastError("null filename"); pData->engine->setLastError("null filename");
return false; return false;
} }


if (label == nullptr)
if (label == nullptr || label[0] == '\0')
{ {
pData->engine->setLastError("null label"); pData->engine->setLastError("null label");
return false; return false;
@@ -1580,7 +1588,7 @@ public:
pData->filename = carla_strdup(filename); pData->filename = carla_strdup(filename);
fLabel = label2.dup(); fLabel = label2.dup();


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else else
pData->name = pData->engine->getUniquePluginName(label); pData->name = pData->engine->getUniquePluginName(label);
@@ -1648,8 +1656,8 @@ private:
const bool fUses16Outs; const bool fUses16Outs;


fluid_settings_t* fSettings; fluid_settings_t* fSettings;
fluid_synth_t* fSynth;
int fSynthId;
fluid_synth_t* fSynth;
int fSynthId;


float** fAudio16Buffers; float** fAudio16Buffers;
float fParamBuffers[FluidSynthParametersMax]; float fParamBuffers[FluidSynthParametersMax];


+ 4
- 4
source/backend/plugin/LadspaPlugin.cpp View File

@@ -387,7 +387,7 @@ public:
} }


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


// nothing // nothing


@@ -1399,11 +1399,11 @@ public:
if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor)) if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor))
fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor); fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor);


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr)
else if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr && fRdfDescriptor->Title[0] != '\0')
pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Title); pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Title);
else if (fDescriptor->Name != nullptr)
else if (fDescriptor->Name != nullptr && fDescriptor->Name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(fDescriptor->Name); pData->name = pData->engine->getUniquePluginName(fDescriptor->Name);
else else
pData->name = pData->engine->getUniquePluginName(fDescriptor->Label); pData->name = pData->engine->getUniquePluginName(fDescriptor->Label);


+ 137
- 76
source/backend/plugin/LinuxSamplerPlugin.cpp View File

@@ -177,8 +177,11 @@ class LinuxSamplerPlugin : public CarlaPlugin
public: public:
LinuxSamplerPlugin(CarlaEngine* const engine, const unsigned int id, const char* const format, const bool use16Outs) LinuxSamplerPlugin(CarlaEngine* const engine, const unsigned int id, const char* const format, const bool use16Outs)
: CarlaPlugin(engine, id), : CarlaPlugin(engine, id),
fFormat(carla_strdup(format)),
fUses16Outs(use16Outs), fUses16Outs(use16Outs),
fFormat(carla_strdup(format)),
fRealName(nullptr),
fLabel(nullptr),
fMaker(nullptr),
fEngine(nullptr), fEngine(nullptr),
fMidiInputDevice(nullptr), fMidiInputDevice(nullptr),
fMidiInputPort(nullptr), fMidiInputPort(nullptr),
@@ -261,6 +264,24 @@ public:
fFormat = nullptr; fFormat = nullptr;
} }


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

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

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

clearBuffers(); clearBuffers();
} }


@@ -296,6 +317,7 @@ public:


options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES; options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES; options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
options |= PLUGIN_OPTION_SEND_PITCHBEND; options |= PLUGIN_OPTION_SEND_PITCHBEND;
options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF; options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;


@@ -304,12 +326,18 @@ public:


void getLabel(char* const strBuf) const override void getLabel(char* const strBuf) const override
{ {
std::strncpy(strBuf, (const char*)fLabel, STR_MAX);
if (fLabel != nullptr)
std::strncpy(strBuf, fLabel, STR_MAX);
else
CarlaPlugin::getLabel(strBuf);
} }


void getMaker(char* const strBuf) const override void getMaker(char* const strBuf) const override
{ {
std::strncpy(strBuf, (const char*)fMaker, STR_MAX);
if (fMaker != nullptr)
std::strncpy(strBuf, fMaker, STR_MAX);
else
CarlaPlugin::getMaker(strBuf);
} }


void getCopyright(char* const strBuf) const override void getCopyright(char* const strBuf) const override
@@ -319,7 +347,10 @@ public:


void getRealName(char* const strBuf) const override void getRealName(char* const strBuf) const override
{ {
std::strncpy(strBuf, (const char*)fRealName, STR_MAX);
if (fRealName != nullptr)
std::strncpy(strBuf, fRealName, STR_MAX);
else
CarlaPlugin::getRealName(strBuf);
} }


// ------------------------------------------------------------------- // -------------------------------------------------------------------
@@ -355,7 +386,7 @@ public:
CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',); CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',); CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
CARLA_SAFE_ASSERT_RETURN(value != nullptr && value[0] != '\0',); CARLA_SAFE_ASSERT_RETURN(value != nullptr && value[0] != '\0',);
carla_debug("DssiPlugin::setCustomData(%s, \"%s\", \"%s\", %s)", type, key, value, bool2str(sendGui));
carla_debug("LinuxSamplerPlugin::setCustomData(%s, \"%s\", \"%s\", %s)", type, key, value, bool2str(sendGui));


if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0) if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0)
return carla_stderr2("LinuxSamplerPlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string", type, key, value, bool2str(sendGui)); return carla_stderr2("LinuxSamplerPlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string", type, key, value, bool2str(sendGui));
@@ -373,6 +404,8 @@ public:
uint i = 0; uint i = 0;
foreach (const QString& midiProg, midiProgramList) foreach (const QString& midiProg, midiProgramList)
{ {
CARLA_SAFE_ASSERT_BREAK(i < MAX_MIDI_CHANNELS);

bool ok; bool ok;
uint index = midiProg.toUInt(&ok); uint index = midiProg.toUInt(&ok);


@@ -426,7 +459,7 @@ public:
const uint32_t program = pData->midiprog.data[index].program; const uint32_t program = pData->midiprog.data[index].program;
const uint32_t rIndex = bank*128 + program; const uint32_t rIndex = bank*128 + program;


LinuxSampler::EngineChannel* const engineChannel(fUses16Outs ? fEngineChannels[pData->ctrlChannel] : fEngineChannels[0]);
LinuxSampler::EngineChannel* const engineChannel(fEngineChannels[pData->ctrlChannel]);


const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback)); const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));


@@ -446,6 +479,11 @@ public:
CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback); CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback);
} }


// -------------------------------------------------------------------
// Set ui stuff

// nothing

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


@@ -470,7 +508,7 @@ public:


pData->audioOut.createNew(aOuts); pData->audioOut.createNew(aOuts);


const int portNameSize = pData->engine->getMaxPortNameSize();
const int portNameSize(pData->engine->getMaxPortNameSize());
CarlaString portName; CarlaString portName;


// --------------------------------------- // ---------------------------------------
@@ -478,7 +516,7 @@ public:


if (fUses16Outs) if (fUses16Outs)
{ {
for (uint32_t i=0; i < 32; ++i)
for (int i=0; i < 32; ++i)
{ {
portName.clear(); portName.clear();


@@ -551,7 +589,7 @@ public:
portName += ":"; portName += ":";
} }


portName += "event-in";
portName += "events-in";
portName.truncate(portNameSize); portName.truncate(portNameSize);


pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true); pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true);
@@ -589,16 +627,17 @@ public:
pData->midiprog.clear(); pData->midiprog.clear();


// Query new programs // Query new programs
uint32_t i, count = (uint32_t)fInstrumentIds.size();
uint32_t count = uint32_t(fInstrumentIds.size());


// sound kits must always have at least 1 midi-program // sound kits must always have at least 1 midi-program
CARLA_SAFE_ASSERT_RETURN(count > 0,); CARLA_SAFE_ASSERT_RETURN(count > 0,);


pData->midiprog.createNew(count); pData->midiprog.createNew(count);


// Update data
LinuxSampler::InstrumentManager::instrument_info_t info; LinuxSampler::InstrumentManager::instrument_info_t info;


for (i=0; i < pData->midiprog.count; ++i)
for (uint32_t i=0; i < pData->midiprog.count; ++i)
{ {
pData->midiprog.data[i].bank = i / 128; pData->midiprog.data[i].bank = i / 128;
pData->midiprog.data[i].program = i % 128; pData->midiprog.data[i].program = i % 128;
@@ -620,7 +659,7 @@ public:
{ {
pData->engine->oscSend_control_set_midi_program_count(pData->id, count); pData->engine->oscSend_control_set_midi_program_count(pData->id, count);


for (i=0; i < count; ++i)
for (uint32_t i=0; i < count; ++i)
pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name); pData->engine->oscSend_control_set_midi_program_data(pData->id, i, pData->midiprog.data[i].bank, pData->midiprog.data[i].program, pData->midiprog.data[i].name);
} }
#endif #endif
@@ -647,6 +686,7 @@ public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Plugin processing // Plugin processing


#if 0
void activate() override void activate() override
{ {
for (int i=0; i < 16; ++i) for (int i=0; i < 16; ++i)
@@ -664,18 +704,17 @@ public:
fAudioOutputDevices[i]->Stop(); fAudioOutputDevices[i]->Stop();
} }
} }
#endif


void process(float** const, float** const outBuffer, const uint32_t frames) override void process(float** const, float** const outBuffer, const uint32_t frames) override
{ {
uint32_t i, k;

// -------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------
// Check if active // Check if active


if (! pData->active) if (! pData->active)
{ {
// disable any output sound // disable any output sound
for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
FLOAT_CLEAR(outBuffer[i], frames); FLOAT_CLEAR(outBuffer[i], frames);
return; return;
} }
@@ -687,16 +726,16 @@ public:
{ {
if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF) if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
{ {
for (k=0, i=MAX_MIDI_CHANNELS; k < MAX_MIDI_CHANNELS; ++k)
for (uint i=0; i < MAX_MIDI_CHANNELS; ++i)
{ {
fMidiInputPort->DispatchControlChange(MIDI_CONTROL_ALL_NOTES_OFF, 0, k);
fMidiInputPort->DispatchControlChange(MIDI_CONTROL_ALL_SOUND_OFF, 0, k);
fMidiInputPort->DispatchControlChange(MIDI_CONTROL_ALL_NOTES_OFF, 0, i);
fMidiInputPort->DispatchControlChange(MIDI_CONTROL_ALL_SOUND_OFF, 0, i);
} }
} }
else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
{ {
for (uint8_t i=0; i < MAX_MIDI_NOTE; ++i) for (uint8_t i=0; i < MAX_MIDI_NOTE; ++i)
fMidiInputPort->DispatchNoteOff(i, 0, (uint)pData->ctrlChannel);
fMidiInputPort->DispatchNoteOff(i, 0, uint(pData->ctrlChannel));
} }


pData->needsReset = false; pData->needsReset = false;
@@ -715,12 +754,12 @@ public:
{ {
const ExternalMidiNote& note(pData->extNotes.data.getFirst(true)); const ExternalMidiNote& note(pData->extNotes.data.getFirst(true));


CARLA_ASSERT(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);


if (note.velo > 0) if (note.velo > 0)
fMidiInputPort->DispatchNoteOn(note.note, note.velo, note.channel, 0);
fMidiInputPort->DispatchNoteOn(note.note, note.velo, note.channel);
else else
fMidiInputPort->DispatchNoteOff(note.note, note.velo, note.channel, 0);
fMidiInputPort->DispatchNoteOff(note.note, note.velo, note.channel);
} }


pData->extNotes.mutex.unlock(); pData->extNotes.mutex.unlock();
@@ -736,21 +775,20 @@ public:
uint32_t time, nEvents = pData->event.portIn->getEventCount(); uint32_t time, nEvents = pData->event.portIn->getEventCount();
uint32_t startTime = 0; uint32_t startTime = 0;
uint32_t timeOffset = 0; uint32_t timeOffset = 0;
uint32_t nextBankId = 0;


if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
uint32_t nextBankIds[MAX_MIDI_CHANNELS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0 };

if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;


for (i=0; i < nEvents; ++i)
for (uint32_t i=0; i < nEvents; ++i)
{ {
const EngineEvent& event(pData->event.portIn->getEvent(i)); const EngineEvent& event(pData->event.portIn->getEvent(i));


time = event.time; time = event.time;


if (time >= frames)
continue;

CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);
CARLA_SAFE_ASSERT_CONTINUE(time < frames);
CARLA_SAFE_ASSERT_BREAK(time >= timeOffset);


if (time > timeOffset && sampleAccurate) if (time > timeOffset && sampleAccurate)
{ {
@@ -759,10 +797,8 @@ public:
startTime = 0; startTime = 0;
timeOffset = time; timeOffset = time;


if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
else
nextBankId = 0;
if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;
} }
else else
startTime += timeOffset; startTime += timeOffset;
@@ -835,7 +871,7 @@ public:
#endif #endif


// Control plugin parameters // Control plugin parameters
for (k=0; k < pData->param.count; ++k)
for (uint32_t k=0; k < pData->param.count; ++k)
{ {
if (pData->param.data[k].midiChannel != event.channel) if (pData->param.data[k].midiChannel != event.channel)
continue; continue;
@@ -873,21 +909,38 @@ public:
} }


case kEngineControlEventTypeMidiBank: case kEngineControlEventTypeMidiBank:
if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
nextBankId = ctrlEvent.param;
if (event.channel < MAX_MIDI_CHANNELS && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
nextBankIds[event.channel] = ctrlEvent.param;
break; break;


case kEngineControlEventTypeMidiProgram: case kEngineControlEventTypeMidiProgram:
if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
if (event.channel < MAX_MIDI_CHANNELS && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)
{ {
const uint32_t nextProgramId = ctrlEvent.param;
const uint32_t bankId(nextBankIds[event.channel]);
const uint32_t progId(ctrlEvent.param);
const uint32_t rIndex = bankId*128 + progId;


for (k=0; k < pData->midiprog.count; ++k)
for (uint32_t k=0; k < pData->midiprog.count; ++k)
{ {
if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)
if (pData->midiprog.data[k].bank == bankId && pData->midiprog.data[k].program == progId)
{ {
setMidiProgram(k, false, false, false);
pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, k, 0, 0.0f);
LinuxSampler::EngineChannel* const engineChannel(fEngineChannels[pData->ctrlChannel]);

if (pData->engine->isOffline())
{
engineChannel->PrepareLoadInstrument(pData->filename, rIndex);
engineChannel->LoadInstrument();
}
else
{
fInstrument->LoadInstrumentInBackground(fInstrumentIds[rIndex], engineChannel);
}

fCurMidiProgs[event.channel] = k;

if (event.channel == pData->ctrlChannel)
pData->postponeRtEvent(kPluginPostRtEventMidiProgramChange, k, 0, 0.0f);

break; break;
} }
} }
@@ -914,7 +967,6 @@ public:
} }
break; break;
} }

break; break;
} }


@@ -925,7 +977,7 @@ public:
uint8_t status = MIDI_GET_STATUS_FROM_DATA(midiEvent.data); uint8_t status = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);
uint8_t channel = event.channel; uint8_t channel = event.channel;


// Fix bad note-off (per DSSI spec)
// Fix bad note-off
if (MIDI_IS_STATUS_NOTE_ON(status) && midiEvent.data[2] == 0) if (MIDI_IS_STATUS_NOTE_ON(status) && midiEvent.data[2] == 0)
status = MIDI_STATUS_NOTE_OFF; status = MIDI_STATUS_NOTE_OFF;


@@ -970,10 +1022,11 @@ public:
} }
else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) != 0) else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) != 0)
{ {
const uint8_t lsb = midiEvent.data[1];
const uint8_t msb = midiEvent.data[2];
const uint8_t lsb = midiEvent.data[1];
const uint8_t msb = midiEvent.data[2];
const int value = ((msb << 7) | lsb) - 8192;


fMidiInputPort->DispatchPitchbend(((msb << 7) | lsb) - 8192, channel, fragmentPos);
fMidiInputPort->DispatchPitchbend(value, channel, fragmentPos);
} }


break; break;
@@ -991,15 +1044,8 @@ public:


bool processSingle(float** const outBuffer, const uint32_t frames, const uint32_t timeOffset) bool processSingle(float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)
{ {
CARLA_ASSERT(outBuffer != nullptr);
CARLA_ASSERT(frames > 0);

if (outBuffer == nullptr)
return false;
if (frames == 0)
return false;

uint32_t i, k;
CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false);
CARLA_SAFE_ASSERT_RETURN(frames > 0, false);


// -------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------
// Try lock, silence otherwise // Try lock, silence otherwise
@@ -1010,9 +1056,9 @@ public:
} }
else if (! pData->singleMutex.tryLock()) else if (! pData->singleMutex.tryLock())
{ {
for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] = 0.0f; outBuffer[i][k+timeOffset] = 0.0f;
} }


@@ -1051,7 +1097,7 @@ public:


float oldBufLeft[doBalance ? frames : 1]; float oldBufLeft[doBalance ? frames : 1];


for (i=0; i < pData->audioOut.count; ++i)
for (uint32_t i=0; i < pData->audioOut.count; ++i)
{ {
// Balance // Balance
if (doBalance) if (doBalance)
@@ -1062,7 +1108,7 @@ public:
float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f; float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f;
float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f; float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;


for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
{ {
if (i % 2 == 0) if (i % 2 == 0)
{ {
@@ -1082,7 +1128,7 @@ public:
// Volume // Volume
if (doVolume) if (doVolume)
{ {
for (k=0; k < frames; ++k)
for (uint32_t k=0; k < frames; ++k)
outBuffer[i][k+timeOffset] *= pData->postProc.volume; outBuffer[i][k+timeOffset] *= pData->postProc.volume;
} }
} }
@@ -1096,6 +1142,18 @@ public:
return true; return true;
} }


void bufferSizeChanged(const uint32_t newBufferSize) override
{
// TODO
(void)newBufferSize;
}

void sampleRateChanged(const double newSampleRate) override
{
// TODO
(void)newSampleRate;
}

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


@@ -1105,7 +1163,9 @@ public:


const void* getExtraStuff() const noexcept override const void* getExtraStuff() const noexcept override
{ {
return fUses16Outs ? (const void*)0x1 : nullptr;
static const char xtrue[] = "true";
static const char xfalse[] = "false";
return fUses16Outs ? xtrue : xfalse;
} }


bool init(const char* filename, const char* const name, const char* label) bool init(const char* filename, const char* const name, const char* label)
@@ -1233,19 +1293,21 @@ public:
return false; return false;
} }


fRealName = info.InstrumentName.c_str();
fLabel = info.Product.c_str();
fMaker = info.Artists.c_str();
CarlaString label2(label);


pData->filename = carla_strdup(filename);
if (fUses16Outs && ! label2.endsWith(" (16 outs)"))
label2 += " (16 outs)";


if (fUses16Outs && ! fLabel.endsWith(" (16 outs)"))
fLabel += " (16 outs)";
fRealName = carla_strdup(info.InstrumentName.c_str());
fLabel = label2.dup();
fMaker = carla_strdup(info.Artists.c_str());


if (name != nullptr)
pData->filename = carla_strdup(filename);

if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else else
pData->name = pData->engine->getUniquePluginName((const char*)fRealName);
pData->name = pData->engine->getUniquePluginName(fRealName);


// --------------------------------------------------------------- // ---------------------------------------------------------------
// Register client // Register client
@@ -1293,15 +1355,14 @@ public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------


private: private:
const char* fFormat;
const bool fUses16Outs; const bool fUses16Outs;
const char* fFormat;
const char* fRealName;
const char* fLabel;
const char* fMaker;


int32_t fCurMidiProgs[16]; int32_t fCurMidiProgs[16];


CarlaString fRealName;
CarlaString fLabel;
CarlaString fMaker;

LinuxSampler::Sampler fSampler; LinuxSampler::Sampler fSampler;
LinuxSampler::Engine* fEngine; LinuxSampler::Engine* fEngine;




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

@@ -1053,7 +1053,7 @@ public:
} }


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


void showCustomUI(const bool yesNo) override void showCustomUI(const bool yesNo) override
{ {
@@ -4123,25 +4123,18 @@ protected:
public: public:
bool init(const char* const name, const char* const uri) bool init(const char* const name, const char* const uri)
{ {
CARLA_ASSERT(pData->engine != nullptr);
CARLA_ASSERT(pData->client == nullptr);
CARLA_ASSERT(uri != nullptr);
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);


// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
return false; return false;
} }


if (uri == nullptr)
if (uri == nullptr || uri[0] == '\0')
{ {
pData->engine->setLastError("null uri"); pData->engine->setLastError("null uri");
return false; return false;
@@ -4403,7 +4396,7 @@ public:
// --------------------------------------------------------------- // ---------------------------------------------------------------
// get info // get info


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else else
pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name); pData->name = pData->engine->getUniquePluginName(fRdfDescriptor->Name);


+ 5
- 8
source/backend/plugin/NativePlugin.cpp View File

@@ -625,7 +625,7 @@ public:
} }


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


void showCustomUI(const bool yesNo) override void showCustomUI(const bool yesNo) override
{ {
@@ -2173,14 +2173,11 @@ public:


bool init(const char* const name, const char* const label) bool init(const char* const name, const char* const label)
{ {
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
@@ -2240,9 +2237,9 @@ public:
// --------------------------------------------------------------- // ---------------------------------------------------------------
// get info // get info


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
else if (fDescriptor->name != nullptr)
else if (fDescriptor->name != nullptr && fDescriptor->name[0] != '\0')
pData->name = pData->engine->getUniquePluginName(fDescriptor->name); pData->name = pData->engine->getUniquePluginName(fDescriptor->name);
else else
pData->name = pData->engine->getUniquePluginName(label); pData->name = pData->engine->getUniquePluginName(label);


+ 9
- 13
source/backend/plugin/VstPlugin.cpp View File

@@ -361,7 +361,7 @@ public:
} }


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


void showCustomUI(const bool yesNo) override void showCustomUI(const bool yesNo) override
{ {
@@ -2139,25 +2139,18 @@ protected:
public: public:
bool init(const char* const filename, const char* const name) bool init(const char* const filename, const char* const name)
{ {
CARLA_ASSERT(pData->engine != nullptr);
CARLA_ASSERT(pData->client == nullptr);
CARLA_ASSERT(filename != nullptr);
CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);


// --------------------------------------------------------------- // ---------------------------------------------------------------
// first checks // first checks


if (pData->engine == nullptr)
{
return false;
}

if (pData->client != nullptr) if (pData->client != nullptr)
{ {
pData->engine->setLastError("Plugin client is already registered"); pData->engine->setLastError("Plugin client is already registered");
return false; return false;
} }


if (filename == nullptr)
if (filename == nullptr || filename[0] == '\0')
{ {
pData->engine->setLastError("null filename"); pData->engine->setLastError("null filename");
return false; return false;
@@ -2218,7 +2211,7 @@ public:
// --------------------------------------------------------------- // ---------------------------------------------------------------
// get info // get info


if (name != nullptr)
if (name != nullptr && name[0] != '\0')
{ {
pData->name = pData->engine->getUniquePluginName(name); pData->name = pData->engine->getUniquePluginName(name);
} }
@@ -2231,10 +2224,13 @@ public:
{ {
pData->name = pData->engine->getUniquePluginName(strBuf); pData->name = pData->engine->getUniquePluginName(strBuf);
} }
else if (const char* const shortname = std::strrchr(filename, OS_SEP))
{
pData->name = pData->engine->getUniquePluginName(shortname+1);
}
else else
{ {
const char* const label = std::strrchr(filename, OS_SEP)+1;
pData->name = pData->engine->getUniquePluginName(label);
pData->name = pData->engine->getUniquePluginName("unknown");
} }
} }




Write Preview
Loading…
Cancel
Save