falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
23 Commits
16 Branches
3.6GB
Tree: 391f5a0d60
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '391f5a0d60'
${ noResults }
Carla/source/backend/engine/plugin.cpp

540 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Engine

  3.  * Copyright (C) 2012 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #ifdef CARLA_ENGINE_PLUGIN

  19. 

  20. #include "carla_engine.hpp"

  21. #include "carla_plugin.hpp"

  22. 

  23. #include "DistrhoPlugin.h"

  24. 

  25. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. // -----------------------------------------

  28. // Parameters

  29. 

  30. static const unsigned char paramMap[] = {

  31.     0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,

  32.     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,

  33.     0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,

  34.     0x50, 0x51, 0x52, 0x53, 0x54, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F

  35. };

  36. 

  37. static const unsigned int paramVolume  = 5;

  38. static const unsigned int paramBalance = 6;

  39. static const unsigned int paramPan     = 8;

  40. 

  41. static const unsigned int paramCount   = sizeof(paramMap);

  42. static const unsigned int programCount = 128;

  43. 

  44. // -------------------------------------------------------------------------------------------------------------------

  45. // Plugin Engine client

  46. 

  47. class CarlaEnginePluginClient : public CarlaEngineClient

  48. {

  49. public:

  50.     CarlaEnginePluginClient(const CarlaEngineType engineType, const ProcessMode processMode)

  51.         : CarlaEngineClient(engineType, processMode)

  52.     {

  53.     }

  54. 

  55.     ~CarlaEnginePluginClient()

  56.     {

  57.     }

  58. 

  59.     const CarlaEngineBasePort* addPort(const CarlaEnginePortType portType, const char* const name, const bool isInput)

  60.     {

  61.         qDebug("CarlaEnginePluginClient::addPort(%i, \"%s\", %s)", portType, name, bool2str(isInput));

  62. 

  63.         switch (portType)

  64.         {

  65.         case CarlaEnginePortTypeNull:

  66.             break;

  67.         case CarlaEnginePortTypeAudio:

  68.             return new CarlaEngineAudioPort(isInput, processMode);

  69.         case CarlaEnginePortTypeControl:

  70.             return new CarlaEngineControlPort(isInput, processMode);

  71.         case CarlaEnginePortTypeMIDI:

  72.             return new CarlaEngineMidiPort(isInput, processMode);

  73.         }

  74. 

  75.         qCritical("CarlaEnginePluginClient::addPort(%i, \"%s\", %s) - invalid type", portType, name, bool2str(isInput));

  76.         return nullptr;

  77.     }

  78. };

  79. 

  80. // -----------------------------------------

  81. 

  82. class CarlaEnginePlugin : public CarlaEngine,

  83.                           public DISTRHO::Plugin

  84. {

  85. public:

  86.     short idZyn;

  87. 

  88.     CarlaEnginePlugin()

  89.         : CarlaEngine(),

  90.           DISTRHO::Plugin(paramCount, programCount, 0)

  91.     {

  92.         qDebug("CarlaEnginePlugin::CarlaEnginePlugin()");

  93. 

  94.         // init parameters

  95.         for (unsigned int i=0; i < paramCount; i++)

  96.             paramBuffers[i] = 0.0f;

  97. 

  98.         paramBuffers[paramVolume]  = 100.0f;

  99.         paramBuffers[paramBalance] = 63.5f;

  100.         paramBuffers[paramPan]     = 63.5f;

  101. 

  102.         memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);

  103. 

  104.         // set-up engine

  105.         options.processMode = PROCESS_MODE_CONTINUOUS_RACK;

  106.         options.forceStereo = true;

  107.         options.preferPluginBridges = false;

  108.         options.preferUiBridges = false;

  109.         init("Carla");

  110. 

  111.         // Force thread start so we get some OSC usage

  112.         // (liblo locks otherwise)

  113.         //startCheckThread();

  114. 

  115.         // testing

  116.         idZyn = addPlugin(PLUGIN_DSSI, "/usr/lib/dssi/sineshaper.so", nullptr, "ll-sineshaper");

  117.     }

  118. 

  119.     ~CarlaEnginePlugin()

  120.     {

  121.         qDebug("CarlaEnginePlugin::~CarlaEnginePlugin()");

  122. 

  123.         removeAllPlugins();

  124.         close();

  125.     }

  126. 

  127.     // -------------------------------------

  128.     // CarlaEngine virtual calls

  129. 

  130.     bool init(const char* const clientName)

  131.     {

  132.         qDebug("CarlaEnginePlugin::init(\"%s\")", clientName);

  133. 

  134.         bufferSize = d_bufferSize();

  135.         sampleRate = d_sampleRate();

  136. 

  137.         name = clientName;

  138.         name.toBasic();

  139. 

  140.         CarlaEngine::init(name);

  141.         return true;

  142.     }

  143. 

  144.     bool close()

  145.     {

  146.         qDebug("CarlaEnginePlugin::close()");

  147.         CarlaEngine::close();

  148. 

  149.         return true;

  150.     }

  151. 

  152.     bool isRunning() const

  153.     {

  154.         return true;

  155.     }

  156. 

  157.     bool isOffline() const

  158.     {

  159.         return false;

  160.     }

  161. 

  162.     CarlaEngineType type() const

  163.     {

  164.         return CarlaEngineTypeRtAudio;

  165.     }

  166. 

  167.     CarlaEngineClient* addClient(CarlaPlugin* const)

  168.     {

  169.         return new CarlaEnginePluginClient(CarlaEngineTypeRtAudio, options.processMode);

  170.     }

  171. 

  172. protected:

  173.     // ---------------------------------------------

  174.     // DISTRHO Plugin Information

  175. 

  176.     const char* d_label()

  177.     {

  178.         return "Carla";

  179.     }

  180. 

  181.     const char* d_maker()

  182.     {

  183.         return "falkTX";

  184.     }

  185. 

  186.     const char* d_license()

  187.     {

  188.         return "GPL v2+";

  189.     }

  190. 

  191.     uint32_t d_version()

  192.     {

  193.         return 0x0500;

  194.     }

  195. 

  196.     long d_uniqueId()

  197.     {

  198.         return d_cconst('C', 'r', 'l', 'a');

  199.     }

  200. 

  201.     // ---------------------------------------------

  202.     // DISTRHO Plugin Init

  203. 

  204.     void d_initParameter(uint32_t index, DISTRHO::Parameter& parameter)

  205.     {

  206.         if (index >= paramCount)

  207.             return;

  208. 

  209.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  210.         parameter.ranges.def = 0.0f;

  211.         parameter.ranges.min = 0.0f;

  212.         parameter.ranges.max = 127.0f;

  213. 

  214.         if (index == paramVolume)

  215.             parameter.ranges.def = 100.0f;

  216.         else if (index == paramBalance)

  217.             parameter.ranges.def = 63.5f;

  218.         else if (index == paramPan)

  219.             parameter.ranges.def = 63.5f;

  220. 

  221.         switch (paramMap[index])

  222.         {

  223.         case 0x01:

  224.             parameter.name = "0x01 Modulation";

  225.             break;

  226.         case 0x02:

  227.             parameter.name = "0x02 Breath";

  228.             break;

  229.         case 0x03:

  230.             parameter.name = "0x03 (Undefined)";

  231.             break;

  232.         case 0x04:

  233.             parameter.name = "0x04 Foot";

  234.             break;

  235.         case 0x05:

  236.             parameter.name = "0x05 Portamento";

  237.             break;

  238.         case 0x07:

  239.             parameter.name = "0x07 Volume";

  240.             break;

  241.         case 0x08:

  242.             parameter.name = "0x08 Balance";

  243.             break;

  244.         case 0x09:

  245.             parameter.name = "0x09 (Undefined)";

  246.             break;

  247.         case 0x0A:

  248.             parameter.name = "0x0A Pan";

  249.             break;

  250.         case 0x0B:

  251.             parameter.name = "0x0B Expression";

  252.             break;

  253.         case 0x0C:

  254.             parameter.name = "0x0C FX Control 1";

  255.             break;

  256.         case 0x0D:

  257.             parameter.name = "0x0D FX Control 2";

  258.             break;

  259.         case 0x0E:

  260.             parameter.name = "0x0E (Undefined)";

  261.             break;

  262.         case 0x0F:

  263.             parameter.name = "0x0F (Undefined)";

  264.             break;

  265.         case 0x10:

  266.             parameter.name = "0x10 General Purpose 1";

  267.             break;

  268.         case 0x11:

  269.             parameter.name = "0x11 General Purpose 2";

  270.             break;

  271.         case 0x12:

  272.             parameter.name = "0x12 General Purpose 3";

  273.             break;

  274.         case 0x13:

  275.             parameter.name = "0x13 General Purpose 4";

  276.             break;

  277.         case 0x14:

  278.             parameter.name = "0x14 (Undefined)";

  279.             break;

  280.         case 0x15:

  281.             parameter.name = "0x15 (Undefined)";

  282.             break;

  283.         case 0x16:

  284.             parameter.name = "0x16 (Undefined)";

  285.             break;

  286.         case 0x17:

  287.             parameter.name = "0x17 (Undefined)";

  288.             break;

  289.         case 0x18:

  290.             parameter.name = "0x18 (Undefined)";

  291.             break;

  292.         case 0x19:

  293.             parameter.name = "0x19 (Undefined)";

  294.             break;

  295.         case 0x1A:

  296.             parameter.name = "0x1A (Undefined)";

  297.             break;

  298.         case 0x1B:

  299.             parameter.name = "0x1B (Undefined)";

  300.             break;

  301.         case 0x1C:

  302.             parameter.name = "0x1C (Undefined)";

  303.             break;

  304.         case 0x1D:

  305.             parameter.name = "0x1D (Undefined)";

  306.             break;

  307.         case 0x1E:

  308.             parameter.name = "0x1E (Undefined)";

  309.             break;

  310.         case 0x1F:

  311.             parameter.name = "0x1F (Undefined)";

  312.             break;

  313.         case 0x46:

  314.             parameter.name = "0x46 Control 1 [Variation]";

  315.             break;

  316.         case 0x47:

  317.             parameter.name = "0x47 Control 2 [Timbre]";

  318.             break;

  319.         case 0x48:

  320.             parameter.name = "0x48 Control 3 [Release]";

  321.             break;

  322.         case 0x49:

  323.             parameter.name = "0x49 Control 4 [Attack]";

  324.             break;

  325.         case 0x4A:

  326.             parameter.name = "0x4A Control 5 [Brightness]";

  327.             break;

  328.         case 0x4B:

  329.             parameter.name = "0x4B Control 6 [Decay]";

  330.             break;

  331.         case 0x4C:

  332.             parameter.name = "0x4C Control 7 [Vib Rate]";

  333.             break;

  334.         case 0x4D:

  335.             parameter.name = "0x4D Control 8 [Vib Depth]";

  336.             break;

  337.         case 0x4E:

  338.             parameter.name = "0x4E Control 9 [Vib Delay]";

  339.             break;

  340.         case 0x4F:

  341.             parameter.name = "0x4F Control 10 [Undefined]";

  342.             break;

  343.         case 0x50:

  344.             parameter.name = "0x50 General Purpose 5";

  345.             break;

  346.         case 0x51:

  347.             parameter.name = "0x51 General Purpose 6";

  348.             break;

  349.         case 0x52:

  350.             parameter.name = "0x52 General Purpose 7";

  351.             break;

  352.         case 0x53:

  353.             parameter.name = "0x53 General Purpose 8";

  354.             break;

  355.         case 0x54:

  356.             parameter.name = "0x54 Portamento Control";

  357.             break;

  358.         case 0x5B:

  359.             parameter.name = "0x5B FX 1 Depth [Reverb]";

  360.             break;

  361.         case 0x5C:

  362.             parameter.name = "0x5C FX 2 Depth [Tremolo]";

  363.             break;

  364.         case 0x5D:

  365.             parameter.name = "0x5D FX 3 Depth [Chorus]";

  366.             break;

  367.         case 0x5E:

  368.             parameter.name = "0x5E FX 4 Depth [Detune]";

  369.             break;

  370.         case 0x5F:

  371.             parameter.name = "0x5F FX 5 Depth [Phaser]";

  372.             break;

  373.         }

  374.     }

  375. 

  376.     void d_initProgramName(uint32_t index, d_string& programName)

  377.     {

  378.         programName = "Program #" + d_string(index);

  379.     }

  380. 

  381.     void d_initStateKey(uint32_t index, d_string& stateKey)

  382.     {

  383.         Q_UNUSED(index);

  384.         Q_UNUSED(stateKey);

  385.     }

  386. 

  387.     // ---------------------------------------------

  388.     // DISTRHO Plugin Internal data

  389. 

  390.     float d_parameterValue(uint32_t index)

  391.     {

  392.         if (index >= paramCount)

  393.             return 0.0f;

  394. 

  395.         return paramBuffers[index];

  396.     }

  397. 

  398.     void  d_setParameterValue(uint32_t index, float value)

  399.     {

  400.         if (index >= paramCount)

  401.             return;

  402. 

  403.         paramBuffers[index] = value;

  404.     }

  405. 

  406.     void  d_setProgram(uint32_t index)

  407.     {

  408.         if (index >= programCount)

  409.             return;

  410.         if (maxPluginNumber() == 0)

  411.             return;

  412. 

  413.         if (CarlaPlugin* const plugin = getPlugin(0))

  414.         {

  415.             if (index > plugin->programCount())

  416.                 plugin->setProgram(index, true, true, false, true);

  417.         }

  418.     }

  419. 

  420.     void  d_setState(const char* key, const char* value)

  421.     {

  422.         Q_UNUSED(key);

  423.         Q_UNUSED(value);

  424.     }

  425. 

  426.     // ---------------------------------------------

  427.     // DISTRHO Plugin Process

  428. 

  429.     void d_activate()

  430.     {

  431. //#if 0

  432.         for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)

  433.         {

  434.             CarlaPlugin* const plugin = getPluginUnchecked(i);

  435. 

  436.             if (plugin && plugin->enabled())

  437.                 plugin->setActive(true, true, false);

  438.         }

  439. //#endif

  440. 

  441.         memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);

  442.     }

  443. 

  444.     void d_deactivate()

  445.     {

  446. //#if 0

  447.         for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)

  448.         {

  449.             CarlaPlugin* const plugin = getPluginUnchecked(i);

  450. 

  451.             if (plugin && plugin->enabled())

  452.                 plugin->setActive(false, true, false);

  453.         }

  454. //#endif

  455.     }

  456. 

  457.     void d_run(float** inputs, float** outputs, uint32_t frames, uint32_t midiEventCount, const DISTRHO::MidiEvent* midiEvents)

  458.     {

  459.         if (maxPluginNumber() == 0)

  460.             return;

  461. 

  462.         // create audio buffers

  463.         float* inBuf[2]  = { (float*)inputs[0], (float*)inputs[1] };

  464.         float* outBuf[2] = { outputs[0], outputs[1] };

  465. 

  466.         // initialize control input

  467.         memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*CarlaEngine::MAX_CONTROL_EVENTS);

  468.         {

  469.             uint32_t carlaEventIndex = 0;

  470. 

  471.             for (unsigned int i=0; i < paramCount; i++)

  472.             {

  473.                 if (prevParamBuffers[i] == paramBuffers[i])

  474.                     continue;

  475. 

  476.                 CarlaEngineControlEvent* const carlaEvent = &rackControlEventsIn[carlaEventIndex++];

  477. 

  478.                 carlaEvent->type      = CarlaEngineParameterChangeEvent;

  479.                 carlaEvent->parameter = paramMap[i];

  480.                 carlaEvent->value     = paramBuffers[i]/127;

  481.             }

  482.         }

  483.         memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);

  484. 

  485.         // initialize midi input

  486.         memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*CarlaEngine::MAX_MIDI_EVENTS);

  487.         {

  488.             const DISTRHO::MidiEvent* event;

  489. 

  490.             for (uint32_t i=0, j=0; j < midiEventCount; j++)

  491.             {

  492.                 if (i == CarlaEngine::MAX_MIDI_EVENTS)

  493.                     break;

  494. 

  495.                 event = &midiEvents[j];

  496. 

  497.                 rackMidiEventsIn[i].time = event->frame;

  498.                 rackMidiEventsIn[i].size = 3;

  499.                 memcpy(rackMidiEventsIn[i].data, event->buffer, 3);

  500.                 i += 1;

  501.             }

  502.         }

  503. 

  504.         processRack(inBuf, outBuf, frames);

  505.     }

  506. 

  507.     // ---------------------------------------------

  508.     // Callbacks

  509. 

  510.     void d_bufferSizeChanged(uint32_t newBufferSize)

  511.     {

  512.         bufferSizeChanged(newBufferSize);

  513.     }

  514. 

  515.     // ---------------------------------------------

  516. 

  517. private:

  518.     float paramBuffers[paramCount];

  519.     float prevParamBuffers[paramCount];

  520. };

  521. 

  522. CARLA_BACKEND_END_NAMESPACE

  523. 

  524. // -------------------------------------------------

  525. 

  526. START_NAMESPACE_DISTRHO

  527. 

  528. Plugin* createPlugin()

  529. {

  530.     return new CarlaBackend::CarlaEnginePlugin();

  531. }

  532. 

  533. END_NAMESPACE_DISTRHO

  534. 

  535. // -------------------------------------------------

  536. 

  537. #include "DistrhoPluginMain.cpp"

  538. 

  539. #endif // CARLA_ENGINE_PLUGIN