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.
239 Commits
16 Branches
14GB
Tree: 9b46d3124f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9b46d3124f'
${ noResults }
Carla/source/backend/plugin/FluidSynthPlugin.cpp

1491 lines
53KB
Raw Blame History 

  1. /*

  2.  * Carla FluidSynth Plugin

  3.  * Copyright (C) 2011-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. #include "CarlaPluginInternal.hpp"

  19. 

  20. #ifdef WANT_FLUIDSYNTH

  21. 

  22. #include <fluidsynth.h>

  23. 

  24. #define FLUIDSYNTH_VERSION_NEW_API (FLUIDSYNTH_VERSION_MAJOR >= 1 && FLUIDSYNTH_VERSION_MINOR >= 1 && FLUIDSYNTH_VERSION_MICRO >= 4)

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

  28. class FluidSynthPlugin : public CarlaPlugin

  29. {

  30. public:

  31.     FluidSynthPlugin(CarlaEngine* const engine, const unsigned int id, const bool use16Outs)

  32.         : CarlaPlugin(engine, id),

  33.           kUses16Outs(use16Outs),

  34.           fSettings(nullptr),

  35.           fSynth(nullptr),

  36.           fSynthId(-1),

  37.           fAudio16Buffers(nullptr)

  38.     {

  39.         carla_debug("FluidSynthPlugin::FluidSynthPlugin(%p, %i, %s)", engine, id,  bool2str(use16Outs));

  40. 

  41.         // create settings

  42.         fSettings = new_fluid_settings();

  43. 

  44.         // define settings

  45.         fluid_settings_setint(fSettings, "synth.audio-channels", use16Outs ? 16 : 1);

  46.         fluid_settings_setint(fSettings, "synth.audio-groups", use16Outs ? 16 : 1);

  47.         fluid_settings_setnum(fSettings, "synth.sample-rate", kData->engine->getSampleRate());

  48.         fluid_settings_setint(fSettings, "synth.threadsafe-api ", 0);

  49. 

  50.         // create synth

  51.         fSynth = new_fluid_synth(fSettings);

  52. 

  53. #ifdef FLUIDSYNTH_VERSION_NEW_API

  54.         fluid_synth_set_sample_rate(fSynth, kData->engine->getSampleRate());

  55. #endif

  56. 

  57.         // set default values

  58.         fluid_synth_set_reverb_on(fSynth, 0);

  59.         fluid_synth_set_reverb(fSynth, FLUID_REVERB_DEFAULT_ROOMSIZE, FLUID_REVERB_DEFAULT_DAMP, FLUID_REVERB_DEFAULT_WIDTH, FLUID_REVERB_DEFAULT_LEVEL);

  60. 

  61.         fluid_synth_set_chorus_on(fSynth, 0);

  62.         fluid_synth_set_chorus(fSynth, FLUID_CHORUS_DEFAULT_N, FLUID_CHORUS_DEFAULT_LEVEL, FLUID_CHORUS_DEFAULT_SPEED, FLUID_CHORUS_DEFAULT_DEPTH, FLUID_CHORUS_DEFAULT_TYPE);

  63. 

  64.         fluid_synth_set_polyphony(fSynth, 64);

  65. 

  66.         for (int i=0; i < 16; i++)

  67.             fluid_synth_set_interp_method(fSynth, i, FLUID_INTERP_DEFAULT);

  68.     }

  69. 

  70.     ~FluidSynthPlugin()

  71.     {

  72.         carla_debug("FluidSynthPlugin::~FluidSynthPlugin()");

  73. 

  74.         kData->singleMutex.lock();

  75.         kData->masterMutex.lock();

  76. 

  77.         delete_fluid_synth(fSynth);

  78.         delete_fluid_settings(fSettings);

  79. 

  80.         deleteBuffers();

  81.     }

  82. 

  83.     // -------------------------------------------------------------------

  84.     // Information (base)

  85. 

  86.     PluginType type() const

  87.     {

  88.         return PLUGIN_SF2;

  89.     }

  90. 

  91.     PluginCategory category()

  92.     {

  93.         return PLUGIN_CATEGORY_SYNTH;

  94.     }

  95. 

  96.     // -------------------------------------------------------------------

  97.     // Information (count)

  98. 

  99.     uint32_t parameterScalePointCount(const uint32_t parameterId) const

  100.     {

  101.         CARLA_ASSERT(parameterId < kData->param.count);

  102. 

  103.         switch (parameterId)

  104.         {

  105.         case FluidSynthChorusType:

  106.             return 2;

  107.         case FluidSynthInterpolation:

  108.             return 4;

  109.         default:

  110.             return 0;

  111.         }

  112.     }

  113. 

  114.     // -------------------------------------------------------------------

  115.     // Information (per-plugin data)

  116. 

  117.     unsigned int availableOptions()

  118.     {

  119.         unsigned int options = 0x0;

  120. 

  121.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  122.         options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  123.         options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  124.         options |= PLUGIN_OPTION_SEND_PITCHBEND;

  125.         options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  126. 

  127.         return options;

  128.     }

  129. 

  130.     float getParameterValue(const uint32_t parameterId)

  131.     {

  132.         CARLA_ASSERT(parameterId < kData->param.count);

  133. 

  134.         return fParamBuffers[parameterId];

  135.     }

  136. 

  137.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId)

  138.     {

  139.         CARLA_ASSERT(parameterId < kData->param.count);

  140.         CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  141. 

  142.         switch (parameterId)

  143.         {

  144.         case FluidSynthChorusType:

  145.             switch (scalePointId)

  146.             {

  147.             case 0:

  148.                 return FLUID_CHORUS_MOD_SINE;

  149.             case 1:

  150.                 return FLUID_CHORUS_MOD_TRIANGLE;

  151.             default:

  152.                 return FLUID_CHORUS_DEFAULT_TYPE;

  153.             }

  154.         case FluidSynthInterpolation:

  155.             switch (scalePointId)

  156.             {

  157.             case 0:

  158.                 return FLUID_INTERP_NONE;

  159.             case 1:

  160.                 return FLUID_INTERP_LINEAR;

  161.             case 2:

  162.                 return FLUID_INTERP_4THORDER;

  163.             case 3:

  164.                 return FLUID_INTERP_7THORDER;

  165.             default:

  166.                 return FLUID_INTERP_DEFAULT;

  167.             }

  168.         default:

  169.             return 0.0f;

  170.         }

  171.     }

  172. 

  173.     void getLabel(char* const strBuf)

  174.     {

  175.         if (fLabel.isNotEmpty())

  176.             std::strncpy(strBuf, (const char*)fLabel, STR_MAX);

  177.         else

  178.             CarlaPlugin::getLabel(strBuf);

  179.     }

  180. 

  181.     void getMaker(char* const strBuf)

  182.     {

  183.         std::strncpy(strBuf, "FluidSynth SF2 engine", STR_MAX);

  184.     }

  185. 

  186.     void getCopyright(char* const strBuf)

  187.     {

  188.         std::strncpy(strBuf, "GNU GPL v2+", STR_MAX);

  189.     }

  190. 

  191.     void getRealName(char* const strBuf)

  192.     {

  193.         getLabel(strBuf);

  194.     }

  195. 

  196.     void getParameterName(const uint32_t parameterId, char* const strBuf)

  197.     {

  198.         CARLA_ASSERT(parameterId < kData->param.count);

  199. 

  200.         switch (parameterId)

  201.         {

  202.         case FluidSynthReverbOnOff:

  203.             std::strncpy(strBuf, "Reverb On/Off", STR_MAX);

  204.             break;

  205.         case FluidSynthReverbRoomSize:

  206.             std::strncpy(strBuf, "Reverb Room Size", STR_MAX);

  207.             break;

  208.         case FluidSynthReverbDamp:

  209.             std::strncpy(strBuf, "Reverb Damp", STR_MAX);

  210.             break;

  211.         case FluidSynthReverbLevel:

  212.             std::strncpy(strBuf, "Reverb Level", STR_MAX);

  213.             break;

  214.         case FluidSynthReverbWidth:

  215.             std::strncpy(strBuf, "Reverb Width", STR_MAX);

  216.             break;

  217.         case FluidSynthChorusOnOff:

  218.             std::strncpy(strBuf, "Chorus On/Off", STR_MAX);

  219.             break;

  220.         case FluidSynthChorusNr:

  221.             std::strncpy(strBuf, "Chorus Voice Count", STR_MAX);

  222.             break;

  223.         case FluidSynthChorusLevel:

  224.             std::strncpy(strBuf, "Chorus Level", STR_MAX);

  225.             break;

  226.         case FluidSynthChorusSpeedHz:

  227.             std::strncpy(strBuf, "Chorus Speed", STR_MAX);

  228.             break;

  229.         case FluidSynthChorusDepthMs:

  230.             std::strncpy(strBuf, "Chorus Depth", STR_MAX);

  231.             break;

  232.         case FluidSynthChorusType:

  233.             std::strncpy(strBuf, "Chorus Type", STR_MAX);

  234.             break;

  235.         case FluidSynthPolyphony:

  236.             std::strncpy(strBuf, "Polyphony", STR_MAX);

  237.             break;

  238.         case FluidSynthInterpolation:

  239.             std::strncpy(strBuf, "Interpolation", STR_MAX);

  240.             break;

  241.         case FluidSynthVoiceCount:

  242.             std::strncpy(strBuf, "Voice Count", STR_MAX);

  243.             break;

  244.         default:

  245.             CarlaPlugin::getParameterName(parameterId, strBuf);

  246.             break;

  247.         }

  248.     }

  249. 

  250.     void getParameterUnit(const uint32_t parameterId, char* const strBuf)

  251.     {

  252.         CARLA_ASSERT(parameterId < kData->param.count);

  253. 

  254.         switch (parameterId)

  255.         {

  256.         case FluidSynthChorusSpeedHz:

  257.             std::strncpy(strBuf, "Hz", STR_MAX);

  258.             break;

  259.         case FluidSynthChorusDepthMs:

  260.             std::strncpy(strBuf, "ms", STR_MAX);

  261.             break;

  262.         default:

  263.             CarlaPlugin::getParameterUnit(parameterId, strBuf);

  264.             break;

  265.         }

  266.     }

  267. 

  268.     void getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf)

  269.     {

  270.         CARLA_ASSERT(parameterId < kData->param.count);

  271.         CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  272. 

  273.         switch (parameterId)

  274.         {

  275.         case FluidSynthChorusType:

  276.             switch (scalePointId)

  277.             {

  278.             case 0:

  279.                 std::strncpy(strBuf, "Sine wave", STR_MAX);

  280.                 return;

  281.             case 1:

  282.                 std::strncpy(strBuf, "Triangle wave", STR_MAX);

  283.                 return;

  284.             }

  285.         case FluidSynthInterpolation:

  286.             switch (scalePointId)

  287.             {

  288.             case 0:

  289.                 std::strncpy(strBuf, "None", STR_MAX);

  290.                 return;

  291.             case 1:

  292.                 std::strncpy(strBuf, "Straight-line", STR_MAX);

  293.                 return;

  294.             case 2:

  295.                 std::strncpy(strBuf, "Fourth-order", STR_MAX);

  296.                 return;

  297.             case 3:

  298.                 std::strncpy(strBuf, "Seventh-order", STR_MAX);

  299.                 return;

  300.             }

  301.         }

  302. 

  303.         CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  304.     }

  305. 

  306.     // -------------------------------------------------------------------

  307.     // Set data (plugin-specific stuff)

  308. 

  309.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback)

  310.     {

  311.         CARLA_ASSERT(parameterId < kData->param.count);

  312. 

  313.         const float fixedValue = kData->param.fixValue(parameterId, value);

  314.         fParamBuffers[parameterId] = fixedValue;

  315. 

  316.         {

  317.             const ScopedProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  318. 

  319.             switch (parameterId)

  320.             {

  321.             case FluidSynthReverbOnOff:

  322.                 fluid_synth_set_reverb_on(fSynth, (fixedValue > 0.5f) ? 1 : 0);

  323.                 break;

  324. 

  325.             case FluidSynthReverbRoomSize:

  326.             case FluidSynthReverbDamp:

  327.             case FluidSynthReverbLevel:

  328.             case FluidSynthReverbWidth:

  329.                 fluid_synth_set_reverb(fSynth, fParamBuffers[FluidSynthReverbRoomSize], fParamBuffers[FluidSynthReverbDamp], fParamBuffers[FluidSynthReverbWidth], fParamBuffers[FluidSynthReverbLevel]);

  330.                 break;

  331. 

  332.             case FluidSynthChorusOnOff:

  333.                 fluid_synth_set_chorus_on(fSynth, (value > 0.5f) ? 1 : 0);

  334.                 break;

  335. 

  336.             case FluidSynthChorusNr:

  337.             case FluidSynthChorusLevel:

  338.             case FluidSynthChorusSpeedHz:

  339.             case FluidSynthChorusDepthMs:

  340.             case FluidSynthChorusType:

  341.                 fluid_synth_set_chorus(fSynth, fParamBuffers[FluidSynthChorusNr], fParamBuffers[FluidSynthChorusLevel], fParamBuffers[FluidSynthChorusSpeedHz], fParamBuffers[FluidSynthChorusDepthMs], fParamBuffers[FluidSynthChorusType]);

  342.                 break;

  343. 

  344.             case FluidSynthPolyphony:

  345.                 fluid_synth_set_polyphony(fSynth, value);

  346.                 break;

  347. 

  348.             case FluidSynthInterpolation:

  349.                 for (int i=0; i < 16; i++)

  350.                     fluid_synth_set_interp_method(fSynth, i, value);

  351.                 break;

  352. 

  353.             default:

  354.                 break;

  355.             }

  356.         }

  357. 

  358.         CarlaPlugin::setParameterValue(parameterId, value, sendGui, sendOsc, sendCallback);

  359.     }

  360. 

  361.     void setMidiProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback)

  362.     {

  363.         CARLA_ASSERT(fSynth != nullptr);

  364.         CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(kData->midiprog.count));

  365. 

  366.         if (index < -1)

  367.             index = -1;

  368.         else if (index > static_cast<int32_t>(kData->midiprog.count))

  369.             return;

  370. 

  371.         if (kData->ctrlChannel < 0 || kData->ctrlChannel >= 16)

  372.             return;

  373. 

  374.         if (index >= 0)

  375.         {

  376.             const uint32_t bank    = kData->midiprog.data[index].bank;

  377.             const uint32_t program = kData->midiprog.data[index].program;

  378. 

  379.             const ScopedProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  380.             fluid_synth_program_select(fSynth, kData->ctrlChannel, fSynthId, bank, program);

  381.         }

  382. 

  383.         CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback);

  384.     }

  385. 

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

  387.     // Plugin state

  388. 

  389.     void reload()

  390.     {

  391.         carla_debug("FluidSynthPlugin::reload() - start");

  392.         CARLA_ASSERT(kData->engine != nullptr);

  393.         CARLA_ASSERT(fSynth != nullptr);

  394. 

  395.         const ProcessMode processMode(kData->engine->getProccessMode());

  396. 

  397.         // Safely disable plugin for reload

  398.         const ScopedDisabler sd(this);

  399. 

  400.         deleteBuffers();

  401. 

  402.         uint32_t aOuts, params, j;

  403.         aOuts  = kUses16Outs ? 32 : 2;

  404.         params = FluidSynthParametersMax;

  405. 

  406.         kData->audioOut.createNew(aOuts);

  407.         kData->param.createNew(params);

  408. 

  409.         const int   portNameSize = kData->engine->maxPortNameSize();

  410.         CarlaString portName;

  411. 

  412.         // ---------------------------------------

  413.         // Audio Outputs

  414. 

  415.         if (kUses16Outs)

  416.         {

  417.             for (j=0; j < 32; j++)

  418.             {

  419.                 portName.clear();

  420. 

  421.                 if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  422.                 {

  423.                     portName  = fName;

  424.                     portName += ":";

  425.                 }

  426. 

  427.                 portName += "out-";

  428. 

  429.                 if ((j+2)/2 < 9)

  430.                     portName += "0";

  431. 

  432.                 portName += CarlaString((j+2)/2);

  433. 

  434.                 if (j % 2 == 0)

  435.                     portName += "L";

  436.                 else

  437.                     portName += "R";

  438. 

  439.                 portName.truncate(portNameSize);

  440. 

  441.                 kData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  442.                 kData->audioOut.ports[j].rindex = j;

  443.             }

  444. 

  445.             fAudio16Buffers = new float*[aOuts];

  446. 

  447.             for (j=0; j < aOuts; j++)

  448.                 fAudio16Buffers[j] = nullptr;

  449.         }

  450.         else

  451.         {

  452.             // out-left

  453.             portName.clear();

  454. 

  455.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  456.             {

  457.                 portName  = fName;

  458.                 portName += ":";

  459.             }

  460. 

  461.             portName += "out-left";

  462.             portName.truncate(portNameSize);

  463. 

  464.             kData->audioOut.ports[0].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  465.             kData->audioOut.ports[0].rindex = 0;

  466. 

  467.             // out-right

  468.             portName.clear();

  469. 

  470.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  471.             {

  472.                 portName  = fName;

  473.                 portName += ":";

  474.             }

  475. 

  476.             portName += "out-right";

  477.             portName.truncate(portNameSize);

  478. 

  479.             kData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)kData->client->addPort(kEnginePortTypeAudio, portName, false);

  480.             kData->audioOut.ports[1].rindex = 1;

  481.         }

  482. 

  483.         // ---------------------------------------

  484.         // Event Input

  485. 

  486.         {

  487.             portName.clear();

  488. 

  489.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  490.             {

  491.                 portName  = fName;

  492.                 portName += ":";

  493.             }

  494. 

  495.             portName += "event-in";

  496.             portName.truncate(portNameSize);

  497. 

  498.             kData->event.portIn = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, true);

  499.         }

  500. 

  501.         // ---------------------------------------

  502.         // Event Output

  503. 

  504.         {

  505.             portName.clear();

  506. 

  507.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  508.             {

  509.                 portName  = fName;

  510.                 portName += ":";

  511.             }

  512. 

  513.             portName += "event-out";

  514.             portName.truncate(portNameSize);

  515. 

  516.             kData->event.portOut = (CarlaEngineEventPort*)kData->client->addPort(kEnginePortTypeEvent, portName, false);

  517.         }

  518. 

  519.         // ----------------------

  520.         j = FluidSynthReverbOnOff;

  521.         kData->param.data[j].index  = j;

  522.         kData->param.data[j].rindex = j;

  523.         kData->param.data[j].type   = PARAMETER_INPUT;

  524.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE | PARAMETER_IS_BOOLEAN;

  525.         kData->param.data[j].midiChannel = 0;

  526.         kData->param.data[j].midiCC = -1;

  527.         kData->param.ranges[j].min = 0.0f;

  528.         kData->param.ranges[j].max = 1.0f;

  529.         kData->param.ranges[j].def = 0.0f; // off

  530.         kData->param.ranges[j].step = 1.0f;

  531.         kData->param.ranges[j].stepSmall = 1.0f;

  532.         kData->param.ranges[j].stepLarge = 1.0f;

  533.         fParamBuffers[j] = kData->param.ranges[j].def;

  534. 

  535.         // ----------------------

  536.         j = FluidSynthReverbRoomSize;

  537.         kData->param.data[j].index  = j;

  538.         kData->param.data[j].rindex = j;

  539.         kData->param.data[j].type   = PARAMETER_INPUT;

  540.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE;

  541.         kData->param.data[j].midiChannel = 0;

  542.         kData->param.data[j].midiCC = -1;

  543.         kData->param.ranges[j].min = 0.0f;

  544.         kData->param.ranges[j].max = 1.2f;

  545.         kData->param.ranges[j].def = FLUID_REVERB_DEFAULT_ROOMSIZE;

  546.         kData->param.ranges[j].step = 0.01f;

  547.         kData->param.ranges[j].stepSmall = 0.0001f;

  548.         kData->param.ranges[j].stepLarge = 0.1f;

  549.         fParamBuffers[j] = kData->param.ranges[j].def;

  550. 

  551.         // ----------------------

  552.         j = FluidSynthReverbDamp;

  553.         kData->param.data[j].index  = j;

  554.         kData->param.data[j].rindex = j;

  555.         kData->param.data[j].type   = PARAMETER_INPUT;

  556.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE;

  557.         kData->param.data[j].midiChannel = 0;

  558.         kData->param.data[j].midiCC = -1;

  559.         kData->param.ranges[j].min = 0.0f;

  560.         kData->param.ranges[j].max = 1.0f;

  561.         kData->param.ranges[j].def = FLUID_REVERB_DEFAULT_DAMP;

  562.         kData->param.ranges[j].step = 0.01f;

  563.         kData->param.ranges[j].stepSmall = 0.0001f;

  564.         kData->param.ranges[j].stepLarge = 0.1f;

  565.         fParamBuffers[j] = kData->param.ranges[j].def;

  566. 

  567.         // ----------------------

  568.         j = FluidSynthReverbLevel;

  569.         kData->param.data[j].index  = j;

  570.         kData->param.data[j].rindex = j;

  571.         kData->param.data[j].type   = PARAMETER_INPUT;

  572.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE;

  573.         kData->param.data[j].midiChannel = 0;

  574.         kData->param.data[j].midiCC = MIDI_CONTROL_REVERB_SEND_LEVEL;

  575.         kData->param.ranges[j].min = 0.0f;

  576.         kData->param.ranges[j].max = 1.0f;

  577.         kData->param.ranges[j].def = FLUID_REVERB_DEFAULT_LEVEL;

  578.         kData->param.ranges[j].step = 0.01f;

  579.         kData->param.ranges[j].stepSmall = 0.0001f;

  580.         kData->param.ranges[j].stepLarge = 0.1f;

  581.         fParamBuffers[j] = kData->param.ranges[j].def;

  582. 

  583.         // ----------------------

  584.         j = FluidSynthReverbWidth;

  585.         kData->param.data[j].index  = j;

  586.         kData->param.data[j].rindex = j;

  587.         kData->param.data[j].type   = PARAMETER_INPUT;

  588.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE;

  589.         kData->param.data[j].midiChannel = 0;

  590.         kData->param.data[j].midiCC = -1;

  591.         kData->param.ranges[j].min = 0.0f;

  592.         kData->param.ranges[j].max = 10.0f; // should be 100, but that sounds too much

  593.         kData->param.ranges[j].def = FLUID_REVERB_DEFAULT_WIDTH;

  594.         kData->param.ranges[j].step = 0.01f;

  595.         kData->param.ranges[j].stepSmall = 0.0001f;

  596.         kData->param.ranges[j].stepLarge = 0.1f;

  597.         fParamBuffers[j] = kData->param.ranges[j].def;

  598. 

  599.         // ----------------------

  600.         j = FluidSynthChorusOnOff;

  601.         kData->param.data[j].index  = j;

  602.         kData->param.data[j].rindex = j;

  603.         kData->param.data[j].type   = PARAMETER_INPUT;

  604.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_BOOLEAN;

  605.         kData->param.data[j].midiChannel = 0;

  606.         kData->param.data[j].midiCC = -1;

  607.         kData->param.ranges[j].min = 0.0f;

  608.         kData->param.ranges[j].max = 1.0f;

  609.         kData->param.ranges[j].def = 0.0f; // off

  610.         kData->param.ranges[j].step = 1.0f;

  611.         kData->param.ranges[j].stepSmall = 1.0f;

  612.         kData->param.ranges[j].stepLarge = 1.0f;

  613.         fParamBuffers[j] = kData->param.ranges[j].def;

  614. 

  615.         // ----------------------

  616.         j = FluidSynthChorusNr;

  617.         kData->param.data[j].index  = j;

  618.         kData->param.data[j].rindex = j;

  619.         kData->param.data[j].type   = PARAMETER_INPUT;

  620.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  621.         kData->param.data[j].midiChannel = 0;

  622.         kData->param.data[j].midiCC = -1;

  623.         kData->param.ranges[j].min = 0.0f;

  624.         kData->param.ranges[j].max = 99.0f;

  625.         kData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_N;

  626.         kData->param.ranges[j].step = 1.0f;

  627.         kData->param.ranges[j].stepSmall = 1.0f;

  628.         kData->param.ranges[j].stepLarge = 10.0f;

  629.         fParamBuffers[j] = kData->param.ranges[j].def;

  630. 

  631.         // ----------------------

  632.         j = FluidSynthChorusLevel;

  633.         kData->param.data[j].index  = j;

  634.         kData->param.data[j].rindex = j;

  635.         kData->param.data[j].type   = PARAMETER_INPUT;

  636.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  637.         kData->param.data[j].midiChannel = 0;

  638.         kData->param.data[j].midiCC = 0; //MIDI_CONTROL_CHORUS_SEND_LEVEL;

  639.         kData->param.ranges[j].min = 0.0f;

  640.         kData->param.ranges[j].max = 10.0f;

  641.         kData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_LEVEL;

  642.         kData->param.ranges[j].step = 0.01f;

  643.         kData->param.ranges[j].stepSmall = 0.0001f;

  644.         kData->param.ranges[j].stepLarge = 0.1f;

  645.         fParamBuffers[j] = kData->param.ranges[j].def;

  646. 

  647.         // ----------------------

  648.         j = FluidSynthChorusSpeedHz;

  649.         kData->param.data[j].index  = j;

  650.         kData->param.data[j].rindex = j;

  651.         kData->param.data[j].type   = PARAMETER_INPUT;

  652.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  653.         kData->param.data[j].midiChannel = 0;

  654.         kData->param.data[j].midiCC = -1;

  655.         kData->param.ranges[j].min = 0.29f;

  656.         kData->param.ranges[j].max = 5.0f;

  657.         kData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_SPEED;

  658.         kData->param.ranges[j].step = 0.01f;

  659.         kData->param.ranges[j].stepSmall = 0.0001f;

  660.         kData->param.ranges[j].stepLarge = 0.1f;

  661.         fParamBuffers[j] = kData->param.ranges[j].def;

  662. 

  663.         // ----------------------

  664.         j = FluidSynthChorusDepthMs;

  665.         kData->param.data[j].index  = j;

  666.         kData->param.data[j].rindex = j;

  667.         kData->param.data[j].type   = PARAMETER_INPUT;

  668.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  669.         kData->param.data[j].midiChannel = 0;

  670.         kData->param.data[j].midiCC = -1;

  671.         kData->param.ranges[j].min = 0.0f;

  672.         kData->param.ranges[j].max = 2048000.0 / kData->engine->getSampleRate();

  673.         kData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_DEPTH;

  674.         kData->param.ranges[j].step = 0.01f;

  675.         kData->param.ranges[j].stepSmall = 0.0001f;

  676.         kData->param.ranges[j].stepLarge = 0.1f;

  677.         fParamBuffers[j] = kData->param.ranges[j].def;

  678. 

  679.         // ----------------------

  680.         j = FluidSynthChorusType;

  681.         kData->param.data[j].index  = j;

  682.         kData->param.data[j].rindex = j;

  683.         kData->param.data[j].type   = PARAMETER_INPUT;

  684.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;

  685.         kData->param.data[j].midiChannel = 0;

  686.         kData->param.data[j].midiCC = -1;

  687.         kData->param.ranges[j].min = FLUID_CHORUS_MOD_SINE;

  688.         kData->param.ranges[j].max = FLUID_CHORUS_MOD_TRIANGLE;

  689.         kData->param.ranges[j].def = FLUID_CHORUS_DEFAULT_TYPE;

  690.         kData->param.ranges[j].step = 1.0f;

  691.         kData->param.ranges[j].stepSmall = 1.0f;

  692.         kData->param.ranges[j].stepLarge = 1.0f;

  693.         fParamBuffers[j] = kData->param.ranges[j].def;

  694. 

  695.         // ----------------------

  696.         j = FluidSynthPolyphony;

  697.         kData->param.data[j].index  = j;

  698.         kData->param.data[j].rindex = j;

  699.         kData->param.data[j].type   = PARAMETER_INPUT;

  700.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  701.         kData->param.data[j].midiChannel = 0;

  702.         kData->param.data[j].midiCC = -1;

  703.         kData->param.ranges[j].min = 1.0f;

  704.         kData->param.ranges[j].max = 512.0f; // max theoric is 65535

  705.         kData->param.ranges[j].def = fluid_synth_get_polyphony(fSynth);

  706.         kData->param.ranges[j].step = 1.0f;

  707.         kData->param.ranges[j].stepSmall = 1.0f;

  708.         kData->param.ranges[j].stepLarge = 10.0f;

  709.         fParamBuffers[j] = kData->param.ranges[j].def;

  710. 

  711.         // ----------------------

  712.         j = FluidSynthInterpolation;

  713.         kData->param.data[j].index  = j;

  714.         kData->param.data[j].rindex = j;

  715.         kData->param.data[j].type   = PARAMETER_INPUT;

  716.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;

  717.         kData->param.data[j].midiChannel = 0;

  718.         kData->param.data[j].midiCC = -1;

  719.         kData->param.ranges[j].min = FLUID_INTERP_NONE;

  720.         kData->param.ranges[j].max = FLUID_INTERP_HIGHEST;

  721.         kData->param.ranges[j].def = FLUID_INTERP_DEFAULT;

  722.         kData->param.ranges[j].step = 1.0f;

  723.         kData->param.ranges[j].stepSmall = 1.0f;

  724.         kData->param.ranges[j].stepLarge = 1.0f;

  725.         fParamBuffers[j] = kData->param.ranges[j].def;

  726. 

  727.         // ----------------------

  728.         j = FluidSynthVoiceCount;

  729.         kData->param.data[j].index  = j;

  730.         kData->param.data[j].rindex = j;

  731.         kData->param.data[j].type   = PARAMETER_OUTPUT;

  732.         kData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMABLE | PARAMETER_IS_INTEGER;

  733.         kData->param.data[j].midiChannel = 0;

  734.         kData->param.data[j].midiCC = -1;

  735.         kData->param.ranges[j].min = 0.0f;

  736.         kData->param.ranges[j].max = 65535.0f;

  737.         kData->param.ranges[j].def = 0.0f;

  738.         kData->param.ranges[j].step = 1.0f;

  739.         kData->param.ranges[j].stepSmall = 1.0f;

  740.         kData->param.ranges[j].stepLarge = 1.0f;

  741.         fParamBuffers[j] = kData->param.ranges[j].def;

  742. 

  743.         // ---------------------------------------

  744. 

  745.         // plugin hints

  746.         fHints  = 0x0;

  747.         fHints |= PLUGIN_IS_RTSAFE;

  748.         fHints |= PLUGIN_IS_SYNTH;

  749.         fHints |= PLUGIN_CAN_VOLUME;

  750.         fHints |= PLUGIN_CAN_BALANCE;

  751. 

  752.         // extra plugin hints

  753.         kData->extraHints  = 0x0;

  754.         kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  755. 

  756.         // plugin options

  757.         fOptions  = 0x0;

  758.         fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  759.         fOptions |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  760.         fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  761.         fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  762.         fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  763. 

  764.         bufferSizeChanged(kData->engine->getBufferSize());

  765.         reloadPrograms(true);

  766. 

  767.         carla_debug("FluidSynthPlugin::reload() - end");

  768.     }

  769. 

  770.     void reloadPrograms(const bool init)

  771.     {

  772.         carla_debug("FluidSynthPlugin::reloadPrograms(%s)", bool2str(init));

  773. 

  774.         // Delete old programs

  775.         kData->midiprog.clear();

  776. 

  777.         // Query new programs

  778.         uint32_t count = 0;

  779.         fluid_sfont_t* f_sfont;

  780.         fluid_preset_t f_preset;

  781.         bool hasDrums = false;

  782. 

  783.         f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId);

  784. 

  785.         // initial check to know how much midi-programs we have

  786.         f_sfont->iteration_start(f_sfont);

  787.         while (f_sfont->iteration_next(f_sfont, &f_preset))

  788.             count += 1;

  789. 

  790.         // soundfonts must always have at least 1 midi-program

  791.         CARLA_ASSERT(count > 0);

  792. 

  793.         if (count == 0)

  794.             return;

  795. 

  796.         kData->midiprog.createNew(count);

  797. 

  798.         // Update data

  799.         uint32_t i = 0;

  800.         f_sfont->iteration_start(f_sfont);

  801. 

  802.         while (f_sfont->iteration_next(f_sfont, &f_preset))

  803.         {

  804.             CARLA_ASSERT(i < kData->midiprog.count);

  805.             kData->midiprog.data[i].bank    = f_preset.get_banknum(&f_preset);

  806.             kData->midiprog.data[i].program = f_preset.get_num(&f_preset);

  807.             kData->midiprog.data[i].name    = carla_strdup(f_preset.get_name(&f_preset));

  808. 

  809.             if (kData->midiprog.data[i].bank == 128)

  810.                 hasDrums = true;

  811. 

  812.             i++;

  813.         }

  814. 

  815.         //f_sfont->free(f_sfont);

  816. 

  817. #ifndef BUILD_BRIDGE

  818.         // Update OSC Names

  819.         if (kData->engine->isOscControlRegistered())

  820.         {

  821.             kData->engine->osc_send_control_set_midi_program_count(fId, count);

  822. 

  823.             for (i=0; i < count; i++)

  824.                 kData->engine->osc_send_control_set_midi_program_data(fId, i, kData->midiprog.data[i].bank, kData->midiprog.data[i].program, kData->midiprog.data[i].name);

  825.         }

  826. #endif

  827. 

  828.         if (init)

  829.         {

  830.             fluid_synth_program_reset(fSynth);

  831. 

  832.             // select first program, or 128 for ch10

  833.             for (i=0; i < 16 && i != 9; i++)

  834.             {

  835.                 fluid_synth_program_select(fSynth, i, fSynthId, kData->midiprog.data[0].bank, kData->midiprog.data[0].program);

  836. #ifdef FLUIDSYNTH_VERSION_NEW_API

  837.                 fluid_synth_set_channel_type(fSynth, i, CHANNEL_TYPE_MELODIC);

  838. #endif

  839.             }

  840. 

  841.             if (hasDrums)

  842.             {

  843.                 fluid_synth_program_select(fSynth, 9, fSynthId, 128, 0);

  844. #ifdef FLUIDSYNTH_VERSION_NEW_API

  845.                 fluid_synth_set_channel_type(fSynth, 9, CHANNEL_TYPE_DRUM);

  846. #endif

  847.             }

  848.             else

  849.             {

  850.                 fluid_synth_program_select(fSynth, 9, fSynthId, kData->midiprog.data[0].bank, kData->midiprog.data[0].program);

  851. #ifdef FLUIDSYNTH_VERSION_NEW_API

  852.                 fluid_synth_set_channel_type(fSynth, 9, CHANNEL_TYPE_MELODIC);

  853. #endif

  854.             }

  855. 

  856.             setMidiProgram(0, false, false, false);

  857.         }

  858.         else

  859.         {

  860.             kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0f, nullptr);

  861.         }

  862.     }

  863. 

  864.     // -------------------------------------------------------------------

  865.     // Plugin processing

  866. 

  867.     void process(float** const, float** const outBuffer, const uint32_t frames)

  868.     {

  869.         uint32_t i, k;

  870. 

  871.         // --------------------------------------------------------------------------------------------------------

  872.         // Check if active

  873. 

  874.         if (! kData->active)

  875.         {

  876.             // disable any output sound

  877.             for (i=0; i < kData->audioOut.count; i++)

  878.                 carla_zeroFloat(outBuffer[i], frames);

  879. 

  880.             kData->activeBefore = kData->active;

  881.             return;

  882.         }

  883. 

  884.         // --------------------------------------------------------------------------------------------------------

  885.         // Check if not active before

  886. 

  887.         if (kData->needsReset || ! kData->activeBefore)

  888.         {

  889.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  890.             {

  891.                 for (int c=0; c < MAX_MIDI_CHANNELS; c++)

  892.                 {

  893. #ifdef FLUIDSYNTH_VERSION_NEW_API

  894.                     fluid_synth_all_notes_off(fSynth, c);

  895.                     fluid_synth_all_sounds_off(fSynth, c);

  896. #else

  897.                     fluid_synth_cc(f_synth, c, MIDI_CONTROL_ALL_SOUND_OFF, 0);

  898.                     fluid_synth_cc(f_synth, c, MIDI_CONTROL_ALL_NOTES_OFF, 0);

  899. #endif

  900.                 }

  901.             }

  902. 

  903.             kData->needsReset = false;

  904.         }

  905. 

  906.         // --------------------------------------------------------------------------------------------------------

  907.         // Event Input and Processing

  908. 

  909.         if (kData->activeBefore)

  910.         {

  911.             // ----------------------------------------------------------------------------------------------------

  912.             // MIDI Input (External)

  913. 

  914.             if (kData->extNotes.mutex.tryLock())

  915.             {

  916.                 while (! kData->extNotes.data.isEmpty())

  917.                 {

  918.                     const ExternalMidiNote& note = kData->extNotes.data.getFirst(true);

  919. 

  920.                     CARLA_ASSERT(note.channel >= 0);

  921. 

  922.                     if (note.velo > 0)

  923.                         fluid_synth_noteon(fSynth, note.channel, note.note, note.velo);

  924.                     else

  925.                         fluid_synth_noteoff(fSynth,note.channel, note.note);

  926.                 }

  927. 

  928.                 kData->extNotes.mutex.unlock();

  929. 

  930.             } // End of MIDI Input (External)

  931. 

  932.             // ----------------------------------------------------------------------------------------------------

  933.             // Event Input (System)

  934. 

  935.             bool allNotesOffSent = false;

  936. 

  937.             uint32_t time, nEvents = kData->event.portIn->getEventCount();

  938.             uint32_t timeOffset = 0;

  939. 

  940.             uint32_t nextBankIds[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0 };

  941. 

  942.             if (kData->midiprog.current >= 0 && kData->midiprog.count > 0 && kData->ctrlChannel >= 0 && kData->ctrlChannel < 16)

  943.                 nextBankIds[kData->ctrlChannel] = kData->midiprog.data[kData->midiprog.current].bank;

  944. 

  945.             for (i=0; i < nEvents; i++)

  946.             {

  947.                 const EngineEvent& event = kData->event.portIn->getEvent(i);

  948. 

  949.                 time = event.time;

  950. 

  951.                 if (time >= frames)

  952.                     continue;

  953. 

  954.                 CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);

  955. 

  956.                 if (time > timeOffset)

  957.                 {

  958.                     if (processSingle(outBuffer, time - timeOffset, timeOffset))

  959.                     {

  960.                         timeOffset = time;

  961. 

  962.                         if (kData->midiprog.current >= 0 && kData->midiprog.count > 0 && kData->ctrlChannel >= 0 && kData->ctrlChannel < 16)

  963.                             nextBankIds[kData->ctrlChannel] = kData->midiprog.data[kData->midiprog.current].bank;

  964.                     }

  965.                 }

  966. 

  967.                 // Control change

  968.                 switch (event.type)

  969.                 {

  970.                 case kEngineEventTypeNull:

  971.                     break;

  972. 

  973.                 case kEngineEventTypeControl:

  974.                 {

  975.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  976. 

  977.                     switch (ctrlEvent.type)

  978.                     {

  979.                     case kEngineControlEventTypeNull:

  980.                         break;

  981. 

  982.                     case kEngineControlEventTypeParameter:

  983.                     {

  984.                         // Control backend stuff

  985.                         if (event.channel == kData->ctrlChannel)

  986.                         {

  987.                             float value;

  988. 

  989.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0)

  990.                             {

  991.                                 value = ctrlEvent.value;

  992.                                 setDryWet(value, false, false);

  993.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  994.                                 continue;

  995.                             }

  996. 

  997.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0)

  998.                             {

  999.                                 value = ctrlEvent.value*127.0f/100.0f;

  1000.                                 setVolume(value, false, false);

  1001.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1002.                                 continue;

  1003.                             }

  1004. 

  1005.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0)

  1006.                             {

  1007.                                 float left, right;

  1008.                                 value = ctrlEvent.value/0.5f - 1.0f;

  1009. 

  1010.                                 if (value < 0.0f)

  1011.                                 {

  1012.                                     left  = -1.0f;

  1013.                                     right = (value*2.0f)+1.0f;

  1014.                                 }

  1015.                                 else if (value > 0.0f)

  1016.                                 {

  1017.                                     left  = (value*2.0f)-1.0f;

  1018.                                     right = 1.0f;

  1019.                                 }

  1020.                                 else

  1021.                                 {

  1022.                                     left  = -1.0f;

  1023.                                     right = 1.0f;

  1024.                                 }

  1025. 

  1026.                                 setBalanceLeft(left, false, false);

  1027.                                 setBalanceRight(right, false, false);

  1028.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1029.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1030.                                 continue;

  1031.                             }

  1032.                         }

  1033. 

  1034.                         // Control plugin parameters

  1035.                         for (k=0; k < kData->param.count; k++)

  1036.                         {

  1037.                             if (kData->param.data[k].midiChannel != event.channel)

  1038.                                 continue;

  1039.                             if (kData->param.data[k].midiCC != ctrlEvent.param)

  1040.                                 continue;

  1041.                             if (kData->param.data[k].type != PARAMETER_INPUT)

  1042.                                 continue;

  1043.                             if ((kData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  1044.                                 continue;

  1045. 

  1046.                             float value;

  1047. 

  1048.                             if (kData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1049.                             {

  1050.                                 value = (ctrlEvent.value < 0.5f) ? kData->param.ranges[k].min : kData->param.ranges[k].max;

  1051.                             }

  1052.                             else

  1053.                             {

  1054.                                 value = kData->param.ranges[i].unnormalizeValue(ctrlEvent.value);

  1055. 

  1056.                                 if (kData->param.data[k].hints & PARAMETER_IS_INTEGER)

  1057.                                     value = std::rint(value);

  1058.                             }

  1059. 

  1060.                             setParameterValue(k, value, false, false, false);

  1061.                             postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1062.                         }

  1063. 

  1064.                         break;

  1065.                     }

  1066. 

  1067.                     case kEngineControlEventTypeMidiBank:

  1068.                         if (event.channel < 16)

  1069.                             nextBankIds[event.channel] = ctrlEvent.param;

  1070.                         break;

  1071. 

  1072.                     case kEngineControlEventTypeMidiProgram:

  1073.                         if (event.channel < 16)

  1074.                         {

  1075.                             const uint32_t bankId = nextBankIds[event.channel];

  1076.                             const uint32_t progId = ctrlEvent.param;

  1077. 

  1078.                             for (k=0; k < kData->midiprog.count; k++)

  1079.                             {

  1080.                                 if (kData->midiprog.data[k].bank == bankId && kData->midiprog.data[k].program == progId)

  1081.                                 {

  1082.                                     if (event.channel == kData->ctrlChannel)

  1083.                                     {

  1084.                                         setMidiProgram(k, false, false, false);

  1085.                                         postponeRtEvent(kPluginPostRtEventMidiProgramChange, k, 0, 0.0f);

  1086.                                     }

  1087.                                     else

  1088.                                         fluid_synth_program_select(fSynth, event.channel, fSynthId, bankId, progId);

  1089. 

  1090.                                     break;

  1091.                                 }

  1092.                             }

  1093.                         }

  1094.                         break;

  1095. 

  1096.                     case kEngineControlEventTypeAllSoundOff:

  1097.                         if (event.channel == kData->ctrlChannel)

  1098.                         {

  1099.                             if (! allNotesOffSent)

  1100.                             {

  1101.                                 allNotesOffSent = true;

  1102.                                 sendMidiAllNotesOff();

  1103.                             }

  1104. 

  1105.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 0.0f);

  1106.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 1.0f);

  1107. 

  1108.                             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1109.                             {

  1110. #ifdef FLUIDSYNTH_VERSION_NEW_API

  1111.                                 fluid_synth_all_sounds_off(fSynth, event.channel);

  1112. #else

  1113.                                 fluid_synth_cc(f_synth, event.channel, MIDI_CONTROL_ALL_SOUND_OFF, 0);

  1114. #endif

  1115.                             }

  1116.                         }

  1117.                         break;

  1118. 

  1119.                     case kEngineControlEventTypeAllNotesOff:

  1120.                         if (event.channel == kData->ctrlChannel)

  1121.                         {

  1122.                             if (! allNotesOffSent)

  1123.                             {

  1124.                                 allNotesOffSent = true;

  1125.                                 sendMidiAllNotesOff();

  1126.                             }

  1127. 

  1128.                             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1129.                             {

  1130. #ifdef FLUIDSYNTH_VERSION_NEW_API

  1131.                                 fluid_synth_all_notes_off(fSynth, event.channel);

  1132. #else

  1133.                                 fluid_synth_cc(f_synth, event.channel, MIDI_CONTROL_ALL_NOTES_OFF, 0);

  1134. #endif

  1135.                             }

  1136.                         }

  1137.                         break;

  1138.                     }

  1139. 

  1140.                     break;

  1141.                 }

  1142. 

  1143.                 case kEngineEventTypeMidi:

  1144.                 {

  1145.                     const EngineMidiEvent& midiEvent = event.midi;

  1146. 

  1147.                     uint8_t status  = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);

  1148.                     uint8_t channel = event.channel;

  1149. 

  1150.                     // Fix bad note-off

  1151.                     if (MIDI_IS_STATUS_NOTE_ON(status) && midiEvent.data[2] == 0)

  1152.                         status -= 0x10;

  1153. 

  1154.                     if (MIDI_IS_STATUS_NOTE_OFF(status))

  1155.                     {

  1156.                         const uint8_t note = midiEvent.data[1];

  1157. 

  1158.                         fluid_synth_noteoff(fSynth, channel, note);

  1159. 

  1160.                         postponeRtEvent(kPluginPostRtEventNoteOff, channel, note, 0.0f);

  1161.                     }

  1162.                     else if (MIDI_IS_STATUS_NOTE_ON(status))

  1163.                     {

  1164.                         const uint8_t note = midiEvent.data[1];

  1165.                         const uint8_t velo = midiEvent.data[2];

  1166. 

  1167.                         fluid_synth_noteon(fSynth, channel, note, velo);

  1168. 

  1169.                         postponeRtEvent(kPluginPostRtEventNoteOn, channel, note, velo);

  1170.                     }

  1171.                     else if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) != 0)

  1172.                     {

  1173.                         //const uint8_t note     = midiEvent.data[1];

  1174.                         //const uint8_t pressure = midiEvent.data[2];

  1175. 

  1176.                         // TODO, not in fluidsynth API

  1177.                     }

  1178.                     else if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0)

  1179.                     {

  1180.                         const uint8_t control = midiEvent.data[1];

  1181.                         const uint8_t value   = midiEvent.data[2];

  1182. 

  1183.                         fluid_synth_cc(fSynth, channel, control, value);

  1184.                     }

  1185.                     else if (MIDI_IS_STATUS_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) != 0)

  1186.                     {

  1187.                         const uint8_t pressure = midiEvent.data[1];

  1188. 

  1189.                         fluid_synth_channel_pressure(fSynth, channel, pressure);;

  1190.                     }

  1191.                     else if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (fOptions & PLUGIN_OPTION_SEND_PITCHBEND) != 0)

  1192.                     {

  1193.                         const uint8_t lsb = midiEvent.data[1];

  1194.                         const uint8_t msb = midiEvent.data[2];

  1195. 

  1196.                         fluid_synth_pitch_bend(fSynth, channel, (msb << 7) | lsb);

  1197.                     }

  1198. 

  1199.                     break;

  1200.                 }

  1201.                 }

  1202.             }

  1203. 

  1204.             kData->postRtEvents.trySplice();

  1205. 

  1206.             if (frames > timeOffset)

  1207.                 processSingle(outBuffer, frames - timeOffset, timeOffset);

  1208. 

  1209.         } // End of Event Input and Processing

  1210. 

  1211.         CARLA_PROCESS_CONTINUE_CHECK;

  1212. 

  1213.         // --------------------------------------------------------------------------------------------------------

  1214.         // Control Output

  1215. 

  1216.         {

  1217.             k = FluidSynthVoiceCount;

  1218.             fParamBuffers[k] = fluid_synth_get_active_voice_count(fSynth);

  1219.             kData->param.ranges[k].fixValue(fParamBuffers[k]);

  1220. 

  1221.             if (kData->param.data[k].midiCC > 0)

  1222.             {

  1223.                 double value = kData->param.ranges[k].normalizeValue(fParamBuffers[k]);

  1224.                 kData->event.portOut->writeControlEvent(0, kData->param.data[k].midiChannel, kEngineControlEventTypeParameter, kData->param.data[k].midiCC, value);

  1225.             }

  1226. 

  1227.         } // End of Control Output

  1228. 

  1229.         // --------------------------------------------------------------------------------------------------------

  1230. 

  1231.         kData->activeBefore = kData->active;

  1232.     }

  1233. 

  1234.     bool processSingle(float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)

  1235.     {

  1236.         uint32_t i, k;

  1237. 

  1238.         // --------------------------------------------------------------------------------------------------------

  1239.         // Try lock, silence otherwise

  1240. 

  1241.         if (kData->engine->isOffline())

  1242.         {

  1243.             kData->singleMutex.lock();

  1244.         }

  1245.         else if (! kData->singleMutex.tryLock())

  1246.         {

  1247.             for (i=0; i < kData->audioOut.count; i++)

  1248.             {

  1249.                 for (k=0; k < frames; k++)

  1250.                     outBuffer[i][k+timeOffset] = 0.0f;

  1251.             }

  1252. 

  1253.             return false;

  1254.         }

  1255. 

  1256.         // --------------------------------------------------------------------------------------------------------

  1257.         // Fill plugin buffers and Run plugin

  1258. 

  1259.         if (kUses16Outs)

  1260.         {

  1261.             for (i=0; i < kData->audioOut.count; i++)

  1262.                 carla_zeroFloat(fAudio16Buffers[i], frames);

  1263. 

  1264.             fluid_synth_process(fSynth, frames, 0, nullptr, kData->audioOut.count, fAudio16Buffers);

  1265.         }

  1266.         else

  1267.             fluid_synth_write_float(fSynth, frames, outBuffer[0] + timeOffset, 0, 1, outBuffer[1] + timeOffset, 0, 1);

  1268. 

  1269.         // --------------------------------------------------------------------------------------------------------

  1270.         // Post-processing (volume and balance)

  1271. 

  1272.         {

  1273.             // note - balance not possible with kUses16Outs, so we can safely skip fAudioOutBuffers

  1274.             const bool doVolume  = (fHints & PLUGIN_CAN_VOLUME) > 0 && kData->postProc.volume != 1.0f;

  1275.             const bool doBalance = (fHints & PLUGIN_CAN_BALANCE) > 0 && (kData->postProc.balanceLeft != -1.0f || kData->postProc.balanceRight != 1.0f);

  1276. 

  1277.             float oldBufLeft[doBalance ? frames : 1];

  1278. 

  1279.             for (i=0; i < kData->audioOut.count; i++)

  1280.             {

  1281.                 // Balance

  1282.                 if (doBalance)

  1283.                 {

  1284.                     if (i % 2 == 0)

  1285.                         carla_copyFloat(oldBufLeft, outBuffer[i]+timeOffset, frames);

  1286. 

  1287.                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;

  1288.                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;

  1289. 

  1290.                     for (k=0; k < frames; k++)

  1291.                     {

  1292.                         if (i % 2 == 0)

  1293.                         {

  1294.                             // left

  1295.                             outBuffer[i][k+timeOffset]  = oldBufLeft[k]                * (1.0f - balRangeL);

  1296.                             outBuffer[i][k+timeOffset] += outBuffer[i+1][k+timeOffset] * (1.0f - balRangeR);

  1297.                         }

  1298.                         else

  1299.                         {

  1300.                             // right

  1301.                             outBuffer[i][k+timeOffset]  = outBuffer[i][k+timeOffset] * balRangeR;

  1302.                             outBuffer[i][k+timeOffset] += oldBufLeft[k]              * balRangeL;

  1303.                         }

  1304.                     }

  1305.                 }

  1306. 

  1307.                 // Volume

  1308.                 if (kUses16Outs)

  1309.                 {

  1310.                     for (k=0; k < frames; k++)

  1311.                         outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k] * kData->postProc.volume;

  1312.                 }

  1313.                 else if (doVolume)

  1314.                 {

  1315.                     for (k=0; k < frames; k++)

  1316.                         outBuffer[i][k+timeOffset] *= kData->postProc.volume;

  1317.                 }

  1318.             }

  1319. 

  1320.         } // End of Post-processing

  1321. 

  1322.         // --------------------------------------------------------------------------------------------------------

  1323. 

  1324.         kData->singleMutex.unlock();

  1325.         return true;

  1326.     }

  1327. 

  1328.     void bufferSizeChanged(const uint32_t newBufferSize)

  1329.     {

  1330.         if (! kUses16Outs)

  1331.             return;

  1332. 

  1333.         for (uint32_t i=0; i < kData->audioOut.count; i++)

  1334.         {

  1335.             if (fAudio16Buffers[i] != nullptr)

  1336.                 delete[] fAudio16Buffers[i];

  1337.             fAudio16Buffers[i] = new float[newBufferSize];

  1338.         }

  1339.     }

  1340. 

  1341.     // -------------------------------------------------------------------

  1342.     // Cleanup

  1343. 

  1344.     void deleteBuffers()

  1345.     {

  1346.         carla_debug("FluidSynthPlugin::deleteBuffers() - start");

  1347. 

  1348.         if (fAudio16Buffers != nullptr)

  1349.         {

  1350.             for (uint32_t i=0; i < kData->audioOut.count; i++)

  1351.             {

  1352.                 if (fAudio16Buffers[i] != nullptr)

  1353.                 {

  1354.                     delete[] fAudio16Buffers[i];

  1355.                     fAudio16Buffers[i] = nullptr;

  1356.                 }

  1357.             }

  1358. 

  1359.             delete[] fAudio16Buffers;

  1360.             fAudio16Buffers = nullptr;

  1361.         }

  1362. 

  1363.         CarlaPlugin::deleteBuffers();

  1364. 

  1365.         carla_debug("FluidSynthPlugin::deleteBuffers() - end");

  1366.     }

  1367. 

  1368.     // -------------------------------------------------------------------

  1369. 

  1370.     bool init(const char* const filename, const char* const name, const char* const label)

  1371.     {

  1372.         CARLA_ASSERT(fSynth != nullptr);

  1373.         CARLA_ASSERT(filename != nullptr);

  1374.         CARLA_ASSERT(label != nullptr);

  1375. 

  1376.         // ---------------------------------------------------------------

  1377.         // open soundfont

  1378. 

  1379.         fSynthId = fluid_synth_sfload(fSynth, filename, 0);

  1380. 

  1381.         if (fSynthId < 0)

  1382.         {

  1383.             kData->engine->setLastError("Failed to load SoundFont file");

  1384.             return false;

  1385.         }

  1386. 

  1387.         // ---------------------------------------------------------------

  1388.         // get info

  1389. 

  1390.         fFilename = filename;

  1391.         fLabel    = label;

  1392. 

  1393.         if (name != nullptr)

  1394.             fName = kData->engine->getNewUniquePluginName(name);

  1395.         else

  1396.             fName = kData->engine->getNewUniquePluginName(label);

  1397. 

  1398.         // ---------------------------------------------------------------

  1399.         // register client

  1400. 

  1401.         kData->client = kData->engine->addClient(this);

  1402. 

  1403.         if (kData->client == nullptr || ! kData->client->isOk())

  1404.         {

  1405.             kData->engine->setLastError("Failed to register plugin client");

  1406.             return false;

  1407.         }

  1408. 

  1409.         return true;

  1410.     }

  1411. 

  1412. private:

  1413.     enum FluidSynthInputParameters {

  1414.         FluidSynthReverbOnOff    = 0,

  1415.         FluidSynthReverbRoomSize = 1,

  1416.         FluidSynthReverbDamp     = 2,

  1417.         FluidSynthReverbLevel    = 3,

  1418.         FluidSynthReverbWidth    = 4,

  1419.         FluidSynthChorusOnOff    = 5,

  1420.         FluidSynthChorusNr       = 6,

  1421.         FluidSynthChorusLevel    = 7,

  1422.         FluidSynthChorusSpeedHz  = 8,

  1423.         FluidSynthChorusDepthMs  = 9,

  1424.         FluidSynthChorusType     = 10,

  1425.         FluidSynthPolyphony      = 11,

  1426.         FluidSynthInterpolation  = 12,

  1427.         FluidSynthVoiceCount     = 13,

  1428.         FluidSynthParametersMax  = 14

  1429.     };

  1430. 

  1431.     const bool kUses16Outs;

  1432. 

  1433.     CarlaString fLabel;

  1434. 

  1435.     fluid_settings_t* fSettings;

  1436.     fluid_synth_t* fSynth;

  1437.     int fSynthId;

  1438. 

  1439.     float** fAudio16Buffers;

  1440.     double  fParamBuffers[FluidSynthParametersMax];

  1441. 

  1442.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(FluidSynthPlugin)

  1443. };

  1444. 

  1445. CARLA_BACKEND_END_NAMESPACE

  1446. 

  1447. #else // WANT_FLUIDSYNTH

  1448. # warning fluidsynth not available (no SF2 support)

  1449. #endif

  1450. 

  1451. CARLA_BACKEND_START_NAMESPACE

  1452. 

  1453. CarlaPlugin* CarlaPlugin::newSF2(const Initializer& init, const bool use16Outs)

  1454. {

  1455.     carla_debug("CarlaPlugin::newSF2({%p, \"%s\", \"%s\", \"%s\"}, %s)", init.engine, init.filename, init.name, init.label, bool2str(use16Outs));

  1456. 

  1457. #ifdef WANT_FLUIDSYNTH

  1458.     if (! fluid_is_soundfont(init.filename))

  1459.     {

  1460.         init.engine->setLastError("Requested file is not a valid SoundFont");

  1461.         return nullptr;

  1462.     }

  1463. 

  1464.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && use16Outs)

  1465.     {

  1466.         init.engine->setLastError("Carla's rack mode can only work with Stereo modules, please choose the 2-channel only SoundFont version");

  1467.         return nullptr;

  1468.     }

  1469. 

  1470.     FluidSynthPlugin* const plugin = new FluidSynthPlugin(init.engine, init.id,  use16Outs);

  1471. 

  1472.     if (! plugin->init(init.filename, init.name, init.label))

  1473.     {

  1474.         delete plugin;

  1475.         return nullptr;

  1476.     }

  1477. 

  1478.     plugin->reload();

  1479. 

  1480.     return plugin;

  1481. #else

  1482.     init.engine->setLastError("fluidsynth support not available");

  1483.     return nullptr;

  1484. 

  1485.     // unused

  1486.     (void)use16Outs;

  1487. #endif

  1488. }

  1489. 

  1490. CARLA_BACKEND_END_NAMESPACE