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.
476 Commits
16 Branches
14GB
Tree: 6be14ec8ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6be14ec8ae'
${ noResults }
Carla/source/backend/engine/CarlaEnginePlugin.cpp

537 lines
15KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Engine

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or 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 GPL.txt file

  16.  */

  17. 

  18. #ifdef WANT_PLUGIN

  19. 

  20. #include "CarlaEngineInternal.hpp"

  21. #include "CarlaBackendUtils.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "DistrhoPlugin.hpp"

  25. 

  26. using DISTRHO::d_cconst;

  27. using DISTRHO::d_string;

  28. 

  29. CARLA_BACKEND_START_NAMESPACE

  30. 

  31. // -----------------------------------------

  32. // Parameters

  33. 

  34. static const unsigned char paramMap[] = {

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

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

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

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

  39. };

  40. 

  41. static const unsigned int paramVolume  = 5;

  42. static const unsigned int paramBalance = 6;

  43. static const unsigned int paramPan     = 8;

  44. 

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

  46. static const unsigned int programCount = 128;

  47. static const unsigned int stateCount   = MAX_RACK_PLUGINS;

  48. 

  49. // -----------------------------------------

  50. 

  51. class CarlaEnginePlugin : public CarlaEngine,

  52.                           public DISTRHO::Plugin

  53. {

  54. public:

  55.     CarlaEnginePlugin()

  56.         : CarlaEngine(),

  57.           DISTRHO::Plugin(paramCount, programCount, stateCount),

  58.           paramBuffers{0.0f},

  59.           prevParamBuffers{0.0f}

  60.     {

  61.         carla_debug("CarlaEnginePlugin::CarlaEnginePlugin()");

  62. 

  63.         // init parameters

  64.         paramBuffers[paramVolume]  = 100.0f;

  65.         paramBuffers[paramBalance] = 63.5f;

  66.         paramBuffers[paramPan]     = 63.5f;

  67. 

  68.         prevParamBuffers[paramVolume]  = 100.0f;

  69.         prevParamBuffers[paramBalance] = 63.5f;

  70.         prevParamBuffers[paramPan]     = 63.5f;

  71. 

  72.         // set-up engine

  73.         fOptions.processMode   = PROCESS_MODE_CONTINUOUS_RACK;

  74.         fOptions.transportMode = TRANSPORT_MODE_INTERNAL;

  75.         fOptions.forceStereo   = true;

  76.         fOptions.preferPluginBridges = false;

  77.         fOptions.preferUiBridges = false;

  78.         init("Carla");

  79.     }

  80. 

  81.     ~CarlaEnginePlugin() override

  82.     {

  83.         carla_debug("CarlaEnginePlugin::~CarlaEnginePlugin()");

  84. 

  85.         setAboutToClose();

  86.         removeAllPlugins();

  87.         close();

  88.     }

  89. 

  90.     // -------------------------------------

  91.     // CarlaEngine virtual calls

  92. 

  93.     bool init(const char* const clientName) override

  94.     {

  95.         carla_debug("CarlaEnginePlugin::init(\"%s\")", clientName);

  96. 

  97.         fBufferSize = d_bufferSize();

  98.         fSampleRate = d_sampleRate();

  99. 

  100.         CarlaEngine::init(clientName);

  101.         return true;

  102.     }

  103. 

  104.     bool close() override

  105.     {

  106.         carla_debug("CarlaEnginePlugin::close()");

  107.         CarlaEngine::close();

  108. 

  109.         return true;

  110.     }

  111. 

  112.     bool isRunning() const override

  113.     {

  114.         return true;

  115.     }

  116. 

  117.     bool isOffline() const override

  118.     {

  119.         return false;

  120.     }

  121. 

  122.     EngineType type() const override

  123.     {

  124.         return kEngineTypePlugin;

  125.     }

  126. 

  127. protected:

  128.     // ---------------------------------------------

  129.     // DISTRHO Plugin Information

  130. 

  131.     const char* d_label() const override

  132.     {

  133.         return "Carla";

  134.     }

  135. 

  136.     const char* d_maker() const override

  137.     {

  138.         return "falkTX";

  139.     }

  140. 

  141.     const char* d_license() const override

  142.     {

  143.         return "GPL v2+";

  144.     }

  145. 

  146.     uint32_t d_version() const override

  147.     {

  148.         return 0x0600;

  149.     }

  150. 

  151.     long d_uniqueId() const override

  152.     {

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

  154.     }

  155. 

  156.     // ---------------------------------------------

  157.     // DISTRHO Plugin Init

  158. 

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

  160.     {

  161.         if (index >= paramCount)

  162.             return;

  163. 

  164.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  165.         parameter.ranges.def = 0.0f;

  166.         parameter.ranges.min = 0.0f;

  167.         parameter.ranges.max = 127.0f;

  168. 

  169.         if (index == paramVolume)

  170.             parameter.ranges.def = 100.0f;

  171.         else if (index == paramBalance)

  172.             parameter.ranges.def = 63.5f;

  173.         else if (index == paramPan)

  174.             parameter.ranges.def = 63.5f;

  175. 

  176.         switch (paramMap[index])

  177.         {

  178.         case 0x01:

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

  180.             break;

  181.         case 0x02:

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

  183.             break;

  184.         case 0x03:

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

  186.             break;

  187.         case 0x04:

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

  189.             break;

  190.         case 0x05:

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

  192.             break;

  193.         case 0x07:

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

  195.             break;

  196.         case 0x08:

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

  198.             break;

  199.         case 0x09:

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

  201.             break;

  202.         case 0x0A:

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

  204.             break;

  205.         case 0x0B:

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

  207.             break;

  208.         case 0x0C:

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

  210.             break;

  211.         case 0x0D:

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

  213.             break;

  214.         case 0x0E:

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

  216.             break;

  217.         case 0x0F:

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

  219.             break;

  220.         case 0x10:

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

  222.             break;

  223.         case 0x11:

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

  225.             break;

  226.         case 0x12:

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

  228.             break;

  229.         case 0x13:

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

  231.             break;

  232.         case 0x14:

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

  234.             break;

  235.         case 0x15:

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

  237.             break;

  238.         case 0x16:

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

  240.             break;

  241.         case 0x17:

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

  243.             break;

  244.         case 0x18:

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

  246.             break;

  247.         case 0x19:

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

  249.             break;

  250.         case 0x1A:

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

  252.             break;

  253.         case 0x1B:

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

  255.             break;

  256.         case 0x1C:

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

  258.             break;

  259.         case 0x1D:

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

  261.             break;

  262.         case 0x1E:

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

  264.             break;

  265.         case 0x1F:

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

  267.             break;

  268.         case 0x46:

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

  270.             break;

  271.         case 0x47:

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

  273.             break;

  274.         case 0x48:

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

  276.             break;

  277.         case 0x49:

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

  279.             break;

  280.         case 0x4A:

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

  282.             break;

  283.         case 0x4B:

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

  285.             break;

  286.         case 0x4C:

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

  288.             break;

  289.         case 0x4D:

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

  291.             break;

  292.         case 0x4E:

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

  294.             break;

  295.         case 0x4F:

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

  297.             break;

  298.         case 0x50:

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

  300.             break;

  301.         case 0x51:

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

  303.             break;

  304.         case 0x52:

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

  306.             break;

  307.         case 0x53:

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

  309.             break;

  310.         case 0x54:

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

  312.             break;

  313.         case 0x5B:

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

  315.             break;

  316.         case 0x5C:

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

  318.             break;

  319.         case 0x5D:

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

  321.             break;

  322.         case 0x5E:

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

  324.             break;

  325.         case 0x5F:

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

  327.             break;

  328.         }

  329.     }

  330. 

  331.     void d_initProgramName(uint32_t index, d_string& programName) override

  332.     {

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

  334.     }

  335. 

  336.     void d_initStateKey(uint32_t index, d_string& stateKey) override

  337.     {

  338.         stateKey = "Plugin #" + d_string(index);

  339.     }

  340. 

  341.     // ---------------------------------------------

  342.     // DISTRHO Plugin Internal data

  343. 

  344.     float d_parameterValue(uint32_t index) override

  345.     {

  346.         if (index >= paramCount)

  347.             return 0.0f;

  348. 

  349.         return paramBuffers[index];

  350.     }

  351. 

  352.     void d_setParameterValue(uint32_t index, float value) override

  353.     {

  354.         if (index >= paramCount)

  355.             return;

  356. 

  357.         paramBuffers[index] = value;

  358.     }

  359. 

  360.     void d_setProgram(uint32_t index) override

  361.     {

  362.         if (index >= programCount)

  363.             return;

  364.         if (kData->curPluginCount == 0)

  365.             return;

  366. 

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

  368.         {

  369.             if (plugin->programCount() > 0)

  370.             {

  371.                 if (index <= plugin->programCount())

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

  373.             }

  374.             else if (plugin->midiProgramCount())

  375.             {

  376.                 if (index <= plugin->midiProgramCount())

  377.                     plugin->setMidiProgram(index, true, true, false);

  378.             }

  379.         }

  380.     }

  381. 

  382.     void  d_setState(const char* key, const char* value) override

  383.     {

  384.         // TODO

  385.         (void)key;

  386.         (void)value;

  387.     }

  388. 

  389.     // ---------------------------------------------

  390.     // DISTRHO Plugin Process

  391. 

  392.     void d_activate() override

  393.     {

  394.         static bool firstTestInit = true;

  395. 

  396.         if (firstTestInit)

  397.         {

  398.             firstTestInit = false;

  399.             if (! addPlugin(PLUGIN_INTERNAL, nullptr, nullptr, "zynaddsubfx"))

  400.                 carla_stderr2("Plugin add zynaddsubfx failed");

  401.             if (! addPlugin(PLUGIN_INTERNAL, nullptr, nullptr, "PingPongPan"))

  402.                 carla_stderr2("Plugin add Pan failed");

  403.         }

  404. 

  405.         for (unsigned int i=0; i < kData->curPluginCount; ++i)

  406.         {

  407.             CarlaPlugin* const plugin(getPluginUnchecked(i));

  408. 

  409.             if (plugin != nullptr && plugin->enabled())

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

  411.         }

  412. 

  413.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  414.     }

  415. 

  416.     void d_deactivate() override

  417.     {

  418.         for (unsigned int i=0; i < kData->curPluginCount; ++i)

  419.         {

  420.             CarlaPlugin* const plugin(getPluginUnchecked(i));

  421. 

  422.             if (plugin != nullptr && plugin->enabled())

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

  424.         }

  425.     }

  426. 

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

  428.     {

  429.         if (kData->curPluginCount == 0)

  430.         {

  431.             carla_zeroFloat(outputs[0], frames);

  432.             carla_zeroFloat(outputs[1], frames);

  433.             return;

  434.         }

  435. 

  436.         // create audio buffers

  437.         float* inBuf[2]  = { inputs[0], inputs[1] };

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

  439. 

  440.         // initialize input events

  441.         carla_zeroStruct<EngineEvent>(kData->rack.in, RACK_EVENT_COUNT);

  442.         {

  443.             uint32_t engineEventIndex = 0;

  444. 

  445.             for (unsigned int i=0; i < paramCount && engineEventIndex+midiEventCount < RACK_EVENT_COUNT; ++i)

  446.             {

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

  448.                     continue;

  449. 

  450.                 EngineEvent* const engineEvent = &kData->rack.in[engineEventIndex++];

  451.                 engineEvent->clear();

  452. 

  453.                 engineEvent->type    = kEngineEventTypeControl;

  454.                 engineEvent->time    = 0;

  455.                 engineEvent->channel = 0;

  456. 

  457.                 engineEvent->ctrl.type  = kEngineControlEventTypeParameter;

  458.                 engineEvent->ctrl.param = paramMap[i];

  459.                 engineEvent->ctrl.value = paramBuffers[i]/127.0f;

  460. 

  461.                 prevParamBuffers[i] = paramBuffers[i];

  462.             }

  463. 

  464.             const DISTRHO::MidiEvent* midiEvent;

  465. 

  466.             for (uint32_t i=0; i < midiEventCount && engineEventIndex < RACK_EVENT_COUNT; ++i)

  467.             {

  468.                 midiEvent = &midiEvents[i];

  469. 

  470.                 if (midiEvent->size > 4)

  471.                     continue;

  472. 

  473.                 EngineEvent* const engineEvent = &kData->rack.in[engineEventIndex++];

  474.                 engineEvent->clear();

  475. 

  476.                 engineEvent->type    = kEngineEventTypeMidi;

  477.                 engineEvent->time    = midiEvent->frame;

  478.                 engineEvent->channel = MIDI_GET_CHANNEL_FROM_DATA(midiEvent->buf);

  479. 

  480.                 engineEvent->midi.data[0] = MIDI_GET_STATUS_FROM_DATA(midiEvent->buf);

  481.                 engineEvent->midi.data[1] = midiEvent->buf[1];

  482.                 engineEvent->midi.data[2] = midiEvent->buf[2];

  483.                 engineEvent->midi.data[3] = midiEvent->buf[3];

  484.                 engineEvent->midi.size    = midiEvent->size;

  485.             }

  486.         }

  487. 

  488.         processRack(inBuf, outBuf, frames);

  489.     }

  490. 

  491.     // ---------------------------------------------

  492.     // Callbacks

  493. 

  494.     void d_bufferSizeChanged(uint32_t newBufferSize) override

  495.     {

  496.         if (fBufferSize == newBufferSize)

  497.             return;

  498. 

  499.         fBufferSize = newBufferSize;

  500.         bufferSizeChanged(newBufferSize);

  501.     }

  502. 

  503.     void d_sampleRateChanged(double newSampleRate) override

  504.     {

  505.         if (fSampleRate == newSampleRate)

  506.             return;

  507. 

  508.         fSampleRate = newSampleRate;

  509.         sampleRateChanged(newSampleRate);

  510.     }

  511. 

  512.     // ---------------------------------------------

  513. 

  514. private:

  515.     float paramBuffers[paramCount];

  516.     float prevParamBuffers[paramCount];

  517. };

  518. 

  519. CARLA_BACKEND_END_NAMESPACE

  520. 

  521. // -------------------------------------------------

  522. 

  523. START_NAMESPACE_DISTRHO

  524. 

  525. Plugin* createPlugin()

  526. {

  527.     return new CarlaBackend::CarlaEnginePlugin();

  528. }

  529. 

  530. END_NAMESPACE_DISTRHO

  531. 

  532. // -------------------------------------------------

  533. 

  534. #include "DistrhoPluginMain.cpp"

  535. 

  536. #endif // CARLA_ENGINE_PLUGIN