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.
7030 Commits
17 Branches
940MB
Tree: 8e813ef9c9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8e813ef9c9'
${ noResults }
Carla/source/backend/engine/CarlaEngineOscHandlers.cpp

807 lines
27KB
Raw Blame History 

  1.  /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2019 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 "CarlaEngineOsc.hpp"

  19. 

  20. #ifdef HAVE_LIBLO

  21. 

  22. #include "CarlaEngineInternal.hpp"

  23. #include "CarlaPlugin.hpp"

  24. #include "CarlaMIDI.h"

  25. 

  26. #include <cctype>

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. // -----------------------------------------------------------------------

  31. 

  32. int CarlaEngineOsc::handleMessage(const bool isTCP, const char* const path,

  33.                                   const int argc, const lo_arg* const* const argv, const char* const types,

  34.                                   const lo_message msg)

  35. {

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

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

  38.     CARLA_SAFE_ASSERT_RETURN(path[0] == '/', 1);

  39. #ifdef DEBUG

  40.     if (std::strncmp(path, "/bridge_pong", 12) != 0) {

  41.         carla_debug("CarlaEngineOsc::handleMessage(%s, \"%s\", %i, %p, \"%s\", %p)",

  42.                     bool2str(isTCP), path, argc, argv, types, msg);

  43.     }

  44. #endif

  45. 

  46.     if (isTCP)

  47.     {

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

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

  50.     }

  51.     else

  52.     {

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

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

  55.     }

  56. 

  57.     const lo_address source = lo_message_get_source(msg);

  58. 

  59.     // Initial path check

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

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

  62. 

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

  64.         return handleMsgUnregister(isTCP, argc, argv, types, source);

  65. 

  66.     if (std::strncmp(path, "/ctrl/", 6) == 0)

  67.     {

  68.         CARLA_SAFE_ASSERT_RETURN(isTCP, 1);

  69.         return handleMsgControl(path + 6, argc, argv, types);

  70.     }

  71. 

  72.     // Check if message is for this client

  73.     std::size_t bytesAfterName;

  74.     if (fControlDataTCP.owner != nullptr && std::strcmp(lo_address_get_hostname(source), fControlDataTCP.owner) == 0)

  75.     {

  76.         if (const char* const slash = std::strchr(path+1, '/'))

  77.         {

  78.             bytesAfterName = static_cast<std::size_t>(slash - path);

  79.         }

  80.         else

  81.         {

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

  83.             return 1;

  84.         }

  85.     }

  86.     else

  87.     {

  88.         bytesAfterName = fName.length();

  89. 

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

  91.             path[bytesAfterName+1] != '/')

  92.         {

  93.             carla_stderr("CarlaEngineOsc::handleMessage() - message not for this client -> '%s' != '/%s/'",

  94.                         path, fName.buffer());

  95.             return 1;

  96.         }

  97. 

  98.         ++bytesAfterName;

  99.     }

  100. 

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

  102.     uint pluginId = 0;

  103. 

  104.     const char* const pluginPath = &path[bytesAfterName+1];

  105.     std::size_t pluginLen;

  106.     if (const char* const slash = std::strchr(pluginPath, '/'))

  107.     {

  108.         pluginLen = slash - pluginPath;

  109.     }

  110.     else

  111.     {

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

  113.         return 1;

  114.     }

  115. 

  116.     CarlaPluginPtr plugin = nullptr;

  117.     bool isNumeric = true;

  118.     for (std::size_t i = 0; i < pluginLen; i++) {

  119.         if (! std::isdigit(pluginPath[i]))

  120.         {

  121.             isNumeric = false;

  122.             break;

  123.         }

  124.     }

  125.     if (pluginLen <= 4 && isNumeric)

  126.     {

  127.         pluginId = atoi(pluginPath);

  128. 

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

  130.         {

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

  132.             return 0;

  133.         }

  134. 

  135.         // Get plugin

  136.         plugin = fEngine->getPluginUnchecked(pluginId);

  137. 

  138.     }

  139.     else

  140.     {

  141.         for (pluginId = 0; pluginId < fEngine->getCurrentPluginCount(); pluginId++)

  142.         {

  143.             plugin = fEngine->getPluginUnchecked(pluginId);

  144. 

  145.             carla_stderr("%s %s %d\n", plugin->getName(), pluginPath, pluginLen);

  146.             if (strlen(plugin->getName()) == pluginLen && !strncmp(plugin->getName(), pluginPath, pluginLen)) {

  147.                 break;

  148.             }

  149. 

  150.             plugin = nullptr;

  151.         }

  152.     }

  153. 

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

  155.     {

  156.         carla_stderr("CarlaEngineOsc::handleMessage() - plugin not found, probably has been removed (path: '%s')", path);

  157.         return 0;

  158.     }

  159. 

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

  161.     char method[48];

  162.     std::strncpy(method, &pluginPath[pluginLen + 1], 47);

  163.     method[47] = '\0';

  164. 

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

  166.     {

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

  168.         return 0;

  169.     }

  170. 

  171.     // Internal methods

  172.     if (std::strcmp(method, "set_option") == 0)

  173.         return 0; //handleMsgSetOption(plugin, argc, argv, types); // TODO

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

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

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

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

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

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

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

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

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

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

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

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

  186.     if (std::strcmp(method, "set_ctrl_channel") == 0)

  187.         return 0; //handleMsgSetControlChannel(plugin, argc, argv, types); // TODO

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

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

  190.     if (std::strcmp(method, "set_parameter_mapped_control_index") == 0)

  191.         return handleMsgSetParameterMappedControlIndex(plugin, argc, argv, types);

  192.     if (std::strcmp(method, "set_parameter_mapped_range") == 0)

  193.         return handleMsgSetParameterMappedRange(plugin, argc, argv, types);

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

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

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

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

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

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

  200.     if (std::strcmp(method, "set_custom_data") == 0)

  201.         return 0; //handleMsgSetCustomData(plugin, argc, argv, types); // TODO

  202.     if (std::strcmp(method, "set_chunk") == 0)

  203.         return 0; //handleMsgSetChunk(plugin, argc, argv, types); // TODO

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

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

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

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

  208. 

  209.     // Send all other methods to plugins, TODO

  210.     plugin->handleOscMessage(method, argc, argv, types, msg);

  211.     return 0;

  212. }

  213. 

  214. // -----------------------------------------------------------------------

  215. 

  216. int CarlaEngineOsc::handleMsgRegister(const bool isTCP,

  217.                                       const int argc, const lo_arg* const* const argv, const char* const types,

  218.                                       const lo_address source)

  219. {

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

  221.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  222. 

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

  224. 

  225.     CarlaOscData& oscData(isTCP ? fControlDataTCP : fControlDataUDP);

  226. 

  227.     if (oscData.owner != nullptr)

  228.     {

  229.         carla_stderr("OSC backend already registered to %s", oscData.owner);

  230. 

  231.         char* const path = lo_url_get_path(url);

  232.         const size_t pathlen = std::strlen(path);

  233.         CARLA_SAFE_ASSERT_RETURN(pathlen < 32, 0);

  234. 

  235.         char targetPath[pathlen+12];

  236.         std::strcpy(targetPath, path);

  237.         std::strcat(targetPath, "/exit-error");

  238. 

  239.         lo_send_from(source, isTCP ? fServerTCP : fServerUDP, LO_TT_IMMEDIATE,

  240.                      targetPath, "s", "OSC already registered to another client");

  241. 

  242.         free(path);

  243.     }

  244.     else

  245.     {

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

  247.         /* */ char* const port  = lo_url_get_port(url); // NOTE: lo_address_get_port is buggy against TCP

  248.         const lo_address target = lo_address_new_with_proto(isTCP ? LO_TCP : LO_UDP, host, port);

  249. 

  250.         oscData.owner  = carla_strdup_safe(host);

  251.         oscData.path   = carla_strdup_free(lo_url_get_path(url));

  252.         oscData.target = target;

  253. 

  254.         char* const targeturl = lo_address_get_url(target);

  255.         carla_stdout("OSC %s backend registered to %s, path: %s, target: %s (host: %s, port: %s)",

  256.                      isTCP ? "TCP" : "UDP", url, oscData.path, targeturl, host, port);

  257.         free(targeturl);

  258.         free(port);

  259. 

  260.         if (isTCP)

  261.         {

  262.             const EngineOptions& opts(fEngine->getOptions());

  263. 

  264.             fEngine->callback(false, true,

  265.                               ENGINE_CALLBACK_ENGINE_STARTED,

  266.                               fEngine->getCurrentPluginCount(),

  267.                               opts.processMode,

  268.                               opts.transportMode,

  269.                               static_cast<int>(fEngine->getBufferSize()),

  270.                               static_cast<float>(fEngine->getSampleRate()),

  271.                               fEngine->getCurrentDriverName());

  272. 

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

  274.             {

  275.                 const CarlaPluginPtr plugin = fEngine->getPluginUnchecked(i);

  276.                 CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  277. 

  278.                 fEngine->callback(false, true, ENGINE_CALLBACK_PLUGIN_ADDED, i, plugin->getType(),

  279.                                   0, 0, 0.0f,

  280.                                   plugin->getName());

  281.             }

  282. 

  283.             fEngine->patchbayRefresh(false, true, fEngine->pData->graph.isUsingExternalOSC());

  284.         }

  285.     }

  286. 

  287.     return 0;

  288. }

  289. 

  290. int CarlaEngineOsc::handleMsgUnregister(const bool isTCP,

  291.                                         const int argc, const lo_arg* const* const argv, const char* const types,

  292.                                         const lo_address source)

  293. {

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

  295.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  296. 

  297.     CarlaOscData& oscData(isTCP ? fControlDataTCP : fControlDataUDP);

  298. 

  299.     if (oscData.owner == nullptr)

  300.     {

  301.         carla_stderr("OSC backend is not registered yet, unregister failed");

  302.         return 0;

  303.     }

  304. 

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

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

  307.     const char* const path = lo_url_get_path(url);

  308. 

  309.     if (std::strcmp(oscData.owner, host) != 0)

  310.     {

  311.         carla_stderr("OSC backend unregister failed, current owner host %s does not match requested %s",

  312.                      oscData.owner, host);

  313.         return 0;

  314.     }

  315. 

  316.     if (std::strcmp(oscData.path, path) != 0)

  317.     {

  318.         carla_stderr("OSC backend unregister failed, current owner path %s does not match requested %s",

  319.                      oscData.path, path);

  320.         return 0;

  321.     }

  322. 

  323.     carla_stdout("OSC client %s unregistered", url);

  324.     oscData.clear();

  325.     return 0;

  326. }

  327. 

  328. int CarlaEngineOsc::handleMsgControl(const char* const method,

  329.                                      const int argc, const lo_arg* const* const argv, const char* const types)

  330. {

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

  332.     CARLA_SAFE_ASSERT_RETURN(method != nullptr && method[0] != '\0', 0);

  333.     CARLA_SAFE_ASSERT_RETURN(types != nullptr, 0);

  334.     CARLA_SAFE_ASSERT_RETURN(types[0] == 'i', 0);

  335. 

  336.     if (fControlDataTCP.owner == nullptr)

  337.     {

  338.         carla_stderr("OSC backend is not registered yet, control failed");

  339.         return 0;

  340.     }

  341. 

  342.     const int32_t messageId = argv[0]->i;

  343.     bool ok;

  344. 

  345. #define CARLA_SAFE_ASSERT_RETURN_OSC_ERR(cond) \

  346.     if (! (cond)) { carla_safe_assert(#cond, __FILE__, __LINE__); sendResponse(messageId, #cond); return 0; }

  347. 

  348.     /**/ if (std::strcmp(method, "clear_engine_xruns") == 0)

  349.     {

  350.         ok = true;

  351.         fEngine->clearXruns();

  352.     }

  353.     else if (std::strcmp(method, "cancel_engine_action") == 0)

  354.     {

  355.         ok = true;

  356.         fEngine->setActionCanceled(true);

  357.     }

  358.     else if (std::strcmp(method, "patchbay_connect") == 0)

  359.     {

  360.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 6);

  361.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  362.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 'i');

  363.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[3] == 'i');

  364.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[4] == 'i');

  365.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[5] == 'i');

  366. 

  367.         const bool external = argv[1]->i != 0;

  368. 

  369.         const int32_t groupA = argv[2]->i;

  370.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupA >= 0);

  371. 

  372.         const int32_t portA = argv[3]->i;

  373.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portA >= 0);

  374. 

  375.         const int32_t groupB = argv[4]->i;

  376.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupB >= 0);

  377. 

  378.         const int32_t portB = argv[5]->i;

  379.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portB >= 0);

  380. 

  381.         ok = fEngine->patchbayConnect(external,

  382.                                       static_cast<uint32_t>(groupA),

  383.                                       static_cast<uint32_t>(portA),

  384.                                       static_cast<uint32_t>(groupB),

  385.                                       static_cast<uint32_t>(portB));

  386.     }

  387.     else if (std::strcmp(method, "patchbay_disconnect") == 0)

  388.     {

  389.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

  390.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  391.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 'i');

  392. 

  393.         const bool external = argv[1]->i != 0;

  394. 

  395.         const int32_t connectionId = argv[2]->i;

  396.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(connectionId >= 0);

  397. 

  398.         ok = fEngine->patchbayDisconnect(external, static_cast<uint32_t>(connectionId));

  399.     }

  400.     else if (std::strcmp(method, "patchbay_set_group_pos") == 0)

  401.     {

  402.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 7);

  403.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  404.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 'i');

  405.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[3] == 'i');

  406.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[4] == 'i');

  407.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[5] == 'i');

  408.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[6] == 'i');

  409. 

  410.         const bool external = argv[1]->i != 0;

  411. 

  412.         const int32_t groupId = argv[2]->i;

  413.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupId >= 0);

  414. 

  415.         ok = fEngine->patchbaySetGroupPos(true, false,

  416.                                           external, static_cast<uint32_t>(groupId),

  417.                                           argv[3]->i, argv[4]->i, argv[5]->i, argv[6]->i);

  418.     }

  419.     else if (std::strcmp(method, "patchbay_refresh") == 0)

  420.     {

  421.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  422.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  423. 

  424.         const bool external = argv[1]->i != 0;

  425. 

  426.         ok = fEngine->patchbayRefresh(false, true, external);

  427.     }

  428.     else if (std::strcmp(method, "transport_play") == 0)

  429.     {

  430.         ok = true;

  431.         fEngine->transportPlay();

  432.     }

  433.     else if (std::strcmp(method, "transport_pause") == 0)

  434.     {

  435.         ok = true;

  436.         fEngine->transportPause();

  437.     }

  438.     else if (std::strcmp(method, "transport_bpm") == 0)

  439.     {

  440.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  441.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'f');

  442. 

  443.         const double bpm = argv[1]->f;

  444.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(bpm >= 0.0);

  445. 

  446.         ok = true;

  447.         fEngine->transportBPM(bpm);

  448.     }

  449.     else if (std::strcmp(method, "transport_relocate") == 0)

  450.     {

  451.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  452. 

  453.         uint64_t frame;

  454. 

  455.         /**/ if (types[1] == 'i')

  456.         {

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

  458.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(i >= 0);

  459.             frame = static_cast<uint64_t>(i);

  460.         }

  461.         else if (types[1] == 'h')

  462.         {

  463.             const int64_t h = argv[1]->h;

  464.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(h >= 0);

  465.             frame = static_cast<uint64_t>(h);

  466.         }

  467.         else

  468.         {

  469.             carla_stderr2("Wrong OSC type used for '%s'", method);

  470.             sendResponse(messageId, "Wrong OSC type");

  471.             return 0;

  472.         }

  473. 

  474.         ok = true;

  475.         fEngine->transportRelocate(frame);

  476.     }

  477.     else if (std::strcmp(method, "add_plugin") == 0)

  478.     {

  479.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 8);

  480.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  481.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 'i');

  482.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[3] == 's');

  483.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[4] == 's');

  484.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[5] == 's');

  485.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[7] == 'i');

  486. 

  487.         int32_t btype = argv[1]->i;

  488.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(btype >= 0);

  489. 

  490.         const int32_t ptype = argv[2]->i;

  491.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(ptype >= 0);

  492. 

  493.         // Force binary type to be native in some cases

  494.         switch (ptype)

  495.         {

  496.         case PLUGIN_INTERNAL:

  497.         case PLUGIN_LV2:

  498.         case PLUGIN_SF2:

  499.         case PLUGIN_SFZ:

  500.         case PLUGIN_JACK:

  501.             btype = BINARY_NATIVE;

  502.             break;

  503.         }

  504. 

  505.         const char* filename = &argv[3]->s;

  506. 

  507.         if (filename != nullptr && std::strcmp(filename, "(null)") == 0)

  508.             filename = nullptr;

  509. 

  510.         const char* name = &argv[4]->s;

  511. 

  512.         if (name != nullptr && std::strcmp(name, "(null)") == 0)

  513.             name = nullptr;

  514. 

  515.         const char* const label = &argv[5]->s;

  516.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(label != nullptr && label[0] != '\0');

  517. 

  518.         int64_t uniqueId;

  519. 

  520.         /**/ if (types[6] == 'i')

  521.         {

  522.             uniqueId = argv[6]->i;

  523.         }

  524.         else if (types[6] == 'h')

  525.         {

  526.             uniqueId = argv[6]->h;

  527.         }

  528.         else

  529.         {

  530.             carla_stderr2("Wrong OSC type used for '%s' uniqueId", method);

  531.             sendResponse(messageId, "Wrong OSC type");

  532.             return 0;

  533.         }

  534. 

  535.         const int32_t options = argv[7]->i;

  536.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(options >= 0);

  537. 

  538.         ok = fEngine->addPlugin(static_cast<BinaryType>(btype),

  539.                                 static_cast<PluginType>(ptype),

  540.                                 filename, name, label, uniqueId, nullptr, static_cast<uint32_t>(options));

  541.     }

  542.     else if (std::strcmp(method, "remove_plugin") == 0)

  543.     {

  544.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  545.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  546. 

  547.         const int32_t id = argv[1]->i;

  548.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  549. 

  550.         ok = fEngine->removePlugin(static_cast<uint32_t>(id));

  551.     }

  552.     else if (std::strcmp(method, "remove_all_plugins") == 0)

  553.     {

  554.         ok = fEngine->removeAllPlugins();

  555.     }

  556.     else if (std::strcmp(method, "rename_plugin") == 0)

  557.     {

  558.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

  559.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  560.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 's');

  561. 

  562.         const int32_t id = argv[1]->i;

  563.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  564. 

  565.         const char* const newName = &argv[2]->s;

  566.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(newName != nullptr && newName[0] != '\0');

  567. 

  568.         ok = fEngine->renamePlugin(static_cast<uint32_t>(id), newName);

  569.     }

  570.     else if (std::strcmp(method, "clone_plugin") == 0)

  571.     {

  572.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  573.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  574. 

  575.         const int32_t id = argv[1]->i;

  576.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  577. 

  578.         ok = fEngine->clonePlugin(static_cast<uint32_t>(id));

  579.     }

  580.     else if (std::strcmp(method, "replace_plugin") == 0)

  581.     {

  582.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  583.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  584. 

  585.         const int32_t id = argv[1]->i;

  586.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  587. 

  588.         ok = fEngine->replacePlugin(static_cast<uint32_t>(id));

  589.     }

  590.     else if (std::strcmp(method, "switch_plugins") == 0)

  591.     {

  592.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

  593.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[1] == 'i');

  594.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(types[2] == 'i');

  595. 

  596.         const int32_t idA = argv[1]->i;

  597.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idA >= 0);

  598. 

  599.         const int32_t idB = argv[2]->i;

  600.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idB >= 0);

  601. 

  602.         ok = fEngine->switchPlugins(static_cast<uint32_t>(idA), static_cast<uint32_t>(idB));

  603.     }

  604.     else

  605.     {

  606.         carla_stderr2("Unhandled OSC control for '%s'", method);

  607.         sendResponse(messageId, "Unhandled OSC control method");

  608.         return 0;

  609.     }

  610. 

  611. #undef CARLA_SAFE_ASSERT_RETURN_OSC_ERR

  612. 

  613.     sendResponse(messageId, ok ? "" : fEngine->getLastError());

  614.     return 0;

  615. }

  616. 

  617. // -----------------------------------------------------------------------

  618. 

  619. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS)

  620. {

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

  622.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  623. 

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

  625. 

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

  627.     return 0;

  628. }

  629. 

  630. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS)

  631. {

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

  633.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  634. 

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

  636. 

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

  638.     return 0;

  639. }

  640. 

  641. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS)

  642. {

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

  644.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  645. 

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

  647. 

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

  649.     return 0;

  650. }

  651. 

  652. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS)

  653. {

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

  655.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  656. 

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

  658. 

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

  660.     return 0;

  661. }

  662. 

  663. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS)

  664. {

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

  666.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  667. 

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

  669. 

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

  671.     return 0;

  672. }

  673. 

  674. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS)

  675. {

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

  677.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  678. 

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

  680. 

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

  682.     return 0;

  683. }

  684. 

  685. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS)

  686. {

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

  688.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  689. 

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

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

  692. 

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

  694. 

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

  696.     return 0;

  697. }

  698. 

  699. int CarlaEngineOsc::handleMsgSetParameterMappedControlIndex(CARLA_ENGINE_OSC_HANDLE_ARGS)

  700. {

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

  702.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  703. 

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

  705.     const int32_t ctrl  = argv[1]->i;

  706. 

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

  708.     CARLA_SAFE_ASSERT_RETURN(ctrl >= CONTROL_INDEX_NONE && ctrl <= CONTROL_INDEX_MAX_ALLOWED, 0);

  709. 

  710.     plugin->setParameterMappedControlIndex(static_cast<uint32_t>(index), static_cast<int16_t>(ctrl), false, true, true);

  711.     return 0;

  712. }

  713. 

  714. int CarlaEngineOsc::handleMsgSetParameterMappedRange(CARLA_ENGINE_OSC_HANDLE_ARGS)

  715. {

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

  717.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "iff");

  718. 

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

  720.     const float   minimum = argv[1]->f;

  721.     const float   maximum = argv[2]->f;

  722. 

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

  724. 

  725.     plugin->setParameterMappedRange(static_cast<uint32_t>(index), minimum, maximum, false, true);

  726.     return 0;

  727. }

  728. 

  729. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS)

  730. {

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

  732.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  733. 

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

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

  736. 

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

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

  739. 

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

  741.     return 0;

  742. }

  743. 

  744. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  745. {

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

  747.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  748. 

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

  750. 

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

  752. 

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

  754.     return 0;

  755. }

  756. 

  757. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  758. {

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

  760.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  761. 

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

  763. 

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

  765. 

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

  767.     return 0;

  768. }

  769. 

  770. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS)

  771. {

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

  773.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  774. 

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

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

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

  778. 

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

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

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

  782. 

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

  784.     return 0;

  785. }

  786. 

  787. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS)

  788. {

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

  790.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  791. 

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

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

  794. 

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

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

  797. 

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

  799.     return 0;

  800. }

  801. 

  802. // -----------------------------------------------------------------------

  803. 

  804. CARLA_BACKEND_END_NAMESPACE

  805. 

  806. #endif // HAVE_LIBLO