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

767 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. #include <cctype>

  29. 

  30. CARLA_BACKEND_START_NAMESPACE

  31. 

  32. #ifndef BUILD_BRIDGE

  33. // -------------------------------------------------------------------

  34. // Bridge Helper, defined in BridgePlugin.cpp

  35. 

  36. extern int CarlaPluginSetOscBridgeInfo(CarlaPlugin* const plugin, const PluginBridgeOscInfoType type,

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

  38. #endif

  39. 

  40. // -----------------------------------------------------------------------

  41. 

  42. CarlaEngineOsc::CarlaEngineOsc(CarlaEngine* const engine) noexcept

  43.     : fEngine(engine),

  44. #ifndef BUILD_BRIDGE

  45.       fControlData(),

  46. #endif

  47.       fName(),

  48.       fServerPathTCP(),

  49.       fServerPathUDP(),

  50.       fServerTCP(nullptr),

  51.       fServerUDP(nullptr),

  52.       leakDetector()

  53. {

  54.     CARLA_SAFE_ASSERT(engine != nullptr);

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

  56. }

  57. 

  58. CarlaEngineOsc::~CarlaEngineOsc() noexcept

  59. {

  60.     CARLA_SAFE_ASSERT(fName.isEmpty());

  61.     CARLA_SAFE_ASSERT(fServerPathTCP.isEmpty());

  62.     CARLA_SAFE_ASSERT(fServerPathUDP.isEmpty());

  63.     CARLA_SAFE_ASSERT(fServerTCP == nullptr);

  64.     CARLA_SAFE_ASSERT(fServerUDP == nullptr);

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

  66. }

  67. 

  68. // -----------------------------------------------------------------------

  69. 

  70. void CarlaEngineOsc::init(const char* const name) noexcept

  71. {

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

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

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

  75.     CARLA_SAFE_ASSERT_RETURN(fServerTCP == nullptr,);

  76.     CARLA_SAFE_ASSERT_RETURN(fServerUDP == nullptr,);

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

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

  79. 

  80.     fName = name;

  81.     fName.toBasic();

  82. 

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

  84. 

  85.     if (fServerTCP != nullptr)

  86.     {

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

  88.         {

  89.             fServerPathTCP  = tmpServerPathTCP;

  90.             fServerPathTCP += fName;

  91.             std::free(tmpServerPathTCP);

  92.         }

  93. 

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

  95.     }

  96. 

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

  98. 

  99.     if (fServerUDP != nullptr)

  100.     {

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

  102.         {

  103.             fServerPathUDP  = tmpServerPathUDP;

  104.             fServerPathUDP += fName;

  105.             std::free(tmpServerPathUDP);

  106.         }

  107. 

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

  109.     }

  110. 

  111.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  112.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  113.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  114.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  115.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

  116. }

  117. 

  118. void CarlaEngineOsc::idle() const noexcept

  119. {

  120.     if (fServerTCP != nullptr)

  121.     {

  122.         for (;;)

  123.         {

  124.             try {

  125.                 if (lo_server_recv_noblock(fServerTCP, 0) == 0)

  126.                     break;

  127.             } CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle TCP")

  128.         }

  129.     }

  130. 

  131.     if (fServerUDP != nullptr)

  132.     {

  133.         for (;;)

  134.         {

  135.             try {

  136.                 if (lo_server_recv_noblock(fServerUDP, 0) == 0)

  137.                     break;

  138.             } CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle UDP")

  139.         }

  140.     }

  141. }

  142. 

  143. void CarlaEngineOsc::close() noexcept

  144. {

  145.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  146.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  147.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  148.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  149.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

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

  151. 

  152.     fName.clear();

  153. 

  154.     if (fServerTCP != nullptr)

  155.     {

  156.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  157.         lo_server_free(fServerTCP);

  158.         fServerTCP = nullptr;

  159.     }

  160. 

  161.     if (fServerUDP != nullptr)

  162.     {

  163.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  164.         lo_server_free(fServerUDP);

  165.         fServerUDP = nullptr;

  166.     }

  167. 

  168.     fServerPathTCP.clear();

  169.     fServerPathUDP.clear();

  170. 

  171. #ifndef BUILD_BRIDGE

  172.     fControlData.clear();

  173. #endif

  174. }

  175. 

  176. // -----------------------------------------------------------------------

  177. 

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

  179. {

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

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

  182. #ifdef DEBUG

  183.     if (std::strstr(path, "/bridge_pong") == nullptr) {

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

  185.     }

  186. #endif

  187. 

  188.     //if (isTCP)

  189.     {

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

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

  192.     }

  193.     //else

  194.     {

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

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

  197.     }

  198. 

  199. #ifndef BUILD_BRIDGE

  200.     // Initial path check

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

  202.     {

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

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

  205.     }

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

  207.     {

  208.         return handleMsgUnregister();

  209.     }

  210. #endif

  211. 

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

  213. 

  214.     // Check if message is for this client

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

  216.     {

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

  218.         return 1;

  219.     }

  220. 

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

  222.     uint pluginId = 0;

  223.     size_t offset;

  224. 

  225.     if (std::isdigit(path[nameSize+2]))

  226.     {

  227.         if (std::isdigit(path[nameSize+3]))

  228.         {

  229.             if (std::isdigit(path[nameSize+5]))

  230.             {

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

  232.                 return 1;

  233.             }

  234.             else if (std::isdigit(path[nameSize+4]))

  235.             {

  236.                 // 3 digits, /xyz/method

  237.                 offset    = 6;

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

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

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

  241.             }

  242.             else

  243.             {

  244.                 // 2 digits, /xy/method

  245.                 offset    = 5;

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

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

  248.             }

  249.         }

  250.         else

  251.         {

  252.             // single digit, /x/method

  253.             offset    = 4;

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

  255.         }

  256.     }

  257.     else

  258.     {

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

  260.         return 1;

  261.     }

  262. 

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

  264.     {

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

  266.         return 0;

  267.     }

  268. 

  269.     // Get plugin

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

  271. 

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

  273.     {

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

  275.         return 0;

  276.     }

  277. 

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

  279.     char method[32+1];

  280.     method[32] = '\0';

  281.     std::strncpy(method, path + (nameSize + offset), 32);

  282. 

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

  284.     {

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

  286.         return 0;

  287.     }

  288. 

  289.     // Common OSC methods (all bridges)

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

  291.     {

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

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

  294.     }

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

  296.         return handleMsgExiting(plugin);

  297. 

  298. #ifndef BUILD_BRIDGE

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

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

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

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

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

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

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

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

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

  308. 

  309.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  336. 

  337.     // Plugin Bridges

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

  339.     {

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

  341. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  373.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscCurrentMidiProgram, argc, argv, types);

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

  375.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscProgramName, argc, argv, types);

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

  377.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscMidiProgramData, argc, argv, types);

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

  379.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscConfigure, argc, argv, types);

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

  381.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscSetCustomData, argc, argv, types);

  382.         if (std::strcmp(bmethod, "set_chunk_data_file") == 0)

  383.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscSetChunkDataFile, argc, argv, types);

  384.         if (std::strcmp(bmethod, "latency") == 0)

  385.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscLatency, argc, argv, types);

  386.         if (std::strcmp(bmethod, "ready") == 0)

  387.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscReady, argc, argv, types);

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

  389.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeOscError, argc, argv, types);

  390.     }

  391. 

  392.     // Plugin-specific methods

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

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

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

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

  397. #endif

  398. 

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

  400.     return 1;

  401. }

  402. 

  403. // -----------------------------------------------------------------------

  404. 

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

  406. {

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

  408.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  409. 

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

  411. 

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

  413.     return 0;

  414. }

  415. 

  416. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  417. {

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

  419. 

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

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

  422. 

  423.     plugin->showCustomUI(false);

  424.     return 0;

  425. }

  426. 

  427. // -----------------------------------------------------------------------

  428. 

  429. #ifndef BUILD_BRIDGE

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

  431. {

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

  433.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  434. 

  435.     if (fControlData.path != nullptr)

  436.     {

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

  438.         return 1;

  439.     }

  440. 

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

  442. 

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

  444. 

  445.     {

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

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

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

  449.     }

  450. 

  451.     {

  452.         char* host = lo_url_get_hostname(url);

  453.         char* port = lo_url_get_port(url);

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

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

  456. 

  457.         std::free(host);

  458.         std::free(port);

  459.     }

  460. 

  461.     for (uint i=0, count=fEngine->getCurrentPluginCount(); i < count; ++i)

  462.     {

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

  464. 

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

  466.             plugin->registerToOscClient();

  467.     }

  468. 

  469.     return 0;

  470. }

  471. 

  472. int CarlaEngineOsc::handleMsgUnregister()

  473. {

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

  475. 

  476.     if (fControlData.path == nullptr)

  477.     {

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

  479.         return 1;

  480.     }

  481. 

  482.     fControlData.clear();

  483.     return 0;

  484. }

  485. 

  486. // -----------------------------------------------------------------------

  487. 

  488. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  489. {

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

  491.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  492. 

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

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

  495. 

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

  497.     return 0;

  498. }

  499. 

  500. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  501. {

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

  503.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  504. 

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

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

  507. 

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

  509.     return 0;

  510. }

  511. 

  512. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  513. {

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

  515. 

  516.     if (argc == 2)

  517.     {

  518.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  519. 

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

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

  522. 

  523.         CARLA_SAFE_ASSERT_RETURN(bank >= 0, 0);

  524.         CARLA_SAFE_ASSERT_RETURN(program >= 0, 0);

  525. 

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

  527.         return 0;

  528.     }

  529.     else

  530.     {

  531.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  532. 

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

  534. 

  535.         CARLA_SAFE_ASSERT_RETURN(program >= 0, 0);

  536.         CARLA_SAFE_ASSERT_RETURN(program < static_cast<int32_t>(plugin->getProgramCount()), 0);

  537. 

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

  539.         return 0;

  540.     }

  541. }

  542. 

  543. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  544. {

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

  546.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  547. 

  548. #ifdef BUILD_BRIDGE

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

  550.     return 0;

  551. 

  552.     // unused

  553.     (void)plugin;

  554.     (void)argv;

  555. #else

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

  557.     {

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

  559.         return 0;

  560.     }

  561. 

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

  563.     uint8_t status  = data[1];

  564.     uint8_t channel = status & 0x0F;

  565. 

  566.     // Fix bad note-off

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

  568.         status = MIDI_STATUS_NOTE_OFF;

  569. 

  570.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  571.     {

  572.         const uint8_t note = data[2];

  573. 

  574.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  575. 

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

  577.     }

  578.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  579.     {

  580.         const uint8_t note = data[2];

  581.         const uint8_t velo = data[3];

  582. 

  583.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  584.         CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE, 0);

  585. 

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

  587.     }

  588. 

  589.     return 0;

  590. #endif

  591. }

  592. 

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

  594. 

  595. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  596. {

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

  598.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  599. 

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

  601. 

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

  603.     return 0;

  604. }

  605. 

  606. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  607. {

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

  609.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  610. 

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

  612. 

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

  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.     return 0;

  626. }

  627. 

  628. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  629. {

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

  631.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  632. 

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

  634. 

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

  636.     return 0;

  637. }

  638. 

  639. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  640. {

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

  642.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  643. 

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

  645. 

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

  647.     return 0;

  648. }

  649. 

  650. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  651. {

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

  653.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  654. 

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

  656. 

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

  658.     return 0;

  659. }

  660. 

  661. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  662. {

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

  664.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  665. 

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

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

  668. 

  669.     CARLA_SAFE_ASSERT_RETURN(index >= 0, 0);

  670. 

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

  672.     return 0;

  673. }

  674. 

  675. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  676. {

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

  678.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  679. 

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

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

  682. 

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

  684.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc <= 0x5F, 0);

  685. 

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

  687.     return 0;

  688. }

  689. 

  690. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  691. {

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

  693.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  694. 

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

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

  697. 

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

  699.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS, 0);

  700. 

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

  702.     return 0;

  703. }

  704. 

  705. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  706. {

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

  708.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  709. 

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

  711. 

  712.     CARLA_SAFE_ASSERT_RETURN(index >= -1, 0);

  713. 

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

  715.     return 0;

  716. }

  717. 

  718. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  719. {

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

  721.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  722. 

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

  724. 

  725.     CARLA_SAFE_ASSERT_RETURN(index >= -1, 0);

  726. 

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

  728.     return 0;

  729. }

  730. 

  731. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  732. {

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

  734.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  735. 

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

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

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

  739. 

  740.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS, 0);

  741.     CARLA_SAFE_ASSERT_RETURN(note >= 0 && note < MAX_MIDI_NOTE, 0);

  742.     CARLA_SAFE_ASSERT_RETURN(velo >= 0 && velo < MAX_MIDI_VALUE, 0);

  743. 

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

  745.     return 0;

  746. }

  747. 

  748. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  749. {

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

  751.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  752. 

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

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

  755. 

  756.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS, 0);

  757.     CARLA_SAFE_ASSERT_RETURN(note >= 0 && note < MAX_MIDI_NOTE, 0);

  758. 

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

  760.     return 0;

  761. }

  762. #endif // ! BUILD_BRIDGE

  763. 

  764. // -----------------------------------------------------------------------

  765. 

  766. CARLA_BACKEND_END_NAMESPACE