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

816 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.         {

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

  93.                         path, fName.buffer());

  94.             return 1;

  95.         }

  96. 

  97.         ++bytesAfterName;

  98.     }

  99. 

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

  101.     uint pluginId = 0;

  102.     std::size_t offset;

  103. 

  104.     if (! std::isdigit(path[bytesAfterName+1]))

  105.     {

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

  107.         return 1;

  108.     }

  109. 

  110.     if (std::isdigit(path[bytesAfterName+2]))

  111.     {

  112.         if (std::isdigit(path[bytesAfterName+4]))

  113.         {

  114.             carla_stderr2("CarlaEngineOsc::handleMessage() - invalid plugin id, over 999? (value: \"%s\")",

  115.                           path+bytesAfterName);

  116.             return 1;

  117.         }

  118.         else if (std::isdigit(path[bytesAfterName+3]))

  119.         {

  120.             // 3 digits, /xyz/method

  121.             offset    = 5;

  122.             pluginId += uint(path[bytesAfterName+1]-'0')*100;

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

  124.             pluginId += uint(path[bytesAfterName+3]-'0');

  125.         }

  126.         else

  127.         {

  128.             // 2 digits, /xy/method

  129.             offset    = 4;

  130.             pluginId += uint(path[bytesAfterName+1]-'0')*10;

  131.             pluginId += uint(path[bytesAfterName+2]-'0');

  132.         }

  133.     }

  134.     else

  135.     {

  136.         // single digit, /x/method

  137.         offset    = 3;

  138.         pluginId += uint(path[bytesAfterName+1]-'0');

  139.     }

  140. 

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

  142.     {

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

  144.         return 0;

  145.     }

  146. 

  147.     // Get plugin

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

  149. 

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

  151.     {

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

  153.         return 0;

  154.     }

  155. 

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

  157.     char method[48];

  158.     std::strncpy(method, path + (bytesAfterName + offset), 47);

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

  160. 

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

  162.     {

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

  164.         return 0;

  165.     }

  166. 

  167.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  206. 

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

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

  209.     return 0;

  210. }

  211. 

  212. // -----------------------------------------------------------------------

  213. 

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

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

  216.                                       const lo_address source)

  217. {

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

  219.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  220. 

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

  222. 

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

  224. 

  225.     if (oscData.owner != nullptr)

  226.     {

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

  228. 

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

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

  231.         CARLA_SAFE_ASSERT_RETURN(pathlen < 32, 0);

  232. 

  233.         char targetPath[pathlen+12];

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

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

  236. 

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

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

  239. 

  240.         free(path);

  241.     }

  242.     else

  243.     {

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

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

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

  247. 

  248.         oscData.owner  = carla_strdup_safe(host);

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

  250.         oscData.target = target;

  251. 

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

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

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

  255.         free(targeturl);

  256.         free(port);

  257. 

  258.         if (isTCP)

  259.         {

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

  261. 

  262.             fEngine->callback(false, true,

  263.                               ENGINE_CALLBACK_ENGINE_STARTED,

  264.                               fEngine->getCurrentPluginCount(),

  265.                               opts.processMode,

  266.                               opts.transportMode,

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

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

  269.                               fEngine->getCurrentDriverName());

  270. 

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

  272.             {

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

  274.                 CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  275. 

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

  277.                                   0, 0, 0.0f,

  278.                                   plugin->getName());

  279.             }

  280. 

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

  282.         }

  283.     }

  284. 

  285.     return 0;

  286. }

  287. 

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

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

  290.                                         const lo_address source)

  291. {

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

  293.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  294. 

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

  296. 

  297.     if (oscData.owner == nullptr)

  298.     {

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

  300.         return 0;

  301.     }

  302. 

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

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

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

  306. 

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

  308.     {

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

  310.                      oscData.owner, host);

  311.         return 0;

  312.     }

  313. 

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

  315.     {

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

  317.                      oscData.path, path);

  318.         return 0;

  319.     }

  320. 

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

  322.     oscData.clear();

  323.     return 0;

  324. }

  325. 

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

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

  328. {

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

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

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

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

  333. 

  334.     if (fControlDataTCP.owner == nullptr)

  335.     {

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

  337.         return 0;

  338.     }

  339. 

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

  341.     bool ok;

  342. 

  343. #define CARLA_SAFE_ASSERT_RETURN_OSC_ERR(cond) \

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

  345. 

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

  347.     {

  348.         ok = true;

  349.         fEngine->clearXruns();

  350.     }

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

  352.     {

  353.         ok = true;

  354.         fEngine->setActionCanceled(true);

  355.     }

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

  357.     {

  358.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 6);

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

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

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

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

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

  364. 

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

  366. 

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

  368.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupA >= 0);

  369. 

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

  371.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portA >= 0);

  372. 

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

  374.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupB >= 0);

  375. 

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

  377.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(portB >= 0);

  378. 

  379.         ok = fEngine->patchbayConnect(external,

  380.                                       static_cast<uint32_t>(groupA),

  381.                                       static_cast<uint32_t>(portA),

  382.                                       static_cast<uint32_t>(groupB),

  383.                                       static_cast<uint32_t>(portB));

  384.     }

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

  386.     {

  387.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  390. 

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

  392. 

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

  394.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(connectionId >= 0);

  395. 

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

  397.     }

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

  399.     {

  400.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 7);

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

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

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

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

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

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

  407. 

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

  409. 

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

  411.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(groupId >= 0);

  412. 

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

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

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

  416.     }

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

  418.     {

  419.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  421. 

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

  423. 

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

  425.     }

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

  427.     {

  428.         ok = true;

  429.         fEngine->transportPlay();

  430.     }

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

  432.     {

  433.         ok = true;

  434.         fEngine->transportPause();

  435.     }

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

  437.     {

  438.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  440. 

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

  442.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(bpm >= 0.0);

  443. 

  444.         ok = true;

  445.         fEngine->transportBPM(bpm);

  446.     }

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

  448.     {

  449.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

  450. 

  451.         uint64_t frame;

  452. 

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

  454.         {

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

  456.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(i >= 0);

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

  458.         }

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

  460.         {

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

  462.             CARLA_SAFE_ASSERT_RETURN_OSC_ERR(h >= 0);

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

  464.         }

  465.         else

  466.         {

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

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

  469.             return 0;

  470.         }

  471. 

  472.         ok = true;

  473.         fEngine->transportRelocate(frame);

  474.     }

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

  476.     {

  477.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 8);

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

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

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

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

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

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

  484. 

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

  486.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(btype >= 0);

  487. 

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

  489.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(ptype >= 0);

  490. 

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

  492.         switch (ptype)

  493.         {

  494.         case PLUGIN_INTERNAL:

  495.         case PLUGIN_LV2:

  496.         case PLUGIN_SF2:

  497.         case PLUGIN_SFZ:

  498.         case PLUGIN_JACK:

  499.             btype = BINARY_NATIVE;

  500.             break;

  501.         }

  502. 

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

  504. 

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

  506.             filename = nullptr;

  507. 

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

  509. 

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

  511.             name = nullptr;

  512. 

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

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

  515. 

  516.         int64_t uniqueId;

  517. 

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

  519.         {

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

  521.         }

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

  523.         {

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

  525.         }

  526.         else

  527.         {

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

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

  530.             return 0;

  531.         }

  532. 

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

  534.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(options >= 0);

  535. 

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

  537.                                 static_cast<PluginType>(ptype),

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

  539.     }

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

  541.     {

  542.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  544. 

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

  546.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  547. 

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

  549.     }

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

  551.     {

  552.         ok = fEngine->removeAllPlugins();

  553.     }

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

  555.     {

  556.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  559. 

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

  561.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  562. 

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

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

  565. 

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

  567.     }

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

  569.     {

  570.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  572. 

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

  574.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  575. 

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

  577.     }

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

  579.     {

  580.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 2);

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

  582. 

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

  584.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(id >= 0);

  585. 

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

  587.     }

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

  589.     {

  590.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(argc == 3);

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

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

  593. 

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

  595.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idA >= 0);

  596. 

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

  598.         CARLA_SAFE_ASSERT_RETURN_OSC_ERR(idB >= 0);

  599. 

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

  601.     }

  602.     else

  603.     {

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

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

  606.         return 0;

  607.     }

  608. 

  609. #undef CARLA_SAFE_ASSERT_RETURN_OSC_ERR

  610. 

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

  612.     return 0;

  613. }

  614. 

  615. // -----------------------------------------------------------------------

  616. 

  617. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS)

  618. {

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

  620.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  621. 

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

  623. 

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

  625.     return 0;

  626. }

  627. 

  628. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS)

  629. {

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

  631.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  632. 

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

  634. 

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

  636.     return 0;

  637. }

  638. 

  639. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS)

  640. {

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

  642.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  643. 

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

  645. 

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

  647.     return 0;

  648. }

  649. 

  650. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS)

  651. {

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

  653.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  654. 

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

  656. 

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

  658.     return 0;

  659. }

  660. 

  661. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS)

  662. {

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

  664.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  665. 

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

  667. 

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

  669.     return 0;

  670. }

  671. 

  672. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS)

  673. {

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

  675.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  676. 

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

  678. 

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

  680.     return 0;

  681. }

  682. 

  683. int CarlaEngineOsc::handleMsgSetForth(CARLA_ENGINE_OSC_HANDLE_ARGS)

  684. {

  685.     carla_debug("CarlaEngineOsc::handleMsgSetForth()");

  686.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  687. 

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

  689. 

  690.     plugin->setForth(value, false, true);

  691.     return 0;

  692. }

  693. 

  694. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS)

  695. {

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

  697.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  698. 

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

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

  701. 

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

  703. 

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

  705.     return 0;

  706. }

  707. 

  708. int CarlaEngineOsc::handleMsgSetParameterMappedControlIndex(CARLA_ENGINE_OSC_HANDLE_ARGS)

  709. {

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

  711.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  712. 

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

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

  715. 

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

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

  718. 

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

  720.     return 0;

  721. }

  722. 

  723. int CarlaEngineOsc::handleMsgSetParameterMappedRange(CARLA_ENGINE_OSC_HANDLE_ARGS)

  724. {

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

  726.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "iff");

  727. 

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

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

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

  731. 

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

  733. 

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

  735.     return 0;

  736. }

  737. 

  738. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS)

  739. {

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

  741.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  742. 

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

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

  745. 

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

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

  748. 

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

  750.     return 0;

  751. }

  752. 

  753. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  754. {

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

  756.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  757. 

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

  759. 

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

  761. 

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

  763.     return 0;

  764. }

  765. 

  766. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS)

  767. {

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

  769.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  770. 

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

  772. 

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

  774. 

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

  776.     return 0;

  777. }

  778. 

  779. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS)

  780. {

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

  782.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  783. 

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

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

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

  787. 

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

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

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

  791. 

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

  793.     return 0;

  794. }

  795. 

  796. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS)

  797. {

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

  799.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  800. 

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

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

  803. 

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

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

  806. 

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

  808.     return 0;

  809. }

  810. 

  811. // -----------------------------------------------------------------------

  812. 

  813. CARLA_BACKEND_END_NAMESPACE

  814. 

  815. #endif // HAVE_LIBLO