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

501 lines
13KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Engine

  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. #if 0 //def 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. 

  47. class CarlaEnginePlugin : public CarlaEngine,

  48.                           public DISTRHO::Plugin

  49. {

  50. public:

  51.     short idZyn;

  52. 

  53.     CarlaEnginePlugin()

  54.         : CarlaEngine(),

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

  56.     {

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

  58. 

  59.         // init parameters

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

  61.             paramBuffers[i] = 0.0f;

  62. 

  63.         paramBuffers[paramVolume]  = 100.0f;

  64.         paramBuffers[paramBalance] = 63.5f;

  65.         paramBuffers[paramPan]     = 63.5f;

  66. 

  67.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  68. 

  69.         // set-up engine

  70.         fOptions.processMode = PROCESS_MODE_CONTINUOUS_RACK;

  71.         fOptions.forceStereo = true;

  72.         fOptions.preferPluginBridges = false;

  73.         fOptions.preferUiBridges = false;

  74.         init("Carla");

  75. 

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

  77.         // (liblo locks otherwise)

  78.         //startCheckThread();

  79. 

  80.         // testing

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

  82.     }

  83. 

  84.     ~CarlaEnginePlugin()

  85.     {

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

  87. 

  88.         removeAllPlugins();

  89.         close();

  90.     }

  91. 

  92.     // -------------------------------------

  93.     // CarlaEngine virtual calls

  94. 

  95.     bool init(const char* const clientName)

  96.     {

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

  98. 

  99.         fBufferSize = d_bufferSize();

  100.         fSampleRate = d_sampleRate();

  101. 

  102.         CarlaEngine::init(clientName);

  103.         return true;

  104.     }

  105. 

  106.     bool close()

  107.     {

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

  109.         CarlaEngine::close();

  110. 

  111.         return true;

  112.     }

  113. 

  114.     bool isRunning() const

  115.     {

  116.         return true;

  117.     }

  118. 

  119.     bool isOffline() const

  120.     {

  121.         return false;

  122.     }

  123. 

  124.     EngineType type() const

  125.     {

  126.         return kEngineTypeRtAudio;

  127.     }

  128. 

  129. protected:

  130.     // ---------------------------------------------

  131.     // DISTRHO Plugin Information

  132. 

  133.     const char* d_label() const

  134.     {

  135.         return "Carla";

  136.     }

  137. 

  138.     const char* d_maker() const

  139.     {

  140.         return "falkTX";

  141.     }

  142. 

  143.     const char* d_license() const

  144.     {

  145.         return "GPL v2+";

  146.     }

  147. 

  148.     uint32_t d_version() const

  149.     {

  150.         return 0x0500;

  151.     }

  152. 

  153.     long d_uniqueId() const

  154.     {

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

  156.     }

  157. 

  158.     // ---------------------------------------------

  159.     // DISTRHO Plugin Init

  160. 

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

  162.     {

  163.         if (index >= paramCount)

  164.             return;

  165. 

  166.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  167.         parameter.ranges.def = 0.0f;

  168.         parameter.ranges.min = 0.0f;

  169.         parameter.ranges.max = 127.0f;

  170. 

  171.         if (index == paramVolume)

  172.             parameter.ranges.def = 100.0f;

  173.         else if (index == paramBalance)

  174.             parameter.ranges.def = 63.5f;

  175.         else if (index == paramPan)

  176.             parameter.ranges.def = 63.5f;

  177. 

  178.         switch (paramMap[index])

  179.         {

  180.         case 0x01:

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

  182.             break;

  183.         case 0x02:

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

  185.             break;

  186.         case 0x03:

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

  188.             break;

  189.         case 0x04:

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

  191.             break;

  192.         case 0x05:

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

  194.             break;

  195.         case 0x07:

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

  197.             break;

  198.         case 0x08:

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

  200.             break;

  201.         case 0x09:

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

  203.             break;

  204.         case 0x0A:

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

  206.             break;

  207.         case 0x0B:

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

  209.             break;

  210.         case 0x0C:

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

  212.             break;

  213.         case 0x0D:

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

  215.             break;

  216.         case 0x0E:

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

  218.             break;

  219.         case 0x0F:

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

  221.             break;

  222.         case 0x10:

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

  224.             break;

  225.         case 0x11:

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

  227.             break;

  228.         case 0x12:

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

  230.             break;

  231.         case 0x13:

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

  233.             break;

  234.         case 0x14:

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

  236.             break;

  237.         case 0x15:

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

  239.             break;

  240.         case 0x16:

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

  242.             break;

  243.         case 0x17:

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

  245.             break;

  246.         case 0x18:

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

  248.             break;

  249.         case 0x19:

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

  251.             break;

  252.         case 0x1A:

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

  254.             break;

  255.         case 0x1B:

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

  257.             break;

  258.         case 0x1C:

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

  260.             break;

  261.         case 0x1D:

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

  263.             break;

  264.         case 0x1E:

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

  266.             break;

  267.         case 0x1F:

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

  269.             break;

  270.         case 0x46:

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

  272.             break;

  273.         case 0x47:

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

  275.             break;

  276.         case 0x48:

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

  278.             break;

  279.         case 0x49:

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

  281.             break;

  282.         case 0x4A:

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

  284.             break;

  285.         case 0x4B:

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

  287.             break;

  288.         case 0x4C:

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

  290.             break;

  291.         case 0x4D:

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

  293.             break;

  294.         case 0x4E:

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

  296.             break;

  297.         case 0x4F:

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

  299.             break;

  300.         case 0x50:

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

  302.             break;

  303.         case 0x51:

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

  305.             break;

  306.         case 0x52:

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

  308.             break;

  309.         case 0x53:

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

  311.             break;

  312.         case 0x54:

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

  314.             break;

  315.         case 0x5B:

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

  317.             break;

  318.         case 0x5C:

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

  320.             break;

  321.         case 0x5D:

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

  323.             break;

  324.         case 0x5E:

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

  326.             break;

  327.         case 0x5F:

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

  329.             break;

  330.         }

  331.     }

  332. 

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

  334.     {

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

  336.     }

  337. 

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

  339.     {

  340.         Q_UNUSED(index);

  341.         Q_UNUSED(stateKey);

  342.     }

  343. 

  344.     // ---------------------------------------------

  345.     // DISTRHO Plugin Internal data

  346. 

  347.     float d_parameterValue(uint32_t index)

  348.     {

  349.         if (index >= paramCount)

  350.             return 0.0f;

  351. 

  352.         return paramBuffers[index];

  353.     }

  354. 

  355.     void d_setParameterValue(uint32_t index, float value)

  356.     {

  357.         if (index >= paramCount)

  358.             return;

  359. 

  360.         paramBuffers[index] = value;

  361.     }

  362. 

  363.     void d_setProgram(uint32_t index)

  364.     {

  365.         if (index >= programCount)

  366.             return;

  367.         if (maxPluginNumber() == 0)

  368.             return;

  369. 

  370. #if 0

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

  372.         {

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

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

  375.         }

  376. #endif

  377.     }

  378. 

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

  380.     {

  381.         Q_UNUSED(key);

  382.         Q_UNUSED(value);

  383.     }

  384. 

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

  386.     // DISTRHO Plugin Process

  387. 

  388.     void d_activate()

  389.     {

  390. #if 0

  391.         for (unsigned int i=0; i < fData->curPluginCount; i++)

  392.         {

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

  394. 

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

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

  397.         }

  398. #endif

  399. 

  400.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  401.     }

  402. 

  403.     void d_deactivate()

  404.     {

  405. #if 0

  406.         for (unsigned int i=0; i < fData->curPluginCount; i++)

  407.         {

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

  409. 

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

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

  412.         }

  413. #endif

  414.     }

  415. 

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

  417.     {

  418.         if (maxPluginNumber() == 0)

  419.             return;

  420. 

  421.         // create audio buffers

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

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

  424. 

  425. #if 0

  426.         // initialize control input

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

  428.         {

  429.             uint32_t carlaEventIndex = 0;

  430. 

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

  432.             {

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

  434.                     continue;

  435. 

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

  437. 

  438.                 carlaEvent->type      = CarlaEngineParameterChangeEvent;

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

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

  441.             }

  442.         }

  443.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  444. 

  445.         // initialize midi input

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

  447.         {

  448.             const DISTRHO::MidiEvent* event;

  449. 

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

  451.             {

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

  453.                     break;

  454. 

  455.                 event = &midiEvents[j];

  456. 

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

  458.                 rackMidiEventsIn[i].size = 3;

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

  460.                 i += 1;

  461.             }

  462.         }

  463. #endif

  464. 

  465.         processRack(inBuf, outBuf, frames);

  466.     }

  467. 

  468.     // ---------------------------------------------

  469.     // Callbacks

  470. 

  471.     void d_bufferSizeChanged(uint32_t newBufferSize)

  472.     {

  473.         bufferSizeChanged(newBufferSize);

  474.     }

  475. 

  476.     // ---------------------------------------------

  477. 

  478. private:

  479.     float paramBuffers[paramCount];

  480.     float prevParamBuffers[paramCount];

  481. };

  482. 

  483. CARLA_BACKEND_END_NAMESPACE

  484. 

  485. // -------------------------------------------------

  486. 

  487. START_NAMESPACE_DISTRHO

  488. 

  489. Plugin* createPlugin()

  490. {

  491.     return new CarlaBackend::CarlaEnginePlugin();

  492. }

  493. 

  494. END_NAMESPACE_DISTRHO

  495. 

  496. // -------------------------------------------------

  497. 

  498. #include "DistrhoPluginMain.cpp"

  499. 

  500. #endif // CARLA_ENGINE_PLUGIN