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.
7011 Commits
17 Branches
116MB
Tree: 84b3316b67
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '84b3316b67'
${ noResults }
Carla/source/backend/plugin/CarlaPluginFluidSynth.cpp

1925 lines
71KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>

  2. // SPDX-License-Identifier: GPL-2.0-or-later

  3. 

  4. #include "CarlaPluginInternal.hpp"

  5. #include "CarlaEngine.hpp"

  6. 

  7. #ifdef HAVE_FLUIDSYNTH

  8. 

  9. #include "CarlaBackendUtils.hpp"

  10. #include "CarlaMathUtils.hpp"

  11. 

  12. #include "water/text/StringArray.h"

  13. 

  14. #include <fluidsynth.h>

  15. 

  16. #define FLUID_DEFAULT_POLYPHONY 64

  17. 

  18. CARLA_BACKEND_START_NAMESPACE

  19. 

  20. // -------------------------------------------------------------------------------------------------------------------

  21. // Fallback data

  22. 

  23. static const ExternalMidiNote kExternalMidiNoteFallback = { -1, 0, 0 };

  24. 

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

  26. 

  27. class CarlaPluginFluidSynth : public CarlaPlugin

  28. {

  29. public:

  30.     CarlaPluginFluidSynth(CarlaEngine* const engine, const uint id, const bool use16Outs)

  31.         : CarlaPlugin(engine, id),

  32.           kUse16Outs(use16Outs),

  33.           fSettings(nullptr),

  34.           fSynth(nullptr),

  35.           fSynthId(0),

  36.           fAudio16Buffers(nullptr),

  37.           fLabel(nullptr)

  38.     {

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

  40. 

  41.         carla_zeroFloats(fParamBuffers, FluidSynthParametersMax);

  42.         carla_fill<int32_t>(fCurMidiProgs, 0, MAX_MIDI_CHANNELS);

  43. 

  44.         // create settings

  45.         fSettings = new_fluid_settings();

  46.         CARLA_SAFE_ASSERT_RETURN(fSettings != nullptr,);

  47. 

  48.         // define settings

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

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

  51.         fluid_settings_setnum(fSettings, "synth.sample-rate", pData->engine->getSampleRate());

  52.         //fluid_settings_setnum(fSettings, "synth.cpu-cores", 2);

  53.         fluid_settings_setint(fSettings, "synth.ladspa.active", 0);

  54.         fluid_settings_setint(fSettings, "synth.lock-memory", 1);

  55. #if FLUIDSYNTH_VERSION_MAJOR < 2

  56.         fluid_settings_setint(fSettings, "synth.parallel-render", 1);

  57. #endif

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

  59. #ifdef DEBUG

  60.         fluid_settings_setint(fSettings, "synth.verbose", 1);

  61. #endif

  62. 

  63.         // create synth

  64.         fSynth = new_fluid_synth(fSettings);

  65.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  66. 

  67.         initializeFluidDefaultsIfNeeded();

  68. 

  69. #if FLUIDSYNTH_VERSION_MAJOR < 2

  70.         fluid_synth_set_sample_rate(fSynth, static_cast<float>(pData->engine->getSampleRate()));

  71. #endif

  72. 

  73.         // set default values

  74.         fluid_synth_set_reverb_on(fSynth, 1);

  75.         fluid_synth_set_reverb(fSynth,

  76.                                sFluidDefaults[FluidSynthReverbRoomSize],

  77.                                sFluidDefaults[FluidSynthReverbDamp],

  78.                                sFluidDefaults[FluidSynthReverbWidth],

  79.                                sFluidDefaults[FluidSynthReverbLevel]);

  80. 

  81.         fluid_synth_set_chorus_on(fSynth, 1);

  82.         fluid_synth_set_chorus(fSynth,

  83.                                static_cast<int>(sFluidDefaults[FluidSynthChorusNr] + 0.5f),

  84.                                sFluidDefaults[FluidSynthChorusLevel],

  85.                                sFluidDefaults[FluidSynthChorusSpeedHz],

  86.                                sFluidDefaults[FluidSynthChorusDepthMs],

  87.                                static_cast<int>(sFluidDefaults[FluidSynthChorusType] + 0.5f));

  88. 

  89.         fluid_synth_set_polyphony(fSynth, FLUID_DEFAULT_POLYPHONY);

  90.         fluid_synth_set_gain(fSynth, 1.0f);

  91. 

  92.         for (int i=0; i < MAX_MIDI_CHANNELS; ++i)

  93.             fluid_synth_set_interp_method(fSynth, i, static_cast<int>(sFluidDefaults[FluidSynthInterpolation] + 0.5f));

  94.     }

  95. 

  96.     ~CarlaPluginFluidSynth() override

  97.     {

  98.         carla_debug("CarlaPluginFluidSynth::~CarlaPluginFluidSynth()");

  99. 

  100.         pData->singleMutex.lock();

  101.         pData->masterMutex.lock();

  102. 

  103.         if (pData->client != nullptr && pData->client->isActive())

  104.             pData->client->deactivate(true);

  105. 

  106.         if (pData->active)

  107.         {

  108.             deactivate();

  109.             pData->active = false;

  110.         }

  111. 

  112.         if (fSynth != nullptr)

  113.         {

  114.             delete_fluid_synth(fSynth);

  115.             fSynth = nullptr;

  116.         }

  117. 

  118.         if (fSettings != nullptr)

  119.         {

  120.             delete_fluid_settings(fSettings);

  121.             fSettings = nullptr;

  122.         }

  123. 

  124.         if (fLabel != nullptr)

  125.         {

  126.             delete[] fLabel;

  127.             fLabel = nullptr;

  128.         }

  129. 

  130.         clearBuffers();

  131.     }

  132. 

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

  134.     // Information (base)

  135. 

  136.     PluginType getType() const noexcept override

  137.     {

  138.         return PLUGIN_SF2;

  139.     }

  140. 

  141.     PluginCategory getCategory() const noexcept override

  142.     {

  143.         return PLUGIN_CATEGORY_SYNTH;

  144.     }

  145. 

  146.     // -------------------------------------------------------------------

  147.     // Information (count)

  148. 

  149.     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override

  150.     {

  151.         switch (parameterId)

  152.         {

  153.         case FluidSynthChorusType:

  154.             return 2;

  155.         case FluidSynthInterpolation:

  156.             return 4;

  157.         default:

  158.             return 0;

  159.         }

  160.     }

  161. 

  162.     // -------------------------------------------------------------------

  163.     // Information (current data)

  164. 

  165.     // nothing

  166. 

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

  168.     // Information (per-plugin data)

  169. 

  170.     uint getOptionsAvailable() const noexcept override

  171.     {

  172.         uint options = 0x0;

  173. 

  174.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  175.         options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  176.         options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  177.         options |= PLUGIN_OPTION_SEND_PITCHBEND;

  178.         options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  179.         options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;

  180. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  181.         options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  182. #endif

  183. 

  184.         return options;

  185.     }

  186. 

  187.     float getParameterValue(const uint32_t parameterId) const noexcept override

  188.     {

  189.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  190. 

  191.         return fParamBuffers[parameterId];

  192.     }

  193. 

  194.     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override

  195.     {

  196.         switch (parameterId)

  197.         {

  198.         case FluidSynthChorusType:

  199.             switch (scalePointId)

  200.             {

  201.             case 0:

  202.                 return FLUID_CHORUS_MOD_SINE;

  203.             case 1:

  204.                 return FLUID_CHORUS_MOD_TRIANGLE;

  205.             default:

  206.                 return sFluidDefaults[FluidSynthChorusType];

  207.             }

  208.         case FluidSynthInterpolation:

  209.             switch (scalePointId)

  210.             {

  211.             case 0:

  212.                 return FLUID_INTERP_NONE;

  213.             case 1:

  214.                 return FLUID_INTERP_LINEAR;

  215.             case 2:

  216.                 return FLUID_INTERP_4THORDER;

  217.             case 3:

  218.                 return FLUID_INTERP_7THORDER;

  219.             default:

  220.                 return sFluidDefaults[FluidSynthInterpolation];

  221.             }

  222.         default:

  223.             return 0.0f;

  224.         }

  225.     }

  226. 

  227.     bool getLabel(char* const strBuf) const noexcept override

  228.     {

  229.         if (fLabel != nullptr)

  230.         {

  231.             std::strncpy(strBuf, fLabel, STR_MAX);

  232.             return true;

  233.         }

  234. 

  235.         return CarlaPlugin::getLabel(strBuf);

  236.     }

  237. 

  238.     bool getMaker(char* const strBuf) const noexcept override

  239.     {

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

  241.         return true;

  242.     }

  243. 

  244.     bool getCopyright(char* const strBuf) const noexcept override

  245.     {

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

  247.         return true;

  248.     }

  249. 

  250.     bool getRealName(char* const strBuf) const noexcept override

  251.     {

  252.         return getLabel(strBuf);

  253.     }

  254. 

  255.     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  256.     {

  257.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  258. 

  259.         switch (parameterId)

  260.         {

  261.         case FluidSynthReverbOnOff:

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

  263.             return true;

  264.         case FluidSynthReverbRoomSize:

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

  266.             return true;

  267.         case FluidSynthReverbDamp:

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

  269.             return true;

  270.         case FluidSynthReverbLevel:

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

  272.             return true;

  273.         case FluidSynthReverbWidth:

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

  275.             return true;

  276.         case FluidSynthChorusOnOff:

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

  278.             return true;

  279.         case FluidSynthChorusNr:

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

  281.             return true;

  282.         case FluidSynthChorusLevel:

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

  284.             return true;

  285.         case FluidSynthChorusSpeedHz:

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

  287.             return true;

  288.         case FluidSynthChorusDepthMs:

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

  290.             return true;

  291.         case FluidSynthChorusType:

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

  293.             return true;

  294.         case FluidSynthPolyphony:

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

  296.             return true;

  297.         case FluidSynthInterpolation:

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

  299.             return true;

  300.         case FluidSynthVoiceCount:

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

  302.             return true;

  303.         }

  304. 

  305.         return CarlaPlugin::getParameterName(parameterId, strBuf);

  306.     }

  307. 

  308.     bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  309.     {

  310.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  311. 

  312.         switch (parameterId)

  313.         {

  314.         case FluidSynthChorusSpeedHz:

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

  316.             return true;

  317.         case FluidSynthChorusDepthMs:

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

  319.             return true;

  320.         }

  321. 

  322.         return CarlaPlugin::getParameterUnit(parameterId, strBuf);

  323.     }

  324. 

  325.     bool getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override

  326.     {

  327.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  328.         CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), false);

  329. 

  330.         switch (parameterId)

  331.         {

  332.         case FluidSynthChorusType:

  333.             switch (scalePointId)

  334.             {

  335.             case 0:

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

  337.                 return true;

  338.             case 1:

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

  340.                 return true;

  341.             }

  342.             break;

  343.         case FluidSynthInterpolation:

  344.             switch (scalePointId)

  345.             {

  346.             case 0:

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

  348.                 return true;

  349.             case 1:

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

  351.                 return true;

  352.             case 2:

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

  354.                 return true;

  355.             case 3:

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

  357.                 return true;

  358.             }

  359.             break;

  360.         }

  361. 

  362.         return CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  363.     }

  364. 

  365.     // -------------------------------------------------------------------

  366.     // Set data (state)

  367. 

  368.     void prepareForSave(bool) override

  369.     {

  370.         char strBuf[STR_MAX+1];

  371.         std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i",

  372.                       fCurMidiProgs[0],  fCurMidiProgs[1],  fCurMidiProgs[2],  fCurMidiProgs[3],

  373.                       fCurMidiProgs[4],  fCurMidiProgs[5],  fCurMidiProgs[6],  fCurMidiProgs[7],

  374.                       fCurMidiProgs[8],  fCurMidiProgs[9],  fCurMidiProgs[10], fCurMidiProgs[11],

  375.                       fCurMidiProgs[12], fCurMidiProgs[13], fCurMidiProgs[14], fCurMidiProgs[15]);

  376. 

  377.         CarlaPlugin::setCustomData(CUSTOM_DATA_TYPE_STRING, "midiPrograms", strBuf, false);

  378.     }

  379. 

  380.     // -------------------------------------------------------------------

  381.     // Set data (internal stuff)

  382. 

  383.     void setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept override

  384.     {

  385.         if (channel >= 0 && channel < MAX_MIDI_CHANNELS)

  386.             pData->midiprog.current = fCurMidiProgs[channel];

  387. 

  388.         CarlaPlugin::setCtrlChannel(channel, sendOsc, sendCallback);

  389.     }

  390. 

  391.     // -------------------------------------------------------------------

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

  393. 

  394.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  395.     {

  396.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  397.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback,);

  398. 

  399.         float fixedValue;

  400. 

  401.         {

  402.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  403.             fixedValue = setParameterValueInFluidSynth(parameterId, value);

  404. 

  405.         }

  406. 

  407.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  408.     }

  409. 

  410.     void setParameterValueRT(const uint32_t parameterId, const float value, const uint32_t frameOffset, const bool sendCallbackLater) noexcept override

  411.     {

  412.         const float fixedValue = setParameterValueInFluidSynth(parameterId, value);

  413. 

  414.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, frameOffset, sendCallbackLater);

  415.     }

  416. 

  417.     float setParameterValueInFluidSynth(const uint32_t parameterId, const float value) noexcept

  418.     {

  419.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, value);

  420. 

  421.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  422.         fParamBuffers[parameterId] = fixedValue;

  423. 

  424.         switch (parameterId)

  425.         {

  426.         case FluidSynthReverbOnOff:

  427.             try {

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

  429.             } CARLA_SAFE_EXCEPTION("fluid_synth_set_reverb_on")

  430.             break;

  431. 

  432.         case FluidSynthReverbRoomSize:

  433.         case FluidSynthReverbDamp:

  434.         case FluidSynthReverbLevel:

  435.         case FluidSynthReverbWidth:

  436.             try {

  437.                 fluid_synth_set_reverb(fSynth,

  438.                                        fParamBuffers[FluidSynthReverbRoomSize],

  439.                                        fParamBuffers[FluidSynthReverbDamp],

  440.                                        fParamBuffers[FluidSynthReverbWidth],

  441.                                        fParamBuffers[FluidSynthReverbLevel]);

  442.             } CARLA_SAFE_EXCEPTION("fluid_synth_set_reverb")

  443.             break;

  444. 

  445.         case FluidSynthChorusOnOff:

  446.             try {

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

  448.             } CARLA_SAFE_EXCEPTION("fluid_synth_set_chorus_on")

  449.             break;

  450. 

  451.         case FluidSynthChorusNr:

  452.         case FluidSynthChorusLevel:

  453.         case FluidSynthChorusSpeedHz:

  454.         case FluidSynthChorusDepthMs:

  455.         case FluidSynthChorusType:

  456.             try {

  457.                 fluid_synth_set_chorus(fSynth,

  458.                                        static_cast<int>(fParamBuffers[FluidSynthChorusNr] + 0.5f),

  459.                                        fParamBuffers[FluidSynthChorusLevel],

  460.                                        fParamBuffers[FluidSynthChorusSpeedHz],

  461.                                        fParamBuffers[FluidSynthChorusDepthMs],

  462.                                        static_cast<int>(fParamBuffers[FluidSynthChorusType] + 0.5f));

  463.             } CARLA_SAFE_EXCEPTION("fluid_synth_set_chorus")

  464.             break;

  465. 

  466.         case FluidSynthPolyphony:

  467.             try {

  468.                 fluid_synth_set_polyphony(fSynth, static_cast<int>(value + 0.5f));

  469.             } CARLA_SAFE_EXCEPTION("fluid_synth_set_polyphony")

  470.             break;

  471. 

  472.         case FluidSynthInterpolation:

  473.             for (int i=0; i < MAX_MIDI_CHANNELS; ++i)

  474.             {

  475.                 try {

  476.                     fluid_synth_set_interp_method(fSynth, i, static_cast<int>(value + 0.5f));

  477.                 } CARLA_SAFE_EXCEPTION_BREAK("fluid_synth_set_interp_method")

  478.             }

  479.             break;

  480. 

  481.         default:

  482.             break;

  483.         }

  484. 

  485.         return fixedValue;

  486.     }

  487. 

  488.     void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override

  489.     {

  490.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  491.         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  492.         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  493.         CARLA_SAFE_ASSERT_RETURN(value != nullptr && value[0] != '\0',);

  494.         carla_debug("CarlaPluginFluidSynth::setCustomData(%s, \"%s\", \"%s\", %s)", type, key, value, bool2str(sendGui));

  495. 

  496.         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)

  497.             return CarlaPlugin::setCustomData(type, key, value, sendGui);

  498. 

  499.         if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0)

  500.             return carla_stderr2("CarlaPluginFluidSynth::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string", type, key, value, bool2str(sendGui));

  501. 

  502.         if (std::strcmp(key, "midiPrograms") != 0)

  503.             return carla_stderr2("CarlaPluginFluidSynth::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is not string", type, key, value, bool2str(sendGui));

  504. 

  505.         water::StringArray midiProgramList(water::StringArray::fromTokens(value, ":", ""));

  506. 

  507.         if (midiProgramList.size() == MAX_MIDI_CHANNELS)

  508.         {

  509.             uint8_t channel = 0;

  510.             for (water::String *it=midiProgramList.begin(), *end=midiProgramList.end(); it != end; ++it)

  511.             {

  512.                 const int index(it->getIntValue());

  513. 

  514.                 if (index >= 0 && index < static_cast<int>(pData->midiprog.count))

  515.                 {

  516.                     const uint32_t bank    = pData->midiprog.data[index].bank;

  517.                     const uint32_t program = pData->midiprog.data[index].program;

  518. 

  519. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  520.                     fluid_synth_program_select(fSynth,

  521.                                                static_cast<int>(channel),

  522.                                                fSynthId,

  523.                                                static_cast<int>(bank),

  524.                                                static_cast<int>(program));

  525. #else

  526.                     fluid_synth_program_select(fSynth, channel, fSynthId, bank, program);

  527. #endif

  528.                     fCurMidiProgs[channel] = index;

  529. 

  530.                     if (pData->ctrlChannel == static_cast<int32_t>(channel))

  531.                     {

  532.                         pData->midiprog.current = index;

  533.                         pData->engine->callback(true, true,

  534.                                                 ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,

  535.                                                 pData->id,

  536.                                                 index,

  537.                                                 0, 0, 0.0f, nullptr);

  538.                     }

  539.                 }

  540. 

  541.                 ++channel;

  542.             }

  543.             CARLA_SAFE_ASSERT(channel == MAX_MIDI_CHANNELS);

  544.         }

  545. 

  546.         CarlaPlugin::setCustomData(type, key, value, sendGui);

  547.     }

  548. 

  549.     void setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override

  550.     {

  551.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  552.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);

  553.         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);

  554. 

  555.         if (index >= 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  556.         {

  557.             const uint32_t bank    = pData->midiprog.data[index].bank;

  558.             const uint32_t program = pData->midiprog.data[index].program;

  559. 

  560.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  561. 

  562.             try {

  563. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  564.                 fluid_synth_program_select(fSynth, pData->ctrlChannel, fSynthId,

  565.                                            static_cast<int>(bank), static_cast<int>(program));

  566. #else

  567.                 fluid_synth_program_select(fSynth, pData->ctrlChannel, fSynthId, bank, program);

  568. #endif

  569.             } CARLA_SAFE_EXCEPTION("fluid_synth_program_select")

  570. 

  571.             fCurMidiProgs[pData->ctrlChannel] = index;

  572.         }

  573. 

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

  575.     }

  576. 

  577.     // FIXME: this is never used

  578.     void setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept override

  579.     {

  580.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  581.         CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);

  582. 

  583.         if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  584.         {

  585.             const uint32_t bank    = pData->midiprog.data[uindex].bank;

  586.             const uint32_t program = pData->midiprog.data[uindex].program;

  587. 

  588.             try {

  589. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  590.                 fluid_synth_program_select(fSynth, pData->ctrlChannel, fSynthId,

  591.                                            static_cast<int>(bank), static_cast<int>(program));

  592. #else

  593.                 fluid_synth_program_select(fSynth, pData->ctrlChannel, fSynthId, bank, program);

  594. #endif

  595.             } CARLA_SAFE_EXCEPTION("fluid_synth_program_select")

  596. 

  597.             fCurMidiProgs[pData->ctrlChannel] = static_cast<int32_t>(uindex);

  598.         }

  599. 

  600.         CarlaPlugin::setMidiProgramRT(uindex, sendCallbackLater);

  601.     }

  602. 

  603.     // -------------------------------------------------------------------

  604.     // Set ui stuff

  605. 

  606.     // nothing

  607. 

  608.     // -------------------------------------------------------------------

  609.     // Plugin state

  610. 

  611.     void reload() override

  612.     {

  613.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  614.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  615.         carla_debug("CarlaPluginFluidSynth::reload() - start");

  616. 

  617.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  618. 

  619.         // Safely disable plugin for reload

  620.         const ScopedDisabler sd(this);

  621. 

  622.         if (pData->active)

  623.             deactivate();

  624. 

  625.         clearBuffers();

  626. 

  627.         uint32_t aOuts, params;

  628.         aOuts  = kUse16Outs ? 32 : 2;

  629.         params = FluidSynthParametersMax;

  630. 

  631.         pData->audioOut.createNew(aOuts);

  632.         pData->param.createNew(params, false);

  633. 

  634.         const uint portNameSize(pData->engine->getMaxPortNameSize());

  635.         String portName;

  636. 

  637.         // ---------------------------------------

  638.         // Audio Outputs

  639. 

  640.         if (kUse16Outs)

  641.         {

  642.             for (uint32_t i=0; i < 32; ++i)

  643.             {

  644.                 portName.clear();

  645. 

  646.                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  647.                 {

  648.                     portName  = pData->name;

  649.                     portName += ":";

  650.                 }

  651. 

  652.                 portName += "out-";

  653. 

  654.                 if ((i+2)/2 < 9)

  655.                     portName += "0";

  656. 

  657.                 portName += String((i+2)/2);

  658. 

  659.                 if (i % 2 == 0)

  660.                     portName += "L";

  661.                 else

  662.                     portName += "R";

  663. 

  664.                 portName.truncate(portNameSize);

  665. 

  666.                 pData->audioOut.ports[i].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, i);

  667.                 pData->audioOut.ports[i].rindex = i;

  668.             }

  669. 

  670.             fAudio16Buffers = new float*[aOuts];

  671. 

  672.             for (uint32_t i=0; i < aOuts; ++i)

  673.                 fAudio16Buffers[i] = nullptr;

  674.         }

  675.         else

  676.         {

  677.             // out-left

  678.             portName.clear();

  679. 

  680.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  681.             {

  682.                 portName  = pData->name;

  683.                 portName += ":";

  684.             }

  685. 

  686.             portName += "out-left";

  687.             portName.truncate(portNameSize);

  688. 

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

  690.             pData->audioOut.ports[0].rindex = 0;

  691. 

  692.             // out-right

  693.             portName.clear();

  694. 

  695.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  696.             {

  697.                 portName  = pData->name;

  698.                 portName += ":";

  699.             }

  700. 

  701.             portName += "out-right";

  702.             portName.truncate(portNameSize);

  703. 

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

  705.             pData->audioOut.ports[1].rindex = 1;

  706.         }

  707. 

  708.         // ---------------------------------------

  709.         // Event Input

  710. 

  711.         {

  712.             portName.clear();

  713. 

  714.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  715.             {

  716.                 portName  = pData->name;

  717.                 portName += ":";

  718.             }

  719. 

  720.             portName += "events-in";

  721.             portName.truncate(portNameSize);

  722. 

  723.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);

  724.         }

  725. 

  726.         // ---------------------------------------

  727.         // Event Output

  728. 

  729.         {

  730.             portName.clear();

  731. 

  732.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  733.             {

  734.                 portName  = pData->name;

  735.                 portName += ":";

  736.             }

  737. 

  738.             portName += "events-out";

  739.             portName.truncate(portNameSize);

  740. 

  741.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);

  742.         }

  743. 

  744.         // ---------------------------------------

  745.         // Parameters

  746. 

  747.         {

  748.             int j;

  749. 

  750.             // ----------------------

  751.             j = FluidSynthReverbOnOff;

  752.             pData->param.data[j].type   = PARAMETER_INPUT;

  753.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMATABLE*/ | PARAMETER_IS_BOOLEAN;

  754.             pData->param.data[j].index  = j;

  755.             pData->param.data[j].rindex = j;

  756.             pData->param.ranges[j].min = 0.0f;

  757.             pData->param.ranges[j].max = 1.0f;

  758.             pData->param.ranges[j].def = sFluidDefaults[j];

  759.             pData->param.ranges[j].step = 1.0f;

  760.             pData->param.ranges[j].stepSmall = 1.0f;

  761.             pData->param.ranges[j].stepLarge = 1.0f;

  762. 

  763.             // ----------------------

  764.             j = FluidSynthReverbRoomSize;

  765.             pData->param.data[j].type   = PARAMETER_INPUT;

  766.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMATABLE*/;

  767.             pData->param.data[j].index  = j;

  768.             pData->param.data[j].rindex = j;

  769.             pData->param.ranges[j].min = 0.0f;

  770.             pData->param.ranges[j].max = 1.0f;

  771.             pData->param.ranges[j].def = sFluidDefaults[j];

  772.             pData->param.ranges[j].step = 0.01f;

  773.             pData->param.ranges[j].stepSmall = 0.0001f;

  774.             pData->param.ranges[j].stepLarge = 0.1f;

  775. 

  776.             // ----------------------

  777.             j = FluidSynthReverbDamp;

  778.             pData->param.data[j].type   = PARAMETER_INPUT;

  779.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMATABLE*/;

  780.             pData->param.data[j].index  = j;

  781.             pData->param.data[j].rindex = j;

  782.             pData->param.ranges[j].min = 0.0f;

  783.             pData->param.ranges[j].max = 1.0f;

  784.             pData->param.ranges[j].def = sFluidDefaults[j];

  785.             pData->param.ranges[j].step = 0.01f;

  786.             pData->param.ranges[j].stepSmall = 0.0001f;

  787.             pData->param.ranges[j].stepLarge = 0.1f;

  788. 

  789.             // ----------------------

  790.             j = FluidSynthReverbLevel;

  791.             pData->param.data[j].type   = PARAMETER_INPUT;

  792.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMATABLE*/;

  793.             pData->param.data[j].index  = j;

  794.             pData->param.data[j].rindex = j;

  795.             pData->param.data[j].mappedControlIndex = MIDI_CONTROL_REVERB_SEND_LEVEL;

  796.             pData->param.ranges[j].min = 0.0f;

  797.             pData->param.ranges[j].max = 1.0f;

  798.             pData->param.ranges[j].def = sFluidDefaults[j];

  799.             pData->param.ranges[j].step = 0.01f;

  800.             pData->param.ranges[j].stepSmall = 0.0001f;

  801.             pData->param.ranges[j].stepLarge = 0.1f;

  802. 

  803.             // ----------------------

  804.             j = FluidSynthReverbWidth;

  805.             pData->param.data[j].type   = PARAMETER_INPUT;

  806.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED /*| PARAMETER_IS_AUTOMATABLE*/;

  807.             pData->param.data[j].index  = j;

  808.             pData->param.data[j].rindex = j;

  809.             pData->param.ranges[j].min = 0.0f;

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

  811.             pData->param.ranges[j].def = sFluidDefaults[j];

  812.             pData->param.ranges[j].step = 0.01f;

  813.             pData->param.ranges[j].stepSmall = 0.0001f;

  814.             pData->param.ranges[j].stepLarge = 0.1f;

  815. 

  816.             // ----------------------

  817.             j = FluidSynthChorusOnOff;

  818.             pData->param.data[j].type   = PARAMETER_INPUT;

  819.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_BOOLEAN;

  820.             pData->param.data[j].index  = j;

  821.             pData->param.data[j].rindex = j;

  822.             pData->param.ranges[j].min = 0.0f;

  823.             pData->param.ranges[j].max = 1.0f;

  824.             pData->param.ranges[j].def = sFluidDefaults[j];

  825.             pData->param.ranges[j].step = 1.0f;

  826.             pData->param.ranges[j].stepSmall = 1.0f;

  827.             pData->param.ranges[j].stepLarge = 1.0f;

  828. 

  829.             // ----------------------

  830.             j = FluidSynthChorusNr;

  831.             pData->param.data[j].type   = PARAMETER_INPUT;

  832.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  833.             pData->param.data[j].index  = j;

  834.             pData->param.data[j].rindex = j;

  835.             pData->param.ranges[j].min = 0.0f;

  836.             pData->param.ranges[j].max = 99.0f;

  837.             pData->param.ranges[j].def = sFluidDefaults[j];

  838.             pData->param.ranges[j].step = 1.0f;

  839.             pData->param.ranges[j].stepSmall = 1.0f;

  840.             pData->param.ranges[j].stepLarge = 10.0f;

  841. 

  842.             // ----------------------

  843.             j = FluidSynthChorusLevel;

  844.             pData->param.data[j].type   = PARAMETER_INPUT;

  845.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  846.             pData->param.data[j].index  = j;

  847.             pData->param.data[j].rindex = j;

  848.             pData->param.ranges[j].min = 0.0f;

  849.             pData->param.ranges[j].max = 10.0f;

  850.             pData->param.ranges[j].def = sFluidDefaults[j];

  851.             pData->param.ranges[j].step = 0.01f;

  852.             pData->param.ranges[j].stepSmall = 0.0001f;

  853.             pData->param.ranges[j].stepLarge = 0.1f;

  854. 

  855.             // ----------------------

  856.             j = FluidSynthChorusSpeedHz;

  857.             pData->param.data[j].type   = PARAMETER_INPUT;

  858.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  859.             pData->param.data[j].index  = j;

  860.             pData->param.data[j].rindex = j;

  861.             pData->param.ranges[j].min = 0.29f;

  862.             pData->param.ranges[j].max = 5.0f;

  863.             pData->param.ranges[j].def = sFluidDefaults[j];

  864.             pData->param.ranges[j].step = 0.01f;

  865.             pData->param.ranges[j].stepSmall = 0.0001f;

  866.             pData->param.ranges[j].stepLarge = 0.1f;

  867. 

  868.             // ----------------------

  869.             j = FluidSynthChorusDepthMs;

  870.             pData->param.data[j].type   = PARAMETER_INPUT;

  871.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED;

  872.             pData->param.data[j].index  = j;

  873.             pData->param.data[j].rindex = j;

  874.             pData->param.ranges[j].min = 0.0f;

  875. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  876.             pData->param.ranges[j].max = 256.0f;

  877. #else

  878.             pData->param.ranges[j].max = float(2048.0 * 1000.0 / pData->engine->getSampleRate()); // FIXME?

  879. #endif

  880.             pData->param.ranges[j].def = sFluidDefaults[j];

  881.             pData->param.ranges[j].step = 0.01f;

  882.             pData->param.ranges[j].stepSmall = 0.0001f;

  883.             pData->param.ranges[j].stepLarge = 0.1f;

  884. 

  885.             // ----------------------

  886.             j = FluidSynthChorusType;

  887.             pData->param.data[j].type   = PARAMETER_INPUT;

  888.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;

  889.             pData->param.data[j].index  = j;

  890.             pData->param.data[j].rindex = j;

  891.             pData->param.ranges[j].min = FLUID_CHORUS_MOD_SINE;

  892.             pData->param.ranges[j].max = FLUID_CHORUS_MOD_TRIANGLE;

  893.             pData->param.ranges[j].def = sFluidDefaults[j];

  894.             pData->param.ranges[j].step = 1.0f;

  895.             pData->param.ranges[j].stepSmall = 1.0f;

  896.             pData->param.ranges[j].stepLarge = 1.0f;

  897. 

  898.             // ----------------------

  899.             j = FluidSynthPolyphony;

  900.             pData->param.data[j].type   = PARAMETER_INPUT;

  901.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER;

  902.             pData->param.data[j].index  = j;

  903.             pData->param.data[j].rindex = j;

  904.             pData->param.ranges[j].min = 1.0f;

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

  906.             pData->param.ranges[j].def = sFluidDefaults[j];

  907.             pData->param.ranges[j].step = 1.0f;

  908.             pData->param.ranges[j].stepSmall = 1.0f;

  909.             pData->param.ranges[j].stepLarge = 10.0f;

  910. 

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

  912.             j = FluidSynthInterpolation;

  913.             pData->param.data[j].type   = PARAMETER_INPUT;

  914.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_INTEGER | PARAMETER_USES_SCALEPOINTS;

  915.             pData->param.data[j].index  = j;

  916.             pData->param.data[j].rindex = j;

  917.             pData->param.ranges[j].min = FLUID_INTERP_NONE;

  918.             pData->param.ranges[j].max = FLUID_INTERP_HIGHEST;

  919.             pData->param.ranges[j].def = sFluidDefaults[j];

  920.             pData->param.ranges[j].step = 1.0f;

  921.             pData->param.ranges[j].stepSmall = 1.0f;

  922.             pData->param.ranges[j].stepLarge = 1.0f;

  923. 

  924.             // ----------------------

  925.             j = FluidSynthVoiceCount;

  926.             pData->param.data[j].type   = PARAMETER_OUTPUT;

  927.             pData->param.data[j].hints  = PARAMETER_IS_ENABLED | PARAMETER_IS_AUTOMATABLE | PARAMETER_IS_INTEGER;

  928.             pData->param.data[j].index  = j;

  929.             pData->param.data[j].rindex = j;

  930.             pData->param.ranges[j].min = 0.0f;

  931.             pData->param.ranges[j].max = 65535.0f;

  932.             pData->param.ranges[j].def = 0.0f;

  933.             pData->param.ranges[j].step = 1.0f;

  934.             pData->param.ranges[j].stepSmall = 1.0f;

  935.             pData->param.ranges[j].stepLarge = 1.0f;

  936. 

  937.             for (j=0; j<FluidSynthParametersMax; ++j)

  938.                 fParamBuffers[j] = pData->param.ranges[j].def;

  939.         }

  940. 

  941.         // ---------------------------------------

  942. 

  943.         // plugin hints

  944.         pData->hints  = 0x0;

  945.         pData->hints |= PLUGIN_IS_SYNTH;

  946.         pData->hints |= PLUGIN_CAN_VOLUME;

  947.         pData->hints |= PLUGIN_USES_MULTI_PROGS;

  948. 

  949.         if (! kUse16Outs)

  950.             pData->hints |= PLUGIN_CAN_BALANCE;

  951. 

  952.         // extra plugin hints

  953.         pData->extraHints  = 0x0;

  954.         pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  955. 

  956.         bufferSizeChanged(pData->engine->getBufferSize());

  957.         reloadPrograms(true);

  958. 

  959.         if (pData->active)

  960.             activate();

  961. 

  962.         carla_debug("CarlaPluginFluidSynth::reload() - end");

  963.     }

  964. 

  965.     void reloadPrograms(const bool doInit) override

  966.     {

  967.         carla_debug("CarlaPluginFluidSynth::reloadPrograms(%s)", bool2str(doInit));

  968. 

  969.         // save drum info in case we have one program for it

  970.         bool hasDrums = false;

  971.         uint32_t drumIndex, drumProg;

  972.         drumIndex = drumProg = 0;

  973. 

  974.         // Delete old programs

  975.         pData->midiprog.clear();

  976. 

  977.         // Query new programs

  978.         uint32_t count = 0;

  979. 

  980.         if (fluid_sfont_t* const f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId))

  981.         {

  982. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  983.             fluid_preset_t* f_preset;

  984. 

  985.             // initial check to know how many midi-programs we have

  986.             fluid_sfont_iteration_start(f_sfont);

  987.             for (; fluid_sfont_iteration_next(f_sfont);)

  988.                 ++count;

  989. 

  990.             // sound kits must always have at least 1 midi-program

  991.             CARLA_SAFE_ASSERT_RETURN(count > 0,);

  992. 

  993.             pData->midiprog.createNew(count);

  994. 

  995.             // Update data

  996.             int tmp;

  997.             uint32_t i = 0;

  998.             fluid_sfont_iteration_start(f_sfont);

  999. 

  1000.             for (; (f_preset = fluid_sfont_iteration_next(f_sfont));)

  1001.             {

  1002.                 CARLA_SAFE_ASSERT_BREAK(i < count);

  1003. 

  1004.                 tmp = fluid_preset_get_banknum(f_preset);

  1005.                 pData->midiprog.data[i].bank = (tmp >= 0) ? static_cast<uint32_t>(tmp) : 0;

  1006. 

  1007.                 tmp = fluid_preset_get_num(f_preset);

  1008.                 pData->midiprog.data[i].program = (tmp >= 0) ? static_cast<uint32_t>(tmp) : 0;

  1009. 

  1010.                 pData->midiprog.data[i].name = carla_strdup(fluid_preset_get_name(f_preset));

  1011. #else

  1012.             fluid_preset_t f_preset;

  1013. 

  1014.             // initial check to know how many midi-programs we have

  1015.             f_sfont->iteration_start(f_sfont);

  1016.             for (; f_sfont->iteration_next(f_sfont, &f_preset);)

  1017.                 ++count;

  1018. 

  1019.             // sound kits must always have at least 1 midi-program

  1020.             CARLA_SAFE_ASSERT_RETURN(count > 0,);

  1021. 

  1022.             pData->midiprog.createNew(count);

  1023. 

  1024.             // Update data

  1025.             int tmp;

  1026.             uint32_t i = 0;

  1027.             f_sfont->iteration_start(f_sfont);

  1028. 

  1029.             for (; f_sfont->iteration_next(f_sfont, &f_preset);)

  1030.             {

  1031.                 CARLA_SAFE_ASSERT_BREAK(i < count);

  1032. 

  1033.                 tmp = f_preset.get_banknum(&f_preset);

  1034.                 pData->midiprog.data[i].bank = (tmp >= 0) ? static_cast<uint32_t>(tmp) : 0;

  1035. 

  1036.                 tmp = f_preset.get_num(&f_preset);

  1037.                 pData->midiprog.data[i].program = (tmp >= 0) ? static_cast<uint32_t>(tmp) : 0;

  1038. 

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

  1040. #endif

  1041. 

  1042.                 if (pData->midiprog.data[i].bank == 128 && ! hasDrums)

  1043.                 {

  1044.                     hasDrums  = true;

  1045.                     drumIndex = i;

  1046.                     drumProg  = pData->midiprog.data[i].program;

  1047.                 }

  1048. 

  1049.                 ++i;

  1050.             }

  1051.         }

  1052.         else

  1053.         {

  1054.             // failing means 0 midi-programs, it shouldn't happen!

  1055.             carla_safe_assert("fluid_sfont_t* const f_sfont = fluid_synth_get_sfont_by_id(fSynth, fSynthId)", __FILE__, __LINE__);

  1056.             return;

  1057.         }

  1058. 

  1059.         if (doInit)

  1060.         {

  1061.             fluid_synth_program_reset(fSynth);

  1062. 

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

  1064.             for (int i=0; i < MAX_MIDI_CHANNELS && i != 9; ++i)

  1065.             {

  1066.                 fluid_synth_set_channel_type(fSynth, i, CHANNEL_TYPE_MELODIC);

  1067. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1068.                 fluid_synth_program_select(fSynth, i, fSynthId,

  1069.                                            static_cast<int>(pData->midiprog.data[0].bank),

  1070.                                            static_cast<int>(pData->midiprog.data[0].program));

  1071. #else

  1072.                 fluid_synth_program_select(fSynth, i, fSynthId,

  1073.                                            pData->midiprog.data[0].bank, pData->midiprog.data[0].program);

  1074. #endif

  1075.                 fCurMidiProgs[i] = 0;

  1076.             }

  1077. 

  1078.             if (hasDrums)

  1079.             {

  1080.                 fluid_synth_set_channel_type(fSynth, 9, CHANNEL_TYPE_DRUM);

  1081. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1082.                 fluid_synth_program_select(fSynth, 9, fSynthId, 128, static_cast<int>(drumProg));

  1083. #else

  1084.                 fluid_synth_program_select(fSynth, 9, fSynthId, 128, drumProg);

  1085. #endif

  1086.                 fCurMidiProgs[9] = static_cast<int32_t>(drumIndex);

  1087.             }

  1088.             else

  1089.             {

  1090.                 fluid_synth_set_channel_type(fSynth, 9, CHANNEL_TYPE_MELODIC);

  1091. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1092.                 fluid_synth_program_select(fSynth, 9, fSynthId,

  1093.                                            static_cast<int>(pData->midiprog.data[0].bank),

  1094.                                            static_cast<int>(pData->midiprog.data[0].program));

  1095. #else

  1096.                 fluid_synth_program_select(fSynth, 9, fSynthId,

  1097.                                            pData->midiprog.data[0].bank, pData->midiprog.data[0].program);

  1098. #endif

  1099.                 fCurMidiProgs[9] = 0;

  1100.             }

  1101. 

  1102.             pData->midiprog.current = 0;

  1103.         }

  1104.         else

  1105.         {

  1106.             pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0, 0.0f, nullptr);

  1107.         }

  1108.     }

  1109. 

  1110.     // -------------------------------------------------------------------

  1111.     // Plugin processing

  1112. 

  1113.     void process(const float* const* const, float** const audioOut,

  1114.                  const float* const*, float**, const uint32_t frames) override

  1115.     {

  1116.         // --------------------------------------------------------------------------------------------------------

  1117.         // Check if active

  1118. 

  1119.         if (! pData->active)

  1120.         {

  1121.             // disable any output sound

  1122.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1123.                 carla_zeroFloats(audioOut[i], frames);

  1124.             return;

  1125.         }

  1126. 

  1127.         // --------------------------------------------------------------------------------------------------------

  1128.         // Check if needs reset

  1129. 

  1130.         if (pData->needsReset)

  1131.         {

  1132.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1133.             {

  1134.                 for (int i=0; i < MAX_MIDI_CHANNELS; ++i)

  1135.                 {

  1136.                     fluid_synth_all_notes_off(fSynth, i);

  1137.                     fluid_synth_all_sounds_off(fSynth, i);

  1138.                 }

  1139.             }

  1140.             else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1141.             {

  1142.                 for (int i=0; i < MAX_MIDI_NOTE; ++i)

  1143.                     fluid_synth_noteoff(fSynth, pData->ctrlChannel, i);

  1144.             }

  1145. 

  1146.             pData->needsReset = false;

  1147.         }

  1148. 

  1149.         // --------------------------------------------------------------------------------------------------------

  1150.         // Event Input and Processing

  1151. 

  1152.         {

  1153.             // ----------------------------------------------------------------------------------------------------

  1154.             // MIDI Input (External)

  1155. 

  1156.             if (pData->extNotes.mutex.tryLock())

  1157.             {

  1158.                 for (RtLinkedList<ExternalMidiNote>::Itenerator it = pData->extNotes.data.begin2(); it.valid(); it.next())

  1159.                 {

  1160.                     const ExternalMidiNote& note(it.getValue(kExternalMidiNoteFallback));

  1161.                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  1162. 

  1163.                     if (note.velo > 0)

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

  1165.                     else

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

  1167.                 }

  1168. 

  1169.                 pData->extNotes.data.clear();

  1170.                 pData->extNotes.mutex.unlock();

  1171. 

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

  1173. 

  1174.             // ----------------------------------------------------------------------------------------------------

  1175.             // Event Input (System)

  1176. 

  1177. #ifndef BUILD_BRIDGE

  1178.             bool allNotesOffSent = false;

  1179. #endif

  1180.             uint32_t timeOffset = 0;

  1181. 

  1182.             uint32_t nextBankIds[MAX_MIDI_CHANNELS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0 };

  1183. 

  1184.             if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1185.                 nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;

  1186. 

  1187.             for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)

  1188.             {

  1189.                 const EngineEvent& event(pData->event.portIn->getEvent(i));

  1190. 

  1191.                 uint32_t eventTime = event.time;

  1192.                 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);

  1193. 

  1194.                 if (eventTime < timeOffset)

  1195.                 {

  1196.                     carla_stderr2("Timing error, eventTime:%u < timeOffset:%u for '%s'",

  1197.                                   eventTime, timeOffset, pData->name);

  1198.                     eventTime = timeOffset;

  1199.                 }

  1200.                 else if (eventTime > timeOffset)

  1201.                 {

  1202.                     if (processSingle(audioOut, eventTime - timeOffset, timeOffset))

  1203.                     {

  1204.                         timeOffset = eventTime;

  1205. 

  1206.                         if (pData->midiprog.current >= 0 && pData->midiprog.count > 0 && pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1207.                             nextBankIds[pData->ctrlChannel] = pData->midiprog.data[pData->midiprog.current].bank;

  1208.                     }

  1209.                 }

  1210. 

  1211.                 // Control change

  1212.                 switch (event.type)

  1213.                 {

  1214.                 case kEngineEventTypeNull:

  1215.                     break;

  1216. 

  1217.                 case kEngineEventTypeControl:

  1218.                 {

  1219.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1220. 

  1221.                     switch (ctrlEvent.type)

  1222.                     {

  1223.                     case kEngineControlEventTypeNull:

  1224.                         break;

  1225. 

  1226.                     case kEngineControlEventTypeParameter:

  1227.                     {

  1228.                         float value;

  1229. 

  1230. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1231.                         // Control backend stuff

  1232.                         if (event.channel == pData->ctrlChannel)

  1233.                         {

  1234.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)

  1235.                             {

  1236.                                 value = ctrlEvent.normalizedValue;

  1237.                                 setDryWetRT(value, true);

  1238.                             }

  1239. 

  1240.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)

  1241.                             {

  1242.                                 value = ctrlEvent.normalizedValue*127.0f/100.0f;

  1243.                                 setVolumeRT(value, true);

  1244.                             }

  1245. 

  1246.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)

  1247.                             {

  1248.                                 float left, right;

  1249.                                 value = ctrlEvent.normalizedValue/0.5f - 1.0f;

  1250. 

  1251.                                 if (value < 0.0f)

  1252.                                 {

  1253.                                     left  = -1.0f;

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

  1255.                                 }

  1256.                                 else if (value > 0.0f)

  1257.                                 {

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

  1259.                                     right = 1.0f;

  1260.                                 }

  1261.                                 else

  1262.                                 {

  1263.                                     left  = -1.0f;

  1264.                                     right = 1.0f;

  1265.                                 }

  1266. 

  1267.                                 setBalanceLeftRT(left, true);

  1268.                                 setBalanceRightRT(right, true);

  1269.                             }

  1270.                         }

  1271. #endif

  1272.                         // Control plugin parameters

  1273.                         for (uint32_t k=0; k < pData->param.count; ++k)

  1274.                         {

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

  1276.                                 continue;

  1277.                             if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)

  1278.                                 continue;

  1279.                             if (pData->param.data[k].hints != PARAMETER_INPUT)

  1280.                                 continue;

  1281.                             if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMATABLE) == 0)

  1282.                                 continue;

  1283. 

  1284.                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);

  1285.                             setParameterValueRT(k, value, event.time, true);

  1286.                         }

  1287. 

  1288.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)

  1289.                         {

  1290.                             fluid_synth_cc(fSynth, event.channel, ctrlEvent.param, int(ctrlEvent.normalizedValue*127.0f + 0.5f));

  1291.                         }

  1292.                         break;

  1293.                     }

  1294. 

  1295.                     case kEngineControlEventTypeMidiBank:

  1296.                         if (event.channel < MAX_MIDI_CHANNELS && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

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

  1298.                         break;

  1299. 

  1300.                     case kEngineControlEventTypeMidiProgram:

  1301.                         if (event.channel < MAX_MIDI_CHANNELS && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1302.                         {

  1303.                             const uint32_t bankId(nextBankIds[event.channel]);

  1304.                             const uint32_t progId(ctrlEvent.param);

  1305. 

  1306.                             // TODO int32_t midiprog.find(bank, prog)

  1307.                             for (uint32_t k=0; k < pData->midiprog.count; ++k)

  1308.                             {

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

  1310.                                 {

  1311. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1312.                                     fluid_synth_program_select(fSynth, event.channel, fSynthId,

  1313.                                                                static_cast<int>(bankId), static_cast<int>(progId));

  1314. #else

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

  1316. #endif

  1317.                                     fCurMidiProgs[event.channel] = static_cast<int32_t>(k);

  1318. 

  1319.                                     if (event.channel == pData->ctrlChannel)

  1320.                                     {

  1321.                                         pData->postponeMidiProgramChangeRtEvent(true, k);

  1322.                                     }

  1323. 

  1324.                                     break;

  1325.                                 }

  1326.                             }

  1327.                         }

  1328.                         break;

  1329. 

  1330.                     case kEngineControlEventTypeAllSoundOff:

  1331.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1332.                             fluid_synth_all_sounds_off(fSynth, event.channel);

  1333.                         break;

  1334. 

  1335.                     case kEngineControlEventTypeAllNotesOff:

  1336.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1337.                         {

  1338. #ifndef BUILD_BRIDGE

  1339.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  1340.                             {

  1341.                                 allNotesOffSent = true;

  1342.                                 postponeRtAllNotesOff();

  1343.                             }

  1344. #endif

  1345. 

  1346.                             fluid_synth_all_notes_off(fSynth, event.channel);

  1347.                         }

  1348.                         break;

  1349.                     }

  1350. 

  1351.                     break;

  1352.                 }

  1353. 

  1354.                 case kEngineEventTypeMidi: {

  1355.                     const EngineMidiEvent& midiEvent(event.midi);

  1356. 

  1357.                     if (midiEvent.size > EngineMidiEvent::kDataSize)

  1358.                         continue;

  1359. 

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

  1361. 

  1362.                     // Fix bad note-off

  1363.                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)

  1364.                         status = MIDI_STATUS_NOTE_OFF;

  1365. 

  1366.                     switch (status)

  1367.                     {

  1368.                     case MIDI_STATUS_NOTE_OFF:

  1369.                         if ((pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES) == 0x0)

  1370.                         {

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

  1372. 

  1373.                             fluid_synth_noteoff(fSynth, event.channel, note);

  1374. 

  1375.                             pData->postponeNoteOffRtEvent(true, event.channel, note);

  1376.                         }

  1377.                         break;

  1378. 

  1379.                     case MIDI_STATUS_NOTE_ON:

  1380.                         if ((pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES) == 0x0)

  1381.                         {

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

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

  1384. 

  1385.                             fluid_synth_noteon(fSynth, event.channel, note, velo);

  1386. 

  1387.                             pData->postponeNoteOnRtEvent(true, event.channel, note, velo);

  1388.                         }

  1389.                         break;

  1390. 

  1391. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1392.                     case MIDI_STATUS_POLYPHONIC_AFTERTOUCH:

  1393.                         if (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH)

  1394.                         {

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

  1396.                             const uint8_t pressure = midiEvent.data[2];

  1397. 

  1398.                             fluid_synth_key_pressure(fSynth, event.channel, note, pressure);

  1399.                         }

  1400.                         break;

  1401. #endif

  1402. 

  1403.                     case MIDI_STATUS_CONTROL_CHANGE:

  1404.                         if (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  1405.                         {

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

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

  1408. 

  1409.                             fluid_synth_cc(fSynth, event.channel, control, value);

  1410.                         }

  1411.                         break;

  1412. 

  1413.                     case MIDI_STATUS_CHANNEL_PRESSURE:

  1414.                         if (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE)

  1415.                         {

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

  1417. 

  1418.                             fluid_synth_channel_pressure(fSynth, event.channel, pressure);;

  1419.                         }

  1420.                         break;

  1421. 

  1422.                     case MIDI_STATUS_PITCH_WHEEL_CONTROL:

  1423.                         if (pData->options & PLUGIN_OPTION_SEND_PITCHBEND)

  1424.                         {

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

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

  1427.                             const int   value = ((msb << 7) | lsb);

  1428. 

  1429.                             fluid_synth_pitch_bend(fSynth, event.channel, value);

  1430.                         }

  1431.                         break;

  1432. 

  1433.                     default:

  1434.                         continue;

  1435.                         break;

  1436.                     } // switch (status)

  1437.                 } break;

  1438.                 } // switch (event.type)

  1439.             }

  1440. 

  1441.             pData->postRtEvents.trySplice();

  1442. 

  1443.             if (frames > timeOffset)

  1444.                 processSingle(audioOut, frames - timeOffset, timeOffset);

  1445. 

  1446.         } // End of Event Input and Processing

  1447. 

  1448. #ifndef BUILD_BRIDGE

  1449.         // --------------------------------------------------------------------------------------------------------

  1450.         // Control Output

  1451. 

  1452.         {

  1453.             uint32_t k = FluidSynthVoiceCount;

  1454.             fParamBuffers[k] = float(fluid_synth_get_active_voice_count(fSynth));

  1455.             pData->param.ranges[k].fixValue(fParamBuffers[k]);

  1456. 

  1457.             if (pData->param.data[k].mappedControlIndex > 0)

  1458.             {

  1459.                 float value(pData->param.ranges[k].getNormalizedValue(fParamBuffers[k]));

  1460.                 pData->event.portOut->writeControlEvent(0,

  1461.                                                         pData->param.data[k].midiChannel,

  1462.                                                         kEngineControlEventTypeParameter,

  1463.                                                         static_cast<uint16_t>(pData->param.data[k].mappedControlIndex),

  1464.                                                         -1,

  1465.                                                         value);

  1466.             }

  1467. 

  1468.         } // End of Control Output

  1469. #endif

  1470.     }

  1471. 

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

  1473.     {

  1474.         CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false);

  1475.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1476. 

  1477.         // --------------------------------------------------------------------------------------------------------

  1478.         // Try lock, silence otherwise

  1479. 

  1480. #ifndef STOAT_TEST_BUILD

  1481.         if (pData->engine->isOffline())

  1482.         {

  1483.             pData->singleMutex.lock();

  1484.         }

  1485.         else

  1486. #endif

  1487.         if (! pData->singleMutex.tryLock())

  1488.         {

  1489.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1490.             {

  1491.                 for (uint32_t k=0; k < frames; ++k)

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

  1493.             }

  1494. 

  1495.             return false;

  1496.         }

  1497. 

  1498.         // --------------------------------------------------------------------------------------------------------

  1499.         // Fill plugin buffers and Run plugin

  1500. 

  1501.         if (kUse16Outs)

  1502.         {

  1503.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1504.                 carla_zeroFloats(fAudio16Buffers[i], frames);

  1505. 

  1506.             // FIXME use '32' or '16' instead of outs

  1507.             fluid_synth_process(fSynth, static_cast<int>(frames),

  1508.                                 0, nullptr,

  1509.                                 static_cast<int>(pData->audioOut.count), fAudio16Buffers);

  1510.         }

  1511.         else

  1512.         {

  1513.             fluid_synth_write_float(fSynth, static_cast<int>(frames),

  1514.                                     outBuffer[0] + timeOffset, 0, 1,

  1515.                                     outBuffer[1] + timeOffset, 0, 1);

  1516.         }

  1517. 

  1518. #ifndef BUILD_BRIDGE

  1519.         // --------------------------------------------------------------------------------------------------------

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

  1521. 

  1522.         {

  1523.             // note - balance not possible with kUse16Outs, so we can safely skip fAudioOutBuffers

  1524.             const bool doVolume  = (pData->hints & PLUGIN_CAN_VOLUME) != 0 && carla_isNotEqual(pData->postProc.volume, 1.0f);

  1525.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));

  1526. 

  1527.             float* const oldBufLeft = pData->postProc.extraBuffer;

  1528. 

  1529.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1530.             {

  1531.                 // Balance

  1532.                 if (doBalance)

  1533.                 {

  1534.                     if (i % 2 == 0)

  1535.                         carla_copyFloats(oldBufLeft, outBuffer[i]+timeOffset, frames);

  1536. 

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

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

  1539. 

  1540.                     for (uint32_t k=0; k < frames; ++k)

  1541.                     {

  1542.                         if (i % 2 == 0)

  1543.                         {

  1544.                             // left

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

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

  1547.                         }

  1548.                         else

  1549.                         {

  1550.                             // right

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

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

  1553.                         }

  1554.                     }

  1555.                 }

  1556. 

  1557.                 // Volume

  1558.                 if (kUse16Outs)

  1559.                 {

  1560.                     for (uint32_t k=0; k < frames; ++k)

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

  1562.                 }

  1563.                 else if (doVolume)

  1564.                 {

  1565.                     for (uint32_t k=0; k < frames; ++k)

  1566.                         outBuffer[i][k+timeOffset] *= pData->postProc.volume;

  1567.                 }

  1568.             }

  1569. 

  1570.         } // End of Post-processing

  1571. #else

  1572.         if (kUse16Outs)

  1573.         {

  1574.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1575.             {

  1576.                 for (uint32_t k=0; k < frames; ++k)

  1577.                     outBuffer[i][k+timeOffset] = fAudio16Buffers[i][k];

  1578.             }

  1579.         }

  1580. #endif

  1581. 

  1582.         // --------------------------------------------------------------------------------------------------------

  1583. 

  1584.         pData->singleMutex.unlock();

  1585.         return true;

  1586.     }

  1587. 

  1588.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1589.     {

  1590.         if (kUse16Outs)

  1591.         {

  1592.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1593.             {

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

  1595.                     delete[] fAudio16Buffers[i];

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

  1597.             }

  1598.         }

  1599. 

  1600.         CarlaPlugin::bufferSizeChanged(newBufferSize);

  1601.     }

  1602. 

  1603.     void sampleRateChanged(const double newSampleRate) override

  1604.     {

  1605.         CARLA_SAFE_ASSERT_RETURN(fSettings != nullptr,);

  1606.         fluid_settings_setnum(fSettings, "synth.sample-rate", newSampleRate);

  1607. 

  1608. #if FLUIDSYNTH_VERSION_MAJOR < 2

  1609.         CARLA_SAFE_ASSERT_RETURN(fSynth != nullptr,);

  1610.         fluid_synth_set_sample_rate(fSynth, static_cast<float>(newSampleRate));

  1611. #endif

  1612.     }

  1613. 

  1614.     // -------------------------------------------------------------------

  1615.     // Plugin buffers

  1616. 

  1617.     void clearBuffers() noexcept override

  1618.     {

  1619.         carla_debug("CarlaPluginFluidSynth::clearBuffers() - start");

  1620. 

  1621.         if (fAudio16Buffers != nullptr)

  1622.         {

  1623.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  1624.             {

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

  1626.                 {

  1627.                     delete[] fAudio16Buffers[i];

  1628.                     fAudio16Buffers[i] = nullptr;

  1629.                 }

  1630.             }

  1631. 

  1632.             delete[] fAudio16Buffers;

  1633.             fAudio16Buffers = nullptr;

  1634.         }

  1635. 

  1636.         CarlaPlugin::clearBuffers();

  1637. 

  1638.         carla_debug("CarlaPluginFluidSynth::clearBuffers() - end");

  1639.     }

  1640. 

  1641.     // -------------------------------------------------------------------

  1642. 

  1643.     const void* getExtraStuff() const noexcept override

  1644.     {

  1645.         static const char xtrue[]  = "true";

  1646.         static const char xfalse[] = "false";

  1647.         return kUse16Outs ? xtrue : xfalse;

  1648.     }

  1649. 

  1650.     // -------------------------------------------------------------------

  1651. 

  1652.     bool init(const CarlaPluginPtr plugin,

  1653.               const char* const filename, const char* const name, const char* const label, const uint options)

  1654.     {

  1655.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  1656. 

  1657.         // ---------------------------------------------------------------

  1658.         // first checks

  1659. 

  1660.         if (pData->client != nullptr)

  1661.         {

  1662.             pData->engine->setLastError("Plugin client is already registered");

  1663.             return false;

  1664.         }

  1665. 

  1666.         if (fSynth == nullptr)

  1667.         {

  1668.             pData->engine->setLastError("null synth");

  1669.             return false;

  1670.         }

  1671. 

  1672.         if (filename == nullptr || filename[0] == '\0')

  1673.         {

  1674.             pData->engine->setLastError("null filename");

  1675.             return false;

  1676.         }

  1677. 

  1678.         if (label == nullptr || label[0] == '\0')

  1679.         {

  1680.             pData->engine->setLastError("null label");

  1681.             return false;

  1682.         }

  1683. 

  1684.         // ---------------------------------------------------------------

  1685.         // open soundfont

  1686. 

  1687.         const int synthId = fluid_synth_sfload(fSynth, filename, 0);

  1688. 

  1689.         if (synthId < 0)

  1690.         {

  1691.             pData->engine->setLastError("Failed to load SoundFont file");

  1692.             return false;

  1693.         }

  1694. 

  1695. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1696.         fSynthId = synthId;

  1697. #else

  1698.         fSynthId = static_cast<uint>(synthId);

  1699. #endif

  1700. 

  1701. 

  1702.         // ---------------------------------------------------------------

  1703.         // get info

  1704. 

  1705.         String label2(label);

  1706. 

  1707.         if (kUse16Outs && ! label2.endsWith(" (16 outs)"))

  1708.             label2 += " (16 outs)";

  1709. 

  1710.         fLabel          = carla_strdup(label2);

  1711.         pData->filename = carla_strdup(filename);

  1712. 

  1713.         if (name != nullptr && name[0] != '\0')

  1714.             pData->name = pData->engine->getUniquePluginName(name);

  1715.         else

  1716.             pData->name = pData->engine->getUniquePluginName(label);

  1717. 

  1718.         // ---------------------------------------------------------------

  1719.         // register client

  1720. 

  1721.         pData->client = pData->engine->addClient(plugin);

  1722. 

  1723.         if (pData->client == nullptr || ! pData->client->isOk())

  1724.         {

  1725.             pData->engine->setLastError("Failed to register plugin client");

  1726.             return false;

  1727.         }

  1728. 

  1729.         // ---------------------------------------------------------------

  1730.         // set options

  1731. 

  1732.         pData->options = 0x0;

  1733. 

  1734.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))

  1735.             pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1736.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))

  1737.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1738.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))

  1739.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1740.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))

  1741.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1742.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))

  1743.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1744.         if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))

  1745.             pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;

  1746. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1747.         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))

  1748.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1749. #endif

  1750. 

  1751.         return true;

  1752.     }

  1753. 

  1754. private:

  1755.     void initializeFluidDefaultsIfNeeded()

  1756.     {

  1757.         if (sFluidDefaultsStored)

  1758.             return;

  1759. 

  1760.         sFluidDefaultsStored = true;

  1761. 

  1762.         // reverb defaults

  1763.         sFluidDefaults[FluidSynthReverbOnOff] = 1.0f;

  1764. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1765.         double reverbVal;

  1766. 

  1767.         reverbVal = 0.2;

  1768.         fluid_settings_getnum_default(fSettings, "synth.reverb.room-size", &reverbVal);

  1769.         sFluidDefaults[FluidSynthReverbRoomSize] = static_cast<float>(reverbVal);

  1770. 

  1771.         reverbVal = 0.0;

  1772.         fluid_settings_getnum_default(fSettings, "synth.reverb.damp", &reverbVal);

  1773.         sFluidDefaults[FluidSynthReverbDamp] = static_cast<float>(reverbVal);

  1774. 

  1775.         reverbVal = 0.9;

  1776.         fluid_settings_getnum_default(fSettings, "synth.reverb.level", &reverbVal);

  1777.         sFluidDefaults[FluidSynthReverbLevel] = static_cast<float>(reverbVal);

  1778. 

  1779.         reverbVal = 0.5;

  1780.         fluid_settings_getnum_default(fSettings, "synth.reverb.width", &reverbVal);

  1781.         sFluidDefaults[FluidSynthReverbWidth] = static_cast<float>(reverbVal);

  1782. #else

  1783.         sFluidDefaults[FluidSynthReverbRoomSize] = FLUID_REVERB_DEFAULT_ROOMSIZE;

  1784.         sFluidDefaults[FluidSynthReverbDamp] = FLUID_REVERB_DEFAULT_DAMP;

  1785.         sFluidDefaults[FluidSynthReverbLevel] = FLUID_REVERB_DEFAULT_LEVEL;

  1786.         sFluidDefaults[FluidSynthReverbWidth] = FLUID_REVERB_DEFAULT_WIDTH;

  1787. #endif

  1788. 

  1789.         // chorus defaults

  1790.         sFluidDefaults[FluidSynthChorusOnOff] = 1.0f;

  1791. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1792.         double chorusVal;

  1793. 

  1794.         chorusVal = 3.0;

  1795.         fluid_settings_getnum_default(fSettings, "synth.chorus.nr", &chorusVal);

  1796.         sFluidDefaults[FluidSynthChorusNr] = static_cast<float>(chorusVal);

  1797. 

  1798.         chorusVal = 2.0;

  1799.         fluid_settings_getnum_default(fSettings, "synth.chorus.level", &chorusVal);

  1800.         sFluidDefaults[FluidSynthChorusLevel] = static_cast<float>(chorusVal);

  1801. 

  1802.         chorusVal = 0.3;

  1803.         fluid_settings_getnum_default(fSettings, "synth.chorus.speed", &chorusVal);

  1804.         sFluidDefaults[FluidSynthChorusSpeedHz] = static_cast<float>(chorusVal);

  1805. 

  1806.         chorusVal = 8.0;

  1807.         fluid_settings_getnum_default(fSettings, "synth.chorus.depth", &chorusVal);

  1808.         sFluidDefaults[FluidSynthChorusDepthMs] = static_cast<float>(chorusVal);

  1809. 

  1810.         // There is no settings for chorus default type

  1811.         sFluidDefaults[FluidSynthChorusType] = static_cast<float>(fluid_synth_get_chorus_type(fSynth));

  1812. #else

  1813.         sFluidDefaults[FluidSynthChorusNr] = FLUID_CHORUS_DEFAULT_N;

  1814.         sFluidDefaults[FluidSynthChorusLevel] = FLUID_CHORUS_DEFAULT_LEVEL;

  1815.         sFluidDefaults[FluidSynthChorusSpeedHz] = FLUID_CHORUS_DEFAULT_SPEED;

  1816.         sFluidDefaults[FluidSynthChorusDepthMs] = FLUID_CHORUS_DEFAULT_DEPTH;

  1817.         sFluidDefaults[FluidSynthChorusType] = FLUID_CHORUS_DEFAULT_TYPE;

  1818. #endif

  1819. 

  1820.         // misc. defaults

  1821.         sFluidDefaults[FluidSynthInterpolation] = FLUID_INTERP_DEFAULT;

  1822.         sFluidDefaults[FluidSynthPolyphony] = FLUID_DEFAULT_POLYPHONY;

  1823.     }

  1824. 

  1825.     enum FluidSynthParameters {

  1826.         FluidSynthReverbOnOff    = 0,

  1827.         FluidSynthReverbRoomSize = 1,

  1828.         FluidSynthReverbDamp     = 2,

  1829.         FluidSynthReverbLevel    = 3,

  1830.         FluidSynthReverbWidth    = 4,

  1831.         FluidSynthChorusOnOff    = 5,

  1832.         FluidSynthChorusNr       = 6,

  1833.         FluidSynthChorusLevel    = 7,

  1834.         FluidSynthChorusSpeedHz  = 8,

  1835.         FluidSynthChorusDepthMs  = 9,

  1836.         FluidSynthChorusType     = 10,

  1837.         FluidSynthPolyphony      = 11,

  1838.         FluidSynthInterpolation  = 12,

  1839.         FluidSynthVoiceCount     = 13,

  1840.         FluidSynthParametersMax  = 14

  1841.     };

  1842. 

  1843.     const bool kUse16Outs;

  1844. 

  1845.     fluid_settings_t* fSettings;

  1846.     fluid_synth_t*    fSynth;

  1847. #if FLUIDSYNTH_VERSION_MAJOR >= 2

  1848.     int fSynthId;

  1849. #else

  1850.     uint fSynthId;

  1851. #endif

  1852. 

  1853.     float** fAudio16Buffers;

  1854.     float   fParamBuffers[FluidSynthParametersMax];

  1855. 

  1856.     static bool sFluidDefaultsStored;

  1857.     static float sFluidDefaults[FluidSynthParametersMax];

  1858. 

  1859.     int32_t fCurMidiProgs[MAX_MIDI_CHANNELS];

  1860. 

  1861.     const char* fLabel;

  1862. 

  1863.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginFluidSynth)

  1864. };

  1865. 

  1866. bool CarlaPluginFluidSynth::sFluidDefaultsStored = false;

  1867. float CarlaPluginFluidSynth::sFluidDefaults[FluidSynthParametersMax] = {

  1868.     0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,

  1869. };

  1870. 

  1871. CARLA_BACKEND_END_NAMESPACE

  1872. 

  1873. #endif // HAVE_FLUIDSYNTH

  1874. 

  1875. CARLA_BACKEND_START_NAMESPACE

  1876. 

  1877. // -------------------------------------------------------------------------------------------------------------------

  1878. 

  1879. CarlaPluginPtr CarlaPlugin::newFluidSynth(const Initializer& init, PluginType ptype, bool use16Outs)

  1880. {

  1881.     carla_debug("CarlaPlugin::newFluidSynth({%p, \"%s\", \"%s\", \"%s\", " P_INT64 "}, %s)",

  1882.                 init.engine, init.filename, init.name, init.label, init.uniqueId, bool2str(use16Outs));

  1883. 

  1884. #ifdef HAVE_FLUIDSYNTH

  1885.     if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1886.         use16Outs = false;

  1887. 

  1888.     if (ptype == PLUGIN_SF2 && ! fluid_is_soundfont(init.filename))

  1889.     {

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

  1891.         return nullptr;

  1892.     }

  1893. #ifndef HAVE_FLUIDSYNTH_INSTPATCH

  1894.     if (ptype == PLUGIN_DLS)

  1895.     {

  1896.         init.engine->setLastError("DLS file support not available");

  1897.         return nullptr;

  1898.     }

  1899.     if (ptype == PLUGIN_GIG)

  1900.     {

  1901.         init.engine->setLastError("GIG file support not available");

  1902.         return nullptr;

  1903.     }

  1904. #endif

  1905. 

  1906.     std::shared_ptr<CarlaPluginFluidSynth> plugin(new CarlaPluginFluidSynth(init.engine, init.id,  use16Outs));

  1907. 

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

  1909.         return nullptr;

  1910. 

  1911.     return plugin;

  1912. #else

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

  1914.     return nullptr;

  1915. 

  1916.     // unused

  1917.     (void)ptype;

  1918.     (void)use16Outs;

  1919. #endif

  1920. }

  1921. 

  1922. // -------------------------------------------------------------------------------------------------------------------

  1923. 

  1924. CARLA_BACKEND_END_NAMESPACE