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

761 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 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_CarlaEngineOsc()

  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. #endif

  392. 

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

  394.     return 1;

  395. }

  396. 

  397. // -----------------------------------------------------------------------

  398. 

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

  400. {

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

  402.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  403. 

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

  405. 

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

  407.     return 0;

  408. }

  409. 

  410. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  411. {

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

  413. 

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

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

  416. 

  417.     plugin->showCustomUI(false);

  418.     return 0;

  419. }

  420. 

  421. // -----------------------------------------------------------------------

  422. 

  423. #ifndef BUILD_BRIDGE

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

  425. {

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

  427.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  428. 

  429.     if (fControlData.path != nullptr)

  430.     {

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

  432.         return 1;

  433.     }

  434. 

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

  436. 

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

  438. 

  439.     {

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

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

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

  443.     }

  444. 

  445.     {

  446.         char* host = lo_url_get_hostname(url);

  447.         char* port = lo_url_get_port(url);

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

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

  450. 

  451.         std::free(host);

  452.         std::free(port);

  453.     }

  454. 

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

  456.     {

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

  458. 

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

  460.             plugin->registerToOscClient();

  461.     }

  462. 

  463.     return 0;

  464. }

  465. 

  466. int CarlaEngineOsc::handleMsgUnregister()

  467. {

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

  469. 

  470.     if (fControlData.path == nullptr)

  471.     {

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

  473.         return 1;

  474.     }

  475. 

  476.     fControlData.clear();

  477.     return 0;

  478. }

  479. 

  480. // -----------------------------------------------------------------------

  481. 

  482. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  483. {

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

  485.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  486. 

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

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

  489. 

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

  491.     return 0;

  492. }

  493. 

  494. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  495. {

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

  497.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  498. 

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

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

  501. 

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

  503.     return 0;

  504. }

  505. 

  506. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  507. {

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

  509. 

  510.     if (argc == 2)

  511.     {

  512.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  513. 

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

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

  516. 

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

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

  519. 

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

  521.         return 0;

  522.     }

  523.     else

  524.     {

  525.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  526. 

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

  528. 

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

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

  531. 

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

  533.         return 0;

  534.     }

  535. }

  536. 

  537. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  538. {

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

  540.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  541. 

  542. #ifdef BUILD_BRIDGE

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

  544.     return 0;

  545. 

  546.     // unused

  547.     (void)plugin;

  548.     (void)argv;

  549. #else

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

  551.     {

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

  553.         return 0;

  554.     }

  555. 

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

  557.     uint8_t status  = data[1];

  558.     uint8_t channel = status & 0x0F;

  559. 

  560.     // Fix bad note-off

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

  562.         status = MIDI_STATUS_NOTE_OFF;

  563. 

  564.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  565.     {

  566.         const uint8_t note = data[2];

  567. 

  568.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  569. 

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

  571.     }

  572.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  573.     {

  574.         const uint8_t note = data[2];

  575.         const uint8_t velo = data[3];

  576. 

  577.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  578.         CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE, 0);

  579. 

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

  581.     }

  582. 

  583.     return 0;

  584. #endif

  585. }

  586. 

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

  588. 

  589. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  590. {

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

  592.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  593. 

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

  595. 

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

  597.     return 0;

  598. }

  599. 

  600. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  601. {

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

  603.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  604. 

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

  606. 

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

  608.     return 0;

  609. }

  610. 

  611. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  612. {

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

  614.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  615. 

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

  617. 

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

  619.     return 0;

  620. }

  621. 

  622. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  623. {

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

  625.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  626. 

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

  628. 

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

  630.     return 0;

  631. }

  632. 

  633. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  634. {

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

  636.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  637. 

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

  639. 

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

  641.     return 0;

  642. }

  643. 

  644. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  645. {

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

  647.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  648. 

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

  650. 

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

  652.     return 0;

  653. }

  654. 

  655. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  656. {

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

  658.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  659. 

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

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

  662. 

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

  664. 

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

  666.     return 0;

  667. }

  668. 

  669. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  670. {

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

  672.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  673. 

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

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

  676. 

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

  678.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL, 0);

  679. 

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

  681.     return 0;

  682. }

  683. 

  684. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  685. {

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

  687.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  688. 

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

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

  691. 

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

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

  694. 

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

  696.     return 0;

  697. }

  698. 

  699. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  700. {

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

  702.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  703. 

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

  705. 

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

  707. 

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

  709.     return 0;

  710. }

  711. 

  712. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  713. {

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

  715.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  716. 

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

  718. 

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

  720. 

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

  722.     return 0;

  723. }

  724. 

  725. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  726. {

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

  728.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  729. 

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

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

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

  733. 

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

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

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

  737. 

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

  739.     return 0;

  740. }

  741. 

  742. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  743. {

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

  745.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  746. 

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

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

  749. 

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

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

  752. 

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

  754.     return 0;

  755. }

  756. #endif // ! BUILD_BRIDGE

  757. 

  758. // -----------------------------------------------------------------------

  759. 

  760. CARLA_BACKEND_END_NAMESPACE