falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1301 Commits
16 Branches
16GB
Tree: 7a4bcbeb88
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7a4bcbeb88'
${ noResults }
Carla/source/backend/engine/CarlaEngineOsc.cpp

797 lines
25KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngine.hpp"

  19. #include "CarlaEngineOsc.hpp"

  20. #include "CarlaPlugin.hpp"

  21. 

  22. #ifndef BUILD_BRIDGE

  23. # include "CarlaBridgeUtils.hpp"

  24. #endif

  25. 

  26. #include "CarlaMIDI.h"

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. #ifndef BUILD_BRIDGE

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

  32. // Bridge Helper, defined in BridgePlugin.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.     : fEngine(engine),

  42.       fServerTCP(nullptr),

  43.       fServerUDP(nullptr)

  44. {

  45.     CARLA_ASSERT(engine != nullptr);

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

  47. }

  48. 

  49. CarlaEngineOsc::~CarlaEngineOsc()

  50. {

  51.     CARLA_ASSERT(fName.isEmpty());

  52.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  53.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  54.     CARLA_ASSERT(fServerTCP == nullptr);

  55.     CARLA_ASSERT(fServerUDP == nullptr);

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

  57. }

  58. 

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

  60. 

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

  62. {

  63.     CARLA_SAFE_ASSERT_RETURN(fName.isEmpty(),);

  64.     CARLA_SAFE_ASSERT_RETURN(fServerPathTCP.isEmpty(),);

  65.     CARLA_SAFE_ASSERT_RETURN(fServerPathUDP.isEmpty(),);

  66.     CARLA_SAFE_ASSERT_RETURN(fServerTCP == nullptr,);

  67.     CARLA_SAFE_ASSERT_RETURN(fServerUDP == nullptr,);

  68.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0',);

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

  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_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  104.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  105.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  106.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

  107. }

  108. 

  109. void CarlaEngineOsc::idle() const

  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_ASSERT(fName.isNotEmpty());

  125.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  126.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  127.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  128.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

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

  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. 

  155. // -----------------------------------------------------------------------

  156. 

  157. bool isDigit(const char c);

  158. bool isDigit(const char c)

  159. {

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

  161. }

  162. 

  163. 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)

  164. {

  165.     CARLA_SAFE_ASSERT_RETURN(fName.isNotEmpty(), 1);

  166.     CARLA_SAFE_ASSERT_RETURN(path != nullptr && path[0] != '\0', 1);

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

  168. 

  169.     if (isTCP)

  170.     {

  171.         CARLA_SAFE_ASSERT_RETURN(fServerPathTCP.isNotEmpty(), 1);

  172.         CARLA_SAFE_ASSERT_RETURN(fServerTCP != nullptr, 1);

  173.     }

  174.     else

  175.     {

  176.         CARLA_SAFE_ASSERT_RETURN(fServerPathUDP.isNotEmpty(), 1);

  177.         CARLA_SAFE_ASSERT_RETURN(fServerUDP != nullptr, 1);

  178.     }

  179. 

  180. #ifndef BUILD_BRIDGE

  181.     // Initial path check

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

  183.     {

  184.         const lo_address source = lo_message_get_source(msg);

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

  186.     }

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

  188.     {

  189.         return handleMsgUnregister();

  190.     }

  191. #endif

  192. 

  193.     const size_t nameSize(fName.length());

  194. 

  195.     // Check if message is for this client

  196.     if (std::strlen(path) <= nameSize || std::strncmp(path+1, fName.getBuffer(), nameSize) != 0)

  197.     {

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

  199.         return 1;

  200.     }

  201. 

  202.     // Get plugin id from path, "/carla/23/method" -> 23

  203.     uint pluginId = 0;

  204.     size_t offset;

  205. 

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

  207.     {

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

  209.         {

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

  211.             {

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

  213.                 return 1;

  214.             }

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

  216.             {

  217.                 // 3 digits, /xyz/method

  218.                 offset    = 6;

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

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

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

  222.             }

  223.             else

  224.             {

  225.                 // 2 digits, /xy/method

  226.                 offset    = 5;

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

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

  229.             }

  230.         }

  231.         else

  232.         {

  233.             // single digit, /x/method

  234.             offset    = 4;

  235.             pluginId += uint(path[nameSize+2]-'0');

  236.         }

  237.     }

  238.     else

  239.     {

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

  241.         return 1;

  242.     }

  243. 

  244.     if (pluginId > fEngine->getCurrentPluginCount())

  245.     {

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

  247.         return 1;

  248.     }

  249. 

  250.     // Get plugin

  251.     CarlaPlugin* const plugin(fEngine->getPluginUnchecked(pluginId));

  252. 

  253.     if (plugin == nullptr || plugin->getId() != pluginId)

  254.     {

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

  256.         return 1;

  257.     }

  258. 

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

  260.     char method[32];

  261.     carla_zeroChar(method, 32);

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

  263. 

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

  265.     {

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

  267.         return 1;

  268.     }

  269. 

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

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

  272.     {

  273.         const lo_address source(lo_message_get_source(msg));

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

  275.     }

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

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

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

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

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

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

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

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

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

  285.         return handleMsgExiting(plugin);

  286. 

  287. #ifndef BUILD_BRIDGE

  288.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  315. 

  316.     // Plugin Bridges

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

  318.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  359.     }

  360. #endif

  361. 

  362.     // Plugin-specific methods

  363. #ifdef WANT_LV2

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

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

  366.     if (std::strcmp(method, "lv2_urid_map") == 0)

  367.         return handleMsgLv2UridMap(plugin, argc, argv, types);

  368. #endif

  369. 

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

  371.     return 1;

  372. }

  373. 

  374. // -----------------------------------------------------------------------

  375. 

  376. #ifndef BUILD_BRIDGE

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

  378. {

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

  380.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  381. 

  382.     if (fControlData.path != nullptr)

  383.     {

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

  385.         return 1;

  386.     }

  387. 

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

  389. 

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

  391. 

  392.     {

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

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

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

  396.     }

  397. 

  398.     {

  399.         char* host = lo_url_get_hostname(url);

  400.         char* port = lo_url_get_port(url);

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

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

  403. 

  404.         std::free(host);

  405.         std::free(port);

  406.     }

  407. 

  408.     for (unsigned int i=0, count=fEngine->getCurrentPluginCount(); i < count; ++i)

  409.     {

  410.         CarlaPlugin* const plugin(fEngine->getPluginUnchecked(i));

  411. 

  412.         if (plugin != nullptr && plugin->isEnabled())

  413.             plugin->registerToOscClient();

  414.     }

  415. 

  416.     return 0;

  417. }

  418. 

  419. int CarlaEngineOsc::handleMsgUnregister()

  420. {

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

  422. 

  423.     if (fControlData.path == nullptr)

  424.     {

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

  426.         return 1;

  427.     }

  428. 

  429.     fControlData.free();

  430.     return 0;

  431. }

  432. #endif

  433. 

  434. // -----------------------------------------------------------------------

  435. 

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

  437. {

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

  439.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  440. 

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

  442. 

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

  444. 

  445.     return 0;

  446. }

  447. 

  448. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  449. {

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

  451.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  452. 

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

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

  455. 

  456.     plugin->setCustomData(CUSTOM_DATA_TYPE_STRING, key, value, false);

  457. 

  458.     return 0;

  459. }

  460. 

  461. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  462. {

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

  464.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  465. 

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

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

  468. 

  469.     plugin->setParameterValueByRealIndex(rindex, value, false, true, true);

  470. 

  471.     return 0;

  472. }

  473. 

  474. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  475. {

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

  477. 

  478.     if (argc == 2)

  479.     {

  480.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  481. 

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

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

  484. 

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

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

  487. 

  488.         if (bank < 0)

  489.             return 1;

  490.         if (program < 0)

  491.             return 1;

  492. 

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

  494. 

  495.         return 0;

  496.     }

  497.     else

  498.     {

  499.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  500. 

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

  502. 

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

  504. 

  505.         if (program < 0)

  506.             return 1;

  507. 

  508.         if (program < static_cast<int32_t>(plugin->getProgramCount()))

  509.         {

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

  511.             return 0;

  512.         }

  513. 

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

  515.         return 1;

  516.     }

  517. }

  518. 

  519. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  520. {

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

  522.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  523. 

  524. #ifdef BUILD_BRIDGE

  525.     CARLA_ASSERT(false); // this should never happen

  526.     return 1;

  527. 

  528.     // unused

  529.     (void)plugin;

  530.     (void)argv;

  531. #else

  532.     if (plugin->getMidiInCount() == 0)

  533.     {

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

  535.         return 1;

  536.     }

  537. 

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

  539.     uint8_t status  = data[1];

  540.     uint8_t channel = status & 0x0F;

  541. 

  542.     // Fix bad note-off

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

  544.         status = static_cast<uint8_t>(status - 0x10);

  545. 

  546.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  547.     {

  548.         const uint8_t note = data[2];

  549. 

  550.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  551. 

  552.         if (note >= MAX_MIDI_NOTE)

  553.             return 1;

  554. 

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

  556.     }

  557.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  558.     {

  559.         const uint8_t note = data[2];

  560.         const uint8_t velo = data[3];

  561. 

  562.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  563.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  564. 

  565.         if (note >= MAX_MIDI_NOTE)

  566.             return 1;

  567.         if (velo >= MAX_MIDI_VALUE)

  568.             return 1;

  569. 

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

  571.     }

  572. 

  573.     return 0;

  574. #endif

  575. }

  576. 

  577. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  578. {

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

  580. 

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

  582.     fEngine->callback(ENGINE_CALLBACK_UI_STATE_CHANGED, plugin->getId(), 0, 0, 0.0f, nullptr);

  583. 

  584.     // TODO

  585.     //plugin->freeOscData();

  586. 

  587.     return 0;

  588. }

  589. 

  590. // -----------------------------------------------------------------------

  591. 

  592. #ifndef BUILD_BRIDGE

  593. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  594. {

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

  596.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  597. 

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

  599. 

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

  601. 

  602.     return 0;

  603. }

  604. 

  605. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  606. {

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

  608.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  609. 

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

  611. 

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

  613. 

  614.     return 0;

  615. }

  616. 

  617. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  618. {

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

  620.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  621. 

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

  623. 

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

  625. 

  626.     return 0;

  627. }

  628. 

  629. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  630. {

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

  632.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  633. 

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

  635. 

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

  637. 

  638.     return 0;

  639. }

  640. 

  641. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  642. {

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

  644.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  645. 

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

  647. 

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

  649. 

  650.     return 0;

  651. }

  652. 

  653. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  654. {

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

  656.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  657. 

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

  659. 

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

  661. 

  662.     return 0;

  663. }

  664. 

  665. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  666. {

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

  668.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  669. 

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

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

  672. 

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

  674. 

  675.     if (index < 0)

  676.         return 1;

  677. 

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

  679. 

  680.     return 0;

  681. }

  682. 

  683. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  684. {

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

  686.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  687. 

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

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

  690. 

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

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

  693. 

  694.     if (index < 0)

  695.         return 1;

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

  697.         return 1;

  698. 

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

  700. 

  701.     return 0;

  702. }

  703. 

  704. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  705. {

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

  707.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  708. 

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

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

  711. 

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

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

  714. 

  715.     if (index < 0)

  716.         return 1;

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

  718.         return 1;

  719. 

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

  721. 

  722.     return 0;

  723. }

  724. 

  725. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  726. {

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

  728.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  729. 

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

  731. 

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

  733. 

  734.     return 0;

  735. }

  736. 

  737. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  738. {

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

  740.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  741. 

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

  743. 

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

  745. 

  746.     return 0;

  747. }

  748. 

  749. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  750. {

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

  752.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  753. 

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

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

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

  757. 

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

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

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

  761. 

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

  763.         return 1;

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

  765.         return 1;

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

  767.         return 1;

  768. 

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

  770. 

  771.     return 0;

  772. }

  773. 

  774. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  775. {

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

  777.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  778. 

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

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

  781. 

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

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

  784. 

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

  786.         return 1;

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

  788.         return 1;

  789. 

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

  791. 

  792.     return 0;

  793. }

  794. #endif

  795. 

  796. CARLA_BACKEND_END_NAMESPACE