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.
5846 Commits
16 Branches
330MB
Tree: 899d277cfc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '899d277cfc'
${ noResults }
Carla/source/backend/engine/CarlaEngineOscHandlers.cpp

768 lines
26KB
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::strncmp(path, "/bridge_pong", 12) != 0) {

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

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

  40.     }

  41. #endif

  42. 

  43.     if (isTCP)

  44.     {

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

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

  47.     }

  48.     else

  49.     {

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

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

  52.     }

  53. 

  54.     // Initial path check

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

  56.         return handleMsgRegister(isTCP, argc, argv, types, lo_message_get_source(msg));

  57. 

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

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

  60. 

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

  62.     {

  63.         CARLA_SAFE_ASSERT_RETURN(isTCP, 1);

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

  65.     }

  66. 

  67.     const std::size_t nameSize = fName.length();

  68. 

  69.     // Check if message is for this client

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

  71.     {

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

  73.                      path, fName.buffer());

  74.         return 1;

  75.     }

  76. 

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

  78.     uint pluginId = 0;

  79.     std::size_t offset;

  80. 

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

  82.     {

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

  84.         {

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

  86.             {

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

  88.                 return 1;

  89.             }

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

  91.             {

  92.                 // 3 digits, /xyz/method

  93.                 offset    = 6;

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

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

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

  97.             }

  98.             else

  99.             {

  100.                 // 2 digits, /xy/method

  101.                 offset    = 5;

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

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

  104.             }

  105.         }

  106.         else

  107.         {

  108.             // single digit, /x/method

  109.             offset    = 4;

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

  111.         }

  112.     }

  113.     else

  114.     {

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

  116.         return 1;

  117.     }

  118. 

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

  120.     {

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

  122.         return 0;

  123.     }

  124. 

  125.     // Get plugin

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

  127. 

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

  129.     {

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

  131.         return 0;

  132.     }

  133. 

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

  135.     char method[48];

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

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

  138. 

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

  140.     {

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

  142.         return 0;

  143.     }

  144. 

  145.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  182. 

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

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

  185.     return 0;

  186. }

  187. 

  188. // -----------------------------------------------------------------------

  189. 

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

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

  192.                                       const lo_address source)

  193. {

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

  195.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  196. 

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

  198. 

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

  200. 

  201.     if (oscData.owner != nullptr)

  202.     {

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

  204. 

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

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

  207.         CARLA_SAFE_ASSERT_RETURN(pathlen < 32, 0);

  208. 

  209.         char targetPath[pathlen+12];

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

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

  212. 

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

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

  215. 

  216.         free(path);

  217.     }

  218.     else

  219.     {

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

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

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

  223. 

  224.         oscData.owner  = carla_strdup_safe(url);

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

  226.         oscData.target = target;

  227. 

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

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

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

  231.         free(targeturl);

  232.         free(port);

  233. 

  234.         if (isTCP)

  235.         {

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

  237. 

  238.             fEngine->callback(false, true,

  239.                               ENGINE_CALLBACK_ENGINE_STARTED,

  240.                               fEngine->getCurrentPluginCount(),

  241.                               opts.processMode,

  242.                               opts.transportMode,

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

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

  245.                               fEngine->getCurrentDriverName());

  246. 

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

  248.             {

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

  250.                 CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  251. 

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

  253.             }

  254. 

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

  256.         }

  257.     }

  258. 

  259.     return 0;

  260. }

  261. 

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

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

  264. {

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

  266.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  267. 

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

  269. 

  270.     if (oscData.owner == nullptr)

  271.     {

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

  273.         return 0;

  274.     }

  275. 

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

  277. 

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

  279.     {

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

  281.         oscData.clear();

  282.         return 0;

  283.     }

  284. 

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

  286.     return 0;

  287. }

  288. 

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

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

  291. {

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

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

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

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

  296. 

  297.     if (fControlDataTCP.owner == nullptr)

  298.     {

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

  300.         return 0;

  301.     }

  302. 

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

  304.     bool ok;

  305. 

  306. #define CARLA_SAFE_ASSERT_RETURN_OSC_ERR(cond) \

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

  308. 

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

  310.     {

  311.         ok = true;

  312.         fEngine->clearXruns();

  313.     }

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

  315.     {

  316.         ok = true;

  317.         fEngine->setActionCanceled(true);

  318.     }

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

  320.     {

  321.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 6);

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

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

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

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

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

  327. 

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

  329. 

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

  331.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupA >= 0);

  332. 

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

  334.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portA >= 0);

  335. 

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

  337.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupB >= 0);

  338. 

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

  340.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portB >= 0);

  341. 

  342.         ok = fEngine->patchbayConnect(external,

  343.                                       static_cast<uint32_t>(groupA),

  344.                                       static_cast<uint32_t>(portA),

  345.                                       static_cast<uint32_t>(groupB),

  346.                                       static_cast<uint32_t>(portB));

  347.     }

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

  349.     {

  350.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  353. 

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

  355. 

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

  357.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(connectionId >= 0);

  358. 

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

  360.     }

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

  362.     {

  363.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 7);

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

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

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

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

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

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

  370. 

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

  372. 

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

  374.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupId >= 0);

  375. 

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

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

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

  379.     }

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

  381.     {

  382.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  384. 

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

  386. 

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

  388.     }

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

  390.     {

  391.         ok = true;

  392.         fEngine->transportPlay();

  393.     }

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

  395.     {

  396.         ok = true;

  397.         fEngine->transportPause();

  398.     }

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

  400.     {

  401.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  403. 

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

  405.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(bpm >= 0.0);

  406. 

  407.         ok = true;

  408.         fEngine->transportBPM(bpm);

  409.     }

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

  411.     {

  412.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  413. 

  414.         uint64_t frame;

  415. 

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

  417.         {

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

  419.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(i >= 0);

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

  421.         }

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

  423.         {

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

  425.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(h >= 0);

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

  427.         }

  428.         else

  429.         {

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

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

  432.             return 0;

  433.         }

  434. 

  435.         ok = true;

  436.         fEngine->transportRelocate(frame);

  437.     }

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

  439.     {

  440.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 8);

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

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

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

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

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

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

  447. 

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

  449.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(btype >= 0);

  450. 

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

  452.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(ptype >= 0);

  453. 

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

  455.         switch (ptype)

  456.         {

  457.         case PLUGIN_INTERNAL:

  458.         case PLUGIN_LV2:

  459.         case PLUGIN_SF2:

  460.         case PLUGIN_SFZ:

  461.         case PLUGIN_JACK:

  462.             btype = BINARY_NATIVE;

  463.             break;

  464.         }

  465. 

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

  467. 

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

  469.             filename = nullptr;

  470. 

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

  472. 

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

  474.             name = nullptr;

  475. 

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

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

  478. 

  479.         int64_t uniqueId;

  480. 

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

  482.         {

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

  484.         }

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

  486.         {

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

  488.         }

  489.         else

  490.         {

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

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

  493.             return 0;

  494.         }

  495. 

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

  497.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(options >= 0);

  498. 

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

  500.                                 static_cast<PluginType>(ptype),

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

  502.     }

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

  504.     {

  505.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  507. 

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

  509.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  510. 

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

  512.     }

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

  514.     {

  515.         ok = fEngine->removeAllPlugins();

  516.     }

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

  518.     {

  519.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  522. 

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

  524.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  525. 

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

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

  528. 

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

  530.     }

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

  532.     {

  533.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  535. 

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

  537.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  538. 

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

  540.     }

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

  542.     {

  543.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  545. 

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

  547.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  548. 

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

  550.     }

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

  552.     {

  553.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  556. 

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

  558.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idA >= 0);

  559. 

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

  561.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idB >= 0);

  562. 

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

  564.     }

  565.     else

  566.     {

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

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

  569.         return 0;

  570.     }

  571. 

  572. #undef CARLA_SAFE_ASSERT_RETURN_OSC_ERR

  573. 

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

  575.     return 0;

  576. }

  577. 

  578. // -----------------------------------------------------------------------

  579. 

  580. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS)

  581. {

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

  583.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  584. 

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

  586. 

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

  588.     return 0;

  589. }

  590. 

  591. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS)

  592. {

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

  594.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  595. 

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

  597. 

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

  599.     return 0;

  600. }

  601. 

  602. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS)

  603. {

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

  605.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  606. 

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

  608. 

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

  610.     return 0;

  611. }

  612. 

  613. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS)

  614. {

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

  616.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  617. 

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

  619. 

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

  621.     return 0;

  622. }

  623. 

  624. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS)

  625. {

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

  627.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  628. 

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

  630. 

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

  632.     return 0;

  633. }

  634. 

  635. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS)

  636. {

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

  638.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  639. 

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

  641. 

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

  643.     return 0;

  644. }

  645. 

  646. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS)

  647. {

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

  649.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  650. 

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

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

  653. 

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

  655. 

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

  657.     return 0;

  658. }

  659. 

  660. int CarlaEngineOsc::handleMsgSetParameterMappedControlIndex(CARLA_ENGINE_OSC_HANDLE_ARGS)

  661. {

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

  663.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  664. 

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

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

  667. 

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

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

  670. 

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

  672.     return 0;

  673. }

  674. 

  675. int CarlaEngineOsc::handleMsgSetParameterMappedRange(CARLA_ENGINE_OSC_HANDLE_ARGS)

  676. {

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

  678.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "iff");

  679. 

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

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

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

  683. 

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

  685. 

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

  687.     return 0;

  688. }

  689. 

  690. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS)

  691. {

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

  693.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  694. 

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

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

  697. 

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

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

  700. 

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

  702.     return 0;

  703. }

  704. 

  705. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  706. {

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

  708.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  709. 

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

  711. 

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

  713. 

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

  715.     return 0;

  716. }

  717. 

  718. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  719. {

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

  721.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  722. 

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

  724. 

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

  726. 

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

  728.     return 0;

  729. }

  730. 

  731. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS)

  732. {

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

  734.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  735. 

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

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

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

  739. 

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

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

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

  743. 

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

  745.     return 0;

  746. }

  747. 

  748. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS)

  749. {

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

  751.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  752. 

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

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

  755. 

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

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

  758. 

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

  760.     return 0;

  761. }

  762. 

  763. // -----------------------------------------------------------------------

  764. 

  765. CARLA_BACKEND_END_NAMESPACE

  766. 

  767. #endif // HAVE_LIBLO