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.
1084 Commits
16 Branches
14GB
Tree: aafd65787b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'aafd65787b'
${ noResults }
Carla/source/backend/engine/CarlaEngineOsc.cpp

807 lines
25KB
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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngineOsc.hpp"

  19. 

  20. #include "CarlaEngine.hpp"

  21. #include "CarlaPlugin.hpp"

  22. 

  23. #ifndef BUILD_BRIDGE

  24. # include "CarlaBridgeUtils.hpp"

  25. #endif

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. #ifndef BUILD_BRIDGE

  30. // -------------------------------------------------------------------

  31. // Bridge Helper, defined in CarlaPlugin.cpp

  32. 

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

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

  35. #endif

  36. 

  37. // -----------------------------------------------------------------------

  38. 

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

  40.     : fEngine(engine),

  41.       fServerTCP(nullptr),

  42.       fServerUDP(nullptr)

  43. {

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

  45.     CARLA_ASSERT(engine != nullptr);

  46. }

  47. 

  48. CarlaEngineOsc::~CarlaEngineOsc()

  49. {

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

  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. }

  57. 

  58. // -----------------------------------------------------------------------

  59. 

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

  61. {

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

  63.     CARLA_ASSERT(fName.isEmpty());

  64.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  65.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  66.     CARLA_ASSERT(fServerTCP == nullptr);

  67.     CARLA_ASSERT(fServerUDP == nullptr);

  68.     CARLA_ASSERT(name != nullptr);

  69. 

  70.     fName = name;

  71.     fName.toBasic();

  72. 

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

  74. 

  75.     if (fServerTCP != nullptr)

  76.     {

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

  78.         {

  79.             fServerPathTCP  = tmpServerPathTCP;

  80.             fServerPathTCP += fName;

  81.             std::free(tmpServerPathTCP);

  82.         }

  83. 

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

  85.     }

  86. 

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

  88. 

  89.     if (fServerUDP != nullptr)

  90.     {

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

  92.         {

  93.             fServerPathUDP  = tmpServerPathUDP;

  94.             fServerPathUDP += fName;

  95.             std::free(tmpServerPathUDP);

  96.         }

  97. 

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

  99.     }

  100. 

  101.     CARLA_ASSERT(fName.isNotEmpty());

  102.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  103.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  104.     CARLA_ASSERT(fServerTCP != nullptr);

  105.     CARLA_ASSERT(fServerUDP != nullptr);

  106. }

  107. 

  108. void CarlaEngineOsc::idle()

  109. {

  110.     if (fServerTCP != nullptr)

  111.     {

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

  113.     }

  114. 

  115.     if (fServerUDP != nullptr)

  116.     {

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

  118.     }

  119. }

  120. 

  121. void CarlaEngineOsc::close()

  122. {

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

  124.     CARLA_ASSERT(fName.isNotEmpty());

  125.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  126.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  127.     CARLA_ASSERT(fServerTCP != nullptr);

  128.     CARLA_ASSERT(fServerUDP != nullptr);

  129. 

  130.     fName.clear();

  131. 

  132.     if (fServerTCP != nullptr)

  133.     {

  134.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  135.         lo_server_free(fServerTCP);

  136.         fServerTCP = nullptr;

  137.     }

  138. 

  139.     if (fServerUDP != nullptr)

  140.     {

  141.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  142.         lo_server_free(fServerUDP);

  143.         fServerUDP = nullptr;

  144.     }

  145. 

  146.     fServerPathTCP.clear();

  147.     fServerPathUDP.clear();

  148. 

  149. #ifndef BUILD_BRIDGE

  150.     fControlData.free();

  151. #endif

  152. 

  153.     CARLA_ASSERT(fName.isEmpty());

  154.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  155.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  156.     CARLA_ASSERT(fServerTCP == nullptr);

  157.     CARLA_ASSERT(fServerUDP == nullptr);

  158. }

  159. 

  160. // -----------------------------------------------------------------------

  161. 

  162. bool isDigit(const char c)

  163. {

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

  165. }

  166. 

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

  168. {

  169.     CARLA_ASSERT(fName.isNotEmpty());

  170.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  171.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  172.     CARLA_ASSERT(fServerTCP != nullptr);

  173.     CARLA_ASSERT(fServerUDP != nullptr);

  174.     CARLA_ASSERT(path != nullptr);

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

  176. 

  177.     if (path == nullptr)

  178.     {

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

  180.         return 1;

  181.     }

  182. 

  183.     if (fName.isEmpty())

  184.     {

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

  186.         return 1;

  187.     }

  188. 

  189. #ifndef BUILD_BRIDGE

  190.     // Initial path check

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

  192.     {

  193.         const lo_address source = lo_message_get_source(msg);

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

  195.     }

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

  197.     {

  198.         return handleMsgUnregister();

  199.     }

  200. #endif

  201. 

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

  203. 

  204.     // Check if message is for this client

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

  206.     {

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

  208.         return 1;

  209.     }

  210. 

  211.     // Get plugin id from message

  212.     // eg, /carla/23/method

  213. 

  214.     unsigned int pluginId = 0;

  215.     size_t offset;

  216. 

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

  218.     {

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

  220.         {

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

  222.             {

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

  224.                 return 1;

  225.             }

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

  227.             {

  228.                 // 3 digits, /xyz/method

  229.                 offset    = 6;

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

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

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

  233.             }

  234.             else

  235.             {

  236.                 // 2 digits, /xy/method

  237.                 offset    = 5;

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

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

  240.             }

  241.         }

  242.         else

  243.         {

  244.             // single digit, /x/method

  245.             offset    = 4;

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

  247.         }

  248.     }

  249.     else

  250.     {

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

  252.         return 1;

  253.     }

  254. 

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

  256.     {

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

  258.         return 1;

  259.     }

  260. 

  261.     // Get plugin

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

  263. 

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

  265.     {

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

  267.         return 1;

  268.     }

  269. 

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

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

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

  273. 

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

  275.     {

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

  277.         return 1;

  278.     }

  279. 

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

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

  282.     {

  283.         const lo_address source = lo_message_get_source(msg);

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

  285.     }

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

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

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

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

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

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

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

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

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

  295.         return handleMsgExiting(plugin);

  296. 

  297. #ifndef BUILD_BRIDGE

  298.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  325. 

  326.     // Plugin Bridges

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

  328.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  369.     }

  370. #endif

  371. 

  372.     // Plugin-specific methods

  373. #ifdef WANT_LV2

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

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

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

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

  378. #endif

  379. 

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

  381.     return 1;

  382. }

  383. 

  384. // -----------------------------------------------------------------------

  385. 

  386. #ifndef BUILD_BRIDGE

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

  388. {

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

  390.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  391. 

  392.     if (fControlData.path != nullptr)

  393.     {

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

  395.         return 1;

  396.     }

  397. 

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

  399. 

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

  401. 

  402.     {

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

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

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

  406.     }

  407. 

  408.     {

  409.         char* host = lo_url_get_hostname(url);

  410.         char* port = lo_url_get_port(url);

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

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

  413. 

  414.         std::free(host);

  415.         std::free(port);

  416.     }

  417. 

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

  419.     {

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

  421. 

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

  423.             plugin->registerToOscClient();

  424.     }

  425. 

  426.     return 0;

  427. }

  428. 

  429. int CarlaEngineOsc::handleMsgUnregister()

  430. {

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

  432. 

  433.     if (fControlData.path == nullptr)

  434.     {

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

  436.         return 1;

  437.     }

  438. 

  439.     fControlData.free();

  440.     return 0;

  441. }

  442. #endif

  443. 

  444. // -----------------------------------------------------------------------

  445. 

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

  447. {

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

  449.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  450. 

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

  452. 

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

  454. 

  455.     return 0;

  456. }

  457. 

  458. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  459. {

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

  461.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  462. 

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

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

  465. 

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

  467. 

  468.     return 0;

  469. }

  470. 

  471. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  472. {

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

  474.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  475. 

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

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

  478. 

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

  480. 

  481.     return 0;

  482. }

  483. 

  484. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  485. {

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

  487. 

  488.     if (argc == 2)

  489.     {

  490.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  491. 

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

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

  494. 

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

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

  497. 

  498.         if (bank < 0)

  499.             return 1;

  500.         if (program < 0)

  501.             return 1;

  502. 

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

  504. 

  505.         return 0;

  506.     }

  507.     else

  508.     {

  509.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  510. 

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

  512. 

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

  514. 

  515.         if (program < 0)

  516.             return 1;

  517. 

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

  519.         {

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

  521.             return 0;

  522.         }

  523. 

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

  525.         return 1;

  526.     }

  527. }

  528. 

  529. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  530. {

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

  532.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  533. 

  534. #ifdef BUILD_BRIDGE

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

  536.     return 1;

  537. 

  538.     // unused

  539.     (void)plugin;

  540.     (void)argv;

  541. #else

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

  543.     {

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

  545.         return 1;

  546.     }

  547. 

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

  549.     uint8_t status  = data[1];

  550.     uint8_t channel = status & 0x0F;

  551. 

  552.     // Fix bad note-off

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

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

  555. 

  556.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  557.     {

  558.         const uint8_t note = data[2];

  559. 

  560.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  561. 

  562.         if (note >= MAX_MIDI_NOTE)

  563.             return 1;

  564. 

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

  566.     }

  567.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  568.     {

  569.         const uint8_t note = data[2];

  570.         const uint8_t velo = data[3];

  571. 

  572.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  573.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  574. 

  575.         if (note >= MAX_MIDI_NOTE)

  576.             return 1;

  577.         if (velo >= MAX_MIDI_VALUE)

  578.             return 1;

  579. 

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

  581.     }

  582. 

  583.     return 0;

  584. #endif

  585. }

  586. 

  587. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  588. {

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

  590. 

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

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

  593. 

  594.     // TODO

  595.     //plugin->freeOscData();

  596. 

  597.     return 0;

  598. }

  599. 

  600. // -----------------------------------------------------------------------

  601. 

  602. #ifndef BUILD_BRIDGE

  603. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  604. {

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

  606.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  607. 

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

  609. 

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

  611. 

  612.     return 0;

  613. }

  614. 

  615. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  616. {

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

  618.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  619. 

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

  621. 

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

  623. 

  624.     return 0;

  625. }

  626. 

  627. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  628. {

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

  630.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  631. 

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

  633. 

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

  635. 

  636.     return 0;

  637. }

  638. 

  639. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  640. {

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

  642.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  643. 

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

  645. 

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

  647. 

  648.     return 0;

  649. }

  650. 

  651. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  652. {

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

  654.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  655. 

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

  657. 

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

  659. 

  660.     return 0;

  661. }

  662. 

  663. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  664. {

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

  666.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  667. 

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

  669. 

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

  671. 

  672.     return 0;

  673. }

  674. 

  675. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  676. {

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

  678.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  679. 

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

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

  682. 

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

  684. 

  685.     if (index < 0)

  686.         return 1;

  687. 

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

  689. 

  690.     return 0;

  691. }

  692. 

  693. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  694. {

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

  696.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  697. 

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

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

  700. 

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

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

  703. 

  704.     if (index < 0)

  705.         return 1;

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

  707.         return 1;

  708. 

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

  710. 

  711.     return 0;

  712. }

  713. 

  714. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  715. {

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

  717.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  718. 

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

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

  721. 

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

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

  724. 

  725.     if (index < 0)

  726.         return 1;

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

  728.         return 1;

  729. 

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

  731. 

  732.     return 0;

  733. }

  734. 

  735. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  736. {

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

  738.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  739. 

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

  741. 

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

  743. 

  744.     return 0;

  745. }

  746. 

  747. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  748. {

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

  750.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  751. 

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

  753. 

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

  755. 

  756.     return 0;

  757. }

  758. 

  759. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  760. {

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

  762.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  763. 

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

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

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

  767. 

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

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

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

  771. 

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

  773.         return 1;

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

  775.         return 1;

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

  777.         return 1;

  778. 

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

  780. 

  781.     return 0;

  782. }

  783. 

  784. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  785. {

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

  787.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  788. 

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

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

  791. 

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

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

  794. 

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

  796.         return 1;

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

  798.         return 1;

  799. 

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

  801. 

  802.     return 0;

  803. }

  804. #endif

  805. 

  806. CARLA_BACKEND_END_NAMESPACE