/* * Carla VST 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_VST #include "CarlaVstUtils.hpp" #ifdef Q_WS_X11 # include #endif CARLA_BACKEND_START_NAMESPACE /*! * @defgroup PluginHints Plugin Hints * @{ */ const unsigned int PLUGIN_CAN_PROCESS_REPLACING = 0x1000; //!< VST Plugin cas use processReplacing() const unsigned int PLUGIN_HAS_COCKOS_EXTENSIONS = 0x2000; //!< VST Plugin has Cockos extensions const unsigned int PLUGIN_USES_OLD_VSTSDK = 0x4000; //!< VST Plugin uses an old VST SDK const unsigned int PLUGIN_WANTS_MIDI_INPUT = 0x8000; //!< VST Plugin wants MIDI input /**@}*/ class VstPlugin : public CarlaPlugin { public: VstPlugin(CarlaEngine* const engine, const unsigned short id) : CarlaPlugin(engine, id) { carla_debug("VstPlugin::VstPlugin(%p, %i)", engine, id); #if 0 effect = nullptr; events.numEvents = 0; events.reserved = 0; gui.type = GUI_NONE; gui.visible = false; gui.width = 0; gui.height = 0; isProcessing = false; needIdle = false; vstTimeOffset = 0; memset(midiEvents, 0, sizeof(VstMidiEvent)*MAX_MIDI_EVENTS*2); for (unsigned short i=0; i < MAX_MIDI_EVENTS*2; i++) events.data[i] = (VstEvent*)&midiEvents[i]; // make plugin valid srand(id); unique1 = unique2 = rand(); #endif kData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_VST_GUI); } ~VstPlugin() { carla_debug("VstPlugin::~VstPlugin()"); #if 0 // make plugin invalid unique2 += 1; if (effect) { // close UI if (m_hints & PLUGIN_HAS_GUI) { showGui(false); if (gui.type == GUI_EXTERNAL_OSC) { if (osc.thread) { // Wait a bit first, try safe quit, then force kill if (osc.thread->isRunning() && ! osc.thread->wait(x_engine->getOptions().oscUiTimeout)) { carla_stderr("Failed to properly stop VST OSC GUI thread"); osc.thread->terminate(); } delete osc.thread; } } else effect->dispatcher(effect, effEditClose, 0, 0, nullptr, 0.0f); } if (m_activeBefore) effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effClose, 0, 0, nullptr, 0.0f); } #endif } // ------------------------------------------------------------------- // Information (base) PluginType type() const { return PLUGIN_VST; } #if 0 PluginCategory category() { CARLA_ASSERT(effect); if (effect) { intptr_t category = effect->dispatcher(effect, effGetPlugCategory, 0, 0, nullptr, 0.0f); switch (category) { case kPlugCategSynth: return PLUGIN_CATEGORY_SYNTH; case kPlugCategAnalysis: return PLUGIN_CATEGORY_UTILITY; case kPlugCategMastering: return PLUGIN_CATEGORY_DYNAMICS; case kPlugCategRoomFx: return PLUGIN_CATEGORY_DELAY; case kPlugCategRestoration: return PLUGIN_CATEGORY_UTILITY; case kPlugCategGenerator: return PLUGIN_CATEGORY_SYNTH; } if (effect->flags & effFlagsIsSynth) return PLUGIN_CATEGORY_SYNTH; } return getPluginCategoryFromName(m_name); } long uniqueId() { CARLA_ASSERT(effect); return effect ? effect->uniqueID : 0; } // ------------------------------------------------------------------- // Information (current data) int32_t chunkData(void** const dataPtr) { CARLA_ASSERT(dataPtr); CARLA_ASSERT(effect); if (effect) return effect->dispatcher(effect, effGetChunk, 0 /* bank */, 0, dataPtr, 0.0f); return 0; } // ------------------------------------------------------------------- // Information (per-plugin data) double getParameterValue(const uint32_t parameterId) { CARLA_ASSERT(effect); CARLA_ASSERT(parameterId < param.count); if (effect) return effect->getParameter(effect, parameterId); return 0.0; } void getLabel(char* const strBuf) { CARLA_ASSERT(effect); if (effect) effect->dispatcher(effect, effGetProductString, 0, 0, strBuf, 0.0f); else CarlaPlugin::getLabel(strBuf); } void getMaker(char* const strBuf) { CARLA_ASSERT(effect); if (effect) effect->dispatcher(effect, effGetVendorString, 0, 0, strBuf, 0.0f); else CarlaPlugin::getMaker(strBuf); } void getCopyright(char* const strBuf) { CARLA_ASSERT(effect); if (effect) effect->dispatcher(effect, effGetVendorString, 0, 0, strBuf, 0.0f); else CarlaPlugin::getCopyright(strBuf); } void getRealName(char* const strBuf) { CARLA_ASSERT(effect); if (effect) effect->dispatcher(effect, effGetEffectName, 0, 0, strBuf, 0.0f); else CarlaPlugin::getRealName(strBuf); } void getParameterName(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(effect); CARLA_ASSERT(parameterId < param.count); if (effect) effect->dispatcher(effect, effGetParamName, parameterId, 0, strBuf, 0.0f); else CarlaPlugin::getParameterName(parameterId, strBuf); } void getParameterText(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(effect); CARLA_ASSERT(parameterId < param.count); if (effect) { effect->dispatcher(effect, effGetParamDisplay, parameterId, 0, strBuf, 0.0f); if (*strBuf == 0) sprintf(strBuf, "%f", getParameterValue(parameterId)); } else CarlaPlugin::getParameterText(parameterId, strBuf); } void getParameterUnit(const uint32_t parameterId, char* const strBuf) { CARLA_ASSERT(effect); CARLA_ASSERT(parameterId < param.count); if (effect) effect->dispatcher(effect, effGetParamLabel, parameterId, 0, strBuf, 0.0f); else CarlaPlugin::getParameterUnit(parameterId, strBuf); } void getGuiInfo(GuiType* const type, bool* const resizable) { *type = gui.type; *resizable = false; } // ------------------------------------------------------------------- // Set data (plugin-specific stuff) void setParameterValue(const uint32_t parameterId, double value, const bool sendGui, const bool sendOsc, const bool sendCallback) { CARLA_ASSERT(parameterId < param.count); effect->setParameter(effect, parameterId, fixParameterValue(value, param.ranges[parameterId])); CarlaPlugin::setParameterValue(parameterId, value, sendGui, sendOsc, sendCallback); } void setChunkData(const char* const stringData) { CARLA_ASSERT(m_hints & PLUGIN_USES_CHUNKS); CARLA_ASSERT(stringData); static QByteArray chunk; chunk = QByteArray::fromBase64(stringData); if (x_engine->isOffline()) { const CarlaEngine::ScopedLocker m(x_engine); effect->dispatcher(effect, effSetChunk, 0 /* bank */, chunk.size(), chunk.data(), 0.0f); } else { const CarlaPlugin::ScopedDisabler m(this); effect->dispatcher(effect, effSetChunk, 0 /* bank */, chunk.size(), chunk.data(), 0.0f); } } void setProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool block) { CARLA_ASSERT(index >= -1 && index < (int32_t)prog.count); if (index < -1) index = -1; else if (index > (int32_t)prog.count) return; if (index >= 0) { if (x_engine->isOffline()) { const CarlaEngine::ScopedLocker m(x_engine, block); effect->dispatcher(effect, effBeginSetProgram, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effSetProgram, 0, index, nullptr, 0.0f); effect->dispatcher(effect, effEndSetProgram, 0, 0, nullptr, 0.0f); } else { const ScopedDisabler m(this, block); effect->dispatcher(effect, effBeginSetProgram, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effSetProgram, 0, index, nullptr, 0.0f); effect->dispatcher(effect, effEndSetProgram, 0, 0, nullptr, 0.0f); } } CarlaPlugin::setProgram(index, sendGui, sendOsc, sendCallback, block); } // ------------------------------------------------------------------- // Set gui stuff void setGuiContainer(GuiContainer* const container) { carla_debug("VstPlugin::setGuiContainer(%p)", container); CARLA_ASSERT(container); if (gui.type == GUI_EXTERNAL_OSC) return; int32_t value = 0; void* const ptr = (void*)container->winId(); ERect* vstRect = nullptr; #ifdef Q_WS_X11 value = (intptr_t)QX11Info::display(); #endif // get UI size before opening UI, plugin may refuse this effect->dispatcher(effect, effEditGetRect, 0, 0, &vstRect, 0.0f); if (vstRect) { int width = vstRect->right - vstRect->left; int height = vstRect->bottom - vstRect->top; if (width > 0 || height > 0) { container->setFixedSize(width, height); #ifdef BUILD_BRIDGE x_engine->callback(CALLBACK_RESIZE_GUI, m_id, width, height, 1.0, nullptr); #endif } } // open UI if (effect->dispatcher(effect, effEditOpen, 0, value, ptr, 0.0f) == 1) { // get UI size again, can't fail now vstRect = nullptr; effect->dispatcher(effect, effEditGetRect, 0, 0, &vstRect, 0.0f); if (vstRect) { int width = vstRect->right - vstRect->left; int height = vstRect->bottom - vstRect->top; if (width <= 0 || height <= 0) { carla_stderr2("VstPlugin::setGuiContainer(%p) - failed to get proper editor size", container); return; } gui.width = width; gui.height = height; container->setFixedSize(width, height); carla_debug("VstPlugin::setGuiContainer(%p) -> setFixedSize(%i, %i)", container, width, height); } else carla_stderr2("VstPlugin::setGuiContainer(%p) - failed to get plugin editor size", container); } else { // failed to open UI carla_stderr("VstPlugin::setGuiContainer(%p) - failed to open UI", container); m_hints &= ~PLUGIN_HAS_GUI; x_engine->callback(CALLBACK_SHOW_GUI, m_id, -1, 0, 0.0, nullptr); effect->dispatcher(effect, effEditClose, 0, 0, nullptr, 0.0f); } } void showGui(const bool yesNo) { if (gui.type == GUI_EXTERNAL_OSC) { CARLA_ASSERT(osc.thread); if (! osc.thread) { carla_stderr2("VstPlugin::showGui(%s) - attempt to show gui, but it does not exist!", bool2str(yesNo)); return; } if (yesNo) { osc.thread->start(); } else { if (osc.data.target) { osc_send_hide(&osc.data); osc_send_quit(&osc.data); osc.data.free(); } if (! osc.thread->wait(500)) osc.thread->quit(); } } else { if (yesNo && gui.width > 0 && gui.height > 0) x_engine->callback(CALLBACK_RESIZE_GUI, m_id, gui.width, gui.height, 0.0, nullptr); } gui.visible = yesNo; } void idleGui() { #ifdef VESTIGE_HEADER if (effect /*&& effect->ptr1*/) #else if (effect /*&& effect->resvd1*/) #endif { if (needIdle) effect->dispatcher(effect, effIdle, 0, 0, nullptr, 0.0f); if (gui.type != GUI_EXTERNAL_OSC) effect->dispatcher(effect, effEditIdle, 0, 0, nullptr, 0.0f); } CarlaPlugin::idleGui(); } // ------------------------------------------------------------------- // Plugin state void reload() { carla_debug("VstPlugin::reload() - start"); CARLA_ASSERT(effect); const ProcessMode processMode(x_engine->getOptions().processMode); // Safely disable plugin for reload const ScopedDisabler m(this); // Remove client ports removeClientPorts(); // Delete old data deleteBuffers(); uint32_t aIns, aOuts, mIns, mOuts, params, j; aIns = effect->numInputs; aOuts = effect->numOutputs; params = effect->numParams; if (vstPluginCanDo(effect, "receiveVstEvents") || vstPluginCanDo(effect, "receiveVstMidiEvent") || (effect->flags & effFlagsIsSynth) > 0 || (m_hints & PLUGIN_WANTS_MIDI_INPUT)) mIns = 1; else mIns = 0; if (vstPluginCanDo(effect, "sendVstEvents") || vstPluginCanDo(effect, "sendVstMidiEvent")) mOuts = 1; else mOuts = 0; if (aIns > 0) { aIn.ports = new CarlaEngineAudioPort*[aIns]; aIn.rindexes = new uint32_t[aIns]; } if (aOuts > 0) { aOut.ports = new CarlaEngineAudioPort*[aOuts]; aOut.rindexes = new uint32_t[aOuts]; } if (params > 0) { param.data = new ParameterData[params]; param.ranges = new ParameterRanges[params]; } bool needsCtrlIn = (aOuts > 0 || params > 0); const int portNameSize = x_engine->maxPortNameSize(); CarlaString portName; // Audio Ins for (j=0; j < aIns; j++) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = m_name; portName += ":"; } char tmp[12] = { 0 }; sprintf(tmp, "input_%02i", j+1); portName += tmp; aIn.ports[j] = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, true); aIn.rindexes[j] = j; } // Audio Outs for (j=0; j < aOuts; j++) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = m_name; portName += ":"; } char tmp[12] = { 0 }; sprintf(tmp, "output_%02i", j+1); portName += tmp; aOut.ports[j] = (CarlaEngineAudioPort*)x_client->addPort(CarlaEnginePortTypeAudio, portName, false); aOut.rindexes[j] = j; } for (j=0; j < params; j++) { param.data[j].type = PARAMETER_INPUT; param.data[j].index = j; param.data[j].rindex = j; param.data[j].hints = 0; param.data[j].midiChannel = 0; param.data[j].midiCC = -1; double min, max, def, step, stepSmall, stepLarge; VstParameterProperties prop; prop.flags = 0; if (effect->dispatcher(effect, effGetParameterProperties, j, 0, &prop, 0)) { double range[2] = { 0.0, 1.0 }; if ((m_hints & PLUGIN_HAS_COCKOS_EXTENSIONS) > 0 && effect->dispatcher(effect, effVendorSpecific, 0xdeadbef0, j, range, 0.0) >= 0xbeef) { min = range[0]; max = range[1]; } else if (prop.flags & kVstParameterUsesIntegerMinMax) { min = prop.minInteger; max = prop.maxInteger; } else { min = 0.0; max = 1.0; } if (min > max) max = min; else if (max < min) min = max; if (max - min == 0.0) { carla_stderr("Broken plugin parameter: max - min == 0"); max = min + 0.1; } if ((m_hints & PLUGIN_HAS_COCKOS_EXTENSIONS) > 0 && effect->dispatcher(effect, effVendorSpecific, kVstParameterUsesIntStep, j, nullptr, 0.0f) >= 0xbeef) { step = 1.0; stepSmall = 1.0; stepLarge = 10.0; } else if (prop.flags & kVstParameterIsSwitch) { step = max - min; stepSmall = step; stepLarge = step; param.data[j].hints |= PARAMETER_IS_BOOLEAN; } else if (prop.flags & kVstParameterUsesIntStep) { step = prop.stepInteger; stepSmall = prop.stepInteger; stepLarge = prop.largeStepInteger; param.data[j].hints |= PARAMETER_IS_INTEGER; } else if (prop.flags & kVstParameterUsesFloatStep) { step = prop.stepFloat; stepSmall = prop.smallStepFloat; stepLarge = prop.largeStepFloat; } else { double range = max - min; step = range/100.0; stepSmall = range/1000.0; stepLarge = range/10.0; } if (prop.flags & kVstParameterCanRamp) param.data[j].hints |= PARAMETER_IS_LOGARITHMIC; } else { min = 0.0; max = 1.0; step = 0.001; stepSmall = 0.0001; stepLarge = 0.1; } // no such thing as VST default parameters def = effect->getParameter(effect, j); if (def < min) def = min; else if (def > max) def = max; param.ranges[j].min = min; param.ranges[j].max = max; param.ranges[j].def = def; param.ranges[j].step = step; param.ranges[j].stepSmall = stepSmall; param.ranges[j].stepLarge = stepLarge; param.data[j].hints |= PARAMETER_IS_ENABLED; #ifndef BUILD_BRIDGE param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT; #endif if ((m_hints & PLUGIN_USES_OLD_VSTSDK) > 0 || effect->dispatcher(effect, effCanBeAutomated, j, 0, nullptr, 0.0f) == 1) param.data[j].hints |= PARAMETER_IS_AUTOMABLE; } if (needsCtrlIn) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = m_name; portName += ":"; } portName += "control-in"; portName.truncate(portNameSize); param.portCin = (CarlaEngineControlPort*)x_client->addPort(CarlaEnginePortTypeControl, portName, true); } if (mIns == 1) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = m_name; portName += ":"; } portName += "midi-in"; portName.truncate(portNameSize); midi.portMin = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, true); } if (mOuts == 1) { portName.clear(); if (processMode == PROCESS_MODE_SINGLE_CLIENT) { portName = m_name; portName += ":"; } portName += "midi-out"; portName.truncate(portNameSize); midi.portMout = (CarlaEngineMidiPort*)x_client->addPort(CarlaEnginePortTypeMIDI, portName, false); } aIn.count = aIns; aOut.count = aOuts; param.count = params; // plugin checks m_hints &= ~(PLUGIN_IS_SYNTH | PLUGIN_USES_CHUNKS | PLUGIN_CAN_DRYWET | PLUGIN_CAN_VOLUME | PLUGIN_CAN_BALANCE | PLUGIN_CAN_FORCE_STEREO); intptr_t vstCategory = effect->dispatcher(effect, effGetPlugCategory, 0, 0, nullptr, 0.0f); if (vstCategory == kPlugCategSynth || vstCategory == kPlugCategGenerator) m_hints |= PLUGIN_IS_SYNTH; if (effect->flags & effFlagsProgramChunks) m_hints |= PLUGIN_USES_CHUNKS; if (aOuts > 0 && (aIns == aOuts || aIns == 1)) m_hints |= PLUGIN_CAN_DRYWET; if (aOuts > 0) m_hints |= PLUGIN_CAN_VOLUME; if (aOuts >= 2 && aOuts%2 == 0) m_hints |= PLUGIN_CAN_BALANCE; if ((aIns == 0 || aIns == 2) && (aOuts == 0 || aOuts == 2)) m_hints |= PLUGIN_CAN_FORCE_STEREO; // check latency if (m_hints & PLUGIN_CAN_DRYWET) { #ifdef VESTIGE_HEADER char* const empty3Ptr = &effect->empty3[0]; int32_t* initialDelayPtr = (int32_t*)empty3Ptr; m_latency = *initialDelayPtr; #else m_latency = effect->initialDelay; #endif x_client->setLatency(m_latency); recreateLatencyBuffers(); } // special plugin fixes #ifdef __WINE__ // 1. IL Harmless - disable threaded processing if (effect->uniqueID == 1229484653) { char strBuf[255] = { 0 }; getLabel(strBuf); if (std::strcmp(strBuf, "IL Harmless") == 0) { // TODO - disable threaded processing } } #endif reloadPrograms(true); carla_debug("VstPlugin::reload() - end"); } void reloadPrograms(const bool init) { carla_debug("VstPlugin::reloadPrograms(%s)", bool2str(init)); uint32_t i, oldCount = prog.count; // Delete old programs if (prog.count > 0) { for (i=0; i < prog.count; i++) { if (prog.names[i]) free((void*)prog.names[i]); } delete[] prog.names; } prog.count = 0; prog.names = nullptr; // Query new programs prog.count = effect->numPrograms; if (prog.count > 0) prog.names = new const char* [prog.count]; // Update names for (i=0; i < prog.count; i++) { char strBuf[STR_MAX] = { 0 }; if (effect->dispatcher(effect, effGetProgramNameIndexed, i, 0, strBuf, 0.0f) != 1) { // program will be [re-]changed later effect->dispatcher(effect, effSetProgram, 0, i, nullptr, 0.0f); effect->dispatcher(effect, effGetProgramName, 0, 0, strBuf, 0.0f); } prog.names[i] = strdup(strBuf); } #ifndef BUILD_BRIDGE // Update OSC Names if (x_engine->isOscControlRegistered()) { x_engine->osc_send_control_set_program_count(m_id, prog.count); for (i=0; i < prog.count; i++) x_engine->osc_send_control_set_program_name(m_id, i, prog.names[i]); } #endif if (init) { if (prog.count > 0) setProgram(0, false, false, false, true); } else { x_engine->callback(CALLBACK_RELOAD_PROGRAMS, m_id, 0, 0, 0.0, nullptr); // Check if current program is invalid bool programChanged = false; if (prog.count == oldCount+1) { // one program added, probably created by user prog.current = oldCount; programChanged = true; } else if (prog.current >= (int32_t)prog.count) { // current program > count prog.current = 0; programChanged = true; } else if (prog.current < 0 && prog.count > 0) { // programs exist now, but not before prog.current = 0; programChanged = true; } else if (prog.current >= 0 && prog.count == 0) { // programs existed before, but not anymore prog.current = -1; programChanged = true; } if (programChanged) { setProgram(prog.current, true, true, true, true); } else { // Program was changed during update, re-set it if (prog.current >= 0) effect->dispatcher(effect, effSetProgram, 0, prog.current, nullptr, 0.0f); } } } // ------------------------------------------------------------------- // Plugin processing void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) { uint32_t i, k; uint32_t midiEventCount = 0; vstTimeOffset = 0; double aInsPeak[2] = { 0.0 }; double aOutsPeak[2] = { 0.0 }; // reset MIDI events.numEvents = 0; midiEvents[0].type = 0; CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Input VU if (aIn.count > 0 && x_engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK) { if (aIn.count == 1) { for (k=0; k < frames; k++) { if (std::abs(inBuffer[0][k]) > aInsPeak[0]) aInsPeak[0] = std::abs(inBuffer[0][k]); } } else if (aIn.count > 1) { for (k=0; k < frames; k++) { if (std::abs(inBuffer[0][k]) > aInsPeak[0]) aInsPeak[0] = std::abs(inBuffer[0][k]); if (std::abs(inBuffer[1][k]) > aInsPeak[1]) aInsPeak[1] = std::abs(inBuffer[1][k]); } } } CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Parameters Input [Automation] if (param.portCin && m_active && m_activeBefore) { bool allNotesOffSent = false; const CarlaEngineControlEvent* cinEvent; uint32_t time, nEvents = param.portCin->getEventCount(); for (i=0; i < nEvents; i++) { cinEvent = param.portCin->getEvent(i); if (! cinEvent) continue; time = cinEvent->time; if (time >= frames) continue; // Control change switch (cinEvent->type) { case CarlaEngineNullEvent: break; case CarlaEngineParameterChangeEvent: { double value; // Control backend stuff if (cinEvent->channel == m_ctrlInChannel) { if (MIDI_IS_CONTROL_BREATH_CONTROLLER(cinEvent->parameter) && (m_hints & PLUGIN_CAN_DRYWET) > 0) { value = cinEvent->value; setDryWet(value, false, false); postponeEvent(PluginPostEventParameterChange, PARAMETER_DRYWET, 0, value); continue; } if (MIDI_IS_CONTROL_CHANNEL_VOLUME(cinEvent->parameter) && (m_hints & PLUGIN_CAN_VOLUME) > 0) { value = cinEvent->value*127/100; setVolume(value, false, false); postponeEvent(PluginPostEventParameterChange, PARAMETER_VOLUME, 0, value); continue; } if (MIDI_IS_CONTROL_BALANCE(cinEvent->parameter) && (m_hints & PLUGIN_CAN_BALANCE) > 0) { double left, right; value = cinEvent->value/0.5 - 1.0; if (value < 0.0) { left = -1.0; right = (value*2)+1.0; } else if (value > 0.0) { left = (value*2)-1.0; right = 1.0; } else { left = -1.0; right = 1.0; } setBalanceLeft(left, false, false); setBalanceRight(right, false, false); postponeEvent(PluginPostEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left); postponeEvent(PluginPostEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right); continue; } } // Control plugin parameters for (k=0; k < param.count; k++) { if (param.data[k].midiChannel != cinEvent->channel) continue; if (param.data[k].midiCC != cinEvent->parameter) continue; if (param.data[k].type != PARAMETER_INPUT) continue; if (param.data[k].hints & PARAMETER_IS_AUTOMABLE) { if (param.data[k].hints & PARAMETER_IS_BOOLEAN) { value = cinEvent->value < 0.5 ? param.ranges[k].min : param.ranges[k].max; } else { value = cinEvent->value * (param.ranges[k].max - param.ranges[k].min) + param.ranges[k].min; if (param.data[k].hints & PARAMETER_IS_INTEGER) value = rint(value); } setParameterValue(k, value, false, false, false); postponeEvent(PluginPostEventParameterChange, k, 0, value); } } break; } case CarlaEngineMidiBankChangeEvent: break; case CarlaEngineMidiProgramChangeEvent: if (cinEvent->channel == m_ctrlInChannel) { uint32_t progId = rint(cinEvent->value); if (progId < prog.count) { setProgram(progId, false, false, false, false); postponeEvent(PluginPostEventProgramChange, progId, 0, 0.0); } } break; case CarlaEngineAllSoundOffEvent: if (cinEvent->channel == m_ctrlInChannel) { if (midi.portMin && ! allNotesOffSent) sendMidiAllNotesOff(); effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f); effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f); postponeEvent(PluginPostEventParameterChange, PARAMETER_ACTIVE, 0, 0.0); postponeEvent(PluginPostEventParameterChange, PARAMETER_ACTIVE, 0, 1.0); allNotesOffSent = true; } break; case CarlaEngineAllNotesOffEvent: if (cinEvent->channel == m_ctrlInChannel) { if (midi.portMin && ! allNotesOffSent) sendMidiAllNotesOff(); allNotesOffSent = true; } break; } } } // End of Parameters Input CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // MIDI Input if (midi.portMin && m_active && m_activeBefore) { // ---------------------------------------------------------------------------------------------------- // MIDI Input (External) { engineMidiLock(); for (i=0; i < MAX_MIDI_EVENTS && midiEventCount < MAX_MIDI_EVENTS; i++) { if (extMidiNotes[i].channel < 0) break; VstMidiEvent* const midiEvent = &midiEvents[midiEventCount]; memset(midiEvent, 0, sizeof(VstMidiEvent)); midiEvent->type = kVstMidiType; midiEvent->byteSize = sizeof(VstMidiEvent); midiEvent->midiData[0] = uint8_t(extMidiNotes[i].velo ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) + extMidiNotes[i].channel; midiEvent->midiData[1] = extMidiNotes[i].note; midiEvent->midiData[2] = extMidiNotes[i].velo; extMidiNotes[i].channel = -1; // mark as invalid midiEventCount += 1; } engineMidiUnlock(); } // End of MIDI Input (External) CARLA_PROCESS_CONTINUE_CHECK; // ---------------------------------------------------------------------------------------------------- // MIDI Input (System) { const CarlaEngineMidiEvent* minEvent; uint32_t time, nEvents = midi.portMin->getEventCount(); for (i=0; i < nEvents && midiEventCount < MAX_MIDI_EVENTS; i++) { minEvent = midi.portMin->getEvent(i); if (! minEvent) continue; time = minEvent->time; if (time >= frames) continue; uint8_t status = minEvent->data[0]; uint8_t channel = status & 0x0F; // Fix bad note-off if (MIDI_IS_STATUS_NOTE_ON(status) && minEvent->data[2] == 0) status -= 0x10; VstMidiEvent* const midiEvent = &midiEvents[midiEventCount]; memset(midiEvent, 0, sizeof(VstMidiEvent)); midiEvent->type = kVstMidiType; midiEvent->byteSize = sizeof(VstMidiEvent); midiEvent->deltaFrames = minEvent->time; if (MIDI_IS_STATUS_NOTE_OFF(status)) { uint8_t note = minEvent->data[1]; midiEvent->midiData[0] = status; midiEvent->midiData[1] = note; postponeEvent(PluginPostEventNoteOff, channel, note, 0.0); } else if (MIDI_IS_STATUS_NOTE_ON(status)) { uint8_t note = minEvent->data[1]; uint8_t velo = minEvent->data[2]; midiEvent->midiData[0] = status; midiEvent->midiData[1] = note; midiEvent->midiData[2] = velo; postponeEvent(PluginPostEventNoteOn, channel, note, velo); } else if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status)) { uint8_t note = minEvent->data[1]; uint8_t pressure = minEvent->data[2]; midiEvent->midiData[0] = status; midiEvent->midiData[1] = note; midiEvent->midiData[2] = pressure; } else if (MIDI_IS_STATUS_AFTERTOUCH(status)) { uint8_t pressure = minEvent->data[1]; midiEvent->midiData[0] = status; midiEvent->midiData[1] = pressure; } else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status)) { uint8_t lsb = minEvent->data[1]; uint8_t msb = minEvent->data[2]; midiEvent->midiData[0] = status; midiEvent->midiData[1] = lsb; midiEvent->midiData[2] = msb; } else continue; midiEventCount += 1; } } // End of MIDI Input (System) } // End of MIDI Input CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Plugin processing if (m_active) { if (! m_activeBefore) { if (midi.portMin) { for (k=0; k < MAX_MIDI_CHANNELS; k++) { memset(&midiEvents[k], 0, sizeof(VstMidiEvent)); midiEvents[k].type = kVstMidiType; midiEvents[k].byteSize = sizeof(VstMidiEvent); midiEvents[k].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + k; midiEvents[k].midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF; memset(&midiEvents[k*2], 0, sizeof(VstMidiEvent)); midiEvents[k*2].type = kVstMidiType; midiEvents[k*2].byteSize = sizeof(VstMidiEvent); midiEvents[k*2].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + k; midiEvents[k*2].midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF; } midiEventCount = MAX_MIDI_CHANNELS*2; } if (m_latency > 0) { for (i=0; i < aIn.count; i++) memset(m_latencyBuffers[i], 0, sizeof(float)*m_latency); } effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f); effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f); } if (midiEventCount > 0) { events.numEvents = midiEventCount; events.reserved = 0; effect->dispatcher(effect, effProcessEvents, 0, 0, &events, 0.0f); } // FIXME - make this a global option // don't process if not needed //if ((effect->flags & effFlagsNoSoundInStop) > 0 && aInsPeak[0] == 0.0 && aInsPeak[1] == 0.0 && midiEventCount == 0 && ! midi.portMout) //{ if (m_hints & PLUGIN_CAN_PROCESS_REPLACING) { isProcessing = true; effect->processReplacing(effect, inBuffer, outBuffer, frames); isProcessing = false; } else { for (i=0; i < aOut.count; i++) carla_zeroF(outBuffer[i], frames); #if ! VST_FORCE_DEPRECATED isProcessing = true; effect->process(effect, inBuffer, outBuffer, frames); isProcessing = false; #endif } //} } else { if (m_activeBefore) { effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); } } CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Post-processing (dry/wet, volume and balance) if (m_active) { bool do_drywet = (m_hints & PLUGIN_CAN_DRYWET) > 0 && x_dryWet != 1.0; bool do_volume = (m_hints & PLUGIN_CAN_VOLUME) > 0 && x_volume != 1.0; bool do_balance = (m_hints & PLUGIN_CAN_BALANCE) > 0 && (x_balanceLeft != -1.0 || x_balanceRight != 1.0); double bal_rangeL, bal_rangeR; float bufValue, oldBufLeft[do_balance ? frames : 1]; for (i=0; i < aOut.count; i++) { // Dry/Wet if (do_drywet) { for (k=0; k < frames; k++) { if (k < m_latency && m_latency < frames) bufValue = (aIn.count == 1) ? m_latencyBuffers[0][k] : m_latencyBuffers[i][k]; else bufValue = (aIn.count == 1) ? inBuffer[0][k-m_latency] : inBuffer[i][k-m_latency]; outBuffer[i][k] = (outBuffer[i][k]*x_dryWet)+(bufValue*(1.0-x_dryWet)); } } // Balance if (do_balance) { if (i%2 == 0) memcpy(&oldBufLeft, outBuffer[i], sizeof(float)*frames); bal_rangeL = (x_balanceLeft+1.0)/2; bal_rangeR = (x_balanceRight+1.0)/2; for (k=0; k < frames; k++) { if (i%2 == 0) { // left output outBuffer[i][k] = oldBufLeft[k]*(1.0-bal_rangeL); outBuffer[i][k] += outBuffer[i+1][k]*(1.0-bal_rangeR); } else { // right outBuffer[i][k] = outBuffer[i][k]*bal_rangeR; outBuffer[i][k] += oldBufLeft[k]*bal_rangeL; } } } // Volume if (do_volume) { for (k=0; k < frames; k++) outBuffer[i][k] *= x_volume; } // Output VU if (x_engine->getOptions().processMode != PROCESS_MODE_CONTINUOUS_RACK) { for (k=0; i < 2 && k < frames; k++) { if (std::abs(outBuffer[i][k]) > aOutsPeak[i]) aOutsPeak[i] = std::abs(outBuffer[i][k]); } } } // Latency, save values for next callback if (m_latency > 0 && m_latency < frames) { for (i=0; i < aIn.count; i++) memcpy(m_latencyBuffers[i], inBuffer[i] + (frames - m_latency), sizeof(float)*m_latency); } } else { // disable any output sound if not active for (i=0; i < aOut.count; i++) carla_zeroF(outBuffer[i], frames); aOutsPeak[0] = 0.0; aOutsPeak[1] = 0.0; } // End of Post-processing CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // MIDI Output if (midi.portMout && m_active) { uint8_t data[3] = { 0 }; for (int32_t i = midiEventCount; i < events.numEvents; i++) { data[0] = midiEvents[i].midiData[0]; data[1] = midiEvents[i].midiData[1]; data[2] = midiEvents[i].midiData[2]; // Fix bad note-off if (MIDI_IS_STATUS_NOTE_ON(data[0]) && data[2] == 0) data[0] -= 0x10; midi.portMout->writeEvent(midiEvents[i].deltaFrames, data, 3); } } // End of MIDI Output CARLA_PROCESS_CONTINUE_CHECK; // -------------------------------------------------------------------------------------------------------- // Peak Values x_engine->setInputPeak(m_id, 0, aInsPeak[0]); x_engine->setInputPeak(m_id, 1, aInsPeak[1]); x_engine->setOutputPeak(m_id, 0, aOutsPeak[0]); x_engine->setOutputPeak(m_id, 1, aOutsPeak[1]); m_activeBefore = m_active; } void bufferSizeChanged(uint32_t newBufferSize) { if (m_active) { effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); } #if ! VST_FORCE_DEPRECATED effect->dispatcher(effect, effSetBlockSizeAndSampleRate, 0, newBufferSize, nullptr, x_engine->getSampleRate()); #endif effect->dispatcher(effect, effSetBlockSize, 0, newBufferSize, nullptr, 0.0f); if (m_active) { effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f); effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f); } } // ------------------------------------------------------------------- // Post-poned events void uiParameterChange(const uint32_t index, const double value) { CARLA_ASSERT(index < param.count); if (index >= param.count) return; if (gui.type == GUI_EXTERNAL_OSC && osc.data.target) osc_send_control(&osc.data, param.data[index].rindex, value); } void uiProgramChange(const uint32_t index) { CARLA_ASSERT(index < prog.count); if (index >= prog.count) return; if (gui.type == GUI_EXTERNAL_OSC && osc.data.target) osc_send_program(&osc.data, index); } void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) { CARLA_ASSERT(channel < 16); CARLA_ASSERT(note < 128); CARLA_ASSERT(velo > 0 && velo < 128); if (gui.type == GUI_EXTERNAL_OSC && osc.data.target) { uint8_t midiData[4] = { 0 }; midiData[1] = MIDI_STATUS_NOTE_ON + channel; midiData[2] = note; midiData[3] = velo; osc_send_midi(&osc.data, midiData); } } void uiNoteOff(const uint8_t channel, const uint8_t note) { CARLA_ASSERT(channel < 16); CARLA_ASSERT(note < 128); if (gui.type == GUI_EXTERNAL_OSC && osc.data.target) { uint8_t midiData[4] = { 0 }; midiData[1] = MIDI_STATUS_NOTE_OFF + channel; midiData[2] = note; osc_send_midi(&osc.data, midiData); } } // ------------------------------------------------------------------- void handleAudioMasterAutomate(const uint32_t index, const double value) { //CARLA_ASSERT(m_enabled); CARLA_ASSERT_INT(index < param.count, index); if (index >= param.count /*|| ! m_enabled*/) return; if (isProcessing && ! x_engine->isOffline()) { setParameterValue(index, value, false, false, false); postponeEvent(PluginPostEventParameterChange, index, 0, value); } else setParameterValue(index, value, isProcessing, true, true); } intptr_t handleAudioMasterGetCurrentProcessLevel() { if (x_engine->isOffline()) return kVstProcessLevelOffline; if (isProcessing) return kVstProcessLevelRealtime; return kVstProcessLevelUser; } intptr_t handleAudioMasterGetBlockSize() { const uint32_t bufferSize = x_engine->getBufferSize(); effect->dispatcher(effect, effSetBlockSize, 0, bufferSize, nullptr, 0.0f); return bufferSize; } intptr_t handleAudioMasterGetSampleRate() { const double sampleRate = x_engine->getSampleRate(); effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, sampleRate); return sampleRate; } intptr_t handleAudioMasterGetTime() { memset(&vstTimeInfo, 0, sizeof(VstTimeInfo_R)); const CarlaEngineTimeInfo* const timeInfo = x_engine->getTimeInfo(); vstTimeInfo.flags |= kVstTransportChanged; if (timeInfo->playing) vstTimeInfo.flags |= kVstTransportPlaying; vstTimeInfo.samplePos = timeInfo->frame + vstTimeOffset; vstTimeInfo.sampleRate = x_engine->getSampleRate(); vstTimeInfo.nanoSeconds = timeInfo->time; vstTimeInfo.flags |= kVstNanosValid; if (timeInfo->valid & CarlaEngineTimeBBT) { double ppqBar = double(timeInfo->bbt.bar - 1) * timeInfo->bbt.beats_per_bar; double ppqBeat = double(timeInfo->bbt.beat - 1); double ppqTick = double(timeInfo->bbt.tick) / timeInfo->bbt.ticks_per_beat; // Bars vstTimeInfo.barStartPos = ppqBar; vstTimeInfo.flags |= kVstBarsValid; // PPQ Pos vstTimeInfo.ppqPos = ppqBar + ppqBeat + ppqTick; vstTimeInfo.flags |= kVstPpqPosValid; // Tempo vstTimeInfo.tempo = timeInfo->bbt.beats_per_minute; vstTimeInfo.flags |= kVstTempoValid; // Time Signature vstTimeInfo.timeSigNumerator = timeInfo->bbt.beats_per_bar; vstTimeInfo.timeSigDenominator = timeInfo->bbt.beat_type; vstTimeInfo.flags |= kVstTimeSigValid; } else { // Tempo vstTimeInfo.tempo = 120.0; vstTimeInfo.flags |= kVstTempoValid; // Time Signature vstTimeInfo.timeSigNumerator = 4; vstTimeInfo.timeSigDenominator = 4; vstTimeInfo.flags |= kVstTimeSigValid; } return (intptr_t)&vstTimeInfo; } intptr_t handleAudioMasterTempoAt() { const CarlaEngineTimeInfo* const timeInfo = x_engine->getTimeInfo(); if (timeInfo->valid & CarlaEngineTimeBBT) return timeInfo->bbt.beats_per_minute * 10000; return 0; } intptr_t handleAudioMasterIOChanged() { carla_debug("VstPlugin::handleAudioMasterIOChanged()"); CARLA_ASSERT(m_enabled); // TESTING if (! m_enabled) return 1; if (x_engine->getOptions().processMode == PROCESS_MODE_CONTINUOUS_RACK) { carla_stderr2("VstPlugin::handleAudioMasterIOChanged() - plugin asked IO change, but it's not supported in rack mode"); return 0; } engineProcessLock(); m_enabled = false; engineProcessUnlock(); if (m_active) { effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); } reload(); if (m_active) { effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f); effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f); } x_engine->callback(CALLBACK_RELOAD_ALL, m_id, 0, 0, 0.0, nullptr); return 1; } void handleAudioMasterNeedIdle() { carla_debug("VstPlugin::handleAudioMasterNeedIdle()"); needIdle = true; } intptr_t handleAudioMasterProcessEvents(const VstEvents* const vstEvents) { CARLA_ASSERT(m_enabled); CARLA_ASSERT(midi.portMout); CARLA_ASSERT(isProcessing); if (! m_enabled) return 0; if (! midi.portMout) return 0; if (! isProcessing) { carla_stderr2("VstPlugin::handleAudioMasterProcessEvents(%p) - received MIDI out events outside audio thread, ignoring", vstEvents); return 0; } for (int32_t i=0; i < vstEvents->numEvents && events.numEvents < MAX_MIDI_EVENTS*2; i++) { if (! vstEvents->events[i]) break; const VstMidiEvent* const vstMidiEvent = (const VstMidiEvent*)vstEvents->events[i]; if (vstMidiEvent->type == kVstMidiType) memcpy(&midiEvents[events.numEvents++], vstMidiEvent, sizeof(VstMidiEvent)); } return 1; } intptr_t handleAdioMasterSizeWindow(int32_t width, int32_t height) { carla_debug("VstPlugin::handleAudioMasterSizeWindow(%i, %i)", width, height); gui.width = width; gui.height = height; x_engine->callback(CALLBACK_RESIZE_GUI, m_id, width, height, 0.0, nullptr); return 1; } void handleAudioMasterUpdateDisplay() { carla_debug("VstPlugin::handleAudioMasterUpdateDisplay()"); // Update current program name if (prog.count > 0 && prog.current >= 0) { const int32_t index = prog.current; char strBuf[STR_MAX] = { 0 }; effect->dispatcher(effect, effGetProgramName, 0, 0, strBuf, 0.0f); if (! prog.names[index]) { prog.names[index] = strdup(strBuf); } else if (strBuf[0] != 0 && std::strcmp(strBuf, prog.names[index]) != 0) { free((void*)prog.names[index]); prog.names[index] = strdup(strBuf); } } // Tell backend to update x_engine->callback(CALLBACK_UPDATE, m_id, 0, 0, 0.0, nullptr); } void handleAudioMasterWantMidi() { carla_debug("VstPlugin::handleAudioMasterWantMidi()"); m_hints |= PLUGIN_WANTS_MIDI_INPUT; } // ------------------------------------------------------------------- static intptr_t hostCanDo(const char* const feature) { carla_debug("VstPlugin::hostCanDo(\"%s\")", feature); if (std::strcmp(feature, "supplyIdle") == 0) return 1; if (std::strcmp(feature, "sendVstEvents") == 0) return 1; if (std::strcmp(feature, "sendVstMidiEvent") == 0) return 1; if (std::strcmp(feature, "sendVstMidiEventFlagIsRealtime") == 0) return -1; if (std::strcmp(feature, "sendVstTimeInfo") == 0) return 1; if (std::strcmp(feature, "receiveVstEvents") == 0) return 1; if (std::strcmp(feature, "receiveVstMidiEvent") == 0) return 1; if (std::strcmp(feature, "receiveVstTimeInfo") == 0) return -1; if (std::strcmp(feature, "reportConnectionChanges") == 0) return -1; if (std::strcmp(feature, "acceptIOChanges") == 0) { //if (CarlaEngine::processMode == PROCESS_MODE_CONTINUOUS_RACK) // return -1; return 1; } if (std::strcmp(feature, "sizeWindow") == 0) return 1; if (std::strcmp(feature, "offline") == 0) return -1; if (std::strcmp(feature, "openFileSelector") == 0) return -1; if (std::strcmp(feature, "closeFileSelector") == 0) return -1; if (std::strcmp(feature, "startStopProcess") == 0) return 1; if (std::strcmp(feature, "supportShell") == 0) return -1; if (std::strcmp(feature, "shellCategory") == 0) return -1; // unimplemented carla_stderr("VstPlugin::hostCanDo(\"%s\") - unknown feature", feature); return 0; } static intptr_t VSTCALLBACK hostCallback(AEffect* const effect, const int32_t opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt) { #ifdef DEBUG if (opcode != audioMasterGetTime && opcode != audioMasterProcessEvents && opcode != audioMasterGetCurrentProcessLevel && opcode != audioMasterGetOutputLatency) carla_debug("VstPlugin::hostCallback(%p, %02i:%s, %i, " P_INTPTR ", %p, %f)", effect, opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt); #endif #if 0 // Cockos VST extensions if (/*effect &&*/ ptr && (uint32_t)opcode == 0xdeadbeef && (uint32_t)index == 0xdeadf00d) { const char* const func = (char*)ptr; if (std::strcmp(func, "GetPlayPosition") == 0) return 0; if (std::strcmp(func, "GetPlayPosition2") == 0) return 0; if (std::strcmp(func, "GetCursorPosition") == 0) return 0; if (std::strcmp(func, "GetPlayState") == 0) return 0; if (std::strcmp(func, "SetEditCurPos") == 0) return 0; if (std::strcmp(func, "GetSetRepeat") == 0) return 0; if (std::strcmp(func, "GetProjectPath") == 0) return 0; if (std::strcmp(func, "OnPlayButton") == 0) return 0; if (std::strcmp(func, "OnStopButton") == 0) return 0; if (std::strcmp(func, "OnPauseButton") == 0) return 0; if (std::strcmp(func, "IsInRealTimeAudio") == 0) return 0; if (std::strcmp(func, "Audio_IsRunning") == 0) return 0; } #endif // Check if 'resvd1' points to this plugin, or register ourselfs if possible VstPlugin* self = nullptr; if (effect) { #ifdef VESTIGE_HEADER if (effect->ptr1) { self = (VstPlugin*)effect->ptr1; #else if (effect->resvd1) { self = (VstPlugin*)getPointerFromAddress(effect->resvd1); #endif if (self->unique1 != self->unique2) self = nullptr; } if (self) { if (! self->effect) self->effect = effect; CARLA_ASSERT(self->effect == effect); if (self->effect != effect) { carla_stderr("VstPlugin::hostCallback() - host pointer mismatch: %p != %p", self->effect, effect); self = nullptr; } } else if (lastVstPlugin) { #ifdef VESTIGE_HEADER effect->ptr1 = lastVstPlugin; #else effect->resvd1 = getAddressFromPointer(lastVstPlugin); #endif self = lastVstPlugin; } } intptr_t ret = 0; switch (opcode) { case audioMasterAutomate: CARLA_ASSERT(self); if (self) self->handleAudioMasterAutomate(index, opt); else carla_stderr("VstPlugin::hostCallback::audioMasterAutomate called without valid object"); break; case audioMasterVersion: ret = kVstVersion; break; case audioMasterCurrentId: // TODO // if using old sdk, return effect->uniqueID break; case audioMasterIdle: CARLA_ASSERT(effect); if (effect) effect->dispatcher(effect, effEditIdle, 0, 0, nullptr, 0.0f); else carla_stderr("VstPlugin::hostCallback::audioMasterIdle called without valid effect"); break; #if ! VST_FORCE_DEPRECATED case audioMasterPinConnected: // Deprecated in VST SDK 2.4 // TODO break; case audioMasterWantMidi: // Deprecated in VST SDK 2.4 CARLA_ASSERT(self); if (self) self->handleAudioMasterWantMidi(); else carla_stderr("VstPlugin::hostCallback::audioMasterWantMidi called without valid object"); break; #endif case audioMasterGetTime: CARLA_ASSERT(self); if (self) { ret = self->handleAudioMasterGetTime(); } else { static VstTimeInfo_R vstTimeInfo; memset(&vstTimeInfo, 0, sizeof(VstTimeInfo_R)); vstTimeInfo.sampleRate = 44100.0; // Tempo vstTimeInfo.tempo = 120.0; vstTimeInfo.flags |= kVstTempoValid; // Time Signature vstTimeInfo.timeSigNumerator = 4; vstTimeInfo.timeSigDenominator = 4; vstTimeInfo.flags |= kVstTimeSigValid; ret = (intptr_t)&vstTimeInfo; } break; case audioMasterProcessEvents: CARLA_ASSERT(self && ptr); if (self) { if (ptr) ret = self->handleAudioMasterProcessEvents((const VstEvents*)ptr); else carla_stderr("VstPlugin::hostCallback::audioMasterProcessEvents called with invalid pointer"); } else carla_stderr("VstPlugin::hostCallback::audioMasterProcessEvents called without valid object"); break; #if ! VST_FORCE_DEPRECATED case audioMasterSetTime: // Deprecated in VST SDK 2.4 break; case audioMasterTempoAt: // Deprecated in VST SDK 2.4 CARLA_ASSERT(self); if (self) ret = self->handleAudioMasterTempoAt(); else carla_stderr("VstPlugin::hostCallback::audioMasterTempoAt called without valid object"); if (ret == 0) ret = 120 * 10000; break; case audioMasterGetNumAutomatableParameters: // Deprecated in VST SDK 2.4 ret = 0; //x_engine->options.maxParameters; if (effect && ret > effect->numParams) ret = effect->numParams; // FIXME //ret = carla_minPositiveI(effect->numParams, MAX_PARAMETERS); break; case audioMasterGetParameterQuantization: // Deprecated in VST SDK 2.4 ret = 1; // full single float precision break; #endif case audioMasterIOChanged: CARLA_ASSERT(self); if (self) ret = self->handleAudioMasterIOChanged(); else carla_stderr("VstPlugin::hostCallback::audioMasterIOChanged called without valid object"); break; case audioMasterNeedIdle: // Deprecated in VST SDK 2.4 CARLA_ASSERT(self); if (self) self->handleAudioMasterNeedIdle(); else carla_stderr("VstPlugin::hostCallback::audioMasterNeedIdle called without valid object"); break; case audioMasterSizeWindow: CARLA_ASSERT(self); if (self) { if (index > 0 && value > 0) ret = self->handleAdioMasterSizeWindow(index, value); else carla_stderr("VstPlugin::hostCallback::audioMasterSizeWindow called with invalid size"); } else carla_stderr("VstPlugin::hostCallback::audioMasterSizeWindow called without valid object"); break; case audioMasterGetSampleRate: CARLA_ASSERT(self); if (self) ret = self->handleAudioMasterGetSampleRate(); else carla_stderr("VstPlugin::hostCallback::audioMasterGetSampleRate called without valid object"); if (ret == 0) ret = 44100; break; case audioMasterGetBlockSize: CARLA_ASSERT(self); if (self) ret = self->handleAudioMasterGetBlockSize(); else carla_stderr("VstPlugin::hostCallback::audioMasterGetBlockSize called without valid object"); if (ret == 0) // ret = CarlaEngine::processHighPrecision ? 8 : 512; ret = 512; break; case audioMasterGetInputLatency: ret = 0; break; case audioMasterGetOutputLatency: ret = 0; break; #if ! VST_FORCE_DEPRECATED case audioMasterGetPreviousPlug: // Deprecated in VST SDK 2.4 // TODO break; case audioMasterGetNextPlug: // Deprecated in VST SDK 2.4 // TODO break; case audioMasterWillReplaceOrAccumulate: // Deprecated in VST SDK 2.4 ret = 1; // replace break; #endif case audioMasterGetCurrentProcessLevel: if (self) { ret = self->handleAudioMasterGetCurrentProcessLevel(); } else { carla_stderr("VstPlugin::hostCallback::audioMasterGetCurrentProcessLevel called without valid object"); ret = kVstProcessLevelUnknown; } break; case audioMasterGetAutomationState: ret = kVstAutomationReadWrite; break; case audioMasterOfflineStart: case audioMasterOfflineRead: case audioMasterOfflineWrite: case audioMasterOfflineGetCurrentPass: case audioMasterOfflineGetCurrentMetaPass: // TODO break; #if ! VST_FORCE_DEPRECATED case audioMasterSetOutputSampleRate: // Deprecated in VST SDK 2.4 break; case audioMasterGetOutputSpeakerArrangement: // Deprecated in VST SDK 2.4 // TODO break; #endif case audioMasterGetVendorString: CARLA_ASSERT(ptr); if (ptr) { std::strcpy((char*)ptr, "Cadence"); ret = 1; } else carla_stderr("VstPlugin::hostCallback::audioMasterGetVendorString called with invalid pointer"); break; case audioMasterGetProductString: CARLA_ASSERT(ptr); if (ptr) { std::strcpy((char*)ptr, "Carla"); ret = 1; } else carla_stderr("VstPlugin::hostCallback::audioMasterGetProductString called with invalid pointer"); break; case audioMasterGetVendorVersion: ret = 0x050; // 0.5.0 break; case audioMasterVendorSpecific: // TODO - cockos extensions break; #if ! VST_FORCE_DEPRECATED case audioMasterSetIcon: // Deprecated in VST SDK 2.4 break; #endif case audioMasterCanDo: CARLA_ASSERT(ptr); if (ptr) ret = hostCanDo((const char*)ptr); else carla_stderr("VstPlugin::hostCallback::audioMasterCanDo called with invalid pointer"); break; case audioMasterGetLanguage: ret = kVstLangEnglish; break; #if ! VST_FORCE_DEPRECATED case audioMasterOpenWindow: case audioMasterCloseWindow: // Deprecated in VST SDK 2.4 // TODO break; #endif case audioMasterGetDirectory: // TODO //if (ptr) // std::strcpy((char*)ptr, "stuff"); //else // carla_stderr("VstPlugin::hostCallback::audioMasterGetDirectory called with invalid pointer"); break; case audioMasterUpdateDisplay: CARLA_ASSERT(effect); if (self) self->handleAudioMasterUpdateDisplay(); if (effect) effect->dispatcher(effect, effEditIdle, 0, 0, nullptr, 0.0f); ret = 1; break; case audioMasterBeginEdit: case audioMasterEndEdit: // TODO break; case audioMasterOpenFileSelector: case audioMasterCloseFileSelector: // TODO break; #if ! VST_FORCE_DEPRECATED case audioMasterEditFile: // Deprecated in VST SDK 2.4 // TODO break; case audioMasterGetChunkFile: // Deprecated in VST SDK 2.4 // TODO break; case audioMasterGetInputSpeakerArrangement: // Deprecated in VST SDK 2.4 // TODO break; #endif default: #ifdef DEBUG carla_debug("VstPlugin::hostCallback(%p, %02i:%s, %i, " P_INTPTR ", %p, %f)", effect, opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt); #endif break; } return ret; } // ------------------------------------------------------------------- bool init(const char* const filename, const char* const name, const char* const label) { // --------------------------------------------------------------- // open DLL if (! libOpen(filename)) { x_engine->setLastError(libError(filename)); return false; } // --------------------------------------------------------------- // get DLL main entry VST_Function vstFn = (VST_Function)libSymbol("VSTPluginMain"); if (! vstFn) { vstFn = (VST_Function)libSymbol("main"); if (! vstFn) { x_engine->setLastError("Could not find the VST main entry in the plugin library"); return false; } } // --------------------------------------------------------------- // initialize plugin (part 1) lastVstPlugin = this; effect = vstFn(hostCallback); lastVstPlugin = nullptr; if ((! effect) || effect->magic != kEffectMagic) { x_engine->setLastError("Plugin failed to initialize"); return false; } #ifdef VESTIGE_HEADER effect->ptr1 = this; #else effect->resvd1 = getAddressFromPointer(this); #endif effect->dispatcher(effect, effOpen, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); // --------------------------------------------------------------- // get info m_filename = strdup(filename); if (name) { m_name = x_engine->getUniquePluginName(name); } else { char strBuf[STR_MAX] = { 0 }; effect->dispatcher(effect, effGetEffectName, 0, 0, strBuf, 0.0f); if (strBuf[0] != 0) m_name = x_engine->getUniquePluginName(strBuf); else m_name = x_engine->getUniquePluginName(label); } // --------------------------------------------------------------- // register client x_client = x_engine->addClient(this); if (! x_client->isOk()) { x_engine->setLastError("Failed to register plugin client"); return false; } // --------------------------------------------------------------- // initialize plugin (part 2) #if ! VST_FORCE_DEPRECATED effect->dispatcher(effect, effSetBlockSizeAndSampleRate, 0, x_engine->getBufferSize(), nullptr, x_engine->getSampleRate()); #endif effect->dispatcher(effect, effSetSampleRate, 0, 0, nullptr, x_engine->getSampleRate()); effect->dispatcher(effect, effSetBlockSize, 0, x_engine->getBufferSize(), nullptr, 0.0f); effect->dispatcher(effect, effSetProcessPrecision, 0, kVstProcessPrecision32, nullptr, 0.0f); #if ! VST_FORCE_DEPRECATED // dummy pre-start to catch possible wantEvents() call on old plugins effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f); effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f); effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f); #endif // special checks if ((uintptr_t)effect->dispatcher(effect, effCanDo, 0, 0, (void*)"hasCockosExtensions", 0.0f) == 0xbeef0000) { carla_debug("Plugin has Cockos extensions!"); m_hints |= PLUGIN_HAS_COCKOS_EXTENSIONS; } if (effect->dispatcher(effect, effGetVstVersion, 0, 0, nullptr, 0.0f) < kVstVersion) m_hints |= PLUGIN_USES_OLD_VSTSDK; if ((effect->flags & effFlagsCanReplacing) > 0 && effect->processReplacing != effect->process) m_hints |= PLUGIN_CAN_PROCESS_REPLACING; // --------------------------------------------------------------- // gui stuff if (effect->flags & effFlagsHasEditor) { m_hints |= PLUGIN_HAS_GUI; #if defined(Q_OS_LINUX) && 0 // FIXME if (x_engine->options.bridge_vstx11 && x_engine->preferUiBridges() && ! (effect->flags & effFlagsProgramChunks)) { osc.thread = new CarlaPluginThread(x_engine, this, CarlaPluginThread::PLUGIN_THREAD_VST_GUI); osc.thread->setOscData(x_engine->options.bridge_vstx11, label); gui.type = GUI_EXTERNAL_OSC; } else #endif { m_hints |= PLUGIN_USES_SINGLE_THREAD; #if defined(Q_OS_WIN) gui.type = GUI_INTERNAL_HWND; #elif defined(Q_OS_MACOS) gui.type = GUI_INTERNAL_COCOA; #elif defined(Q_OS_LINUX) gui.type = GUI_INTERNAL_X11; #else m_hints &= ~PLUGIN_HAS_GUI; #endif } } return true; } #endif private: int unique1; AEffect* effect; struct { int32_t numEvents; intptr_t reserved; VstEvent* data[MAX_MIDI_EVENTS*2]; } events; VstMidiEvent midiEvents[MAX_MIDI_EVENTS*2]; uint32_t vstTimeOffset; VstTimeInfo_R vstTimeInfo; struct { //GuiType type; bool visible; int width; int height; } gui; bool isProcessing; bool needIdle; static VstPlugin* lastVstPlugin; int unique2; }; VstPlugin* VstPlugin::lastVstPlugin = nullptr; CARLA_BACKEND_END_NAMESPACE #else // WANT_VST # warning Building without VST support #endif CARLA_BACKEND_START_NAMESPACE CarlaPlugin* CarlaPlugin::newVST(const Initializer& init) { carla_debug("CarlaPlugin::newVST(%p, \"%s\", \"%s\", \"%s\")", init.engine, init.filename, init.name, init.label); #ifdef WANT_VST VstPlugin* const plugin = new VstPlugin(init.engine, init.id); //if (! plugin->init(init.filename, init.name, init.label)) { 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 Stereo VST plugins, sorry!"); delete plugin; return nullptr; } return plugin; #else init.engine->setLastError("VST support not available"); return nullptr; #endif } CARLA_BACKEND_END_NAMESPACE