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.
45 Commits
16 Branches
191MB
Tree: 29542a2865
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '29542a2865'
${ noResults }
Carla/source/backend/engine/plugin.cpp

543 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_internal.hpp"

  21. #include "carla_backend_utils.hpp"

  22. #include "carla_midi.h"

  23. 

  24. #include "DistrhoPlugin.h"

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

  28. // -----------------------------------------

  29. // Parameters

  30. 

  31. static const unsigned char paramMap[] = {

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

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

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

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

  36. };

  37. 

  38. static const unsigned int paramVolume  = 5;

  39. static const unsigned int paramBalance = 6;

  40. static const unsigned int paramPan     = 8;

  41. 

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

  43. static const unsigned int programCount = 128;

  44. 

  45. // -------------------------------------------------------------------------------------------------------------------

  46. // Plugin Engine client

  47. 

  48. class CarlaEnginePluginClient : public CarlaEngineClient

  49. {

  50. public:

  51.     CarlaEnginePluginClient(const EngineType engineType, const ProcessMode processMode)

  52.         : CarlaEngineClient(engineType, processMode)

  53.     {

  54.     }

  55. 

  56.     ~CarlaEnginePluginClient()

  57.     {

  58.     }

  59. 

  60.     const CarlaEnginePort* addPort(const EnginePortType portType, const char* const name, const bool isInput)

  61.     {

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

  63. 

  64.         switch (portType)

  65.         {

  66.         case kEnginePortTypeNull:

  67.             break;

  68.         case kEnginePortTypeAudio:

  69.             return new CarlaEngineAudioPort(isInput, kProcessMode);

  70.         case kEnginePortTypeEvent:

  71.             return new CarlaEngineEventPort(isInput, kProcessMode);

  72.         }

  73. 

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

  75.         return nullptr;

  76.     }

  77. };

  78. 

  79. // -----------------------------------------

  80. 

  81. class CarlaEnginePlugin : public CarlaEngine,

  82.                           public DISTRHO::Plugin

  83. {

  84. public:

  85.     short idZyn;

  86. 

  87.     CarlaEnginePlugin()

  88.         : CarlaEngine(),

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

  90.     {

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

  92. 

  93.         // init parameters

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

  95.             paramBuffers[i] = 0.0f;

  96. 

  97.         paramBuffers[paramVolume]  = 100.0f;

  98.         paramBuffers[paramBalance] = 63.5f;

  99.         paramBuffers[paramPan]     = 63.5f;

  100. 

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

  102. 

  103.         // set-up engine

  104.         fOptions.processMode = PROCESS_MODE_CONTINUOUS_RACK;

  105.         fOptions.forceStereo = true;

  106.         fOptions.preferPluginBridges = false;

  107.         fOptions.preferUiBridges = false;

  108.         init("Carla");

  109. 

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

  111.         // (liblo locks otherwise)

  112.         //startCheckThread();

  113. 

  114.         // testing

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

  116.     }

  117. 

  118.     ~CarlaEnginePlugin()

  119.     {

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

  121. 

  122.         removeAllPlugins();

  123.         close();

  124.     }

  125. 

  126.     // -------------------------------------

  127.     // CarlaEngine virtual calls

  128. 

  129.     bool init(const char* const clientName)

  130.     {

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

  132. 

  133.         fBufferSize = d_bufferSize();

  134.         fSampleRate = d_sampleRate();

  135. 

  136.         fName = clientName;

  137.         fName.toBasic();

  138. 

  139.         CarlaEngine::init(fName);

  140.         return true;

  141.     }

  142. 

  143.     bool close()

  144.     {

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

  146.         CarlaEngine::close();

  147. 

  148.         return true;

  149.     }

  150. 

  151.     bool isRunning() const

  152.     {

  153.         return true;

  154.     }

  155. 

  156.     bool isOffline() const

  157.     {

  158.         return false;

  159.     }

  160. 

  161.     EngineType type() const

  162.     {

  163.         return kEngineTypeRtAudio;

  164.     }

  165. 

  166.     CarlaEngineClient* addClient(CarlaPlugin* const)

  167.     {

  168.         return new CarlaEnginePluginClient(kEngineTypePlugin, fOptions.processMode);

  169.     }

  170. 

  171. protected:

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

  173.     // DISTRHO Plugin Information

  174. 

  175.     const char* d_label() const

  176.     {

  177.         return "Carla";

  178.     }

  179. 

  180.     const char* d_maker() const

  181.     {

  182.         return "falkTX";

  183.     }

  184. 

  185.     const char* d_license() const

  186.     {

  187.         return "GPL v2+";

  188.     }

  189. 

  190.     uint32_t d_version() const

  191.     {

  192.         return 0x0500;

  193.     }

  194. 

  195.     long d_uniqueId() const

  196.     {

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

  198.     }

  199. 

  200.     // ---------------------------------------------

  201.     // DISTRHO Plugin Init

  202. 

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

  204.     {

  205.         if (index >= paramCount)

  206.             return;

  207. 

  208.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  209.         parameter.ranges.def = 0.0f;

  210.         parameter.ranges.min = 0.0f;

  211.         parameter.ranges.max = 127.0f;

  212. 

  213.         if (index == paramVolume)

  214.             parameter.ranges.def = 100.0f;

  215.         else if (index == paramBalance)

  216.             parameter.ranges.def = 63.5f;

  217.         else if (index == paramPan)

  218.             parameter.ranges.def = 63.5f;

  219. 

  220.         switch (paramMap[index])

  221.         {

  222.         case 0x01:

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

  224.             break;

  225.         case 0x02:

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

  227.             break;

  228.         case 0x03:

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

  230.             break;

  231.         case 0x04:

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

  233.             break;

  234.         case 0x05:

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

  236.             break;

  237.         case 0x07:

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

  239.             break;

  240.         case 0x08:

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

  242.             break;

  243.         case 0x09:

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

  245.             break;

  246.         case 0x0A:

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

  248.             break;

  249.         case 0x0B:

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

  251.             break;

  252.         case 0x0C:

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

  254.             break;

  255.         case 0x0D:

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

  257.             break;

  258.         case 0x0E:

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

  260.             break;

  261.         case 0x0F:

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

  263.             break;

  264.         case 0x10:

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

  266.             break;

  267.         case 0x11:

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

  269.             break;

  270.         case 0x12:

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

  272.             break;

  273.         case 0x13:

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

  275.             break;

  276.         case 0x14:

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

  278.             break;

  279.         case 0x15:

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

  281.             break;

  282.         case 0x16:

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

  284.             break;

  285.         case 0x17:

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

  287.             break;

  288.         case 0x18:

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

  290.             break;

  291.         case 0x19:

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

  293.             break;

  294.         case 0x1A:

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

  296.             break;

  297.         case 0x1B:

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

  299.             break;

  300.         case 0x1C:

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

  302.             break;

  303.         case 0x1D:

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

  305.             break;

  306.         case 0x1E:

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

  308.             break;

  309.         case 0x1F:

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

  311.             break;

  312.         case 0x46:

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

  314.             break;

  315.         case 0x47:

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

  317.             break;

  318.         case 0x48:

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

  320.             break;

  321.         case 0x49:

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

  323.             break;

  324.         case 0x4A:

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

  326.             break;

  327.         case 0x4B:

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

  329.             break;

  330.         case 0x4C:

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

  332.             break;

  333.         case 0x4D:

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

  335.             break;

  336.         case 0x4E:

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

  338.             break;

  339.         case 0x4F:

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

  341.             break;

  342.         case 0x50:

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

  344.             break;

  345.         case 0x51:

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

  347.             break;

  348.         case 0x52:

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

  350.             break;

  351.         case 0x53:

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

  353.             break;

  354.         case 0x54:

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

  356.             break;

  357.         case 0x5B:

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

  359.             break;

  360.         case 0x5C:

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

  362.             break;

  363.         case 0x5D:

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

  365.             break;

  366.         case 0x5E:

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

  368.             break;

  369.         case 0x5F:

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

  371.             break;

  372.         }

  373.     }

  374. 

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

  376.     {

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

  378.     }

  379. 

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

  381.     {

  382.         Q_UNUSED(index);

  383.         Q_UNUSED(stateKey);

  384.     }

  385. 

  386.     // ---------------------------------------------

  387.     // DISTRHO Plugin Internal data

  388. 

  389.     float d_parameterValue(uint32_t index)

  390.     {

  391.         if (index >= paramCount)

  392.             return 0.0f;

  393. 

  394.         return paramBuffers[index];

  395.     }

  396. 

  397.     void  d_setParameterValue(uint32_t index, float value)

  398.     {

  399.         if (index >= paramCount)

  400.             return;

  401. 

  402.         paramBuffers[index] = value;

  403.     }

  404. 

  405.     void  d_setProgram(uint32_t index)

  406.     {

  407.         if (index >= programCount)

  408.             return;

  409.         if (maxPluginNumber() == 0)

  410.             return;

  411. 

  412. #if 0

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

  414.         {

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

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

  417.         }

  418. #endif

  419.     }

  420. 

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

  422.     {

  423.         Q_UNUSED(key);

  424.         Q_UNUSED(value);

  425.     }

  426. 

  427.     // ---------------------------------------------

  428.     // DISTRHO Plugin Process

  429. 

  430.     void d_activate()

  431.     {

  432. #if 0

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

  434.         {

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

  436. 

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

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

  439.         }

  440. #endif

  441. 

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

  443.     }

  444. 

  445.     void d_deactivate()

  446.     {

  447. #if 0

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

  449.         {

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

  451. 

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

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

  454.         }

  455. #endif

  456.     }

  457. 

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

  459.     {

  460.         if (maxPluginNumber() == 0)

  461.             return;

  462. 

  463.         // create audio buffers

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

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

  466. 

  467. #if 0

  468.         // initialize control input

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

  470.         {

  471.             uint32_t carlaEventIndex = 0;

  472. 

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

  474.             {

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

  476.                     continue;

  477. 

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

  479. 

  480.                 carlaEvent->type      = CarlaEngineParameterChangeEvent;

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

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

  483.             }

  484.         }

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

  486. 

  487.         // initialize midi input

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

  489.         {

  490.             const DISTRHO::MidiEvent* event;

  491. 

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

  493.             {

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

  495.                     break;

  496. 

  497.                 event = &midiEvents[j];

  498. 

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

  500.                 rackMidiEventsIn[i].size = 3;

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

  502.                 i += 1;

  503.             }

  504.         }

  505. #endif

  506. 

  507.         processRack(inBuf, outBuf, frames);

  508.     }

  509. 

  510.     // ---------------------------------------------

  511.     // Callbacks

  512. 

  513.     void d_bufferSizeChanged(uint32_t newBufferSize)

  514.     {

  515.         bufferSizeChanged(newBufferSize);

  516.     }

  517. 

  518.     // ---------------------------------------------

  519. 

  520. private:

  521.     float paramBuffers[paramCount];

  522.     float prevParamBuffers[paramCount];

  523. };

  524. 

  525. CARLA_BACKEND_END_NAMESPACE

  526. 

  527. // -------------------------------------------------

  528. 

  529. START_NAMESPACE_DISTRHO

  530. 

  531. Plugin* createPlugin()

  532. {

  533.     return new CarlaBackend::CarlaEnginePlugin();

  534. }

  535. 

  536. END_NAMESPACE_DISTRHO

  537. 

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

  539. 

  540. #include "DistrhoPluginMain.cpp"

  541. 

  542. #endif // CARLA_ENGINE_PLUGIN