/* * Carla LADSPA Plugin * Copyright (C) 2011-2013 Filipe Coelho * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * For a full copy of the GNU General Public License see the GPL.txt file */ #include "CarlaPluginInternal.hpp" #ifdef WANT_LADSPA #include "CarlaLadspaUtils.hpp" CARLA_BACKEND_START_NAMESPACE class LadspaPlugin : public CarlaPlugin { public: LadspaPlugin(CarlaEngine* const engine, const unsigned int id) : CarlaPlugin(engine, id), fHandle(nullptr), fHandle2(nullptr), fDescriptor(nullptr), fRdfDescriptor(nullptr), fAudioInBuffers(nullptr), fAudioOutBuffers(nullptr), fParamBuffers(nullptr) { carla_debug("LadspaPlugin::LadspaPlugin(%p, %i)", engine, id); } ~LadspaPlugin() { carla_debug("LadspaPlugin::~LadspaPlugin()"); kData->singleMutex.lock(); kData->masterMutex.lock(); if (fDescriptor != nullptr) { if (fDescriptor->deactivate != nullptr && kData->activeBefore) { if (fHandle != nullptr) fDescriptor->deactivate(fHandle); if (fHandle2 != nullptr) fDescriptor->deactivate(fHandle2); } if (fDescriptor->cleanup != nullptr) { if (fHandle != nullptr) fDescriptor->cleanup(fHandle); if (fHandle2 != nullptr) fDescriptor->cleanup(fHandle2); } fHandle = nullptr; fHandle2 = nullptr; fDescriptor = nullptr; } if (fRdfDescriptor != nullptr) { delete fRdfDescriptor; fRdfDescriptor = nullptr; } deleteBuffers(); } // ------------------------------------------------------------------- // Information (base) PluginType type() const { return PLUGIN_LADSPA; } PluginCategory category() { if (fRdfDescriptor != nullptr) { const LADSPA_PluginType category = fRdfDescriptor->Type; // Specific Types if (category & (LADSPA_PLUGIN_DELAY|LADSPA_PLUGIN_REVERB)) return PLUGIN_CATEGORY_DELAY; if (category & (LADSPA_PLUGIN_PHASER|LADSPA_PLUGIN_FLANGER|LADSPA_PLUGIN_CHORUS)) return PLUGIN_CATEGORY_MODULATOR; if (category & (LADSPA_PLUGIN_AMPLIFIER)) return PLUGIN_CATEGORY_DYNAMICS; if (category & (LADSPA_PLUGIN_UTILITY|LADSPA_PLUGIN_SPECTRAL|LADSPA_PLUGIN_FREQUENCY_METER)) return PLUGIN_CATEGORY_UTILITY; // Pre-set LADSPA Types if (LADSPA_IS_PLUGIN_DYNAMICS(category)) return PLUGIN_CATEGORY_DYNAMICS; if (LADSPA_IS_PLUGIN_AMPLITUDE(category)) return PLUGIN_CATEGORY_MODULATOR; if (LADSPA_IS_PLUGIN_EQ(category)) return PLUGIN_CATEGORY_EQ; if (LADSPA_IS_PLUGIN_FILTER(category)) return PLUGIN_CATEGORY_FILTER; if (LADSPA_IS_PLUGIN_FREQUENCY(category)) return PLUGIN_CATEGORY_UTILITY; if (LADSPA_IS_PLUGIN_SIMULATOR(category)) return PLUGIN_CATEGORY_OTHER; if (LADSPA_IS_PLUGIN_TIME(category)) return PLUGIN_CATEGORY_DELAY; if (LADSPA_IS_PLUGIN_GENERATOR(category)) return PLUGIN_CATEGORY_SYNTH; } return getPluginCategoryFromName(fName); } long uniqueId() const { CARLA_ASSERT(fDescriptor != nullptr); return (fDescriptor != nullptr) ? static_cast(fDescriptor->UniqueID) : 0; } // ------------------------------------------------------------------- // Information (count) uint32_t parameterScalePointCount(const uint32_t parameterId) const { CARLA_ASSERT(parameterId < kData->param.count); const int32_t rindex = kData->param.data[parameterId].rindex; if (fRdfDescriptor != nullptr && rindex < static_cast(fRdfDescriptor->PortCount)) { const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex]; return static_cast(port.ScalePointCount); } return 0; } // ------------------------------------------------------------------- // Information (per-plugin data) unsigned int availableOptions() { #ifdef __USE_GNU const bool isDssiVst = fFilename.contains("dssi-vst", true); #else const bool isDssiVst = fFilename.contains("dssi-vst"); #endif unsigned int options = 0x0; if (! isDssiVst) options |= PLUGIN_OPTION_FIXED_BUFFER; //if ((kData->audioIns.count() == 1 || kData->audioOuts.count() == 0) || (kData->audioIns.count() == 0 || kData->audioOuts.count() == 1)) // options |= PLUGIN_OPTION_FORCE_STEREO; return options; } float getParameterValue(const uint32_t parameterId) { CARLA_ASSERT(parameterId < kData->param.count); return fParamBuffers[parameterId]; } float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) { CARLA_ASSERT(fRdfDescriptor != nullptr); CARLA_ASSERT(parameterId < kData->param.count); CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId)); const int32_t rindex = kData->param.data[parameterId].rindex; if (fRdfDescriptor != nullptr && rindex < static_cast(fRdfDescriptor->PortCount)) { const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex]; if (scalePointId < port.ScalePointCount) { const LADSPA_RDF_ScalePoint& scalePoint = port.ScalePoints[scalePointId]; return scalePoint.Value; } } return 0.0f; } void getLabel(char* const strBuf) { CARLA_ASSERT(fDescriptor != nullptr); if (fDescriptor != nullptr && fDescriptor->Label != nullptr) std::strncpy(strBuf, fDescriptor->Label, STR_MAX); else CarlaPlugin::getLabel(strBuf); } void getMaker(char* const strBuf) { CARLA_ASSERT(fDescriptor != nullptr); if (fRdfDescriptor != nullptr && fRdfDescriptor->Creator != nullptr) std::strncpy(strBuf, fRdfDescriptor->Creator, STR_MAX); else if (fDescriptor != nullptr && fDescriptor->Maker != nullptr) std::strncpy(strBuf, fDescriptor->Maker, STR_MAX); else CarlaPlugin::getMaker(strBuf); } void getCopyright(char* const strBuf) { CARLA_ASSERT(fDescriptor != nullptr); if (fDescriptor != nullptr && fDescriptor->Copyright != nullptr) std::strncpy(strBuf, fDescriptor->Copyright, STR_MAX); else CarlaPlugin::getCopyright(strBuf); } void getRealName(char* const strBuf) { CARLA_ASSERT(fDescriptor != nullptr); if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr) std::strncpy(strBuf, fRdfDescriptor->Title, STR_MAX); else if (fDescriptor != nullptr && fDescriptor->Name != nullptr) std::strncpy(strBuf, fDescriptor->Name, STR_MAX); else CarlaPlugin::getRealName(strBuf); } void getParameterName(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(fDescriptor != nullptr); CARLA_ASSERT(parameterId < kData->param.count); const int32_t rindex = kData->param.data[parameterId].rindex; if (fDescriptor != nullptr && rindex < static_cast(fDescriptor->PortCount)) std::strncpy(strBuf, fDescriptor->PortNames[rindex], STR_MAX); else CarlaPlugin::getParameterName(parameterId, strBuf); } void getParameterSymbol(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(parameterId < kData->param.count); const int32_t rindex = kData->param.data[parameterId].rindex; if (fRdfDescriptor != nullptr && rindex < static_cast(fRdfDescriptor->PortCount)) { const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex]; if (LADSPA_PORT_HAS_LABEL(port.Hints) && port.Label != nullptr) { std::strncpy(strBuf, port.Label, STR_MAX); return; } } CarlaPlugin::getParameterSymbol(parameterId, strBuf); } void getParameterUnit(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(parameterId < kData->param.count); const int32_t rindex = kData->param.data[parameterId].rindex; if (fRdfDescriptor != nullptr && rindex < static_cast(fRdfDescriptor->PortCount)) { const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex]; if (LADSPA_PORT_HAS_UNIT(port.Hints)) { switch (port.Unit) { case LADSPA_UNIT_DB: std::strncpy(strBuf, "dB", STR_MAX); return; case LADSPA_UNIT_COEF: std::strncpy(strBuf, "(coef)", STR_MAX); return; case LADSPA_UNIT_HZ: std::strncpy(strBuf, "Hz", STR_MAX); return; case LADSPA_UNIT_S: std::strncpy(strBuf, "s", STR_MAX); return; case LADSPA_UNIT_MS: std::strncpy(strBuf, "ms", STR_MAX); return; case LADSPA_UNIT_MIN: std::strncpy(strBuf, "min", STR_MAX); return; } } } CarlaPlugin::getParameterUnit(parameterId, strBuf); } void getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) { CARLA_ASSERT(fRdfDescriptor != nullptr); CARLA_ASSERT(parameterId < kData->param.count); CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId)); const int32_t rindex = kData->param.data[parameterId].rindex; if (fRdfDescriptor != nullptr && rindex < static_cast(fRdfDescriptor->PortCount)) { const LADSPA_RDF_Port& port = fRdfDescriptor->Ports[rindex]; if (scalePointId < port.ScalePointCount) { const LADSPA_RDF_ScalePoint& scalePoint = port.ScalePoints[scalePointId]; if (scalePoint.Label != nullptr) { std::strncpy(strBuf, scalePoint.Label, STR_MAX); return; } } } CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf); } // ------------------------------------------------------------------- // Set data (plugin-specific stuff) void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) { CARLA_ASSERT(parameterId < kData->param.count); const float fixedValue = kData->param.fixValue(parameterId, value); fParamBuffers[parameterId] = fixedValue; CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback); } // ------------------------------------------------------------------- // Plugin state void reload() { carla_debug("LadspaPlugin::reload() - start"); CARLA_ASSERT(kData->engine != nullptr); CARLA_ASSERT(fDescriptor != nullptr); CARLA_ASSERT(fHandle != nullptr); const ProcessMode processMode(kData->engine->getProccessMode()); // Safely disable plugin for reload const ScopedDisabler sd(this); deleteBuffers(); const float sampleRate = (float)kData->engine->getSampleRate(); const uint32_t portCount = static_cast(fDescriptor->PortCount); uint32_t aIns, aOuts, params, j; aIns = aOuts = params = 0; bool forcedStereoIn, forcedStereoOut; forcedStereoIn = forcedStereoOut = false; bool needsCtrlIn, needsCtrlOut; needsCtrlIn = needsCtrlOut = false; if (portCount > 0) { CARLA_ASSERT(fDescriptor->PortDescriptors != nullptr); CARLA_ASSERT(fDescriptor->PortRangeHints != nullptr); CARLA_ASSERT(fDescriptor->PortNames != nullptr); for (uint32_t i=0; i < portCount; i++) { const LADSPA_PortDescriptor portType = fDescriptor->PortDescriptors[i]; if (LADSPA_IS_PORT_AUDIO(portType)) { if (LADSPA_IS_PORT_INPUT(portType)) aIns += 1; else if (LADSPA_IS_PORT_OUTPUT(portType)) aOuts += 1; } else if (LADSPA_IS_PORT_CONTROL(portType)) params += 1; } } if ((fOptions & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1)) { if (fHandle2 == nullptr) fHandle2 = fDescriptor->instantiate(fDescriptor, (unsigned long)sampleRate); if (aIns == 1) { aIns = 2; forcedStereoIn = true; } if (aOuts == 1) { aOuts = 2; forcedStereoOut = true; } } if (aIns > 0) { kData->audioIn.createNew(aIns); fAudioInBuffers = new float*[aIns]; for (uint32_t i=0; i < aIns; i++) fAudioInBuffers[i] = nullptr; } if (aOuts > 0) { kData->audioOut.createNew(aOuts); fAudioOutBuffers = new float*[aOuts]; needsCtrlIn = true; for (uint32_t i=0; i < aOuts; i++) fAudioOutBuffers[i] = nullptr; } if (params > 0) { kData->param.createNew(params); fParamBuffers = new float[params]; for (uint32_t i=0; i < params; i++) fParamBuffers[i] = 0.0f; } const uint portNameSize = kData->engine->maxPortNameSize(); CarlaString portName; for (uint32_t i=0, iAudioIn=0, iAudioOut=0, iCtrl=0; i < portCount; i++) { const LADSPA_PortDescriptor portType = fDescriptor->PortDescriptors[i]; const LADSPA_PortRangeHint portRangeHints = fDescriptor->PortRangeHints[i]; const bool hasPortRDF = (fRdfDescriptor != nullptr && i < fRdfDescriptor->PortCount); CARLA_ASSERT(fDescriptor->PortNames[i] != nullptr); if (LADSPA_IS_PORT_AUDIO(portType)) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = fName; portName += ":"; } portName += fDescriptor->PortNames[i]; portName.truncate(portNameSize); if (LADSPA_IS_PORT_INPUT(portType)) { j = iAudioIn++; kData->audioIn.ports[j].port = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true); kData->audioIn.ports[j].rindex = i; if (forcedStereoIn) { portName += "_2"; kData->audioIn.ports[1].port = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, true); kData->audioIn.ports[1].rindex = i; } } else if (LADSPA_IS_PORT_OUTPUT(portType)) { j = iAudioOut++; kData->audioOut.ports[j].port = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false); kData->audioOut.ports[j].rindex = i; if (forcedStereoOut) { portName += "_2"; kData->audioOut.ports[1].port = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false); kData->audioOut.ports[1].rindex = i; } } else carla_stderr2("WARNING - Got a broken Port (Audio, but not input or output)"); } else if (LADSPA_IS_PORT_CONTROL(portType)) { j = iCtrl++; kData->param.data[j].index = j; kData->param.data[j].rindex = i; kData->param.data[j].hints = 0x0; kData->param.data[j].midiChannel = 0; kData->param.data[j].midiCC = -1; float min, max, def, step, stepSmall, stepLarge; // min value if (LADSPA_IS_HINT_BOUNDED_BELOW(portRangeHints.HintDescriptor)) min = portRangeHints.LowerBound; else min = 0.0f; // max value if (LADSPA_IS_HINT_BOUNDED_ABOVE(portRangeHints.HintDescriptor)) max = portRangeHints.UpperBound; else max = 1.0f; if (min > max) max = min; else if (max < min) min = max; if (max - min == 0.0f) { carla_stderr2("WARNING - Broken plugin parameter '%s': max - min == 0.0f", fDescriptor->PortNames[i]); max = min + 0.1f; } // default value if (hasPortRDF && LADSPA_PORT_HAS_DEFAULT(fRdfDescriptor->Ports[i].Hints)) def = fRdfDescriptor->Ports[i].Default; else def = get_default_ladspa_port_value(portRangeHints.HintDescriptor, min, max); if (def < min) def = min; else if (def > max) def = max; if (LADSPA_IS_HINT_SAMPLE_RATE(portRangeHints.HintDescriptor)) { min *= sampleRate; max *= sampleRate; def *= sampleRate; kData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE; } if (LADSPA_IS_HINT_TOGGLED(portRangeHints.HintDescriptor)) { step = max - min; stepSmall = step; stepLarge = step; kData->param.data[j].hints |= PARAMETER_IS_BOOLEAN; } else if (LADSPA_IS_HINT_INTEGER(portRangeHints.HintDescriptor)) { step = 1.0f; stepSmall = 1.0f; stepLarge = 10.0f; kData->param.data[j].hints |= PARAMETER_IS_INTEGER; } else { float range = max - min; step = range/100.0f; stepSmall = range/1000.0f; stepLarge = range/10.0f; } if (LADSPA_IS_PORT_INPUT(portType)) { kData->param.data[j].type = PARAMETER_INPUT; kData->param.data[j].hints |= PARAMETER_IS_ENABLED; kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE; needsCtrlIn = true; } else if (LADSPA_IS_PORT_OUTPUT(portType)) { if (std::strcmp(fDescriptor->PortNames[i], "latency") == 0 || std::strcmp(fDescriptor->PortNames[i], "_latency") == 0) { min = 0.0f; max = sampleRate; def = 0.0f; step = 1.0f; stepSmall = 1.0f; stepLarge = 1.0f; kData->param.data[j].type = PARAMETER_LATENCY; kData->param.data[j].hints = 0; } else if (std::strcmp(fDescriptor->PortNames[i], "_sample-rate") == 0) { def = sampleRate; step = 1.0f; stepSmall = 1.0f; stepLarge = 1.0f; kData->param.data[j].type = PARAMETER_SAMPLE_RATE; kData->param.data[j].hints = 0; } else { kData->param.data[j].type = PARAMETER_OUTPUT; kData->param.data[j].hints |= PARAMETER_IS_ENABLED; kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE; needsCtrlOut = true; } } else { kData->param.data[j].type = PARAMETER_UNKNOWN; carla_stderr2("WARNING - Got a broken Port (Control, but not input or output)"); } // extra parameter hints if (LADSPA_IS_HINT_LOGARITHMIC(portRangeHints.HintDescriptor)) kData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC; // check for scalepoints, require at least 2 to make it useful if (hasPortRDF && fRdfDescriptor->Ports[i].ScalePointCount > 1) kData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS; kData->param.ranges[j].min = min; kData->param.ranges[j].max = max; kData->param.ranges[j].def = def; kData->param.ranges[j].step = step; kData->param.ranges[j].stepSmall = stepSmall; kData->param.ranges[j].stepLarge = stepLarge; // Start parameters in their default values fParamBuffers[j] = def; fDescriptor->connect_port(fHandle, i, &fParamBuffers[j]); if (fHandle2 != nullptr) fDescriptor->connect_port(fHandle2, i, &fParamBuffers[j]); } else { // Not Audio or Control carla_stderr2("ERROR - Got a broken Port (neither Audio or Control)"); fDescriptor->connect_port(fHandle, i, nullptr); if (fHandle2 != nullptr) fDescriptor->connect_port(fHandle2, i, nullptr); } } if (needsCtrlIn) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = fName; portName += ":"; } portName += "event-in"; portName.truncate(portNameSize); kData->event.portIn = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true); } if (needsCtrlOut) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = fName; portName += ":"; } portName += "event-out"; portName.truncate(portNameSize); kData->event.portOut = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false); } // plugin hints fHints = 0x0; if (aOuts > 0 && (aIns == aOuts || aIns == 1)) fHints |= PLUGIN_CAN_DRYWET; if (aOuts > 0) fHints |= PLUGIN_CAN_VOLUME; if (aOuts >= 2 && aOuts % 2 == 0) fHints |= PLUGIN_CAN_BALANCE; // extra plugin hints kData->extraHints = 0x0; if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0)) kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK; // plugin options fOptions = 0x0; if (forcedStereoIn || forcedStereoOut) fOptions |= PLUGIN_OPTION_FORCE_STEREO; // check latency if (fHints & PLUGIN_CAN_DRYWET) { for (uint32_t i=0; i < kData->param.count; i++) { if (kData->param.data[i].type != PARAMETER_LATENCY) continue; // we need to pre-run the plugin so it can update its latency control-port float tmpIn[aIns][2]; float tmpOut[aOuts][2]; for (j=0; j < aIns; j++) { tmpIn[j][0] = 0.0f; tmpIn[j][1] = 0.0f; fDescriptor->connect_port(fHandle, kData->audioIn.ports[j].rindex, tmpIn[j]); } for (j=0; j < aOuts; j++) { tmpOut[j][0] = 0.0f; tmpOut[j][1] = 0.0f; fDescriptor->connect_port(fHandle, kData->audioOut.ports[j].rindex, tmpOut[j]); } if (fDescriptor->activate != nullptr) fDescriptor->activate(fHandle); fDescriptor->run(fHandle, 2); if (fDescriptor->deactivate != nullptr) fDescriptor->deactivate(fHandle); const uint32_t latency = (uint32_t)fParamBuffers[i]; if (kData->latency != latency) { kData->latency = latency; kData->client->setLatency(latency); recreateLatencyBuffers(); } break; } } bufferSizeChanged(kData->engine->getBufferSize()); carla_debug("LadspaPlugin::reload() - end"); } // ------------------------------------------------------------------- // Plugin processing void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) { uint32_t i, k; // -------------------------------------------------------------------------------------------------------- // Check if active if (! kData->active) { // disable any output sound for (i=0; i < kData->audioOut.count; i++) carla_zeroFloat(outBuffer[i], frames); if (kData->activeBefore) { if (fDescriptor->deactivate != nullptr) { fDescriptor->deactivate(fHandle); if (fHandle2 != nullptr) fDescriptor->deactivate(fHandle2); } } kData->activeBefore = kData->active; return; } // -------------------------------------------------------------------------------------------------------- // Check if not active before if (kData->needsReset || ! kData->activeBefore) { if (kData->latency > 0) { for (i=0; i < kData->audioIn.count; i++) carla_zeroFloat(kData->latencyBuffers[i], kData->latency); } if (kData->activeBefore) { if (fDescriptor->deactivate != nullptr) { fDescriptor->deactivate(fHandle); if (fHandle2 != nullptr) fDescriptor->deactivate(fHandle2); } } if (fDescriptor->activate != nullptr) { fDescriptor->activate(fHandle); if (fHandle2 != nullptr) fDescriptor->activate(fHandle2); } kData->needsReset = false; } // -------------------------------------------------------------------------------------------------------- // Event Input and Processing if (kData->event.portIn != nullptr && kData->activeBefore) { // ---------------------------------------------------------------------------------------------------- // Event Input (System) bool sampleAccurate = (fOptions & PLUGIN_OPTION_FIXED_BUFFER) == 0; uint32_t time, nEvents = kData->event.portIn->getEventCount(); uint32_t timeOffset = 0; for (i=0; i < nEvents; i++) { const EngineEvent& event = kData->event.portIn->getEvent(i); time = event.time; if (time >= frames) continue; CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset); if (time > timeOffset && sampleAccurate) { if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset)) timeOffset = time; } // Control change switch (event.type) { case kEngineEventTypeNull: break; case kEngineEventTypeControl: { const EngineControlEvent& ctrlEvent = event.ctrl; switch (ctrlEvent.type) { case kEngineControlEventTypeNull: break; case kEngineControlEventTypeParameter: { // Control backend stuff if (event.channel == kData->ctrlChannel) { float value; if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0) { value = ctrlEvent.value; setDryWet(value, false, false); postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value); continue; } if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0) { value = ctrlEvent.value*127.0f/100.0f; setVolume(value, false, false); postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value); continue; } if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0) { float left, right; value = ctrlEvent.value/0.5f - 1.0f; if (value < 0.0f) { left = -1.0f; right = (value*2.0f)+1.0f; } else if (value > 0.0f) { left = (value*2.0f)-1.0f; right = 1.0f; } else { left = -1.0f; right = 1.0f; } setBalanceLeft(left, false, false); setBalanceRight(right, false, false); postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left); postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right); continue; } } // Control plugin parameters for (k=0; k < kData->param.count; k++) { if (kData->param.data[k].midiChannel != event.channel) continue; if (kData->param.data[k].midiCC != ctrlEvent.param) continue; if (kData->param.data[k].type != PARAMETER_INPUT) continue; if ((kData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0) continue; float value; if (kData->param.data[k].hints & PARAMETER_IS_BOOLEAN) { value = (ctrlEvent.value < 0.5f) ? kData->param.ranges[k].min : kData->param.ranges[k].max; } else { value = kData->param.ranges[i].unnormalizeValue(ctrlEvent.value); if (kData->param.data[k].hints & PARAMETER_IS_INTEGER) value = std::rint(value); } setParameterValue(k, value, false, false, false); postponeRtEvent(kPluginPostRtEventParameterChange, static_cast(k), 0, value); } break; } case kEngineControlEventTypeMidiBank: case kEngineControlEventTypeMidiProgram: break; case kEngineControlEventTypeAllSoundOff: if (event.channel == kData->ctrlChannel) { if (fDescriptor->deactivate != nullptr) { fDescriptor->deactivate(fHandle); if (fHandle2 != nullptr) fDescriptor->deactivate(fHandle2); } if (fDescriptor->activate != nullptr) { fDescriptor->activate(fHandle); if (fHandle2 != nullptr) fDescriptor->activate(fHandle2); } postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 0.0f); postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 1.0f); } break; case kEngineControlEventTypeAllNotesOff: break; } break; } case kEngineEventTypeMidi: // ignored in LADSPA break; } } kData->postRtEvents.trySplice(); if (frames > timeOffset) processSingle(inBuffer, outBuffer, frames - timeOffset, timeOffset); } // End of Event Input and Processing // -------------------------------------------------------------------------------------------------------- // Plugin processing (no events) else { processSingle(inBuffer, outBuffer, frames, 0); } // End of Plugin processing (no events) // -------------------------------------------------------------------------------------------------------- // Special Parameters #if 0 CARLA_PROCESS_CONTINUE_CHECK; for (k=0; k < param.count; k++) { if (param.data[k].type == PARAMETER_LATENCY) { // TODO } } CARLA_PROCESS_CONTINUE_CHECK; #endif CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Control Output if (kData->event.portOut != nullptr) { uint8_t channel; uint16_t param; float value; for (k=0; k < kData->param.count; k++) { if (kData->param.data[k].type != PARAMETER_OUTPUT) continue; kData->param.ranges[k].fixValue(fParamBuffers[k]); if (kData->param.data[k].midiCC > 0) { channel = kData->param.data[k].midiChannel; param = static_cast(kData->param.data[k].midiCC); value = kData->param.ranges[k].normalizeValue(fParamBuffers[k]); kData->event.portOut->writeControlEvent(0, channel, kEngineControlEventTypeParameter, param, value); } } } // End of Control Output // -------------------------------------------------------------------------------------------------------- kData->activeBefore = kData->active; } bool processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset) { uint32_t i, k; // -------------------------------------------------------------------------------------------------------- // Try lock, silence otherwise if (kData->engine->isOffline()) { kData->singleMutex.lock(); } else if (! kData->singleMutex.tryLock()) { for (i=0; i < kData->audioOut.count; i++) { for (k=0; k < frames; k++) outBuffer[i][k+timeOffset] = 0.0f; } return false; } // -------------------------------------------------------------------------------------------------------- // Fill plugin buffers for (i=0; i < kData->audioIn.count; i++) carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames); for (i=0; i < kData->audioOut.count; i++) carla_zeroFloat(fAudioOutBuffers[i], frames); // -------------------------------------------------------------------------------------------------------- // Run plugin fDescriptor->run(fHandle, frames); if (fHandle2 != nullptr) fDescriptor->run(fHandle2, frames); // -------------------------------------------------------------------------------------------------------- // Post-processing (dry/wet, volume and balance) { const bool doDryWet = (fHints & PLUGIN_CAN_DRYWET) > 0 && kData->postProc.dryWet != 1.0f; const bool doBalance = (fHints & PLUGIN_CAN_BALANCE) > 0 && (kData->postProc.balanceLeft != -1.0f || kData->postProc.balanceRight != 1.0f); float bufValue, oldBufLeft[doBalance ? frames : 1]; for (i=0; i < kData->audioOut.count; i++) { // Dry/Wet if (doDryWet) { for (k=0; k < frames; k++) { // TODO //if (k < kData->latency && kData->latency < frames) // bufValue = (kData->audioIn.count == 1) ? kData->latencyBuffers[0][k] : kData->latencyBuffers[i][k]; //else // bufValue = (kData->audioIn.count == 1) ? inBuffer[0][k-m_latency] : inBuffer[i][k-m_latency]; bufValue = fAudioInBuffers[(kData->audioIn.count == 1) ? 0 : i][k]; fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * kData->postProc.dryWet) + (bufValue * (1.0f - kData->postProc.dryWet)); } } // Balance if (doBalance) { if (i % 2 == 0) carla_copyFloat(oldBufLeft, fAudioOutBuffers[i], frames); float balRangeL = (kData->postProc.balanceLeft + 1.0f)/2.0f; float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f; for (k=0; k < frames; k++) { if (i % 2 == 0) { // left fAudioOutBuffers[i][k] = oldBufLeft[k] * (1.0f - balRangeL); fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR); } else { // right fAudioOutBuffers[i][k] = fAudioOutBuffers[i][k] * balRangeR; fAudioOutBuffers[i][k] += oldBufLeft[k] * balRangeL; } } } // Volume (and buffer copy) { for (k=0; k < frames; k++) outBuffer[i][k+timeOffset] = fAudioOutBuffers[i][k] * kData->postProc.volume; } } #if 0 // Latency, save values for next callback, TODO if (kData->latency > 0 && kData->latency < frames) { for (i=0; i < kData->audioIn.count; i++) carla_copyFloat(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), kData->latency); } #endif } // End of Post-processing // -------------------------------------------------------------------------------------------------------- kData->singleMutex.unlock(); return true; } void bufferSizeChanged(const uint32_t newBufferSize) { carla_debug("LadspaPlugin::bufferSizeChanged(%i) - start", newBufferSize); for (uint32_t i=0; i < kData->audioIn.count; i++) { if (fAudioInBuffers[i] != nullptr) delete[] fAudioInBuffers[i]; fAudioInBuffers[i] = new float[newBufferSize]; } for (uint32_t i=0; i < kData->audioOut.count; i++) { if (fAudioOutBuffers[i] != nullptr) delete[] fAudioOutBuffers[i]; fAudioOutBuffers[i] = new float[newBufferSize]; } if (fHandle2 == nullptr) { for (uint32_t i=0; i < kData->audioIn.count; i++) { CARLA_ASSERT(fAudioInBuffers[i] != nullptr); fDescriptor->connect_port(fHandle, kData->audioIn.ports[i].rindex, fAudioInBuffers[i]); } for (uint32_t i=0; i < kData->audioOut.count; i++) { CARLA_ASSERT(fAudioOutBuffers[i] != nullptr); fDescriptor->connect_port(fHandle, kData->audioOut.ports[i].rindex, fAudioOutBuffers[i]); } } else { if (kData->audioIn.count > 0) { CARLA_ASSERT(kData->audioIn.count == 2); CARLA_ASSERT(fAudioInBuffers[0] != nullptr); CARLA_ASSERT(fAudioInBuffers[1] != nullptr); fDescriptor->connect_port(fHandle, kData->audioIn.ports[0].rindex, fAudioInBuffers[0]); fDescriptor->connect_port(fHandle2, kData->audioIn.ports[1].rindex, fAudioInBuffers[1]); } if (kData->audioOut.count > 0) { CARLA_ASSERT(kData->audioOut.count == 2); CARLA_ASSERT(fAudioOutBuffers[0] != nullptr); CARLA_ASSERT(fAudioOutBuffers[1] != nullptr); fDescriptor->connect_port(fHandle, kData->audioOut.ports[0].rindex, fAudioOutBuffers[0]); fDescriptor->connect_port(fHandle2, kData->audioOut.ports[1].rindex, fAudioOutBuffers[1]); } } carla_debug("LadspaPlugin::bufferSizeChanged(%i) - end", newBufferSize); } // ------------------------------------------------------------------- // Cleanup void deleteBuffers() { carla_debug("LadspaPlugin::deleteBuffers() - start"); if (fAudioInBuffers != nullptr) { for (uint32_t i=0; i < kData->audioIn.count; i++) { if (fAudioInBuffers[i] != nullptr) { delete[] fAudioInBuffers[i]; fAudioInBuffers[i] = nullptr; } } delete[] fAudioInBuffers; fAudioInBuffers = nullptr; } if (fAudioOutBuffers != nullptr) { for (uint32_t i=0; i < kData->audioOut.count; i++) { if (fAudioOutBuffers[i] != nullptr) { delete[] fAudioOutBuffers[i]; fAudioOutBuffers[i] = nullptr; } } delete[] fAudioOutBuffers; fAudioOutBuffers = nullptr; } if (fParamBuffers != nullptr) { delete[] fParamBuffers; fParamBuffers = nullptr; } CarlaPlugin::deleteBuffers(); carla_debug("LadspaPlugin::deleteBuffers() - end"); } // ------------------------------------------------------------------- bool init(const char* const filename, const char* const name, const char* const label, const LADSPA_RDF_Descriptor* const rdfDescriptor) { CARLA_ASSERT(kData->engine != nullptr); CARLA_ASSERT(kData->client == nullptr); CARLA_ASSERT(filename != nullptr); CARLA_ASSERT(label != nullptr); // --------------------------------------------------------------- // open DLL if (! libOpen(filename)) { kData->engine->setLastError(libError(filename)); return false; } // --------------------------------------------------------------- // get DLL main entry const LADSPA_Descriptor_Function descFn = (LADSPA_Descriptor_Function)libSymbol("ladspa_descriptor"); if (descFn == nullptr) { kData->engine->setLastError("Could not find the LASDPA Descriptor in the plugin library"); return false; } // --------------------------------------------------------------- // get descriptor that matches label unsigned long i = 0; while ((fDescriptor = descFn(i++)) != nullptr) { if (fDescriptor->Label != nullptr && std::strcmp(fDescriptor->Label, label) == 0) break; } if (fDescriptor == nullptr) { kData->engine->setLastError("Could not find the requested plugin label in the plugin library"); return false; } // --------------------------------------------------------------- // get info if (is_ladspa_rdf_descriptor_valid(rdfDescriptor, fDescriptor)) fRdfDescriptor = ladspa_rdf_dup(rdfDescriptor); if (name != nullptr) fName = kData->engine->getNewUniquePluginName(name); else if (fRdfDescriptor != nullptr && fRdfDescriptor->Title != nullptr) fName = kData->engine->getNewUniquePluginName(fRdfDescriptor->Title); else if (fDescriptor->Name != nullptr) fName = kData->engine->getNewUniquePluginName(fDescriptor->Name); else fName = kData->engine->getNewUniquePluginName(fDescriptor->Label); fFilename = filename; // --------------------------------------------------------------- // register client kData->client = kData->engine->addClient(this); if (kData->client == nullptr || ! kData->client->isOk()) { kData->engine->setLastError("Failed to register plugin client"); return false; } // --------------------------------------------------------------- // initialize plugin fHandle = fDescriptor->instantiate(fDescriptor, (unsigned long)kData->engine->getSampleRate()); if (fHandle == nullptr) { kData->engine->setLastError("Plugin failed to initialize"); return false; } return true; } private: LADSPA_Handle fHandle; LADSPA_Handle fHandle2; const LADSPA_Descriptor* fDescriptor; const LADSPA_RDF_Descriptor* fRdfDescriptor; float** fAudioInBuffers; float** fAudioOutBuffers; float* fParamBuffers; CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LadspaPlugin) }; CARLA_BACKEND_END_NAMESPACE #else // WANT_LADSPA # warning Building without LADSPA support #endif CARLA_BACKEND_START_NAMESPACE CarlaPlugin* CarlaPlugin::newLADSPA(const Initializer& init, const LADSPA_RDF_Descriptor* const rdfDescriptor) { carla_debug("CarlaPlugin::newLADSPA({%p, \"%s\", \"%s\", \"%s\"}, %p)", init.engine, init.filename, init.name, init.label, rdfDescriptor); #ifdef WANT_LADSPA LadspaPlugin* const plugin = new LadspaPlugin(init.engine, init.id); if (! plugin->init(init.filename, init.name, init.label, rdfDescriptor)) { delete plugin; return nullptr; } plugin->reload(); if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! CarlaPluginProtectedData::canRunInRack(plugin)) { init.engine->setLastError("Carla's rack mode can only work with Mono or Stereo LADSPA plugins, sorry!"); delete plugin; return nullptr; } return plugin; #else init.engine->setLastError("LADSPA support not available"); return nullptr; #endif } CARLA_BACKEND_END_NAMESPACE