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.
639 Commits
2 Branches
20MB
Tree: e8783f4db4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e8783f4db4'
${ noResults }
Cadence/c++/carla-backend/carla_backend_plugin.cpp

502 lines
13KB
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.h"

  19. #include "carla_plugin.h"

  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. 

  44. class CarlaEnginePlugin : public CarlaEngine,

  45.                           public DISTRHO::Plugin

  46. {

  47. public:

  48.     short idZyn;

  49. 

  50.     CarlaEnginePlugin()

  51.         : CarlaEngine(),

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

  53.     {

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

  55. 

  56.         // init parameters

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

  58.             paramBuffers[i] = 0.0f;

  59. 

  60.         paramBuffers[paramVolume]  = 100.0f;

  61.         paramBuffers[paramBalance] = 63.5f;

  62.         paramBuffers[paramPan]     = 63.5f;

  63. 

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

  65. 

  66.         // set-up engine

  67.         carlaOptions.forceStereo = true;

  68.         carlaOptions.processMode = PROCESS_MODE_CONTINUOUS_RACK;

  69.         carlaOptions.preferPluginBridges = false;

  70.         carlaOptions.preferUiBridges = false;

  71.         init("Carla");

  72. 

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

  74.         // (liblo locks otherwise)

  75.         //startCheckThread();

  76. 

  77.         // testing

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

  79.     }

  80. 

  81.     ~CarlaEnginePlugin()

  82.     {

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

  84. 

  85.         removeAllPlugins();

  86.         close();

  87.     }

  88. 

  89.     // -------------------------------------

  90.     // CarlaEngine virtual calls

  91. 

  92.     bool init(const char* const clientName)

  93.     {

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

  95. 

  96.         bufferSize = d_bufferSize();

  97.         sampleRate = d_sampleRate();

  98. 

  99.         name = strdup(clientName);

  100.         CarlaEngine::init(name);

  101. 

  102.         return true;

  103.     }

  104. 

  105.     bool close()

  106.     {

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

  108.         CarlaEngine::close();

  109. 

  110.         if (name)

  111.         {

  112.             free((void*)name);

  113.             name = nullptr;

  114.         }

  115. 

  116.         return true;

  117.     }

  118. 

  119.     bool isOffline()

  120.     {

  121.         return false;

  122.     }

  123. 

  124.     bool isRunning()

  125.     {

  126.         return true;

  127.     }

  128. 

  129.     CarlaEngineClient* addClient(CarlaPlugin* const plugin)

  130.     {

  131.         CarlaEngineClientNativeHandle handle;

  132.         handle.type = CarlaEngineTypeRtAudio;

  133. 

  134.         return new CarlaEngineClient(handle);

  135.         Q_UNUSED(plugin);

  136.     }

  137. 

  138. protected:

  139.     // ---------------------------------------------

  140.     // DISTRHO Plugin Information

  141. 

  142.     const char* d_label()

  143.     {

  144.         return "Carla";

  145.     }

  146. 

  147.     const char* d_maker()

  148.     {

  149.         return "falkTX";

  150.     }

  151. 

  152.     const char* d_license()

  153.     {

  154.         return "GPL v2+";

  155.     }

  156. 

  157.     uint32_t d_version()

  158.     {

  159.         return 0x0500;

  160.     }

  161. 

  162.     long d_uniqueId()

  163.     {

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

  165.     }

  166. 

  167.     // ---------------------------------------------

  168.     // DISTRHO Plugin Init

  169. 

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

  171.     {

  172.         if (index >= paramCount)

  173.             return;

  174. 

  175.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  176.         parameter.ranges.def = 0.0f;

  177.         parameter.ranges.min = 0.0f;

  178.         parameter.ranges.max = 127.0f;

  179. 

  180.         if (index == paramVolume)

  181.             parameter.ranges.def = 100.0f;

  182.         else if (index == paramBalance)

  183.             parameter.ranges.def = 63.5f;

  184.         else if (index == paramPan)

  185.             parameter.ranges.def = 63.5f;

  186. 

  187.         switch (paramMap[index])

  188.         {

  189.         case 0x01:

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

  191.             break;

  192.         case 0x02:

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

  194.             break;

  195.         case 0x03:

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

  197.             break;

  198.         case 0x04:

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

  200.             break;

  201.         case 0x05:

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

  203.             break;

  204.         case 0x07:

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

  206.             break;

  207.         case 0x08:

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

  209.             break;

  210.         case 0x09:

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

  212.             break;

  213.         case 0x0A:

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

  215.             break;

  216.         case 0x0B:

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

  218.             break;

  219.         case 0x0C:

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

  221.             break;

  222.         case 0x0D:

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

  224.             break;

  225.         case 0x0E:

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

  227.             break;

  228.         case 0x0F:

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

  230.             break;

  231.         case 0x10:

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

  233.             break;

  234.         case 0x11:

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

  236.             break;

  237.         case 0x12:

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

  239.             break;

  240.         case 0x13:

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

  242.             break;

  243.         case 0x14:

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

  245.             break;

  246.         case 0x15:

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

  248.             break;

  249.         case 0x16:

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

  251.             break;

  252.         case 0x17:

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

  254.             break;

  255.         case 0x18:

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

  257.             break;

  258.         case 0x19:

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

  260.             break;

  261.         case 0x1A:

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

  263.             break;

  264.         case 0x1B:

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

  266.             break;

  267.         case 0x1C:

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

  269.             break;

  270.         case 0x1D:

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

  272.             break;

  273.         case 0x1E:

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

  275.             break;

  276.         case 0x1F:

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

  278.             break;

  279.         case 0x46:

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

  281.             break;

  282.         case 0x47:

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

  284.             break;

  285.         case 0x48:

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

  287.             break;

  288.         case 0x49:

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

  290.             break;

  291.         case 0x4A:

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

  293.             break;

  294.         case 0x4B:

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

  296.             break;

  297.         case 0x4C:

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

  299.             break;

  300.         case 0x4D:

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

  302.             break;

  303.         case 0x4E:

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

  305.             break;

  306.         case 0x4F:

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

  308.             break;

  309.         case 0x50:

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

  311.             break;

  312.         case 0x51:

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

  314.             break;

  315.         case 0x52:

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

  317.             break;

  318.         case 0x53:

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

  320.             break;

  321.         case 0x54:

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

  323.             break;

  324.         case 0x5B:

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

  326.             break;

  327.         case 0x5C:

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

  329.             break;

  330.         case 0x5D:

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

  332.             break;

  333.         case 0x5E:

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

  335.             break;

  336.         case 0x5F:

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

  338.             break;

  339.         }

  340.     }

  341. 

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

  343.     {

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

  345.     }

  346. 

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

  348.     {

  349.         Q_UNUSED(index);

  350.         Q_UNUSED(stateKey);

  351.     }

  352. 

  353.     // ---------------------------------------------

  354.     // DISTRHO Plugin Internal data

  355. 

  356.     float d_parameterValue(uint32_t index)

  357.     {

  358.         if (index >= paramCount)

  359.             return 0.0f;

  360. 

  361.         return paramBuffers[index];

  362.     }

  363. 

  364.     void  d_setParameterValue(uint32_t index, float value)

  365.     {

  366.         if (index >= paramCount)

  367.             return;

  368. 

  369.         paramBuffers[index] = value;

  370.     }

  371. 

  372.     void  d_setProgram(uint32_t index)

  373.     {

  374.         if (index >= programCount)

  375.             return;

  376.         if (maxPluginNumber() == 0)

  377.             return;

  378. 

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

  380.         {

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

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

  383.         }

  384.     }

  385. 

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

  387.     {

  388.         Q_UNUSED(key);

  389.         Q_UNUSED(value);

  390.     }

  391. 

  392.     // ---------------------------------------------

  393.     // DISTRHO Plugin Process

  394. 

  395.     void d_activate()

  396.     {

  397. //#if 0

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

  399.         {

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

  401. 

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

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

  404.         }

  405. //#endif

  406. 

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

  408.     }

  409. 

  410.     void d_deactivate()

  411.     {

  412. //#if 0

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

  414.         {

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

  416. 

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

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

  419.         }

  420. //#endif

  421.     }

  422. 

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

  424.     {

  425.         if (maxPluginNumber() == 0)

  426.             return;

  427. 

  428.         // create audio buffers

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

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

  431. 

  432.         // initialize control input

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

  434.         {

  435.             uint32_t carlaEventIndex = 0;

  436. 

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

  438.             {

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

  440.                     continue;

  441. 

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

  443. 

  444.                 carlaEvent->type       = CarlaEngineEventControlChange;

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

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

  447.             }

  448.         }

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

  450. 

  451.         // initialize midi input

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

  453.         {

  454.             const DISTRHO::MidiEvent* event;

  455. 

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

  457.             {

  458.                 if (i == MAX_ENGINE_MIDI_EVENTS)

  459.                     break;

  460. 

  461.                 event = &midiEvents[j];

  462. 

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

  464.                 rackMidiEventsIn[i].size = 3;

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

  466.                 i += 1;

  467.             }

  468.         }

  469. 

  470.         processRack(inBuf, outBuf, frames);

  471.     }

  472. 

  473.     // ---------------------------------------------

  474.     // Callbacks

  475. 

  476.     void d_bufferSizeChanged(uint32_t newBufferSize)

  477.     {

  478.         bufferSizeChanged(newBufferSize);

  479.     }

  480. 

  481.     // ---------------------------------------------

  482. 

  483. private:

  484.     float paramBuffers[paramCount];

  485.     float prevParamBuffers[paramCount];

  486. };

  487. 

  488. CARLA_BACKEND_END_NAMESPACE

  489. 

  490. // -------------------------------------------------

  491. 

  492. START_NAMESPACE_DISTRHO

  493. 

  494. Plugin* createPlugin()

  495. {

  496.     return new CarlaBackend::CarlaEnginePlugin();

  497. }

  498. 

  499. END_NAMESPACE_DISTRHO

  500. 

  501. #include "DistrhoPluginMain.cpp"