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.
599 Commits
16 Branches
215MB
Tree: 21a76e7a23
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '21a76e7a23'
${ noResults }
Carla/source/backend/engine/CarlaEnginePlugin.cpp

567 lines
16KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Engine (DISTRHO)

  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 "CarlaStateUtils.hpp"

  22. 

  23. #include "DistrhoPlugin.hpp"

  24. 

  25. using DISTRHO::d_cconst;

  26. using DISTRHO::d_string;

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. // -----------------------------------------

  31. // Parameters

  32. 

  33. static const unsigned char kParamMap[] = {

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

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

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

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

  38. };

  39. 

  40. static const unsigned int kParamVolume  = 5;

  41. static const unsigned int kParamBalance = 6;

  42. static const unsigned int kParamPan     = 8;

  43. 

  44. static const unsigned int kParamCount   = sizeof(kParamMap);

  45. static const unsigned int kProgramCount = 128;

  46. static const unsigned int kStateCount   = MAX_RACK_PLUGINS;

  47. 

  48. // -----------------------------------------

  49. 

  50. class CarlaEnginePlugin : public DISTRHO::Plugin,

  51.                           public CarlaEngine

  52. {

  53. public:

  54.     CarlaEnginePlugin()

  55.         : DISTRHO::Plugin(kParamCount, kProgramCount, kStateCount),

  56.           CarlaEngine(),

  57.           fParamBuffers{0.0f},

  58.           fPrevParamBuffers{0.0f}

  59.     {

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

  61. 

  62.         // init parameters

  63.         fParamBuffers[kParamVolume]  = 100.0f;

  64.         fParamBuffers[kParamBalance] = 63.5f;

  65.         fParamBuffers[kParamPan]     = 63.5f;

  66. 

  67.         fPrevParamBuffers[kParamVolume]  = 100.0f;

  68.         fPrevParamBuffers[kParamBalance] = 63.5f;

  69.         fPrevParamBuffers[kParamPan]     = 63.5f;

  70. 

  71.         // set-up engine

  72.         fOptions.processMode   = PROCESS_MODE_CONTINUOUS_RACK;

  73.         fOptions.transportMode = TRANSPORT_MODE_PLUGIN;

  74.         fOptions.forceStereo   = true;

  75.         fOptions.preferPluginBridges = false;

  76.         fOptions.preferUiBridges = false;

  77.         init("Carla");

  78.     }

  79. 

  80.     ~CarlaEnginePlugin() override

  81.     {

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

  83. 

  84.         setAboutToClose();

  85.         removeAllPlugins();

  86.         close();

  87.     }

  88. 

  89. protected:

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

  91.     // Carla Engine 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. 

  108.         proccessPendingEvents();

  109.         return CarlaEngine::close();

  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.     // ---------------------------------------------

  128.     // DISTRHO Plugin Information

  129. 

  130.     const char* d_label() const override

  131.     {

  132.         return "Carla";

  133.     }

  134. 

  135.     const char* d_maker() const override

  136.     {

  137.         return "falkTX";

  138.     }

  139. 

  140.     const char* d_license() const override

  141.     {

  142.         return "GPL v2+";

  143.     }

  144. 

  145.     uint32_t d_version() const override

  146.     {

  147.         return 0x0600;

  148.     }

  149. 

  150.     long d_uniqueId() const override

  151.     {

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

  153.     }

  154. 

  155.     // ---------------------------------------------

  156.     // DISTRHO Plugin Init

  157. 

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

  159.     {

  160.         if (index >= kParamCount)

  161.             return;

  162. 

  163.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  164.         parameter.ranges.def = 0.0f;

  165.         parameter.ranges.min = 0.0f;

  166.         parameter.ranges.max = 127.0f;

  167. 

  168.         switch (kParamMap[index])

  169.         {

  170.         case 0x01:

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

  172.             break;

  173.         case 0x02:

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

  175.             break;

  176.         case 0x03:

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

  178.             break;

  179.         case 0x04:

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

  181.             break;

  182.         case 0x05:

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

  184.             break;

  185.         case 0x07:

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

  187.             parameter.ranges.def = 100.0f;

  188.             break;

  189.         case 0x08:

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

  191.             parameter.ranges.def = 63.5f;

  192.             break;

  193.         case 0x09:

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

  195.             break;

  196.         case 0x0A:

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

  198.             parameter.ranges.def = 63.5f;

  199.             break;

  200.         case 0x0B:

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

  202.             break;

  203.         case 0x0C:

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

  205.             break;

  206.         case 0x0D:

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

  208.             break;

  209.         case 0x0E:

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

  211.             break;

  212.         case 0x0F:

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

  214.             break;

  215.         case 0x10:

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

  217.             break;

  218.         case 0x11:

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

  220.             break;

  221.         case 0x12:

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

  223.             break;

  224.         case 0x13:

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

  226.             break;

  227.         case 0x14:

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

  229.             break;

  230.         case 0x15:

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

  232.             break;

  233.         case 0x16:

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

  235.             break;

  236.         case 0x17:

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

  238.             break;

  239.         case 0x18:

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

  241.             break;

  242.         case 0x19:

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

  244.             break;

  245.         case 0x1A:

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

  247.             break;

  248.         case 0x1B:

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

  250.             break;

  251.         case 0x1C:

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

  253.             break;

  254.         case 0x1D:

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

  256.             break;

  257.         case 0x1E:

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

  259.             break;

  260.         case 0x1F:

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

  262.             break;

  263.         case 0x46:

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

  265.             break;

  266.         case 0x47:

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

  268.             break;

  269.         case 0x48:

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

  271.             break;

  272.         case 0x49:

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

  274.             break;

  275.         case 0x4A:

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

  277.             break;

  278.         case 0x4B:

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

  280.             break;

  281.         case 0x4C:

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

  283.             break;

  284.         case 0x4D:

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

  286.             break;

  287.         case 0x4E:

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

  289.             break;

  290.         case 0x4F:

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

  292.             break;

  293.         case 0x50:

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

  295.             break;

  296.         case 0x51:

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

  298.             break;

  299.         case 0x52:

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

  301.             break;

  302.         case 0x53:

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

  304.             break;

  305.         case 0x54:

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

  307.             break;

  308.         case 0x5B:

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

  310.             break;

  311.         case 0x5C:

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

  313.             break;

  314.         case 0x5D:

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

  316.             break;

  317.         case 0x5E:

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

  319.             break;

  320.         case 0x5F:

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

  322.             break;

  323.         default:

  324.             parameter.name = "";

  325.             break;

  326.         }

  327.     }

  328. 

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

  330.     {

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

  332.     }

  333. 

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

  335.     {

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

  337.     }

  338. 

  339.     // ---------------------------------------------

  340.     // DISTRHO Plugin Internal data

  341. 

  342.     float d_parameterValue(uint32_t index) override

  343.     {

  344.         if (index >= kParamCount)

  345.             return 0.0f;

  346. 

  347.         return fParamBuffers[index];

  348.     }

  349. 

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

  351.     {

  352.         if (index >= kParamCount)

  353.             return;

  354. 

  355.         fParamBuffers[index] = value;

  356.     }

  357. 

  358.     void d_setProgram(uint32_t index) override

  359.     {

  360.         if (index >= kProgramCount)

  361.             return;

  362.         if (kData->curPluginCount == 0 || kData->plugins == nullptr)

  363.             return;

  364. 

  365.         CarlaPlugin* const plugin(kData->plugins[0].plugin);

  366. 

  367.         if (plugin == nullptr || ! plugin->enabled())

  368.             return;

  369. 

  370.         if (plugin->midiProgramCount() > 0)

  371.         {

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

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

  374.         }

  375.         else if (plugin->programCount() > 0 && plugin->type() != PLUGIN_LV2)

  376.         {

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

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

  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.         for (unsigned int i=0; i < kData->curPluginCount; ++i)

  395.         {

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

  397. 

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

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

  400.         }

  401. 

  402.         carla_copyFloat(fPrevParamBuffers, fParamBuffers, kParamCount);

  403.     }

  404. 

  405.     void d_deactivate() override

  406.     {

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

  408.         {

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

  410. 

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

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

  413.         }

  414. 

  415.         // just in case

  416.         proccessPendingEvents();

  417.     }

  418. 

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

  420.     {

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

  422.         {

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

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

  425.             return proccessPendingEvents();

  426.         }

  427. 

  428.         // ---------------------------------------------------------------

  429.         // create audio buffers

  430. 

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

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

  433. 

  434.         // ---------------------------------------------------------------

  435.         // initialize input events

  436. 

  437.         carla_zeroStruct<EngineEvent>(kData->bufEvent.in, INTERNAL_EVENT_COUNT);

  438.         {

  439.             uint32_t engineEventIndex = 0;

  440. 

  441.             for (unsigned int i=0; i < kParamCount && engineEventIndex+midiEventCount < INTERNAL_EVENT_COUNT; ++i)

  442.             {

  443.                 if (fParamBuffers[i] == fPrevParamBuffers[i])

  444.                     continue;

  445. 

  446.                 EngineEvent& engineEvent(kData->bufEvent.in[engineEventIndex++]);

  447.                 engineEvent.clear();

  448. 

  449.                 engineEvent.type    = kEngineEventTypeControl;

  450.                 engineEvent.time    = 0;

  451.                 engineEvent.channel = 0;

  452. 

  453.                 engineEvent.ctrl.type  = kEngineControlEventTypeParameter;

  454.                 engineEvent.ctrl.param = kParamMap[i];

  455.                 engineEvent.ctrl.value = fParamBuffers[i]/127.0f;

  456. 

  457.                 fPrevParamBuffers[i] = fParamBuffers[i];

  458.             }

  459. 

  460.             for (uint32_t i=0; i < midiEventCount && engineEventIndex < INTERNAL_EVENT_COUNT; ++i)

  461.             {

  462.                 const DISTRHO::MidiEvent& midiEvent(midiEvents[i]);

  463. 

  464.                 if (midiEvent.size > 4)

  465.                     continue;

  466. 

  467.                 const uint8_t status  = MIDI_GET_STATUS_FROM_DATA(midiEvent.buf);

  468.                 const uint8_t channel = MIDI_GET_CHANNEL_FROM_DATA(midiEvent.buf);

  469. 

  470.                 // we don't want some events

  471.                 if (status == MIDI_STATUS_PROGRAM_CHANGE)

  472.                     continue;

  473. 

  474.                 // handle note/sound off properly

  475.                 if (status == MIDI_STATUS_CONTROL_CHANGE)

  476.                 {

  477.                     const uint8_t control = midiEvent.buf[1];

  478. 

  479.                     if (MIDI_IS_CONTROL_BANK_SELECT(control))

  480.                         continue;

  481. 

  482.                     if (control == MIDI_CONTROL_ALL_SOUND_OFF || control == MIDI_CONTROL_ALL_NOTES_OFF)

  483.                     {

  484.                         EngineEvent& engineEvent(kData->bufEvent.in[engineEventIndex++]);

  485.                         engineEvent.clear();

  486. 

  487.                         engineEvent.type    = kEngineEventTypeControl;

  488.                         engineEvent.time    = midiEvent.frame;

  489.                         engineEvent.channel = channel;

  490. 

  491.                         engineEvent.ctrl.type  = (control == MIDI_CONTROL_ALL_SOUND_OFF) ? kEngineControlEventTypeAllSoundOff : kEngineControlEventTypeAllNotesOff;

  492.                         engineEvent.ctrl.param = 0;

  493.                         engineEvent.ctrl.value = 0.0f;

  494. 

  495.                         continue;

  496.                     }

  497.                 }

  498. 

  499.                 EngineEvent& engineEvent(kData->bufEvent.in[engineEventIndex++]);

  500.                 engineEvent.clear();

  501. 

  502.                 engineEvent.type    = kEngineEventTypeMidi;

  503.                 engineEvent.time    = midiEvent.frame;

  504.                 engineEvent.channel = channel;

  505. 

  506.                 engineEvent.midi.data[0] = MIDI_GET_STATUS_FROM_DATA(midiEvent.buf);

  507.                 engineEvent.midi.data[1] = midiEvent.buf[1];

  508.                 engineEvent.midi.data[2] = midiEvent.buf[2];

  509.                 engineEvent.midi.data[3] = midiEvent.buf[3];

  510.                 engineEvent.midi.size    = midiEvent.size;

  511.             }

  512.         }

  513. 

  514.         // ---------------------------------------------------------------

  515.         // process

  516. 

  517.         processRack(inBuf, outBuf, frames);

  518.         proccessPendingEvents();

  519.     }

  520. 

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

  522.     // Callbacks

  523. 

  524.     void d_bufferSizeChanged(uint32_t newBufferSize) override

  525.     {

  526.         if (fBufferSize == newBufferSize)

  527.             return;

  528. 

  529.         fBufferSize = newBufferSize;

  530.         bufferSizeChanged(newBufferSize);

  531.     }

  532. 

  533.     void d_sampleRateChanged(double newSampleRate) override

  534.     {

  535.         if (fSampleRate == newSampleRate)

  536.             return;

  537. 

  538.         fSampleRate = newSampleRate;

  539.         sampleRateChanged(newSampleRate);

  540.     }

  541. 

  542.     // ---------------------------------------------

  543. 

  544. private:

  545.     float fParamBuffers[kParamCount];

  546.     float fPrevParamBuffers[kParamCount];

  547. };

  548. 

  549. CARLA_BACKEND_END_NAMESPACE

  550. 

  551. // -------------------------------------------------

  552. 

  553. START_NAMESPACE_DISTRHO

  554. 

  555. Plugin* createPlugin()

  556. {

  557.     return new CarlaBackend::CarlaEnginePlugin();

  558. }

  559. 

  560. END_NAMESPACE_DISTRHO

  561. 

  562. // -------------------------------------------------

  563. 

  564. #include "DistrhoPluginMain.cpp"

  565. 

  566. #endif // WANT_PLUGIN