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.
5458 Commits
16 Branches
14GB
Tree: 01bfe05fd8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '01bfe05fd8'
${ noResults }
Carla/source/backend/engine/CarlaEngineOscHandlers.cpp

762 lines
25KB
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, const int argc, const lo_arg* const* const argv, const char* const types, const lo_message msg)

  33. {

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

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

  36. #ifdef DEBUG

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

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

  39.     }

  40. #endif

  41. 

  42.     if (isTCP)

  43.     {

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

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

  46.     }

  47.     else

  48.     {

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

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

  51.     }

  52. 

  53.     // Initial path check

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

  55.         return handleMsgRegister(isTCP, argc, argv, types);

  56. 

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

  58.         return handleMsgUnregister(isTCP, argc, argv, types);

  59. 

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

  61.     {

  62.         CARLA_SAFE_ASSERT_RETURN(isTCP, 1);

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

  64.     }

  65. 

  66.     const std::size_t nameSize(fName.length());

  67. 

  68.     // Check if message is for this client

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

  70.     {

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

  72.                      path, fName.buffer());

  73.         return 1;

  74.     }

  75. 

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

  77.     uint pluginId = 0;

  78.     std::size_t offset;

  79. 

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

  81.     {

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

  83.         {

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

  85.             {

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

  87.                 return 1;

  88.             }

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

  90.             {

  91.                 // 3 digits, /xyz/method

  92.                 offset    = 6;

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

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

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

  96.             }

  97.             else

  98.             {

  99.                 // 2 digits, /xy/method

  100.                 offset    = 5;

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

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

  103.             }

  104.         }

  105.         else

  106.         {

  107.             // single digit, /x/method

  108.             offset    = 4;

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

  110.         }

  111.     }

  112.     else

  113.     {

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

  115.         return 1;

  116.     }

  117. 

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

  119.     {

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

  121.         return 0;

  122.     }

  123. 

  124.     // Get plugin

  125.     const CarlaPluginPtr plugin = fEngine->getPluginUnchecked(pluginId);

  126. 

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

  128.     {

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

  130.         return 0;

  131.     }

  132. 

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

  134.     char method[32+1];

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

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

  137. 

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

  139.     {

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

  141.         return 0;

  142.     }

  143. 

  144.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  181. 

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

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

  184.     return 0;

  185. }

  186. 

  187. // -----------------------------------------------------------------------

  188. 

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

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

  191. {

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

  193.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  194. 

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

  196.     const lo_address addr = lo_address_new_from_url(url);

  197. 

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

  199. 

  200.     if (oscData.owner != nullptr)

  201.     {

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

  203. 

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

  205. 

  206.         char targetPath[std::strlen(path)+18];

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

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

  209. 

  210.         lo_send_from(addr, isTCP ? fServerTCP : fServerUDP, LO_TT_IMMEDIATE,

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

  212. 

  213.         free(path);

  214.     }

  215.     else

  216.     {

  217.         carla_stdout("OSC backend registered to %s", url);

  218. 

  219.         const char* const host  = lo_address_get_hostname(addr);

  220.         const char* const port  = lo_address_get_port(addr);

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

  222. 

  223.         oscData.owner  = carla_strdup_safe(url);

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

  225.         oscData.target = target;

  226. 

  227.         if (isTCP)

  228.         {

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

  230. 

  231.             fEngine->callback(false, true,

  232.                               ENGINE_CALLBACK_ENGINE_STARTED,

  233.                               fEngine->getCurrentPluginCount(),

  234.                               opts.processMode,

  235.                               opts.transportMode,

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

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

  238.                               fEngine->getCurrentDriverName());

  239. 

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

  241.             {

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

  243.                 CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  244. 

  245.                 fEngine->callback(false, true, ENGINE_CALLBACK_PLUGIN_ADDED, i, 0, 0, 0, 0.0f, plugin->getName());

  246.             }

  247. 

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

  249.         }

  250.     }

  251. 

  252.     lo_address_free(addr);

  253.     return 0;

  254. }

  255. 

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

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

  258. {

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

  260.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  261. 

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

  263. 

  264.     if (oscData.owner == nullptr)

  265.     {

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

  267.         return 0;

  268.     }

  269. 

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

  271. 

  272.     if (std::strcmp(oscData.owner, url) == 0)

  273.     {

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

  275.         oscData.clear();

  276.         return 0;

  277.     }

  278. 

  279.     carla_stderr("OSC backend unregister failed, current owner %s does not match requested %s", oscData.owner, url);

  280.     return 0;

  281. }

  282. 

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

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

  285. {

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

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

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

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

  290. 

  291.     if (fControlDataTCP.owner == nullptr)

  292.     {

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

  294.         return 0;

  295.     }

  296. 

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

  298.     bool ok;

  299. 

  300. #define CARLA_SAFE_ASSERT_RETURN_OSC_ERR(cond) \

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

  302. 

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

  304.     {

  305.         ok = true;

  306.         fEngine->clearXruns();

  307.     }

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

  309.     {

  310.         ok = true;

  311.         fEngine->setActionCanceled(true);

  312.     }

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

  314.     {

  315.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 6);

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

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

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

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

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

  321. 

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

  323. 

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

  325.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupA >= 0);

  326. 

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

  328.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portA >= 0);

  329. 

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

  331.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupB >= 0);

  332. 

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

  334.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portB >= 0);

  335. 

  336.         ok = fEngine->patchbayConnect(external,

  337.                                       static_cast<uint32_t>(groupA),

  338.                                       static_cast<uint32_t>(portA),

  339.                                       static_cast<uint32_t>(groupB),

  340.                                       static_cast<uint32_t>(portB));

  341.     }

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

  343.     {

  344.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  347. 

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

  349. 

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

  351.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(connectionId >= 0);

  352. 

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

  354.     }

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

  356.     {

  357.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 7);

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

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

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

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

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

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

  364. 

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

  366. 

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

  368.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupId >= 0);

  369. 

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

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

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

  373.     }

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

  375.     {

  376.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  378. 

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

  380. 

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

  382.     }

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

  384.     {

  385.         ok = true;

  386.         fEngine->transportPlay();

  387.     }

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

  389.     {

  390.         ok = true;

  391.         fEngine->transportPause();

  392.     }

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

  394.     {

  395.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  397. 

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

  399.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(bpm >= 0.0);

  400. 

  401.         ok = true;

  402.         fEngine->transportBPM(bpm);

  403.     }

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

  405.     {

  406.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  407. 

  408.         uint64_t frame;

  409. 

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

  411.         {

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

  413.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(i >= 0);

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

  415.         }

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

  417.         {

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

  419.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(h >= 0);

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

  421.         }

  422.         else

  423.         {

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

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

  426.             return 0;

  427.         }

  428. 

  429.         ok = true;

  430.         fEngine->transportRelocate(frame);

  431.     }

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

  433.     {

  434.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 8);

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

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

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

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

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

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

  441. 

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

  443.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(btype >= 0);

  444. 

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

  446.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(ptype >= 0);

  447. 

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

  449.         switch (ptype)

  450.         {

  451.         case PLUGIN_INTERNAL:

  452.         case PLUGIN_LV2:

  453.         case PLUGIN_SF2:

  454.         case PLUGIN_SFZ:

  455.         case PLUGIN_JACK:

  456.             btype = BINARY_NATIVE;

  457.             break;

  458.         }

  459. 

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

  461. 

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

  463.             filename = nullptr;

  464. 

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

  466. 

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

  468.             name = nullptr;

  469. 

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

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

  472. 

  473.         int64_t uniqueId;

  474. 

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

  476.         {

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

  478.         }

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

  480.         {

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

  482.         }

  483.         else

  484.         {

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

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

  487.             return 0;

  488.         }

  489. 

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

  491.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(options >= 0);

  492. 

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

  494.                                 static_cast<PluginType>(ptype),

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

  496.     }

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

  498.     {

  499.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  501. 

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

  503.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  504. 

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

  506.     }

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

  508.     {

  509.         ok = fEngine->removeAllPlugins();

  510.     }

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

  512.     {

  513.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  516. 

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

  518.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  519. 

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

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

  522. 

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

  524.     }

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

  526.     {

  527.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  529. 

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

  531.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  532. 

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

  534.     }

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

  536.     {

  537.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  539. 

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

  541.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  542. 

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

  544.     }

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

  546.     {

  547.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  550. 

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

  552.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idA >= 0);

  553. 

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

  555.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idB >= 0);

  556. 

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

  558.     }

  559.     else

  560.     {

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

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

  563.         return 0;

  564.     }

  565. 

  566. #undef CARLA_SAFE_ASSERT_RETURN_OSC_ERR

  567. 

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

  569.     return 0;

  570. }

  571. 

  572. // -----------------------------------------------------------------------

  573. 

  574. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS)

  575. {

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

  577.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  578. 

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

  580. 

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

  582.     return 0;

  583. }

  584. 

  585. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS)

  586. {

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

  588.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  589. 

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

  591. 

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

  593.     return 0;

  594. }

  595. 

  596. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS)

  597. {

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

  599.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  600. 

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

  602. 

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

  604.     return 0;

  605. }

  606. 

  607. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS)

  608. {

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

  610.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  611. 

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

  613. 

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

  615.     return 0;

  616. }

  617. 

  618. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS)

  619. {

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

  621.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  622. 

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

  624. 

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

  626.     return 0;

  627. }

  628. 

  629. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS)

  630. {

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

  632.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  633. 

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

  635. 

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

  637.     return 0;

  638. }

  639. 

  640. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS)

  641. {

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

  643.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  644. 

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

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

  647. 

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

  649. 

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

  651.     return 0;

  652. }

  653. 

  654. int CarlaEngineOsc::handleMsgSetParameterMappedControlIndex(CARLA_ENGINE_OSC_HANDLE_ARGS)

  655. {

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

  657.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  658. 

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

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

  661. 

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

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

  664. 

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

  666.     return 0;

  667. }

  668. 

  669. int CarlaEngineOsc::handleMsgSetParameterMappedRange(CARLA_ENGINE_OSC_HANDLE_ARGS)

  670. {

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

  672.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "iff");

  673. 

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

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

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

  677. 

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

  679. 

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

  681.     return 0;

  682. }

  683. 

  684. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS)

  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_ARGS)

  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_ARGS)

  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_ARGS)

  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_ARGS)

  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. 

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

  758. 

  759. CARLA_BACKEND_END_NAMESPACE

  760. 

  761. #endif // HAVE_LIBLO