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

582 lines
17KB
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. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaStateUtils.hpp"

  20. 

  21. #include "DistrhoPlugin.hpp"

  22. 

  23. using DISTRHO::d_cconst;

  24. using DISTRHO::d_string;

  25. 

  26. #ifdef QTCREATOR_TEST

  27. CARLA_BACKEND_START_NAMESPACE

  28. #else

  29. // -----------------------------------------

  30. // needed symbols

  31. 

  32. #include "jackbridge/JackBridge.hpp"

  33. #include "jackbridge/JackBridge2.cpp"

  34. 

  35. CARLA_BACKEND_START_NAMESPACE

  36. 

  37. CarlaEngine* CarlaEngine::newJack() { return nullptr; }

  38. 

  39. # ifdef WANT_RTAUDIO

  40. CarlaEngine* CarlaEngine::newRtAudio(RtAudioApi) { return nullptr; }

  41. size_t       CarlaEngine::getRtAudioApiCount()   { return 0; }

  42. const char*  CarlaEngine::getRtAudioApiName(const unsigned int)        { return nullptr; }

  43. const char** CarlaEngine::getRtAudioApiDeviceNames(const unsigned int) { return nullptr; }

  44. # endif

  45. #endif

  46. 

  47. // -----------------------------------------

  48. // Parameters

  49. 

  50. static const unsigned char kParamMap[] = {

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

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

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

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

  55. };

  56. 

  57. static const unsigned int kParamVolume  = 5;

  58. static const unsigned int kParamBalance = 6;

  59. static const unsigned int kParamPan     = 8;

  60. 

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

  62. static const unsigned int kProgramCount = 128;

  63. static const unsigned int kStateCount   = MAX_RACK_PLUGINS;

  64. 

  65. // -----------------------------------------

  66. 

  67. class CarlaEnginePlugin : public DISTRHO::Plugin,

  68.                           public CarlaEngine

  69. {

  70. public:

  71.     CarlaEnginePlugin()

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

  73.           CarlaEngine(),

  74.           fParamBuffers{0.0f},

  75.           fPrevParamBuffers{0.0f}

  76.     {

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

  78. 

  79.         // init parameters

  80.         fParamBuffers[kParamVolume]  = 100.0f;

  81.         fParamBuffers[kParamBalance] = 63.5f;

  82.         fParamBuffers[kParamPan]     = 63.5f;

  83. 

  84.         fPrevParamBuffers[kParamVolume]  = 100.0f;

  85.         fPrevParamBuffers[kParamBalance] = 63.5f;

  86.         fPrevParamBuffers[kParamPan]     = 63.5f;

  87. 

  88.         // set-up engine

  89.         fOptions.processMode   = PROCESS_MODE_CONTINUOUS_RACK;

  90.         fOptions.transportMode = TRANSPORT_MODE_PLUGIN;

  91.         fOptions.forceStereo   = true;

  92.         fOptions.preferPluginBridges = false;

  93.         fOptions.preferUiBridges = false;

  94.         init("Carla");

  95.     }

  96. 

  97.     ~CarlaEnginePlugin() override

  98.     {

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

  100. 

  101.         setAboutToClose();

  102.         removeAllPlugins();

  103.         close();

  104.     }

  105. 

  106. protected:

  107.     // -------------------------------------

  108.     // Carla Engine virtual calls

  109. 

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

  111.     {

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

  113. 

  114.         fBufferSize = d_bufferSize();

  115.         fSampleRate = d_sampleRate();

  116. 

  117.         CarlaEngine::init(clientName);

  118.         return true;

  119.     }

  120. 

  121.     bool close() override

  122.     {

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

  124. 

  125.         proccessPendingEvents();

  126.         return CarlaEngine::close();

  127.     }

  128. 

  129.     bool isRunning() const override

  130.     {

  131.         return true;

  132.     }

  133. 

  134.     bool isOffline() const override

  135.     {

  136.         return false;

  137.     }

  138. 

  139.     EngineType type() const override

  140.     {

  141.         return kEngineTypePlugin;

  142.     }

  143. 

  144.     // ---------------------------------------------

  145.     // DISTRHO Plugin Information

  146. 

  147.     const char* d_label() const override

  148.     {

  149.         return "Carla";

  150.     }

  151. 

  152.     const char* d_maker() const override

  153.     {

  154.         return "falkTX";

  155.     }

  156. 

  157.     const char* d_license() const override

  158.     {

  159.         return "GPL v2+";

  160.     }

  161. 

  162.     uint32_t d_version() const override

  163.     {

  164.         return 0x0600;

  165.     }

  166. 

  167.     long d_uniqueId() const override

  168.     {

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

  170.     }

  171. 

  172.     // ---------------------------------------------

  173.     // DISTRHO Plugin Init

  174. 

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

  176.     {

  177.         if (index >= kParamCount)

  178.             return;

  179. 

  180.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  181.         parameter.ranges.def = 0.0f;

  182.         parameter.ranges.min = 0.0f;

  183.         parameter.ranges.max = 127.0f;

  184. 

  185.         switch (kParamMap[index])

  186.         {

  187.         case 0x01:

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

  189.             break;

  190.         case 0x02:

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

  192.             break;

  193.         case 0x03:

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

  195.             break;

  196.         case 0x04:

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

  198.             break;

  199.         case 0x05:

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

  201.             break;

  202.         case 0x07:

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

  204.             parameter.ranges.def = 100.0f;

  205.             break;

  206.         case 0x08:

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

  208.             parameter.ranges.def = 63.5f;

  209.             break;

  210.         case 0x09:

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

  212.             break;

  213.         case 0x0A:

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

  215.             parameter.ranges.def = 63.5f;

  216.             break;

  217.         case 0x0B:

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

  219.             break;

  220.         case 0x0C:

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

  222.             break;

  223.         case 0x0D:

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

  225.             break;

  226.         case 0x0E:

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

  228.             break;

  229.         case 0x0F:

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

  231.             break;

  232.         case 0x10:

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

  234.             break;

  235.         case 0x11:

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

  237.             break;

  238.         case 0x12:

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

  240.             break;

  241.         case 0x13:

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

  243.             break;

  244.         case 0x14:

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

  246.             break;

  247.         case 0x15:

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

  249.             break;

  250.         case 0x16:

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

  252.             break;

  253.         case 0x17:

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

  255.             break;

  256.         case 0x18:

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

  258.             break;

  259.         case 0x19:

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

  261.             break;

  262.         case 0x1A:

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

  264.             break;

  265.         case 0x1B:

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

  267.             break;

  268.         case 0x1C:

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

  270.             break;

  271.         case 0x1D:

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

  273.             break;

  274.         case 0x1E:

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

  276.             break;

  277.         case 0x1F:

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

  279.             break;

  280.         case 0x46:

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

  282.             break;

  283.         case 0x47:

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

  285.             break;

  286.         case 0x48:

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

  288.             break;

  289.         case 0x49:

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

  291.             break;

  292.         case 0x4A:

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

  294.             break;

  295.         case 0x4B:

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

  297.             break;

  298.         case 0x4C:

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

  300.             break;

  301.         case 0x4D:

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

  303.             break;

  304.         case 0x4E:

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

  306.             break;

  307.         case 0x4F:

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

  309.             break;

  310.         case 0x50:

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

  312.             break;

  313.         case 0x51:

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

  315.             break;

  316.         case 0x52:

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

  318.             break;

  319.         case 0x53:

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

  321.             break;

  322.         case 0x54:

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

  324.             break;

  325.         case 0x5B:

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

  327.             break;

  328.         case 0x5C:

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

  330.             break;

  331.         case 0x5D:

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

  333.             break;

  334.         case 0x5E:

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

  336.             break;

  337.         case 0x5F:

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

  339.             break;

  340.         default:

  341.             parameter.name = "";

  342.             break;

  343.         }

  344.     }

  345. 

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

  347.     {

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

  349.     }

  350. 

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

  352.     {

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

  354.     }

  355. 

  356.     // ---------------------------------------------

  357.     // DISTRHO Plugin Internal data

  358. 

  359.     float d_parameterValue(uint32_t index) override

  360.     {

  361.         if (index >= kParamCount)

  362.             return 0.0f;

  363. 

  364.         return fParamBuffers[index];

  365.     }

  366. 

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

  368.     {

  369.         if (index >= kParamCount)

  370.             return;

  371. 

  372.         fParamBuffers[index] = value;

  373.     }

  374. 

  375.     void d_setProgram(uint32_t index) override

  376.     {

  377.         if (index >= kProgramCount)

  378.             return;

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

  380.             return;

  381. 

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

  383. 

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

  385.             return;

  386. 

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

  388.         {

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

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

  391.         }

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

  393.         {

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

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

  396.         }

  397.     }

  398. 

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

  400.     {

  401.         // TODO

  402.         (void)key;

  403.         (void)value;

  404.     }

  405. 

  406.     // ---------------------------------------------

  407.     // DISTRHO Plugin Process

  408. 

  409.     void d_activate() override

  410.     {

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

  412.         {

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

  414. 

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

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

  417.         }

  418. 

  419.         carla_copyFloat(fPrevParamBuffers, fParamBuffers, kParamCount);

  420.     }

  421. 

  422.     void d_deactivate() override

  423.     {

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

  425.         {

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

  427. 

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

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

  430.         }

  431. 

  432.         // just in case

  433.         proccessPendingEvents();

  434.     }

  435. 

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

  437.     {

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

  439.         {

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

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

  442.             return proccessPendingEvents();

  443.         }

  444. 

  445.         // ---------------------------------------------------------------

  446.         // create audio buffers

  447. 

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

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

  450. 

  451.         // ---------------------------------------------------------------

  452.         // initialize input events

  453. 

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

  455.         {

  456.             uint32_t engineEventIndex = 0;

  457. 

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

  459.             {

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

  461.                     continue;

  462. 

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

  464.                 engineEvent.clear();

  465. 

  466.                 engineEvent.type    = kEngineEventTypeControl;

  467.                 engineEvent.time    = 0;

  468.                 engineEvent.channel = 0;

  469. 

  470.                 engineEvent.ctrl.type  = kEngineControlEventTypeParameter;

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

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

  473. 

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

  475.             }

  476. 

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

  478.             {

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

  480. 

  481.                 if (midiEvent.size > 4)

  482.                     continue;

  483. 

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

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

  486. 

  487.                 // we don't want some events

  488.                 if (status == MIDI_STATUS_PROGRAM_CHANGE)

  489.                     continue;

  490. 

  491.                 // handle note/sound off properly

  492.                 if (status == MIDI_STATUS_CONTROL_CHANGE)

  493.                 {

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

  495. 

  496.                     if (MIDI_IS_CONTROL_BANK_SELECT(control))

  497.                         continue;

  498. 

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

  500.                     {

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

  502.                         engineEvent.clear();

  503. 

  504.                         engineEvent.type    = kEngineEventTypeControl;

  505.                         engineEvent.time    = midiEvent.frame;

  506.                         engineEvent.channel = channel;

  507. 

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

  509.                         engineEvent.ctrl.param = 0;

  510.                         engineEvent.ctrl.value = 0.0f;

  511. 

  512.                         continue;

  513.                     }

  514.                 }

  515. 

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

  517.                 engineEvent.clear();

  518. 

  519.                 engineEvent.type    = kEngineEventTypeMidi;

  520.                 engineEvent.time    = midiEvent.frame;

  521.                 engineEvent.channel = channel;

  522. 

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

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

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

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

  527.                 engineEvent.midi.size    = midiEvent.size;

  528.             }

  529.         }

  530. 

  531.         // ---------------------------------------------------------------

  532.         // process

  533. 

  534.         processRack(inBuf, outBuf, frames);

  535.         proccessPendingEvents();

  536.     }

  537. 

  538.     // ---------------------------------------------

  539.     // Callbacks

  540. 

  541.     void d_bufferSizeChanged(uint32_t newBufferSize) override

  542.     {

  543.         if (fBufferSize == newBufferSize)

  544.             return;

  545. 

  546.         fBufferSize = newBufferSize;

  547.         bufferSizeChanged(newBufferSize);

  548.     }

  549. 

  550.     void d_sampleRateChanged(double newSampleRate) override

  551.     {

  552.         if (fSampleRate == newSampleRate)

  553.             return;

  554. 

  555.         fSampleRate = newSampleRate;

  556.         sampleRateChanged(newSampleRate);

  557.     }

  558. 

  559.     // ---------------------------------------------

  560. 

  561. private:

  562.     float fParamBuffers[kParamCount];

  563.     float fPrevParamBuffers[kParamCount];

  564. };

  565. 

  566. CARLA_BACKEND_END_NAMESPACE

  567. 

  568. // -------------------------------------------------

  569. 

  570. START_NAMESPACE_DISTRHO

  571. 

  572. Plugin* createPlugin()

  573. {

  574.     return new CarlaBackend::CarlaEnginePlugin();

  575. }

  576. 

  577. END_NAMESPACE_DISTRHO

  578. 

  579. // -------------------------------------------------

  580. 

  581. #include "DistrhoPluginMain.cpp"