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.
2532 Commits
17 Branches
341MB
Tree: 29f7dfb365
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '29f7dfb365'
${ noResults }
Carla/source/backend/engine/CarlaEngineOsc.cpp

763 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. #ifndef BUILD_BRIDGE

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

  406. 

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

  408. #endif

  409.     return 0;

  410. }

  411. 

  412. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  413. {

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

  415. 

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

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

  418. 

  419.     plugin->showCustomUI(false);

  420.     return 0;

  421. }

  422. 

  423. // -----------------------------------------------------------------------

  424. 

  425. #ifndef BUILD_BRIDGE

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

  427. {

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

  429.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  430. 

  431.     if (fControlData.path != nullptr)

  432.     {

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

  434.         return 1;

  435.     }

  436. 

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

  438. 

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

  440. 

  441.     {

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

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

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

  445.     }

  446. 

  447.     {

  448.         char* host = lo_url_get_hostname(url);

  449.         char* port = lo_url_get_port(url);

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

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

  452. 

  453.         std::free(host);

  454.         std::free(port);

  455.     }

  456. 

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

  458.     {

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

  460. 

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

  462.             plugin->registerToOscClient();

  463.     }

  464. 

  465.     return 0;

  466. }

  467. 

  468. int CarlaEngineOsc::handleMsgUnregister()

  469. {

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

  471. 

  472.     if (fControlData.path == nullptr)

  473.     {

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

  475.         return 1;

  476.     }

  477. 

  478.     fControlData.clear();

  479.     return 0;

  480. }

  481. 

  482. // -----------------------------------------------------------------------

  483. 

  484. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  485. {

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

  487.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  488. 

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

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

  491. 

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

  493.     return 0;

  494. }

  495. 

  496. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  497. {

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

  499.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  500. 

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

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

  503. 

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

  505.     return 0;

  506. }

  507. 

  508. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  509. {

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

  511. 

  512.     if (argc == 2)

  513.     {

  514.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  515. 

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

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

  518. 

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

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

  521. 

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

  523.         return 0;

  524.     }

  525.     else

  526.     {

  527.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  528. 

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

  530. 

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

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

  533. 

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

  535.         return 0;

  536.     }

  537. }

  538. 

  539. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  540. {

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

  542.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  543. 

  544. #ifdef BUILD_BRIDGE

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

  546.     return 0;

  547. 

  548.     // unused

  549.     (void)plugin;

  550.     (void)argv;

  551. #else

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

  553.     {

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

  555.         return 0;

  556.     }

  557. 

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

  559.     uint8_t status  = data[1];

  560.     uint8_t channel = status & 0x0F;

  561. 

  562.     // Fix bad note-off

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

  564.         status = MIDI_STATUS_NOTE_OFF;

  565. 

  566.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  567.     {

  568.         const uint8_t note = data[2];

  569. 

  570.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  571. 

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

  573.     }

  574.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  575.     {

  576.         const uint8_t note = data[2];

  577.         const uint8_t velo = data[3];

  578. 

  579.         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE, 0);

  580.         CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE, 0);

  581. 

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

  583.     }

  584. 

  585.     return 0;

  586. #endif

  587. }

  588. 

  589. // -----------------------------------------------------------------------

  590. 

  591. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  592. {

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

  594.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  595. 

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

  597. 

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

  599.     return 0;

  600. }

  601. 

  602. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  603. {

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

  605.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  606. 

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

  608. 

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

  610.     return 0;

  611. }

  612. 

  613. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  614. {

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

  616.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  617. 

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

  619. 

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

  621.     return 0;

  622. }

  623. 

  624. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  625. {

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

  627.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  628. 

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

  630. 

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

  632.     return 0;

  633. }

  634. 

  635. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  636. {

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

  638.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  639. 

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

  641. 

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

  643.     return 0;

  644. }

  645. 

  646. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  647. {

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

  649.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  650. 

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

  652. 

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

  654.     return 0;

  655. }

  656. 

  657. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  658. {

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

  660.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  661. 

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

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

  664. 

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

  666. 

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

  668.     return 0;

  669. }

  670. 

  671. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  672. {

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

  674.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  675. 

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

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

  678. 

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

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

  681. 

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

  683.     return 0;

  684. }

  685. 

  686. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  687. {

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

  689.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  690. 

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

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

  693. 

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

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

  696. 

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

  698.     return 0;

  699. }

  700. 

  701. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  702. {

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

  704.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  705. 

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

  707. 

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

  709. 

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

  711.     return 0;

  712. }

  713. 

  714. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  715. {

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

  717.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  718. 

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

  720. 

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

  722. 

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

  724.     return 0;

  725. }

  726. 

  727. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  728. {

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

  730.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  731. 

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

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

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

  735. 

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

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

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

  739. 

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

  741.     return 0;

  742. }

  743. 

  744. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  745. {

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

  747.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  748. 

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

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

  751. 

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

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

  754. 

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

  756.     return 0;

  757. }

  758. #endif // ! BUILD_BRIDGE

  759. 

  760. // -----------------------------------------------------------------------

  761. 

  762. CARLA_BACKEND_END_NAMESPACE