falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
182 Commits
17 Branches
341MB
Tree: e63cca4f73
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e63cca4f73'
${ noResults }
Carla/source/backend/engine/CarlaEnginePlugin.cpp

504 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.         fName = clientName;

  103.         fName.toBasic();

  104. 

  105.         CarlaEngine::init(fName);

  106.         return true;

  107.     }

  108. 

  109.     bool close()

  110.     {

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

  112.         CarlaEngine::close();

  113. 

  114.         return true;

  115.     }

  116. 

  117.     bool isRunning() const

  118.     {

  119.         return true;

  120.     }

  121. 

  122.     bool isOffline() const

  123.     {

  124.         return false;

  125.     }

  126. 

  127.     EngineType type() const

  128.     {

  129.         return kEngineTypeRtAudio;

  130.     }

  131. 

  132. protected:

  133.     // ---------------------------------------------

  134.     // DISTRHO Plugin Information

  135. 

  136.     const char* d_label() const

  137.     {

  138.         return "Carla";

  139.     }

  140. 

  141.     const char* d_maker() const

  142.     {

  143.         return "falkTX";

  144.     }

  145. 

  146.     const char* d_license() const

  147.     {

  148.         return "GPL v2+";

  149.     }

  150. 

  151.     uint32_t d_version() const

  152.     {

  153.         return 0x0500;

  154.     }

  155. 

  156.     long d_uniqueId() const

  157.     {

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

  159.     }

  160. 

  161.     // ---------------------------------------------

  162.     // DISTRHO Plugin Init

  163. 

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

  165.     {

  166.         if (index >= paramCount)

  167.             return;

  168. 

  169.         parameter.hints = DISTRHO::PARAMETER_IS_AUTOMABLE;

  170.         parameter.ranges.def = 0.0f;

  171.         parameter.ranges.min = 0.0f;

  172.         parameter.ranges.max = 127.0f;

  173. 

  174.         if (index == paramVolume)

  175.             parameter.ranges.def = 100.0f;

  176.         else if (index == paramBalance)

  177.             parameter.ranges.def = 63.5f;

  178.         else if (index == paramPan)

  179.             parameter.ranges.def = 63.5f;

  180. 

  181.         switch (paramMap[index])

  182.         {

  183.         case 0x01:

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

  185.             break;

  186.         case 0x02:

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

  188.             break;

  189.         case 0x03:

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

  191.             break;

  192.         case 0x04:

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

  194.             break;

  195.         case 0x05:

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

  197.             break;

  198.         case 0x07:

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

  200.             break;

  201.         case 0x08:

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

  203.             break;

  204.         case 0x09:

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

  206.             break;

  207.         case 0x0A:

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

  209.             break;

  210.         case 0x0B:

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

  212.             break;

  213.         case 0x0C:

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

  215.             break;

  216.         case 0x0D:

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

  218.             break;

  219.         case 0x0E:

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

  221.             break;

  222.         case 0x0F:

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

  224.             break;

  225.         case 0x10:

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

  227.             break;

  228.         case 0x11:

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

  230.             break;

  231.         case 0x12:

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

  233.             break;

  234.         case 0x13:

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

  236.             break;

  237.         case 0x14:

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

  239.             break;

  240.         case 0x15:

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

  242.             break;

  243.         case 0x16:

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

  245.             break;

  246.         case 0x17:

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

  248.             break;

  249.         case 0x18:

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

  251.             break;

  252.         case 0x19:

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

  254.             break;

  255.         case 0x1A:

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

  257.             break;

  258.         case 0x1B:

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

  260.             break;

  261.         case 0x1C:

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

  263.             break;

  264.         case 0x1D:

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

  266.             break;

  267.         case 0x1E:

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

  269.             break;

  270.         case 0x1F:

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

  272.             break;

  273.         case 0x46:

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

  275.             break;

  276.         case 0x47:

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

  278.             break;

  279.         case 0x48:

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

  281.             break;

  282.         case 0x49:

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

  284.             break;

  285.         case 0x4A:

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

  287.             break;

  288.         case 0x4B:

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

  290.             break;

  291.         case 0x4C:

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

  293.             break;

  294.         case 0x4D:

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

  296.             break;

  297.         case 0x4E:

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

  299.             break;

  300.         case 0x4F:

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

  302.             break;

  303.         case 0x50:

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

  305.             break;

  306.         case 0x51:

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

  308.             break;

  309.         case 0x52:

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

  311.             break;

  312.         case 0x53:

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

  314.             break;

  315.         case 0x54:

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

  317.             break;

  318.         case 0x5B:

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

  320.             break;

  321.         case 0x5C:

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

  323.             break;

  324.         case 0x5D:

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

  326.             break;

  327.         case 0x5E:

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

  329.             break;

  330.         case 0x5F:

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

  332.             break;

  333.         }

  334.     }

  335. 

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

  337.     {

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

  339.     }

  340. 

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

  342.     {

  343.         Q_UNUSED(index);

  344.         Q_UNUSED(stateKey);

  345.     }

  346. 

  347.     // ---------------------------------------------

  348.     // DISTRHO Plugin Internal data

  349. 

  350.     float d_parameterValue(uint32_t index)

  351.     {

  352.         if (index >= paramCount)

  353.             return 0.0f;

  354. 

  355.         return paramBuffers[index];

  356.     }

  357. 

  358.     void d_setParameterValue(uint32_t index, float value)

  359.     {

  360.         if (index >= paramCount)

  361.             return;

  362. 

  363.         paramBuffers[index] = value;

  364.     }

  365. 

  366.     void d_setProgram(uint32_t index)

  367.     {

  368.         if (index >= programCount)

  369.             return;

  370.         if (maxPluginNumber() == 0)

  371.             return;

  372. 

  373. #if 0

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

  375.         {

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

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

  378.         }

  379. #endif

  380.     }

  381. 

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

  383.     {

  384.         Q_UNUSED(key);

  385.         Q_UNUSED(value);

  386.     }

  387. 

  388.     // ---------------------------------------------

  389.     // DISTRHO Plugin Process

  390. 

  391.     void d_activate()

  392.     {

  393. #if 0

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

  395.         {

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

  397. 

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

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

  400.         }

  401. #endif

  402. 

  403.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  404.     }

  405. 

  406.     void d_deactivate()

  407.     {

  408. #if 0

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

  410.         {

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

  412. 

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

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

  415.         }

  416. #endif

  417.     }

  418. 

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

  420.     {

  421.         if (maxPluginNumber() == 0)

  422.             return;

  423. 

  424.         // create audio buffers

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

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

  427. 

  428. #if 0

  429.         // initialize control input

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

  431.         {

  432.             uint32_t carlaEventIndex = 0;

  433. 

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

  435.             {

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

  437.                     continue;

  438. 

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

  440. 

  441.                 carlaEvent->type      = CarlaEngineParameterChangeEvent;

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

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

  444.             }

  445.         }

  446.         carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);

  447. 

  448.         // initialize midi input

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

  450.         {

  451.             const DISTRHO::MidiEvent* event;

  452. 

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

  454.             {

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

  456.                     break;

  457. 

  458.                 event = &midiEvents[j];

  459. 

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

  461.                 rackMidiEventsIn[i].size = 3;

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

  463.                 i += 1;

  464.             }

  465.         }

  466. #endif

  467. 

  468.         processRack(inBuf, outBuf, frames);

  469.     }

  470. 

  471.     // ---------------------------------------------

  472.     // Callbacks

  473. 

  474.     void d_bufferSizeChanged(uint32_t newBufferSize)

  475.     {

  476.         bufferSizeChanged(newBufferSize);

  477.     }

  478. 

  479.     // ---------------------------------------------

  480. 

  481. private:

  482.     float paramBuffers[paramCount];

  483.     float prevParamBuffers[paramCount];

  484. };

  485. 

  486. CARLA_BACKEND_END_NAMESPACE

  487. 

  488. // -------------------------------------------------

  489. 

  490. START_NAMESPACE_DISTRHO

  491. 

  492. Plugin* createPlugin()

  493. {

  494.     return new CarlaBackend::CarlaEnginePlugin();

  495. }

  496. 

  497. END_NAMESPACE_DISTRHO

  498. 

  499. // -------------------------------------------------

  500. 

  501. #include "DistrhoPluginMain.cpp"

  502. 

  503. #endif // CARLA_ENGINE_PLUGIN