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

762 lines
25KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngine.hpp"

  19. #include "CarlaEngineOsc.hpp"

  20. #include "CarlaPlugin.hpp"

  21. 

  22. #ifndef BUILD_BRIDGE

  23. # include "CarlaBridgeUtils.hpp"

  24. #endif

  25. 

  26. #include "CarlaMIDI.h"

  27. 

  28. #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 PluginBridgeInfoType 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.       fServerTCP(nullptr),

  45.       fServerUDP(nullptr)

  46. {

  47.     CARLA_SAFE_ASSERT(engine != nullptr);

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

  49. }

  50. 

  51. CarlaEngineOsc::~CarlaEngineOsc() noexcept

  52. {

  53.     CARLA_SAFE_ASSERT(fName.isEmpty());

  54.     CARLA_SAFE_ASSERT(fServerPathTCP.isEmpty());

  55.     CARLA_SAFE_ASSERT(fServerPathUDP.isEmpty());

  56.     CARLA_SAFE_ASSERT(fServerTCP == nullptr);

  57.     CARLA_SAFE_ASSERT(fServerUDP == nullptr);

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

  59. }

  60. 

  61. // -----------------------------------------------------------------------

  62. 

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

  64. {

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

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

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

  68.     CARLA_SAFE_ASSERT_RETURN(fServerTCP == nullptr,);

  69.     CARLA_SAFE_ASSERT_RETURN(fServerUDP == nullptr,);

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

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

  72. 

  73.     fName = name;

  74.     fName.toBasic();

  75. 

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

  77. 

  78.     if (fServerTCP != nullptr)

  79.     {

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

  81.         {

  82.             fServerPathTCP  = tmpServerPathTCP;

  83.             fServerPathTCP += fName;

  84.             std::free(tmpServerPathTCP);

  85.         }

  86. 

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

  88.     }

  89. 

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

  91. 

  92.     if (fServerUDP != nullptr)

  93.     {

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

  95.         {

  96.             fServerPathUDP  = tmpServerPathUDP;

  97.             fServerPathUDP += fName;

  98.             std::free(tmpServerPathUDP);

  99.         }

  100. 

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

  102.     }

  103. 

  104.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  105.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  106.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  107.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  108.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

  109. }

  110. 

  111. void CarlaEngineOsc::idle() const noexcept

  112. {

  113.     if (fServerTCP != nullptr)

  114.     {

  115.         for (;;)

  116.         {

  117.             try {

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

  119.                     break;

  120.             }

  121.             CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle TCP")

  122.         }

  123.     }

  124. 

  125.     if (fServerUDP != nullptr)

  126.     {

  127.         for (;;)

  128.         {

  129.             try {

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

  131.                     break;

  132.             }

  133.             CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle UDP")

  134.         }

  135.     }

  136. }

  137. 

  138. void CarlaEngineOsc::close() noexcept

  139. {

  140.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  141.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  142.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  143.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  144.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

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

  146. 

  147.     fName.clear();

  148. 

  149.     if (fServerTCP != nullptr)

  150.     {

  151.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  152.         lo_server_free(fServerTCP);

  153.         fServerTCP = nullptr;

  154.     }

  155. 

  156.     if (fServerUDP != nullptr)

  157.     {

  158.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  159.         lo_server_free(fServerUDP);

  160.         fServerUDP = nullptr;

  161.     }

  162. 

  163.     fServerPathTCP.clear();

  164.     fServerPathUDP.clear();

  165. 

  166. #ifndef BUILD_BRIDGE

  167.     fControlData.free();

  168. #endif

  169. }

  170. 

  171. // -----------------------------------------------------------------------

  172. 

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

  174. {

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

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

  177. #ifdef DEBUG

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

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

  180.     }

  181. #endif

  182. 

  183.     //if (isTCP)

  184.     {

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

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

  187.     }

  188.     //else

  189.     {

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

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

  192.     }

  193. 

  194. #ifndef BUILD_BRIDGE

  195.     // Initial path check

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

  197.     {

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

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

  200.     }

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

  202.     {

  203.         return handleMsgUnregister();

  204.     }

  205. #endif

  206. 

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

  208. 

  209.     // Check if message is for this client

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

  211.     {

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

  213.         return 1;

  214.     }

  215. 

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

  217.     uint pluginId = 0;

  218.     size_t offset;

  219. 

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

  221.     {

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

  223.         {

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

  225.             {

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

  227.                 return 1;

  228.             }

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

  230.             {

  231.                 // 3 digits, /xyz/method

  232.                 offset    = 6;

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

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

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

  236.             }

  237.             else

  238.             {

  239.                 // 2 digits, /xy/method

  240.                 offset    = 5;

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

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

  243.             }

  244.         }

  245.         else

  246.         {

  247.             // single digit, /x/method

  248.             offset    = 4;

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

  250.         }

  251.     }

  252.     else

  253.     {

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

  255.         return 1;

  256.     }

  257. 

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

  259.     {

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

  261.         return 0;

  262.     }

  263. 

  264.     // Get plugin

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

  266. 

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

  268.     {

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

  270.         return 0;

  271.     }

  272. 

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

  274.     char method[32+1];

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

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

  277. 

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

  279.     {

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

  281.         return 0;

  282.     }

  283. 

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

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

  286.     {

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

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

  289.     }

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

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

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

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

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

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

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

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

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

  299.         return handleMsgExiting(plugin);

  300. 

  301. #ifndef BUILD_BRIDGE

  302.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  329. 

  330.     // Plugin Bridges

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

  332.     {

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

  334. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  383.     }

  384. #endif

  385. 

  386.     // Plugin-specific methods

  387. #ifdef WANT_LV2

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

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

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

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

  392. #endif

  393. 

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

  395.     return 1;

  396. }

  397. 

  398. // -----------------------------------------------------------------------

  399. 

  400. #ifndef BUILD_BRIDGE

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

  402. {

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

  404.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  405. 

  406.     if (fControlData.path != nullptr)

  407.     {

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

  409.         return 1;

  410.     }

  411. 

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

  413. 

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

  415. 

  416.     {

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

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

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

  420.     }

  421. 

  422.     {

  423.         char* host = lo_url_get_hostname(url);

  424.         char* port = lo_url_get_port(url);

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

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

  427. 

  428.         std::free(host);

  429.         std::free(port);

  430.     }

  431. 

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

  433.     {

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

  435. 

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

  437.             plugin->registerToOscClient();

  438.     }

  439. 

  440.     return 0;

  441. }

  442. 

  443. int CarlaEngineOsc::handleMsgUnregister()

  444. {

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

  446. 

  447.     if (fControlData.path == nullptr)

  448.     {

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

  450.         return 1;

  451.     }

  452. 

  453.     fControlData.free();

  454.     return 0;

  455. }

  456. #endif

  457. 

  458. // -----------------------------------------------------------------------

  459. 

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

  461. {

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

  463.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  464. 

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

  466. 

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

  468.     return 0;

  469. }

  470. 

  471. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  472. {

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

  474.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  475. 

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

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

  478. 

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

  480.     return 0;

  481. }

  482. 

  483. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  484. {

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

  486.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  487. 

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

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

  490. 

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

  492.     return 0;

  493. }

  494. 

  495. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  496. {

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

  498. 

  499.     if (argc == 2)

  500.     {

  501.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  502. 

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

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

  505. 

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

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

  508. 

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

  510.         return 0;

  511.     }

  512.     else

  513.     {

  514.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  515. 

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

  517. 

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

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

  520. 

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

  522.         return 0;

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

  534. 

  535.     // unused

  536.     (void)plugin;

  537.     (void)argv;

  538. #else

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

  540.     {

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

  542.         return 0;

  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 = MIDI_STATUS_NOTE_OFF;

  552. 

  553.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  554.     {

  555.         const uint8_t note = data[2];

  556. 

  557.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  558. 

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

  560.     }

  561.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  562.     {

  563.         const uint8_t note = data[2];

  564.         const uint8_t velo = data[3];

  565. 

  566.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  567.         CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE, 0);

  568. 

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

  570.     }

  571. 

  572.     return 0;

  573. #endif

  574. }

  575. 

  576. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  577. {

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

  579. 

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

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

  582. 

  583.     plugin->showCustomUI(false);

  584.     return 0;

  585. }

  586. 

  587. // -----------------------------------------------------------------------

  588. 

  589. #ifndef BUILD_BRIDGE

  590. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  591. {

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

  593.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  594. 

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

  596. 

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

  598.     return 0;

  599. }

  600. 

  601. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  602. {

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

  604.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  605. 

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

  607. 

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

  609.     return 0;

  610. }

  611. 

  612. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  613. {

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

  615.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  616. 

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

  618. 

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

  620.     return 0;

  621. }

  622. 

  623. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  624. {

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

  626.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  627. 

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

  629. 

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

  631.     return 0;

  632. }

  633. 

  634. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  635. {

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

  637.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  638. 

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

  640. 

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

  642.     return 0;

  643. }

  644. 

  645. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  646. {

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

  648.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  649. 

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

  651. 

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

  653.     return 0;

  654. }

  655. 

  656. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  657. {

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

  659.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  660. 

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

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

  663. 

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

  665. 

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

  667.     return 0;

  668. }

  669. 

  670. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  671. {

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

  673.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  674. 

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

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

  677. 

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

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

  680. 

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

  682.     return 0;

  683. }

  684. 

  685. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  686. {

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

  688.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  689. 

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

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

  692. 

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

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

  695. 

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

  697.     return 0;

  698. }

  699. 

  700. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  701. {

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

  703.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  704. 

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

  706. 

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

  708. 

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

  710.     return 0;

  711. }

  712. 

  713. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  714. {

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

  716.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  717. 

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

  719. 

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

  721. 

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

  723.     return 0;

  724. }

  725. 

  726. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  727. {

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

  729.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  730. 

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

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

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

  734. 

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

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

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

  738. 

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

  740.     return 0;

  741. }

  742. 

  743. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  744. {

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

  746.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  747. 

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

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

  750. 

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

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

  753. 

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

  755.     return 0;

  756. }

  757. #endif

  758. 

  759. // -----------------------------------------------------------------------

  760. 

  761. CARLA_BACKEND_END_NAMESPACE