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.
1513 Commits
16 Branches
229MB
Tree: 223fa2d47f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '223fa2d47f'
${ noResults }
Carla/source/backend/engine/CarlaEngineOsc.cpp

804 lines
26KB
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_SAFE_ASSERT(engine != nullptr);

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

  47. }

  48. 

  49. CarlaEngineOsc::~CarlaEngineOsc()

  50. {

  51.     CARLA_SAFE_ASSERT(fName.isEmpty());

  52.     CARLA_SAFE_ASSERT(fServerPathTCP.isEmpty());

  53.     CARLA_SAFE_ASSERT(fServerPathUDP.isEmpty());

  54.     CARLA_SAFE_ASSERT(fServerTCP == nullptr);

  55.     CARLA_SAFE_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_SAFE_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.         while (lo_server_recv_noblock(fServerTCP, 0) != 0) {}

  113.     }

  114. 

  115.     if (fServerUDP != nullptr) {

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

  117.     }

  118. }

  119. 

  120. void CarlaEngineOsc::close()

  121. {

  122.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  123.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  124.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  125.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  126.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

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

  128. 

  129.     fName.clear();

  130. 

  131.     if (fServerTCP != nullptr)

  132.     {

  133.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  134.         lo_server_free(fServerTCP);

  135.         fServerTCP = nullptr;

  136.     }

  137. 

  138.     if (fServerUDP != nullptr)

  139.     {

  140.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  141.         lo_server_free(fServerUDP);

  142.         fServerUDP = nullptr;

  143.     }

  144. 

  145.     fServerPathTCP.clear();

  146.     fServerPathUDP.clear();

  147. 

  148. #ifndef BUILD_BRIDGE

  149.     fControlData.free();

  150. #endif

  151. }

  152. 

  153. // -----------------------------------------------------------------------

  154. 

  155. static bool isDigit(const char c)

  156. {

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

  158. }

  159. 

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

  161. {

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

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

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

  165. 

  166.     //if (isTCP)

  167.     {

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

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

  170.     }

  171.     //else

  172.     {

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

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

  175.     }

  176. 

  177. #ifndef BUILD_BRIDGE

  178.     // Initial path check

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

  180.     {

  181.         const lo_address source = lo_message_get_source(msg);

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

  183.     }

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

  185.     {

  186.         return handleMsgUnregister();

  187.     }

  188. #endif

  189. 

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

  191. 

  192.     // Check if message is for this client

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

  194.     {

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

  196.         return 1;

  197.     }

  198. 

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

  200.     uint pluginId = 0;

  201.     size_t offset;

  202. 

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

  204.     {

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

  206.         {

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

  208.             {

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

  210.                 return 1;

  211.             }

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

  213.             {

  214.                 // 3 digits, /xyz/method

  215.                 offset    = 6;

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

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

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

  219.             }

  220.             else

  221.             {

  222.                 // 2 digits, /xy/method

  223.                 offset    = 5;

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

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

  226.             }

  227.         }

  228.         else

  229.         {

  230.             // single digit, /x/method

  231.             offset    = 4;

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

  233.         }

  234.     }

  235.     else

  236.     {

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

  238.         return 1;

  239.     }

  240. 

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

  242.     {

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

  244.         return 1;

  245.     }

  246. 

  247.     // Get plugin

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

  249. 

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

  251.     {

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

  253.         return 1;

  254.     }

  255. 

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

  257.     char method[32];

  258.     carla_zeroChar(method, 32);

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

  260. 

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

  262.     {

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

  264.         return 1;

  265.     }

  266. 

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

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

  269.     {

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

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

  272.     }

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

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

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

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

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

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

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

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

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

  282.         return handleMsgExiting(plugin);

  283. 

  284. #ifndef BUILD_BRIDGE

  285.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  312. 

  313.     // Plugin Bridges

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

  315.     {

  316.         const char* const bmethod(method+7);

  317. 

  318.         if (std::strcmp(bmethod, "pong") == 0)

  319.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePong, argc, argv, types);

  320.         if (std::strcmp(bmethod, "plugin_info1") == 0)

  321.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo1, argc, argv, types);

  322.         if (std::strcmp(bmethod, "plugin_info2") == 0)

  323.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo2, argc, argv, types);

  324.         if (std::strcmp(bmethod, "audio_count") == 0)

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

  326.         if (std::strcmp(bmethod, "midi_count") == 0)

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

  328.         if (std::strcmp(bmethod, "parameter_count") == 0)

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

  330.         if (std::strcmp(bmethod, "program_count") == 0)

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

  332.         if (std::strcmp(bmethod, "midi_program_count") == 0)

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

  334.         if (std::strcmp(bmethod, "parameter_data") == 0)

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

  336.         if (std::strcmp(bmethod, "parameter_ranges1") == 0)

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

  338.         if (std::strcmp(bmethod, "parameter_ranges2") == 0)

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

  340.         if (std::strcmp(bmethod, "parameter_midi_cc") == 0)

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

  342.         if (std::strcmp(bmethod, "parameter_midi_channel") == 0)

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

  344.         if (std::strcmp(bmethod, "parameter_value") == 0)

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

  346.         if (std::strcmp(bmethod, "default_value") == 0)

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

  348.         if (std::strcmp(bmethod, "current_program") == 0)

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

  350.         if (std::strcmp(bmethod, "current_midi_program") == 0)

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

  352.         if (std::strcmp(bmethod, "program_name") == 0)

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

  354.         if (std::strcmp(bmethod, "midi_program_data") == 0)

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

  356.         if (std::strcmp(bmethod, "configure") == 0)

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

  358.         if (std::strcmp(bmethod, "set_custom_data") == 0)

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

  360.         if (std::strcmp(bmethod, "set_chunk_data") == 0)

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

  362.         if (std::strcmp(bmethod, "update_now") == 0)

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

  364.         if (std::strcmp(bmethod, "error") == 0)

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

  366.     }

  367. #endif

  368. 

  369.     // Plugin-specific methods

  370. #ifdef WANT_LV2

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

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

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

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

  375. #endif

  376. 

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

  378.     return 1;

  379. }

  380. 

  381. // -----------------------------------------------------------------------

  382. 

  383. #ifndef BUILD_BRIDGE

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

  385. {

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

  387.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  388. 

  389.     if (fControlData.path != nullptr)

  390.     {

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

  392.         return 1;

  393.     }

  394. 

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

  396. 

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

  398. 

  399.     {

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

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

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

  403.     }

  404. 

  405.     {

  406.         char* host = lo_url_get_hostname(url);

  407.         char* port = lo_url_get_port(url);

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

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

  410. 

  411.         std::free(host);

  412.         std::free(port);

  413.     }

  414. 

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

  416.     {

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

  418. 

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

  420.             plugin->registerToOscClient();

  421.     }

  422. 

  423.     return 0;

  424. }

  425. 

  426. int CarlaEngineOsc::handleMsgUnregister()

  427. {

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

  429. 

  430.     if (fControlData.path == nullptr)

  431.     {

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

  433.         return 1;

  434.     }

  435. 

  436.     fControlData.free();

  437.     return 0;

  438. }

  439. #endif

  440. 

  441. // -----------------------------------------------------------------------

  442. 

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

  444. {

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

  446.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  447. 

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

  449. 

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

  451. 

  452.     return 0;

  453. }

  454. 

  455. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  456. {

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

  458.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  459. 

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

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

  462. 

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

  464. 

  465.     return 0;

  466. }

  467. 

  468. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  469. {

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

  471.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  472. 

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

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

  475. 

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

  477. 

  478.     return 0;

  479. }

  480. 

  481. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  482. {

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

  484. 

  485.     if (argc == 2)

  486.     {

  487.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  488. 

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

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

  491. 

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

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

  494. 

  495.         if (bank < 0)

  496.             return 1;

  497.         if (program < 0)

  498.             return 1;

  499. 

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

  501. 

  502.         return 0;

  503.     }

  504.     else

  505.     {

  506.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  507. 

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

  509. 

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

  511. 

  512.         if (program < 0)

  513.             return 1;

  514. 

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

  516.         {

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

  518.             return 0;

  519.         }

  520. 

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

  522.         return 1;

  523.     }

  524. }

  525. 

  526. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  527. {

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

  529.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  530. 

  531. #ifdef BUILD_BRIDGE

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

  533.     return 1;

  534. 

  535.     // unused

  536.     (void)plugin;

  537.     (void)argv;

  538. #else

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

  540.     {

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

  542.         return 1;

  543.     }

  544. 

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

  546.     uint8_t status  = data[1];

  547.     uint8_t channel = status & 0x0F;

  548. 

  549.     // Fix bad note-off

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

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

  552. 

  553.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  554.     {

  555.         const uint8_t note = data[2];

  556. 

  557.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  558. 

  559.         if (note >= MAX_MIDI_NOTE)

  560.             return 1;

  561. 

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

  563.     }

  564.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  565.     {

  566.         const uint8_t note = data[2];

  567.         const uint8_t velo = data[3];

  568. 

  569.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  570.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  571. 

  572.         if (note >= MAX_MIDI_NOTE)

  573.             return 1;

  574.         if (velo >= MAX_MIDI_VALUE)

  575.             return 1;

  576. 

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

  578.     }

  579. 

  580.     return 0;

  581. #endif

  582. }

  583. 

  584. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  585. {

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

  587. 

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

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

  590. 

  591.     // TODO

  592.     //plugin->freeOscData();

  593. 

  594.     return 0;

  595. }

  596. 

  597. // -----------------------------------------------------------------------

  598. 

  599. #ifndef BUILD_BRIDGE

  600. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  601. {

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

  603.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  604. 

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

  606. 

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

  608. 

  609.     return 0;

  610. }

  611. 

  612. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  613. {

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

  615.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  616. 

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

  618. 

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

  620. 

  621.     return 0;

  622. }

  623. 

  624. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  625. {

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

  627.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  628. 

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

  630. 

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

  632. 

  633.     return 0;

  634. }

  635. 

  636. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  637. {

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

  639.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  640. 

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

  642. 

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

  644. 

  645.     return 0;

  646. }

  647. 

  648. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  649. {

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

  651.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  652. 

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

  654. 

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

  656. 

  657.     return 0;

  658. }

  659. 

  660. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  661. {

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

  663.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  664. 

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

  666. 

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

  668. 

  669.     return 0;

  670. }

  671. 

  672. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  673. {

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

  675.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  676. 

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

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

  679. 

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

  681. 

  682.     if (index < 0)

  683.         return 1;

  684. 

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

  686. 

  687.     return 0;

  688. }

  689. 

  690. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  691. {

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

  693.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  694. 

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

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

  697. 

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

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

  700. 

  701.     if (index < 0)

  702.         return 1;

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

  704.         return 1;

  705. 

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

  707. 

  708.     return 0;

  709. }

  710. 

  711. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  712. {

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

  714.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  715. 

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

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

  718. 

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

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

  721. 

  722.     if (index < 0)

  723.         return 1;

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

  725.         return 1;

  726. 

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

  728. 

  729.     return 0;

  730. }

  731. 

  732. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  733. {

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

  735.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  736. 

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

  738. 

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

  740. 

  741.     return 0;

  742. }

  743. 

  744. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  745. {

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

  747.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  748. 

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

  750. 

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

  752. 

  753.     return 0;

  754. }

  755. 

  756. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  757. {

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

  759.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  760. 

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

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

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

  764. 

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

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

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

  768. 

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

  770.         return 1;

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

  772.         return 1;

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

  774.         return 1;

  775. 

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

  777. 

  778.     return 0;

  779. }

  780. 

  781. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  782. {

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

  784.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  785. 

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

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

  788. 

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

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

  791. 

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

  793.         return 1;

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

  795.         return 1;

  796. 

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

  798. 

  799.     return 0;

  800. }

  801. #endif

  802. 

  803. CARLA_BACKEND_END_NAMESPACE