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

760 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.             } CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle TCP")

  121.         }

  122.     }

  123. 

  124.     if (fServerUDP != nullptr)

  125.     {

  126.         for (;;)

  127.         {

  128.             try {

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

  130.                     break;

  131.             } CARLA_SAFE_EXCEPTION_CONTINUE("OSC idle UDP")

  132.         }

  133.     }

  134. }

  135. 

  136. void CarlaEngineOsc::close() noexcept

  137. {

  138.     CARLA_SAFE_ASSERT(fName.isNotEmpty());

  139.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  140.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  141.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  142.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

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

  144. 

  145.     fName.clear();

  146. 

  147.     if (fServerTCP != nullptr)

  148.     {

  149.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  150.         lo_server_free(fServerTCP);

  151.         fServerTCP = nullptr;

  152.     }

  153. 

  154.     if (fServerUDP != nullptr)

  155.     {

  156.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  157.         lo_server_free(fServerUDP);

  158.         fServerUDP = nullptr;

  159.     }

  160. 

  161.     fServerPathTCP.clear();

  162.     fServerPathUDP.clear();

  163. 

  164. #ifndef BUILD_BRIDGE

  165.     fControlData.clear();

  166. #endif

  167. }

  168. 

  169. // -----------------------------------------------------------------------

  170. 

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

  172. {

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

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

  175. #ifdef DEBUG

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

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

  178.     }

  179. #endif

  180. 

  181.     //if (isTCP)

  182.     {

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

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

  185.     }

  186.     //else

  187.     {

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

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

  190.     }

  191. 

  192. #ifndef BUILD_BRIDGE

  193.     // Initial path check

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

  195.     {

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

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

  198.     }

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

  200.     {

  201.         return handleMsgUnregister();

  202.     }

  203. #endif

  204. 

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

  206. 

  207.     // Check if message is for this client

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

  209.     {

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

  211.         return 1;

  212.     }

  213. 

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

  215.     uint pluginId = 0;

  216.     size_t offset;

  217. 

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

  219.     {

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

  221.         {

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

  223.             {

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

  225.                 return 1;

  226.             }

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

  228.             {

  229.                 // 3 digits, /xyz/method

  230.                 offset    = 6;

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

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

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

  234.             }

  235.             else

  236.             {

  237.                 // 2 digits, /xy/method

  238.                 offset    = 5;

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

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

  241.             }

  242.         }

  243.         else

  244.         {

  245.             // single digit, /x/method

  246.             offset    = 4;

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

  248.         }

  249.     }

  250.     else

  251.     {

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

  253.         return 1;

  254.     }

  255. 

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

  257.     {

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

  259.         return 0;

  260.     }

  261. 

  262.     // Get plugin

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

  264. 

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

  266.     {

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

  268.         return 0;

  269.     }

  270. 

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

  272.     char method[32+1];

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

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

  275. 

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

  277.     {

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

  279.         return 0;

  280.     }

  281. 

  282.     // Common OSC methods (all bridges)

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

  284.     {

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

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

  287.     }

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

  289.         return handleMsgExiting(plugin);

  290. 

  291. #ifndef BUILD_BRIDGE

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

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

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

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

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

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

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

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

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

  301. 

  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. 

  385.     // Plugin-specific methods

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

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

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

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

  390. #endif

  391. 

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

  393.     return 1;

  394. }

  395. 

  396. // -----------------------------------------------------------------------

  397. 

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

  399. {

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

  401.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  402. 

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

  404. 

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

  406.     return 0;

  407. }

  408. 

  409. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  410. {

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

  412. 

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

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

  415. 

  416.     plugin->showCustomUI(false);

  417.     return 0;

  418. }

  419. 

  420. // -----------------------------------------------------------------------

  421. 

  422. #ifndef BUILD_BRIDGE

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

  424. {

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

  426.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  427. 

  428.     if (fControlData.path != nullptr)

  429.     {

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

  431.         return 1;

  432.     }

  433. 

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

  435. 

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

  437. 

  438.     {

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

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

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

  442.     }

  443. 

  444.     {

  445.         char* host = lo_url_get_hostname(url);

  446.         char* port = lo_url_get_port(url);

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

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

  449. 

  450.         std::free(host);

  451.         std::free(port);

  452.     }

  453. 

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

  455.     {

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

  457. 

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

  459.             plugin->registerToOscClient();

  460.     }

  461. 

  462.     return 0;

  463. }

  464. 

  465. int CarlaEngineOsc::handleMsgUnregister()

  466. {

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

  468. 

  469.     if (fControlData.path == nullptr)

  470.     {

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

  472.         return 1;

  473.     }

  474. 

  475.     fControlData.clear();

  476.     return 0;

  477. }

  478. 

  479. // -----------------------------------------------------------------------

  480. 

  481. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  482. {

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

  484.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  485. 

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

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

  488. 

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

  490.     return 0;

  491. }

  492. 

  493. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  494. {

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

  496.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  497. 

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

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

  500. 

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

  502.     return 0;

  503. }

  504. 

  505. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  506. {

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

  508. 

  509.     if (argc == 2)

  510.     {

  511.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  512. 

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

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

  515. 

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

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

  518. 

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

  520.         return 0;

  521.     }

  522.     else

  523.     {

  524.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  525. 

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

  527. 

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

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

  530. 

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

  532.         return 0;

  533.     }

  534. }

  535. 

  536. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  537. {

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

  539.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  540. 

  541. #ifdef BUILD_BRIDGE

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

  543.     return 0;

  544. 

  545.     // unused

  546.     (void)plugin;

  547.     (void)argv;

  548. #else

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

  550.     {

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

  552.         return 0;

  553.     }

  554. 

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

  556.     uint8_t status  = data[1];

  557.     uint8_t channel = status & 0x0F;

  558. 

  559.     // Fix bad note-off

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

  561.         status = MIDI_STATUS_NOTE_OFF;

  562. 

  563.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  564.     {

  565.         const uint8_t note = data[2];

  566. 

  567.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  568. 

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

  570.     }

  571.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  572.     {

  573.         const uint8_t note = data[2];

  574.         const uint8_t velo = data[3];

  575. 

  576.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  577.         CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE, 0);

  578. 

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

  580.     }

  581. 

  582.     return 0;

  583. #endif

  584. }

  585. 

  586. // -----------------------------------------------------------------------

  587. 

  588. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  589. {

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

  591.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  592. 

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

  594. 

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

  596.     return 0;

  597. }

  598. 

  599. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  600. {

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

  602.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  603. 

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

  605. 

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

  607.     return 0;

  608. }

  609. 

  610. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  611. {

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

  613.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  614. 

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

  616. 

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

  618.     return 0;

  619. }

  620. 

  621. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  622. {

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

  624.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  625. 

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

  627. 

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

  629.     return 0;

  630. }

  631. 

  632. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  633. {

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

  635.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  636. 

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

  638. 

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

  640.     return 0;

  641. }

  642. 

  643. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  644. {

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

  646.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  647. 

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

  649. 

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

  651.     return 0;

  652. }

  653. 

  654. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  655. {

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

  657.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  658. 

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

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

  661. 

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

  663. 

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

  665.     return 0;

  666. }

  667. 

  668. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  669. {

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

  671.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  672. 

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

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

  675. 

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

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

  678. 

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

  680.     return 0;

  681. }

  682. 

  683. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  684. {

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

  686.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  687. 

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

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

  690. 

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

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

  693. 

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

  695.     return 0;

  696. }

  697. 

  698. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  699. {

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

  701.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  702. 

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

  704. 

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

  706. 

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

  708.     return 0;

  709. }

  710. 

  711. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  712. {

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

  714.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  715. 

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

  717. 

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

  719. 

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

  721.     return 0;

  722. }

  723. 

  724. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  725. {

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

  727.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  728. 

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

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

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

  732. 

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

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

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

  736. 

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

  738.     return 0;

  739. }

  740. 

  741. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  742. {

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

  744.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  745. 

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

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

  748. 

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

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

  751. 

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

  753.     return 0;

  754. }

  755. #endif // ! BUILD_BRIDGE

  756. 

  757. // -----------------------------------------------------------------------

  758. 

  759. CARLA_BACKEND_END_NAMESPACE