falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
664 Commits
2 Branches
24MB
Tree: 7ff10ddc4a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7ff10ddc4a'
${ noResults }
Cadence/c++/carla-engine/plugin.cpp

534 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

  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. #include "carla_engine.hpp"

  19. #include "carla_plugin.hpp"

  20. 

  21. #include "DistrhoPlugin.h"

  22. 

  23. CARLA_BACKEND_START_NAMESPACE

  24. 

  25. // -----------------------------------------

  26. // Parameters

  27. 

  28. static const unsigned char paramMap[] = {

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

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

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

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

  33. };

  34. 

  35. static const unsigned int paramVolume  = 5;

  36. static const unsigned int paramBalance = 6;

  37. static const unsigned int paramPan     = 8;

  38. 

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

  40. static const unsigned int programCount = 128;

  41. 

  42. // -------------------------------------------------------------------------------------------------------------------

  43. // Plugin Engine client

  44. 

  45. class CarlaEnginePluginClient : public CarlaEngineClient

  46. {

  47. public:

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

  49.         : CarlaEngineClient(engineType, processMode)

  50.     {

  51.     }

  52. 

  53.     ~CarlaEnginePluginClient()

  54.     {

  55.     }

  56. 

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

  58.     {

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

  60. 

  61.         switch (portType)

  62.         {

  63.         case CarlaEnginePortTypeNull:

  64.             break;

  65.         case CarlaEnginePortTypeAudio:

  66.             return new CarlaEngineAudioPort(isInput, processMode);

  67.         case CarlaEnginePortTypeControl:

  68.             return new CarlaEngineControlPort(isInput, processMode);

  69.         case CarlaEnginePortTypeMIDI:

  70.             return new CarlaEngineMidiPort(isInput, processMode);

  71.         }

  72. 

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

  74.         return nullptr;

  75.     }

  76. };

  77. 

  78. // -----------------------------------------

  79. 

  80. class CarlaEnginePlugin : public CarlaEngine,

  81.                           public DISTRHO::Plugin

  82. {

  83. public:

  84.     short idZyn;

  85. 

  86.     CarlaEnginePlugin()

  87.         : CarlaEngine(),

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

  89.     {

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

  91. 

  92.         // init parameters

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

  94.             paramBuffers[i] = 0.0f;

  95. 

  96.         paramBuffers[paramVolume]  = 100.0f;

  97.         paramBuffers[paramBalance] = 63.5f;

  98.         paramBuffers[paramPan]     = 63.5f;

  99. 

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

  101. 

  102.         // set-up engine

  103.         options.processMode = PROCESS_MODE_CONTINUOUS_RACK;

  104.         options.forceStereo = true;

  105.         options.preferPluginBridges = false;

  106.         options.preferUiBridges = false;

  107.         init("Carla");

  108. 

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

  110.         // (liblo locks otherwise)

  111.         //startCheckThread();

  112. 

  113.         // testing

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

  115.     }

  116. 

  117.     ~CarlaEnginePlugin()

  118.     {

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

  120. 

  121.         removeAllPlugins();

  122.         close();

  123.     }

  124. 

  125.     // -------------------------------------

  126.     // CarlaEngine virtual calls

  127. 

  128.     bool init(const char* const clientName)

  129.     {

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

  131. 

  132.         bufferSize = d_bufferSize();

  133.         sampleRate = d_sampleRate();

  134. 

  135.         name = clientName;

  136.         name.toBasic();

  137. 

  138.         CarlaEngine::init(name);

  139.         return true;

  140.     }

  141. 

  142.     bool close()

  143.     {

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

  145.         CarlaEngine::close();

  146. 

  147.         return true;

  148.     }

  149. 

  150.     bool isOffline() const

  151.     {

  152.         return false;

  153.     }

  154. 

  155.     bool isRunning() const

  156.     {

  157.         return true;

  158.     }

  159. 

  160.     CarlaEngineType type() const

  161.     {

  162.         return CarlaEngineTypeRtAudio;

  163.     }

  164. 

  165.     CarlaEngineClient* addClient(CarlaPlugin* const)

  166.     {

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

  168.     }

  169. 

  170. protected:

  171.     // ---------------------------------------------

  172.     // DISTRHO Plugin Information

  173. 

  174.     const char* d_label()

  175.     {

  176.         return "Carla";

  177.     }

  178. 

  179.     const char* d_maker()

  180.     {

  181.         return "falkTX";

  182.     }

  183. 

  184.     const char* d_license()

  185.     {

  186.         return "GPL v2+";

  187.     }

  188. 

  189.     uint32_t d_version()

  190.     {

  191.         return 0x0500;

  192.     }

  193. 

  194.     long d_uniqueId()

  195.     {

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

  197.     }

  198. 

  199.     // ---------------------------------------------

  200.     // DISTRHO Plugin Init

  201. 

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

  203.     {

  204.         if (index >= paramCount)

  205.             return;

  206. 

  207.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  208.         parameter.ranges.def = 0.0f;

  209.         parameter.ranges.min = 0.0f;

  210.         parameter.ranges.max = 127.0f;

  211. 

  212.         if (index == paramVolume)

  213.             parameter.ranges.def = 100.0f;

  214.         else if (index == paramBalance)

  215.             parameter.ranges.def = 63.5f;

  216.         else if (index == paramPan)

  217.             parameter.ranges.def = 63.5f;

  218. 

  219.         switch (paramMap[index])

  220.         {

  221.         case 0x01:

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

  223.             break;

  224.         case 0x02:

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

  226.             break;

  227.         case 0x03:

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

  229.             break;

  230.         case 0x04:

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

  232.             break;

  233.         case 0x05:

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

  235.             break;

  236.         case 0x07:

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

  238.             break;

  239.         case 0x08:

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

  241.             break;

  242.         case 0x09:

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

  244.             break;

  245.         case 0x0A:

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

  247.             break;

  248.         case 0x0B:

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

  250.             break;

  251.         case 0x0C:

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

  253.             break;

  254.         case 0x0D:

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

  256.             break;

  257.         case 0x0E:

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

  259.             break;

  260.         case 0x0F:

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

  262.             break;

  263.         case 0x10:

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

  265.             break;

  266.         case 0x11:

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

  268.             break;

  269.         case 0x12:

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

  271.             break;

  272.         case 0x13:

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

  274.             break;

  275.         case 0x14:

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

  277.             break;

  278.         case 0x15:

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

  280.             break;

  281.         case 0x16:

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

  283.             break;

  284.         case 0x17:

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

  286.             break;

  287.         case 0x18:

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

  289.             break;

  290.         case 0x19:

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

  292.             break;

  293.         case 0x1A:

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

  295.             break;

  296.         case 0x1B:

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

  298.             break;

  299.         case 0x1C:

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

  301.             break;

  302.         case 0x1D:

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

  304.             break;

  305.         case 0x1E:

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

  307.             break;

  308.         case 0x1F:

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

  310.             break;

  311.         case 0x46:

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

  313.             break;

  314.         case 0x47:

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

  316.             break;

  317.         case 0x48:

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

  319.             break;

  320.         case 0x49:

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

  322.             break;

  323.         case 0x4A:

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

  325.             break;

  326.         case 0x4B:

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

  328.             break;

  329.         case 0x4C:

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

  331.             break;

  332.         case 0x4D:

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

  334.             break;

  335.         case 0x4E:

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

  337.             break;

  338.         case 0x4F:

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

  340.             break;

  341.         case 0x50:

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

  343.             break;

  344.         case 0x51:

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

  346.             break;

  347.         case 0x52:

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

  349.             break;

  350.         case 0x53:

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

  352.             break;

  353.         case 0x54:

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

  355.             break;

  356.         case 0x5B:

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

  358.             break;

  359.         case 0x5C:

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

  361.             break;

  362.         case 0x5D:

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

  364.             break;

  365.         case 0x5E:

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

  367.             break;

  368.         case 0x5F:

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

  370.             break;

  371.         }

  372.     }

  373. 

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

  375.     {

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

  377.     }

  378. 

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

  380.     {

  381.         Q_UNUSED(index);

  382.         Q_UNUSED(stateKey);

  383.     }

  384. 

  385.     // ---------------------------------------------

  386.     // DISTRHO Plugin Internal data

  387. 

  388.     float d_parameterValue(uint32_t index)

  389.     {

  390.         if (index >= paramCount)

  391.             return 0.0f;

  392. 

  393.         return paramBuffers[index];

  394.     }

  395. 

  396.     void  d_setParameterValue(uint32_t index, float value)

  397.     {

  398.         if (index >= paramCount)

  399.             return;

  400. 

  401.         paramBuffers[index] = value;

  402.     }

  403. 

  404.     void  d_setProgram(uint32_t index)

  405.     {

  406.         if (index >= programCount)

  407.             return;

  408.         if (maxPluginNumber() == 0)

  409.             return;

  410. 

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

  412.         {

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

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

  415.         }

  416.     }

  417. 

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

  419.     {

  420.         Q_UNUSED(key);

  421.         Q_UNUSED(value);

  422.     }

  423. 

  424.     // ---------------------------------------------

  425.     // DISTRHO Plugin Process

  426. 

  427.     void d_activate()

  428.     {

  429. //#if 0

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

  431.         {

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

  433. 

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

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

  436.         }

  437. //#endif

  438. 

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

  440.     }

  441. 

  442.     void d_deactivate()

  443.     {

  444. //#if 0

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

  446.         {

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

  448. 

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

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

  451.         }

  452. //#endif

  453.     }

  454. 

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

  456.     {

  457.         if (maxPluginNumber() == 0)

  458.             return;

  459. 

  460.         // create audio buffers

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

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

  463. 

  464.         // initialize control input

  465.         memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);

  466.         {

  467.             uint32_t carlaEventIndex = 0;

  468. 

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

  470.             {

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

  472.                     continue;

  473. 

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

  475. 

  476.                 carlaEvent->type       = CarlaEngineParameterChangeEvent;

  477.                 carlaEvent->controller = paramMap[i];

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

  479.             }

  480.         }

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

  482. 

  483.         // initialize midi input

  484.         memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);

  485.         {

  486.             const DISTRHO::MidiEvent* event;

  487. 

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

  489.             {

  490.                 if (i == MAX_ENGINE_MIDI_EVENTS)

  491.                     break;

  492. 

  493.                 event = &midiEvents[j];

  494. 

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

  496.                 rackMidiEventsIn[i].size = 3;

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

  498.                 i += 1;

  499.             }

  500.         }

  501. 

  502.         processRack(inBuf, outBuf, frames);

  503.     }

  504. 

  505.     // ---------------------------------------------

  506.     // Callbacks

  507. 

  508.     void d_bufferSizeChanged(uint32_t newBufferSize)

  509.     {

  510.         bufferSizeChanged(newBufferSize);

  511.     }

  512. 

  513.     // ---------------------------------------------

  514. 

  515. private:

  516.     float paramBuffers[paramCount];

  517.     float prevParamBuffers[paramCount];

  518. };

  519. 

  520. CARLA_BACKEND_END_NAMESPACE

  521. 

  522. // -------------------------------------------------

  523. 

  524. START_NAMESPACE_DISTRHO

  525. 

  526. Plugin* createPlugin()

  527. {

  528.     return new CarlaBackend::CarlaEnginePlugin();

  529. }

  530. 

  531. END_NAMESPACE_DISTRHO

  532. 

  533. #include "DistrhoPluginMain.cpp"