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.
296 Commits
17 Branches
9.1GB
Tree: 6970cb280e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6970cb280e'
${ noResults }
Carla/source/backend/engine/CarlaEngineOsc.cpp

818 lines
26KB
Raw Blame History 

  1. /*

  2.  * Carla Engine OSC

  3.  * Copyright (C) 2012-2013 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the GPL.txt file

  16.  */

  17. 

  18. #include "CarlaEngineOsc.hpp"

  19. 

  20. #include "CarlaEngine.hpp"

  21. #include "CarlaPlugin.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #ifndef BUILD_BRIDGE

  25. # include "CarlaBridge.hpp"

  26. #endif

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. #ifndef BUILD_BRIDGE

  31. // -------------------------------------------------------------------

  32. // Bridge Helper, defined in plugin/CarlaBlugin.cpp

  33. 

  34. extern int CarlaPluginSetOscBridgeInfo(CarlaPlugin* const plugin, const PluginBridgeInfoType type,

  35.                                        const int argc, const lo_arg* const* const argv, const char* const types);

  36. #endif

  37. 

  38. // -----------------------------------------------------------------------

  39. 

  40. CarlaEngineOsc::CarlaEngineOsc(CarlaEngine* const engine)

  41.     : kEngine(engine),

  42.       fServerTCP(nullptr),

  43.       fServerUDP(nullptr)

  44. {

  45.     carla_debug("CarlaEngineOsc::CarlaEngineOsc(%p)", engine);

  46.     CARLA_ASSERT(engine != nullptr);

  47. }

  48. 

  49. CarlaEngineOsc::~CarlaEngineOsc()

  50. {

  51.     carla_debug("CarlaEngineOsc::~CarlaEngineOsc()");

  52.     CARLA_ASSERT(fName.isEmpty());

  53.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  54.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  55.     CARLA_ASSERT(fServerTCP == nullptr);

  56.     CARLA_ASSERT(fServerUDP == nullptr);

  57. }

  58. 

  59. // -----------------------------------------------------------------------

  60. 

  61. void CarlaEngineOsc::init(const char* const name)

  62. {

  63.     carla_debug("CarlaEngineOsc::init(\"%s\")", name);

  64.     CARLA_ASSERT(fName.isEmpty());

  65.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  66.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  67.     CARLA_ASSERT(fServerTCP == nullptr);

  68.     CARLA_ASSERT(fServerUDP == nullptr);

  69.     CARLA_ASSERT(name != nullptr);

  70. 

  71.     fName = name;

  72.     fName.toBasic();

  73. 

  74.     fServerTCP = lo_server_new_with_proto(nullptr, LO_TCP, osc_error_handler_TCP);

  75. 

  76.     if (fServerTCP != nullptr)

  77.     {

  78.         if (char* const tmpServerPathTCP = lo_server_get_url(fServerTCP))

  79.         {

  80.             fServerPathTCP  = tmpServerPathTCP;

  81.             fServerPathTCP += fName;

  82.             std::free(tmpServerPathTCP);

  83.         }

  84. 

  85.         lo_server_add_method(fServerTCP, nullptr, nullptr, osc_message_handler_TCP, this);

  86.     }

  87. 

  88.     fServerUDP = lo_server_new_with_proto(nullptr, LO_UDP, osc_error_handler_UDP);

  89. 

  90.     if (fServerUDP != nullptr)

  91.     {

  92.         if (char* const tmpServerPathUDP = lo_server_get_url(fServerUDP))

  93.         {

  94.             fServerPathUDP  = tmpServerPathUDP;

  95.             fServerPathUDP += fName;

  96.             std::free(tmpServerPathUDP);

  97.         }

  98. 

  99.         lo_server_add_method(fServerUDP, nullptr, nullptr, osc_message_handler_UDP, this);

  100.     }

  101. 

  102.     CARLA_ASSERT(fName.isNotEmpty());

  103.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  104.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  105.     CARLA_ASSERT(fServerTCP != nullptr);

  106.     CARLA_ASSERT(fServerUDP != nullptr);

  107. }

  108. 

  109. void CarlaEngineOsc::idle()

  110. {

  111.     if (fServerTCP != nullptr)

  112.     {

  113.         while (lo_server_recv_noblock(fServerTCP, 0) != 0) {}

  114.     }

  115. 

  116.     if (fServerUDP != nullptr)

  117.     {

  118.         while (lo_server_recv_noblock(fServerUDP, 0) != 0) {}

  119.     }

  120. }

  121. 

  122. void CarlaEngineOsc::close()

  123. {

  124.     carla_debug("CarlaEngineOsc::close()");

  125.     CARLA_ASSERT(fName.isNotEmpty());

  126.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  127.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  128.     CARLA_ASSERT(fServerTCP != nullptr);

  129.     CARLA_ASSERT(fServerUDP != nullptr);

  130. 

  131.     fName.clear();

  132. 

  133.     if (fServerTCP != nullptr)

  134.     {

  135.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  136.         lo_server_free(fServerTCP);

  137.         fServerTCP = nullptr;

  138.     }

  139. 

  140.     if (fServerUDP != nullptr)

  141.     {

  142.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  143.         lo_server_free(fServerUDP);

  144.         fServerUDP = nullptr;

  145.     }

  146. 

  147.     fServerPathTCP.clear();

  148.     fServerPathUDP.clear();

  149. 

  150. #ifndef BUILD_BRIDGE

  151.     fControlData.free();

  152. #endif

  153. 

  154.     CARLA_ASSERT(fName.isEmpty());

  155.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  156.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  157.     CARLA_ASSERT(fServerTCP == nullptr);

  158.     CARLA_ASSERT(fServerUDP == nullptr);

  159. }

  160. 

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

  162. 

  163. bool isDigit(const char c)

  164. {

  165.     return (c >= '0' && c <= '9');

  166. }

  167. 

  168. int CarlaEngineOsc::handleMessage(const bool isTCP, const char* const path, const int argc, const lo_arg* const* const argv, const char* const types, const lo_message msg)

  169. {

  170.     carla_debug("CarlaEngineOsc::handleMessage(%s, \"%s\", %i, %p, \"%s\", %p)", bool2str(isTCP), path, argc, argv, types, msg);

  171.     CARLA_ASSERT(fName.isNotEmpty());

  172.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  173.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  174.     CARLA_ASSERT(fServerTCP != nullptr);

  175.     CARLA_ASSERT(fServerUDP != nullptr);

  176.     CARLA_ASSERT(path != nullptr);

  177. 

  178.     if (path == nullptr)

  179.     {

  180.         carla_stderr("CarlaEngineOsc::handleMessage() - got invalid path");

  181.         return 1;

  182.     }

  183. 

  184.     if (fName.isEmpty())

  185.     {

  186.         carla_stderr("CarlaEngineOsc::handleMessage(%s, \"%s\", ...) - received message but client is offline", bool2str(isTCP), path);

  187.         return 1;

  188.     }

  189. 

  190. #ifndef BUILD_BRIDGE

  191.     // Initial path check

  192.     if (std::strcmp(path, "/register") == 0)

  193.     {

  194.         const lo_address source = lo_message_get_source(msg);

  195.         return handleMsgRegister(isTCP, argc, argv, types, source);

  196.     }

  197.     if (std::strcmp(path, "/unregister") == 0)

  198.     {

  199.         return handleMsgUnregister();

  200.     }

  201. #endif

  202. 

  203.     const size_t nameSize = fName.length();

  204. 

  205.     // Check if message is for this client

  206.     if (std::strlen(path) <= nameSize || std::strncmp(path+1, (const char*)fName, nameSize) != 0)

  207.     {

  208.         carla_stderr("CarlaEngineOsc::handleMessage() - message not for this client -> '%s' != '/%s/'", path, (const char*)fName);

  209.         return 1;

  210.     }

  211. 

  212.     // Get plugin id from message

  213.     // eg, /carla/23/method

  214. 

  215.     unsigned int pluginId = 0;

  216.     size_t offset;

  217. 

  218.     if (isDigit(path[nameSize+2]))

  219.     {

  220.         if (isDigit(path[nameSize+3]))

  221.         {

  222.             if (isDigit(path[nameSize+5]))

  223.             {

  224.                 carla_stderr2("CarlaEngineOsc::handleMessage() - invalid plugin id, over 999? (value: \"%s\")", path+nameSize);

  225.                 return 1;

  226.             }

  227.             else if (isDigit(path[nameSize+4]))

  228.             {

  229.                 // 3 digits, /xyz/method

  230.                 offset    = 6;

  231.                 pluginId += (path[nameSize+2]-'0')*100;

  232.                 pluginId += (path[nameSize+3]-'0')*10;

  233.                 pluginId += (path[nameSize+4]-'0');

  234.             }

  235.             else

  236.             {

  237.                 // 2 digits, /xy/method

  238.                 offset    = 5;

  239.                 pluginId += (path[nameSize+2]-'0')*10;

  240.                 pluginId += (path[nameSize+3]-'0');

  241.             }

  242.         }

  243.         else

  244.         {

  245.             // single digit, /x/method

  246.             offset    = 4;

  247.             pluginId += path[nameSize+2]-'0';

  248.         }

  249.     }

  250.     else

  251.     {

  252.         carla_stderr("CarlaEngineOsc::handleMessage() - invalid message '%s'", path);

  253.         return 1;

  254.     }

  255. 

  256.     if (pluginId > kEngine->currentPluginCount())

  257.     {

  258.         carla_stderr("CarlaEngineOsc::handleMessage() - failed to get plugin, wrong id '%i'", pluginId);

  259.         return 1;

  260.     }

  261. 

  262.     // Get plugin

  263.     CarlaPlugin* const plugin = kEngine->getPluginUnchecked(pluginId);

  264. 

  265.     if (plugin == nullptr || plugin->id() != pluginId)

  266.     {

  267.         carla_stderr("CarlaEngineOsc::handleMessage() - invalid plugin id '%i', probably has been removed", pluginId);

  268.         return 1;

  269.     }

  270. 

  271.     // Get method from path, "/Carla/i/method" -> "method"

  272.     char method[32] = { 0 };

  273.     std::strncpy(method, path + (nameSize + offset), 31);

  274. 

  275.     if (method[0] == '\0')

  276.     {

  277.         carla_stderr("CarlaEngineOsc::handleMessage(%s, \"%s\", ...) - received message without method", bool2str(isTCP), path);

  278.         return 1;

  279.     }

  280. 

  281.     // Common OSC methods (DSSI and bridge UIs)

  282.     if (std::strcmp(method, "update") == 0)

  283.     {

  284.         const lo_address source = lo_message_get_source(msg);

  285.         return handleMsgUpdate(plugin, argc, argv, types, source);

  286.     }

  287.     if (std::strcmp(method, "configure") == 0)

  288.         return handleMsgConfigure(plugin, argc, argv, types);

  289.     if (std::strcmp(method, "control") == 0)

  290.         return handleMsgControl(plugin, argc, argv, types);

  291.     if (std::strcmp(method, "program") == 0)

  292.         return handleMsgProgram(plugin, argc, argv, types);

  293.     if (std::strcmp(method, "midi") == 0)

  294.         return handleMsgMidi(plugin, argc, argv, types);

  295.     if (std::strcmp(method, "exiting") == 0)

  296.         return handleMsgExiting(plugin);

  297. 

  298. #ifndef BUILD_BRIDGE

  299.     // Internal methods

  300.     if (std::strcmp(method, "set_active") == 0)

  301.         return handleMsgSetActive(plugin, argc, argv, types);

  302.     if (std::strcmp(method, "set_drywet") == 0)

  303.         return handleMsgSetDryWet(plugin, argc, argv, types);

  304.     if (std::strcmp(method, "set_volume") == 0)

  305.         return handleMsgSetVolume(plugin, argc, argv, types);

  306.     if (std::strcmp(method, "set_balance_left") == 0)

  307.         return handleMsgSetBalanceLeft(plugin, argc, argv, types);

  308.     if (std::strcmp(method, "set_balance_right") == 0)

  309.         return handleMsgSetBalanceRight(plugin, argc, argv, types);

  310.     if (std::strcmp(method, "set_panning") == 0)

  311.         return handleMsgSetPanning(plugin, argc, argv, types);

  312.     if (std::strcmp(method, "set_parameter_value") == 0)

  313.         return handleMsgSetParameterValue(plugin, argc, argv, types);

  314.     if (std::strcmp(method, "set_parameter_midi_cc") == 0)

  315.         return handleMsgSetParameterMidiCC(plugin, argc, argv, types);

  316.     if (std::strcmp(method, "set_parameter_midi_channel") == 0)

  317.         return handleMsgSetParameterMidiChannel(plugin, argc, argv, types);

  318.     if (std::strcmp(method, "set_program") == 0)

  319.         return handleMsgSetProgram(plugin, argc, argv, types);

  320.     if (std::strcmp(method, "set_midi_program") == 0)

  321.         return handleMsgSetMidiProgram(plugin, argc, argv, types);

  322.     if (std::strcmp(method, "note_on") == 0)

  323.         return handleMsgNoteOn(plugin, argc, argv, types);

  324.     if (std::strcmp(method, "note_off") == 0)

  325.         return handleMsgNoteOff(plugin, argc, argv, types);

  326. 

  327.     // Plugin Bridges

  328.     if ((plugin->hints() & PLUGIN_IS_BRIDGE) > 0 && std::strlen(method) > 11 && std::strncmp(method, "bridge_", 7) == 0)

  329.     {

  330.         if (std::strcmp(method+7, "set_peaks") == 0)

  331.             return handleMsgBridgeSetPeaks(plugin, argc, argv, types);

  332.         if (std::strcmp(method+7, "audio_count") == 0)

  333.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeAudioCount, argc, argv, types);

  334.         if (std::strcmp(method+7, "midi_count") == 0)

  335.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiCount, argc, argv, types);

  336.         if (std::strcmp(method+7, "parameter_count") == 0)

  337.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterCount, argc, argv, types);

  338.         if (std::strcmp(method+7, "program_count") == 0)

  339.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeProgramCount, argc, argv, types);

  340.         if (std::strcmp(method+7, "midi_program_count") == 0)

  341.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiProgramCount, argc, argv, types);

  342.         if (std::strcmp(method+7, "plugin_info") == 0)

  343.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo, argc, argv, types);

  344.         if (std::strcmp(method+7, "parameter_info") == 0)

  345.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterInfo, argc, argv, types);

  346.         if (std::strcmp(method+7, "parameter_data") == 0)

  347.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterData, argc, argv, types);

  348.         if (std::strcmp(method+7, "parameter_ranges") == 0)

  349.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterRanges, argc, argv, types);

  350.         if (std::strcmp(method+7, "program_info") == 0)

  351.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeProgramInfo, argc, argv, types);

  352.         if (std::strcmp(method+7, "midi_program_info") == 0)

  353.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiProgramInfo, argc, argv, types);

  354.         if (std::strcmp(method+7, "configure") == 0)

  355.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeConfigure, argc, argv, types);

  356.         if (std::strcmp(method+7, "set_parameter_value") == 0)

  357.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetParameterValue, argc, argv, types);

  358.         if (std::strcmp(method+7, "set_default_value") == 0)

  359.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetDefaultValue, argc, argv, types);

  360.         if (std::strcmp(method+7, "set_program") == 0)

  361.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetProgram, argc, argv, types);

  362.         if (std::strcmp(method+7, "set_midi_program") == 0)

  363.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetMidiProgram, argc, argv, types);

  364.         if (std::strcmp(method+7, "set_custom_data") == 0)

  365.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetCustomData, argc, argv, types);

  366.         if (std::strcmp(method+7, "set_chunk_data") == 0)

  367.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetChunkData, argc, argv, types);

  368.         if (std::strcmp(method+7, "update") == 0)

  369.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeUpdateNow, argc, argv, types);

  370.         if (std::strcmp(method+7, "error") == 0)

  371.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeError, argc, argv, types);

  372.     }

  373. #endif

  374. 

  375.     // Plugin-specific methods, FIXME

  376. #if 0 //def WANT_LV2

  377.     if (std::strcmp(method, "lv2_atom_transfer") == 0)

  378.         return handleMsgLv2AtomTransfer(plugin, argc, argv, types);

  379.     if (std::strcmp(method, "lv2_event_transfer") == 0)

  380.         return handleMsgLv2EventTransfer(plugin, argc, argv, types);

  381. #endif

  382. 

  383.     carla_stderr("CarlaEngineOsc::handleMessage() - unsupported OSC method '%s'", method);

  384.     return 1;

  385. }

  386. 

  387. // -----------------------------------------------------------------------

  388. 

  389. #ifndef BUILD_BRIDGE

  390. int CarlaEngineOsc::handleMsgRegister(const bool isTCP, const int argc, const lo_arg* const* const argv, const char* const types, const lo_address source)

  391. {

  392.     carla_debug("CarlaEngineOsc::handleMsgRegister()");

  393.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  394. 

  395.     if (fControlData.path != nullptr)

  396.     {

  397.         carla_stderr("CarlaEngineOsc::handleMsgRegister() - OSC backend already registered to %s", fControlData.path);

  398.         return 1;

  399.     }

  400. 

  401.     const char* const url = &argv[0]->s;

  402. 

  403.     carla_debug("CarlaEngineOsc::handleMsgRegister() - OSC backend registered to %s", url);

  404. 

  405.     {

  406.         const char* host = lo_address_get_hostname(source);

  407.         const char* port = lo_address_get_port(source);

  408.         fControlData.source = lo_address_new_with_proto(isTCP ? LO_TCP : LO_UDP, host, port);

  409.     }

  410. 

  411.     {

  412.         char* host = lo_url_get_hostname(url);

  413.         char* port = lo_url_get_port(url);

  414.         fControlData.path   = carla_strdup_free(lo_url_get_path(url));

  415.         fControlData.target = lo_address_new_with_proto(isTCP ? LO_TCP : LO_UDP, host, port);

  416. 

  417.         std::free(host);

  418.         std::free(port);

  419.     }

  420. 

  421.     for (unsigned short i=0; i < kEngine->currentPluginCount(); i++)

  422.     {

  423.         CarlaPlugin* const plugin = kEngine->getPluginUnchecked(i);

  424. 

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

  426.             plugin->registerToOscClient();

  427.     }

  428. 

  429.     return 0;

  430. }

  431. 

  432. int CarlaEngineOsc::handleMsgUnregister()

  433. {

  434.     carla_debug("CarlaEngineOsc::handleMsgUnregister()");

  435. 

  436.     if (fControlData.path == nullptr)

  437.     {

  438.         carla_stderr("CarlaEngineOsc::handleMsgUnregister() - OSC backend is not registered yet");

  439.         return 1;

  440.     }

  441. 

  442.     fControlData.free();

  443.     return 0;

  444. }

  445. #endif

  446. 

  447. // -----------------------------------------------------------------------

  448. 

  449. int CarlaEngineOsc::handleMsgUpdate(CARLA_ENGINE_OSC_HANDLE_ARGS2, const lo_address source)

  450. {

  451.     carla_debug("CarlaEngineOsc::handleMsgUpdate()");

  452.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  453. 

  454.     const char* const url = (const char*)&argv[0]->s;

  455. 

  456.     plugin->updateOscData(source, url);

  457. 

  458.     return 0;

  459. }

  460. 

  461. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  462. {

  463.     carla_debug("CarlaEngineOsc::handleMsgConfigure()");

  464.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  465. 

  466.     const char* const key   = (const char*)&argv[0]->s;

  467.     const char* const value = (const char*)&argv[1]->s;

  468. 

  469.     plugin->setCustomData(CUSTOM_DATA_STRING, key, value, false);

  470. 

  471.     return 0;

  472. }

  473. 

  474. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  475. {

  476.     carla_debug("CarlaEngineOsc::handleMsgControl()");

  477.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  478. 

  479.     const int32_t rindex = argv[0]->i;

  480.     const float   value  = argv[1]->f;

  481. 

  482.     plugin->setParameterValueByRIndex(rindex, value, false, true, true);

  483. 

  484.     return 0;

  485. }

  486. 

  487. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  488. {

  489.     carla_debug("CarlaEngineOsc::handleMsgProgram()");

  490. 

  491.     if (argc == 2)

  492.     {

  493.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  494. 

  495.         const int32_t bank    = argv[0]->i;

  496.         const int32_t program = argv[1]->i;

  497. 

  498.         CARLA_SAFE_ASSERT_INT(bank >= 0, bank);

  499.         CARLA_SAFE_ASSERT_INT(program >= 0, program);

  500. 

  501.         if (bank < 0)

  502.             return 1;

  503.         if (program < 0)

  504.             return 1;

  505. 

  506.         plugin->setMidiProgramById(static_cast<uint32_t>(bank), static_cast<uint32_t>(program), false, true, true);

  507. 

  508.         return 0;

  509.     }

  510.     else

  511.     {

  512.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  513. 

  514.         const int32_t program = argv[0]->i;

  515. 

  516.         CARLA_SAFE_ASSERT_INT(program >= 0, program);

  517. 

  518.         if (program < 0)

  519.             return 1;

  520. 

  521.         if (program < static_cast<int32_t>(plugin->programCount()))

  522.         {

  523.             plugin->setProgram(program, false, true, true);

  524.             return 0;

  525.         }

  526. 

  527.         carla_stderr("CarlaEngineOsc::handleMsgProgram() - programId '%i' out of bounds", program);

  528.         return 1;

  529.     }

  530. }

  531. 

  532. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  533. {

  534.     carla_debug("CarlaEngineOsc::handleMsgMidi()");

  535.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  536. 

  537.     if (plugin->midiInCount() == 0)

  538.     {

  539.         carla_stderr("CarlaEngineOsc::handleMsgMidi() - recived midi when plugin has no midi inputs");

  540.         return 1;

  541.     }

  542. 

  543.     const uint8_t* const data = argv[0]->m;

  544.     uint8_t status  = data[1];

  545.     uint8_t channel = status & 0x0F;

  546. 

  547.     // Fix bad note-off

  548.     if (MIDI_IS_STATUS_NOTE_ON(status) && data[3] == 0)

  549.         status -= 0x10;

  550. 

  551.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  552.     {

  553.         const uint8_t note = data[2];

  554. 

  555.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  556. 

  557.         if (note >= MAX_MIDI_NOTE)

  558.             return 1;

  559. 

  560.         plugin->sendMidiSingleNote(channel, note, 0, false, true, true);

  561.     }

  562.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  563.     {

  564.         const uint8_t note = data[2];

  565.         const uint8_t velo = data[3];

  566. 

  567.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  568.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  569. 

  570.         if (note >= MAX_MIDI_NOTE)

  571.             return 1;

  572.         if (velo >= MAX_MIDI_VALUE)

  573.             return 1;

  574. 

  575.         plugin->sendMidiSingleNote(channel, note, velo, false, true, true);

  576.     }

  577. 

  578.     return 0;

  579. }

  580. 

  581. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  582. {

  583.     carla_debug("CarlaEngineOsc::handleMsgExiting()");

  584. 

  585.     // TODO - check for non-UIs (dssi-vst) and set to -1 instead

  586.     kEngine->callback(CALLBACK_SHOW_GUI, plugin->id(), 0, 0, 0.0f, nullptr);

  587. 

  588.     plugin->freeOscData();

  589. 

  590.     return 0;

  591. }

  592. 

  593. // -----------------------------------------------------------------------

  594. 

  595. #ifndef BUILD_BRIDGE

  596. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  597. {

  598.     carla_debug("CarlaEngineOsc::handleMsgSetActive()");

  599.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  600. 

  601.     const bool active = (argv[0]->i != 0);

  602. 

  603.     plugin->setActive(active, false, true);

  604. 

  605.     return 0;

  606. }

  607. 

  608. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  609. {

  610.     carla_debug("CarlaEngineOsc::handleMsgSetDryWet()");

  611.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  612. 

  613.     const float value = argv[0]->f;

  614. 

  615.     plugin->setDryWet(value, false, true);

  616. 

  617.     return 0;

  618. }

  619. 

  620. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  621. {

  622.     carla_debug("CarlaEngineOsc::handleMsgSetVolume()");

  623.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  624. 

  625.     const float value = argv[0]->f;

  626. 

  627.     plugin->setVolume(value, false, true);

  628. 

  629.     return 0;

  630. }

  631. 

  632. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  633. {

  634.     carla_debug("CarlaEngineOsc::handleMsgSetBalanceLeft()");

  635.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  636. 

  637.     const float value = argv[0]->f;

  638. 

  639.     plugin->setBalanceLeft(value, false, true);

  640. 

  641.     return 0;

  642. }

  643. 

  644. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  645. {

  646.     carla_debug("CarlaEngineOsc::handleMsgSetBalanceRight()");

  647.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  648. 

  649.     const float value = argv[0]->f;

  650. 

  651.     plugin->setBalanceRight(value, false, true);

  652. 

  653.     return 0;

  654. }

  655. 

  656. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  657. {

  658.     carla_debug("CarlaEngineOsc::handleMsgSetPanning()");

  659.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  660. 

  661.     const float value = argv[0]->f;

  662. 

  663.     plugin->setPanning(value, false, true);

  664. 

  665.     return 0;

  666. }

  667. 

  668. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  669. {

  670.     carla_debug("CarlaEngineOsc::handleMsgSetParameterValue()");

  671.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  672. 

  673.     const int32_t index = argv[0]->i;

  674.     const float   value = argv[1]->f;

  675. 

  676.     CARLA_SAFE_ASSERT_INT(index >= 0, index);

  677. 

  678.     if (index < 0)

  679.         return 1;

  680. 

  681.     plugin->setParameterValue(static_cast<uint32_t>(index), value, true, false, true);

  682. 

  683.     return 0;

  684. }

  685. 

  686. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  687. {

  688.     carla_debug("CarlaEngineOsc::handleMsgSetParameterMidiCC()");

  689.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  690. 

  691.     const int32_t index = argv[0]->i;

  692.     const int32_t cc    = argv[1]->i;

  693. 

  694.     CARLA_SAFE_ASSERT_INT(index >= 0, index);

  695.     CARLA_SAFE_ASSERT_INT(cc >= -1 && cc <= 0x5F, cc);

  696. 

  697.     if (index < 0)

  698.         return 1;

  699.     if (cc < -1 || cc > 0x5F)

  700.         return 1;

  701. 

  702.     plugin->setParameterMidiCC(static_cast<uint32_t>(index), static_cast<int16_t>(cc), false, true);

  703. 

  704.     return 0;

  705. }

  706. 

  707. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  708. {

  709.     carla_debug("CarlaEngineOsc::handleMsgSetParameterMidiChannel()");

  710.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  711. 

  712.     const int32_t index   = argv[0]->i;

  713.     const int32_t channel = argv[1]->i;

  714. 

  715.     CARLA_SAFE_ASSERT_INT(index >= 0, index);

  716.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  717. 

  718.     if (index < 0)

  719.         return 1;

  720.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  721.         return 1;

  722. 

  723.     plugin->setParameterMidiChannel(static_cast<uint32_t>(index), static_cast<uint8_t>(channel), false, true);

  724. 

  725.     return 0;

  726. }

  727. 

  728. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  729. {

  730.     carla_debug("CarlaEngineOsc::handleMsgSetProgram()");

  731.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  732. 

  733.     const int32_t index = argv[0]->i;

  734. 

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

  736. 

  737.     return 0;

  738. }

  739. 

  740. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  741. {

  742.     carla_debug("CarlaEngineOsc::handleMsgSetMidiProgram()");

  743.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  744. 

  745.     const int32_t index = argv[0]->i;

  746. 

  747.     plugin->setMidiProgram(index, true, false, true);

  748. 

  749.     return 0;

  750. }

  751. 

  752. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  753. {

  754.     carla_debug("CarlaEngineOsc::handleMsgNoteOn()");

  755.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  756. 

  757.     const int32_t channel = argv[0]->i;

  758.     const int32_t note    = argv[1]->i;

  759.     const int32_t velo    = argv[2]->i;

  760. 

  761.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  762.     CARLA_SAFE_ASSERT_INT(note >= 0 && note < MAX_MIDI_NOTE, note);

  763.     CARLA_SAFE_ASSERT_INT(velo >= 0 && velo < MAX_MIDI_VALUE, velo);

  764. 

  765.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  766.         return 1;

  767.     if (note < 0 || note >= MAX_MIDI_NOTE)

  768.         return 1;

  769.     if (velo < 0 || velo >= MAX_MIDI_VALUE)

  770.         return 1;

  771. 

  772.     plugin->sendMidiSingleNote(static_cast<uint8_t>(channel), static_cast<uint8_t>(note), static_cast<uint8_t>(velo), true, false, true);

  773. 

  774.     return 0;

  775. }

  776. 

  777. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  778. {

  779.     carla_debug("CarlaEngineOsc::handleMsgNoteOff()");

  780.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  781. 

  782.     const int32_t channel = argv[0]->i;

  783.     const int32_t note    = argv[1]->i;

  784. 

  785.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  786.     CARLA_SAFE_ASSERT_INT(note >= 0 && note < MAX_MIDI_NOTE, note);

  787. 

  788.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  789.         return 1;

  790.     if (note < 0 || note >= MAX_MIDI_NOTE)

  791.         return 1;

  792. 

  793.     plugin->sendMidiSingleNote(static_cast<uint8_t>(channel), static_cast<uint8_t>(note), 0, true, false, true);

  794. 

  795.     return 0;

  796. }

  797. 

  798. // FIXME - remove once IPC audio is implemented

  799. int CarlaEngineOsc::handleMsgBridgeSetPeaks(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  800. {

  801.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(4, "ffff");

  802. 

  803.     const float in1  = argv[0]->f;

  804.     const float in2  = argv[1]->f;

  805.     const float out1 = argv[2]->f;

  806.     const float out2 = argv[3]->f;

  807. 

  808.     float const inPeaks[CarlaEngine::MAX_PEAKS] = { in1, in2 };

  809.     float const outPeaks[CarlaEngine::MAX_PEAKS] = { out1, out2 };

  810. 

  811.     kEngine->setPeaks(plugin->id(), inPeaks, outPeaks);

  812. 

  813.     return 0;

  814. }

  815. #endif

  816. 

  817. CARLA_BACKEND_END_NAMESPACE