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

Continue work on plugin host code

tags/1.9.4
falkTX 12 years ago
parent
5921f2fa26
commit
99c8e26d90
8 changed files with 175 additions and 142 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +17
    -0
      source/backend/CarlaBackend.hpp
  2. +0
    -5
      source/backend/plugin/CarlaPlugin.cpp
  3. +0
    -2
      source/backend/plugin/CarlaPluginInternal.hpp
  4. +135
    -113
      source/backend/plugin/DssiPlugin.cpp
  5. +17
    -14
      source/backend/plugin/LadspaPlugin.cpp
  6. +3
    -2
      source/backend/plugin/Lv2Plugin.cpp
  7. +2
    -5
      source/backend/plugin/VstPlugin.cpp
  8. +1
    -1
      source/carla.kdev4

+ 17
- 0
source/backend/CarlaBackend.hpp View File

@@ -760,6 +760,23 @@ struct ParameterRanges {
return normValue; return normValue;
} }


float getNormalizedFixedValue(const float& value) const noexcept
{
if (value <= min)
return 0.0f;
if (value >= max)
return 1.0f;

const float normValue((value - min) / (max - min));

if (normValue <= 0.0f)
return 0.0f;
if (normValue >= 1.0f)
return 1.0f;

return normValue;
}

float getUnnormalizedValue(const float& value) const noexcept float getUnnormalizedValue(const float& value) const noexcept
{ {
return value * (max - min) + min; return value * (max - min) + min;


+ 0
- 5
source/backend/plugin/CarlaPlugin.cpp View File

@@ -100,11 +100,6 @@ void* CarlaPluginProtectedData::uiLibSymbol(const char* const symbol)
return lib_symbol(uiLib, symbol); return lib_symbol(uiLib, symbol);
} }


const char* CarlaPluginProtectedData::libError(const char* const filename)
{
return lib_error(filename);
}

// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Settings functions, defined in CarlaPluginInternal.hpp // Settings functions, defined in CarlaPluginInternal.hpp




+ 0
- 2
source/backend/plugin/CarlaPluginInternal.hpp View File

@@ -799,8 +799,6 @@ struct CarlaPluginProtectedData {
bool uiLibClose(); bool uiLibClose();
void* uiLibSymbol(const char* const symbol); void* uiLibSymbol(const char* const symbol);


const char* libError(const char* const filename);

// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Settings functions, see CarlaPlugin.cpp // Settings functions, see CarlaPlugin.cpp




+ 135
- 113
source/backend/plugin/DssiPlugin.cpp View File

@@ -20,6 +20,7 @@
#ifdef WANT_DSSI #ifdef WANT_DSSI


#include "CarlaDssiUtils.hpp" #include "CarlaDssiUtils.hpp"
#include "CarlaLibUtils.hpp"


CARLA_BACKEND_START_NAMESPACE CARLA_BACKEND_START_NAMESPACE


@@ -945,15 +946,13 @@ public:


void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override void process(float** const inBuffer, 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)
carla_zeroFloat(outBuffer[i], frames); carla_zeroFloat(outBuffer[i], frames);


return; return;
@@ -968,43 +967,42 @@ public:
{ {
if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF) if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
{ {
for (unsigned char j=0, l=MAX_MIDI_CHANNELS; j < MAX_MIDI_CHANNELS; ++j)
{
carla_zeroStruct<snd_seq_event_t>(fMidiEvents[j]);
carla_zeroStruct<snd_seq_event_t>(fMidiEvents[j+l]);
midiEventCount = MAX_MIDI_CHANNELS*2;
carla_zeroStruct<snd_seq_event_t>(fMidiEvents, midiEventCount);


fMidiEvents[j].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[j].data.control.channel = j;
fMidiEvents[j].data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;
for (unsigned char i=0, k=MAX_MIDI_CHANNELS; i < MAX_MIDI_CHANNELS; ++i)
{
fMidiEvents[i].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[i].data.control.channel = i;
fMidiEvents[i].data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;


fMidiEvents[j+l].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[j+l].data.control.channel = j;
fMidiEvents[j+l].data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
fMidiEvents[k+i].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[k+i].data.control.channel = i;
fMidiEvents[k+i].data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
} }

midiEventCount = MAX_MIDI_CHANNELS*2;
} }
else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
{ {
for (unsigned char j=0; j < MAX_MIDI_NOTE; ++j)
{
carla_zeroStruct<snd_seq_event_t>(fMidiEvents[j]);
midiEventCount = MAX_MIDI_NOTE;
carla_zeroStruct<snd_seq_event_t>(fMidiEvents, midiEventCount);


fMidiEvents[j].type = SND_SEQ_EVENT_NOTEOFF;
fMidiEvents[j].data.note.channel = pData->ctrlChannel;
fMidiEvents[j].data.note.note = j;
for (unsigned char i=0; i < MAX_MIDI_NOTE; ++i)
{
fMidiEvents[i].type = SND_SEQ_EVENT_NOTEOFF;
fMidiEvents[i].data.note.channel = pData->ctrlChannel;
fMidiEvents[i].data.note.note = i;
} }

midiEventCount = MAX_MIDI_NOTE;
} }


if (pData->latency > 0) if (pData->latency > 0)
{ {
for (i=0; i < pData->audioIn.count; ++i)
for (uint32_t i=0; i < pData->audioIn.count; ++i)
carla_zeroFloat(pData->latencyBuffers[i], pData->latency); carla_zeroFloat(pData->latencyBuffers[i], pData->latency);
} }


pData->needsReset = false; pData->needsReset = false;

CARLA_PROCESS_CONTINUE_CHECK;
} }


// -------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------
@@ -1021,14 +1019,15 @@ 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);


fMidiEvents[midiEventCount].type = (note.velo > 0) ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;
fMidiEvents[midiEventCount].data.note.channel = note.channel;
fMidiEvents[midiEventCount].data.note.note = note.note;
fMidiEvents[midiEventCount].data.note.velocity = note.velo;
snd_seq_event_t& midiEvent(fMidiEvents[midiEventCount++]);
carla_zeroStruct<snd_seq_event_t>(midiEvent);


midiEventCount += 1;
midiEvent.type = (note.velo > 0) ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;
midiEvent.data.note.channel = note.channel;
midiEvent.data.note.note = note.note;
midiEvent.data.note.velocity = note.velo;
} }


pData->extNotes.mutex.unlock(); pData->extNotes.mutex.unlock();
@@ -1038,10 +1037,10 @@ public:
// ---------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------
// Event Input (System) // Event Input (System)


bool allNotesOffSent = false;
bool sampleAccurate = (fOptions & PLUGIN_OPTION_FIXED_BUFFERS) == 0;
bool allNotesOffSent = false;
bool isSampleAccurate = (fOptions & PLUGIN_OPTION_FIXED_BUFFERS) == 0;


uint32_t time, nEvents = pData->event.portIn->getEventCount();
uint32_t time, numEvents = pData->event.portIn->getEventCount();
uint32_t startTime = 0; uint32_t startTime = 0;
uint32_t timeOffset = 0; uint32_t timeOffset = 0;
uint32_t nextBankId = 0; uint32_t nextBankId = 0;
@@ -1049,18 +1048,20 @@ public:
if (pData->midiprog.current >= 0 && pData->midiprog.count > 0) if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
nextBankId = pData->midiprog.data[pData->midiprog.current].bank; nextBankId = pData->midiprog.data[pData->midiprog.current].bank;


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


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


CARLA_ASSERT_INT2(time < frames, time, frames);

if (time >= frames) if (time >= frames)
continue; continue;


CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset); CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);


if (time > timeOffset && sampleAccurate)
if (time > timeOffset && isSampleAccurate)
{ {
if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset, midiEventCount)) if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset, midiEventCount))
{ {
@@ -1077,7 +1078,6 @@ public:
startTime += timeOffset; startTime += timeOffset;
} }


// Control change
switch (event.type) switch (event.type)
{ {
case kEngineEventTypeNull: case kEngineEventTypeNull:
@@ -1085,7 +1085,7 @@ public:


case kEngineEventTypeControl: case kEngineEventTypeControl:
{ {
const EngineControlEvent& ctrlEvent = event.ctrl;
const EngineControlEvent& ctrlEvent(event.ctrl);


switch (ctrlEvent.type) switch (ctrlEvent.type)
{ {
@@ -1100,21 +1100,21 @@ public:
{ {
float value; float value;


if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0)
if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) != 0)
{ {
value = ctrlEvent.value; value = ctrlEvent.value;
setDryWet(value, false, false); setDryWet(value, false, false);
pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value); pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);
} }


if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0)
if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) != 0)
{ {
value = ctrlEvent.value*127.0f/100.0f; value = ctrlEvent.value*127.0f/100.0f;
setVolume(value, false, false); setVolume(value, false, false);
pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value); pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);
} }


if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0)
if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) != 0)
{ {
float left, right; float left, right;
value = ctrlEvent.value/0.5f - 1.0f; value = ctrlEvent.value/0.5f - 1.0f;
@@ -1144,7 +1144,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;
@@ -1178,16 +1178,15 @@ public:
if (midiEventCount >= kPluginMaxMidiEvents) if (midiEventCount >= kPluginMaxMidiEvents)
continue; continue;


carla_zeroStruct<snd_seq_event_t>(fMidiEvents[midiEventCount]);
snd_seq_event_t& midiEvent(fMidiEvents[midiEventCount++]);
carla_zeroStruct<snd_seq_event_t>(midiEvent);


fMidiEvents[midiEventCount].time.tick = sampleAccurate ? startTime : time;
midiEvent.time.tick = isSampleAccurate ? startTime : time;


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[midiEventCount].data.control.channel = event.channel;
fMidiEvents[midiEventCount].data.control.param = ctrlEvent.param;
fMidiEvents[midiEventCount].data.control.value = ctrlEvent.value*127.0f;

midiEventCount += 1;
midiEvent.type = SND_SEQ_EVENT_CONTROLLER;
midiEvent.data.control.channel = event.channel;
midiEvent.data.control.param = ctrlEvent.param;
midiEvent.data.control.value = ctrlEvent.value*127.0f;
} }


break; break;
@@ -1203,7 +1202,7 @@ public:
{ {
const uint32_t nextProgramId = ctrlEvent.param; const uint32_t nextProgramId = 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 == nextBankId && pData->midiprog.data[k].program == nextProgramId) if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)
{ {
@@ -1221,15 +1220,14 @@ public:
if (midiEventCount >= kPluginMaxMidiEvents) if (midiEventCount >= kPluginMaxMidiEvents)
continue; continue;


carla_zeroStruct<snd_seq_event_t>(fMidiEvents[midiEventCount]);

fMidiEvents[midiEventCount].time.tick = sampleAccurate ? startTime : time;
snd_seq_event_t& midiEvent(fMidiEvents[midiEventCount++]);
carla_zeroStruct<snd_seq_event_t>(midiEvent);


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[midiEventCount].data.control.channel = event.channel;
fMidiEvents[midiEventCount].data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
midiEvent.time.tick = isSampleAccurate ? startTime : time;


midiEventCount += 1;
midiEvent.type = SND_SEQ_EVENT_CONTROLLER;
midiEvent.data.control.channel = event.channel;
midiEvent.data.control.param = MIDI_CONTROL_ALL_SOUND_OFF;
} }
break; break;


@@ -1245,13 +1243,14 @@ public:
if (midiEventCount >= kPluginMaxMidiEvents) if (midiEventCount >= kPluginMaxMidiEvents)
continue; continue;


carla_zeroStruct<snd_seq_event_t>(fMidiEvents[midiEventCount]);
snd_seq_event_t& midiEvent(fMidiEvents[midiEventCount++]);
carla_zeroStruct<snd_seq_event_t>(midiEvent);


fMidiEvents[midiEventCount].time.tick = sampleAccurate ? startTime : time;
midiEvent.time.tick = isSampleAccurate ? startTime : time;


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[midiEventCount].data.control.channel = event.channel;
fMidiEvents[midiEventCount].data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;
midiEvent.type = SND_SEQ_EVENT_CONTROLLER;
midiEvent.data.control.channel = event.channel;
midiEvent.data.control.param = MIDI_CONTROL_ALL_NOTES_OFF;


midiEventCount += 1; midiEventCount += 1;
} }
@@ -1266,83 +1265,105 @@ public:
if (midiEventCount >= kPluginMaxMidiEvents) if (midiEventCount >= kPluginMaxMidiEvents)
continue; continue;


const EngineMidiEvent& midiEvent(event.midi);
const EngineMidiEvent& engineEvent(event.midi);


uint8_t status = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);
uint8_t status = MIDI_GET_STATUS_FROM_DATA(engineEvent.data);
uint8_t channel = event.channel; uint8_t channel = event.channel;


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


carla_zeroStruct<snd_seq_event_t>(fMidiEvents[midiEventCount]);
snd_seq_event_t& midiEvent(fMidiEvents[midiEventCount]);
carla_zeroStruct<snd_seq_event_t>(midiEvent);


fMidiEvents[midiEventCount].time.tick = sampleAccurate ? startTime : time;
midiEvent.time.tick = isSampleAccurate ? startTime : time;


if (MIDI_IS_STATUS_NOTE_OFF(status))
switch (status)
{
case MIDI_STATUS_NOTE_OFF:
{ {
const uint8_t note = midiEvent.data[1];
const uint8_t note = engineEvent.data[1];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_NOTEOFF;
fMidiEvents[midiEventCount].data.note.channel = channel;
fMidiEvents[midiEventCount].data.note.note = note;
midiEvent.type = SND_SEQ_EVENT_NOTEOFF;
midiEvent.data.note.channel = channel;
midiEvent.data.note.note = note;


pData->postponeRtEvent(kPluginPostRtEventNoteOff, channel, note, 0.0f); pData->postponeRtEvent(kPluginPostRtEventNoteOff, channel, note, 0.0f);
break;
} }
else if (MIDI_IS_STATUS_NOTE_ON(status))
case MIDI_STATUS_NOTE_ON:
{ {
const uint8_t note = midiEvent.data[1];
const uint8_t velo = midiEvent.data[2];
const uint8_t note = engineEvent.data[1];
const uint8_t velo = engineEvent.data[2];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_NOTEON;
fMidiEvents[midiEventCount].data.note.channel = channel;
fMidiEvents[midiEventCount].data.note.note = note;
fMidiEvents[midiEventCount].data.note.velocity = velo;
midiEvent.type = SND_SEQ_EVENT_NOTEON;
midiEvent.data.note.channel = channel;
midiEvent.data.note.note = note;
midiEvent.data.note.velocity = velo;


pData->postponeRtEvent(kPluginPostRtEventNoteOn, channel, note, velo); pData->postponeRtEvent(kPluginPostRtEventNoteOn, channel, note, velo);
break;
} }
else if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) != 0)
case MIDI_STATUS_POLYPHONIC_AFTERTOUCH:
{ {
const uint8_t note = midiEvent.data[1];
const uint8_t pressure = midiEvent.data[2];
if (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)
{
const uint8_t note = engineEvent.data[1];
const uint8_t pressure = engineEvent.data[2];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_KEYPRESS;
fMidiEvents[midiEventCount].data.note.channel = channel;
fMidiEvents[midiEventCount].data.note.note = note;
fMidiEvents[midiEventCount].data.note.velocity = pressure;
midiEvent.type = SND_SEQ_EVENT_KEYPRESS;
midiEvent.data.note.channel = channel;
midiEvent.data.note.note = note;
midiEvent.data.note.velocity = pressure;
}
break;
} }
else if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0)
case MIDI_STATUS_CONTROL_CHANGE:
{ {
const uint8_t control = midiEvent.data[1];
const uint8_t value = midiEvent.data[2];
if (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES)
{
const uint8_t control = engineEvent.data[1];
const uint8_t value = engineEvent.data[2];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_CONTROLLER;
fMidiEvents[midiEventCount].data.control.channel = channel;
fMidiEvents[midiEventCount].data.control.param = control;
fMidiEvents[midiEventCount].data.control.value = value;
midiEvent.type = SND_SEQ_EVENT_CONTROLLER;
midiEvent.data.control.channel = channel;
midiEvent.data.control.param = control;
midiEvent.data.control.value = value;
}
break;
} }
else if (MIDI_IS_STATUS_CHANNEL_PRESSURE(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) != 0)
case MIDI_STATUS_CHANNEL_PRESSURE:
{ {
const uint8_t pressure = midiEvent.data[1];
if (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)
{
const uint8_t pressure = engineEvent.data[1];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_CHANPRESS;
fMidiEvents[midiEventCount].data.control.channel = channel;
fMidiEvents[midiEventCount].data.control.value = pressure;
midiEvent.type = SND_SEQ_EVENT_CHANPRESS;
midiEvent.data.control.channel = channel;
midiEvent.data.control.value = pressure;
}
break;
} }
else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (fOptions & PLUGIN_OPTION_SEND_PITCHBEND) != 0)
case MIDI_STATUS_PITCH_WHEEL_CONTROL:
{ {
const uint8_t lsb = midiEvent.data[1];
const uint8_t msb = midiEvent.data[2];
if (fOptions & PLUGIN_OPTION_SEND_PITCHBEND)
{
const uint8_t lsb = engineEvent.data[1];
const uint8_t msb = engineEvent.data[2];


fMidiEvents[midiEventCount].type = SND_SEQ_EVENT_PITCHBEND;
fMidiEvents[midiEventCount].data.control.channel = channel;
fMidiEvents[midiEventCount].data.control.value = ((msb << 7) | lsb) - 8192;
midiEvent.type = SND_SEQ_EVENT_PITCHBEND;
midiEvent.data.control.channel = channel;
midiEvent.data.control.value = ((msb << 7) | lsb) - 8192;
}
break;
} }
else
default:
continue; continue;
break;
}


midiEventCount += 1; midiEventCount += 1;

break; break;
} }
} }
@@ -1375,18 +1396,16 @@ public:
uint16_t param; uint16_t param;
float value; float value;


for (k=0; k < pData->param.count; ++k)
for (uint32_t k=0; k < pData->param.count; ++k)
{ {
if (pData->param.data[k].type != PARAMETER_OUTPUT) if (pData->param.data[k].type != PARAMETER_OUTPUT)
continue; continue;


pData->param.ranges[k].fixValue(fParamBuffers[k]);

if (pData->param.data[k].midiCC > 0) if (pData->param.data[k].midiCC > 0)
{ {
channel = pData->param.data[k].midiChannel; channel = pData->param.data[k].midiChannel;
param = static_cast<uint16_t>(pData->param.data[k].midiCC); param = static_cast<uint16_t>(pData->param.data[k].midiCC);
value = pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]);
value = pData->param.ranges[k].getNormalizedFixedValue(fParamBuffers[k]);
pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value); pData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value);
} }
} }
@@ -1750,13 +1769,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;
@@ -1767,7 +1786,7 @@ public:


if (! pData->libOpen(filename)) if (! pData->libOpen(filename))
{ {
pData->engine->setLastError(pData->libError(filename));
pData->engine->setLastError(lib_error(filename));
return false; return false;
} }


@@ -1823,6 +1842,9 @@ public:


fFilename = filename; fFilename = filename;


CARLA_ASSERT(fName.isNotEmpty());
CARLA_ASSERT(fFilename.isNotEmpty());

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




+ 17
- 14
source/backend/plugin/LadspaPlugin.cpp View File

@@ -20,6 +20,7 @@
#ifdef WANT_LADSPA #ifdef WANT_LADSPA


#include "CarlaLadspaUtils.hpp" #include "CarlaLadspaUtils.hpp"
#include "CarlaLibUtils.hpp"


CARLA_BACKEND_START_NAMESPACE CARLA_BACKEND_START_NAMESPACE


@@ -845,15 +846,13 @@ public:


void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override void process(float** const inBuffer, 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)
carla_zeroFloat(outBuffer[i], frames); carla_zeroFloat(outBuffer[i], frames);


return; return;
@@ -866,7 +865,7 @@ public:
{ {
if (pData->latency > 0) if (pData->latency > 0)
{ {
for (i=0; i < pData->audioIn.count; ++i)
for (uint32_t i=0; i < pData->audioIn.count; ++i)
carla_zeroFloat(pData->latencyBuffers[i], pData->latency); carla_zeroFloat(pData->latencyBuffers[i], pData->latency);
} }


@@ -881,12 +880,12 @@ public:
// ---------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------
// Event Input (System) // Event Input (System)


bool sampleAccurate = (fOptions & PLUGIN_OPTION_FIXED_BUFFERS) == 0;
bool isSampleAccurate = (fOptions & PLUGIN_OPTION_FIXED_BUFFERS) == 0;


uint32_t time, nEvents = pData->event.portIn->getEventCount();
uint32_t time, numEvents = pData->event.portIn->getEventCount();
uint32_t timeOffset = 0; uint32_t timeOffset = 0;


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


@@ -897,7 +896,7 @@ public:


CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset); CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);


if (time > timeOffset && sampleAccurate)
if (time > timeOffset && isSampleAccurate)
{ {
if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset)) if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset))
timeOffset = time; timeOffset = time;
@@ -970,7 +969,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;
@@ -1045,7 +1044,7 @@ public:
uint16_t param; uint16_t param;
float value; float value;


for (k=0; k < pData->param.count; ++k)
for (uint32_t k=0; k < pData->param.count; ++k)
{ {
if (pData->param.data[k].type != PARAMETER_OUTPUT) if (pData->param.data[k].type != PARAMETER_OUTPUT)
continue; continue;
@@ -1343,13 +1342,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;
@@ -1360,7 +1359,7 @@ public:


if (! pData->libOpen(filename)) if (! pData->libOpen(filename))
{ {
pData->engine->setLastError(pData->libError(filename));
pData->engine->setLastError(lib_error(filename));
return false; return false;
} }


@@ -1408,6 +1407,9 @@ public:


fFilename = filename; fFilename = filename;


CARLA_ASSERT(fName.isNotEmpty());
CARLA_ASSERT(fFilename.isNotEmpty());

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


@@ -1454,7 +1456,8 @@ public:
pData->idStr += label; pData->idStr += label;
fOptions = pData->loadSettings(fOptions, getAvailableOptions()); fOptions = pData->loadSettings(fOptions, getAvailableOptions());


if (isDssiVst) // ignore settings, we need this anyway
// ignore settings, we need this anyway
if (isDssiVst)
fOptions |= PLUGIN_OPTION_FIXED_BUFFERS; fOptions |= PLUGIN_OPTION_FIXED_BUFFERS;
} }




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

@@ -20,6 +20,7 @@
#ifdef WANT_LV2 #ifdef WANT_LV2


#include "CarlaLv2Utils.hpp" #include "CarlaLv2Utils.hpp"
#include "CarlaLibUtils.hpp"
#include "Lv2AtomQueue.hpp" #include "Lv2AtomQueue.hpp"


#include "../engine/CarlaEngineOsc.hpp" #include "../engine/CarlaEngineOsc.hpp"
@@ -4165,7 +4166,7 @@ public:


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


@@ -4642,7 +4643,7 @@ public:


if (! pData->uiLibOpen(fUi.rdfDescriptor->Binary)) if (! pData->uiLibOpen(fUi.rdfDescriptor->Binary))
{ {
carla_stderr2("Could not load UI library, error was:\n%s", pData->libError(fUi.rdfDescriptor->Binary));
carla_stderr2("Could not load UI library, error was:\n%s", lib_error(fUi.rdfDescriptor->Binary));
fUi.rdfDescriptor = nullptr; fUi.rdfDescriptor = nullptr;
return true; return true;
} }


+ 2
- 5
source/backend/plugin/VstPlugin.cpp View File

@@ -20,10 +20,7 @@
#ifdef WANT_VST #ifdef WANT_VST


#include "CarlaVstUtils.hpp" #include "CarlaVstUtils.hpp"

//#ifdef Q_WS_X11
//# include <QtGui/QX11Info>
//#endif
#include "CarlaLibUtils.hpp"


CARLA_BACKEND_START_NAMESPACE CARLA_BACKEND_START_NAMESPACE


@@ -2166,7 +2163,7 @@ public:


if (! pData->libOpen(filename)) if (! pData->libOpen(filename))
{ {
pData->engine->setLastError(pData->libError(filename));
pData->engine->setLastError(lib_error(filename));
return false; return false;
} }




+ 1
- 1
source/carla.kdev4 View File

@@ -1,5 +1,5 @@
[Project] [Project]
Manager=KDevCustomMakeManager
Manager=KDevGenericManager
Name=Carla Name=Carla


[Filters] [Filters]


Write Preview
Loading…
Cancel
Save