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

801 lines
26KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngine.hpp"

  19. #include "CarlaEngineOsc.hpp"

  20. #include "CarlaPlugin.hpp"

  21. 

  22. #ifndef BUILD_BRIDGE

  23. # include "CarlaBridgeUtils.hpp"

  24. #endif

  25. 

  26. #include "CarlaMIDI.h"

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. #ifndef BUILD_BRIDGE

  31. // -------------------------------------------------------------------

  32. // Bridge Helper, defined in BridgePlugin.cpp

  33. 

  34. extern int CarlaPluginSetOscBridgeInfo(CarlaPlugin* const plugin, const PluginBridgeInfoType type,

  35.                                        const int argc, const lo_arg* const* const argv, const char* const types);

  36. #endif

  37. 

  38. // -----------------------------------------------------------------------

  39. 

  40. CarlaEngineOsc::CarlaEngineOsc(CarlaEngine* const engine)

  41.     : fEngine(engine),

  42.       fServerTCP(nullptr),

  43.       fServerUDP(nullptr)

  44. {

  45.     CARLA_ASSERT(engine != nullptr);

  46.     carla_debug("CarlaEngineOsc::CarlaEngineOsc(%p)", engine);

  47. }

  48. 

  49. CarlaEngineOsc::~CarlaEngineOsc()

  50. {

  51.     CARLA_ASSERT(fName.isEmpty());

  52.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  53.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  54.     CARLA_ASSERT(fServerTCP == nullptr);

  55.     CARLA_ASSERT(fServerUDP == nullptr);

  56.     carla_debug("CarlaEngineOsc::~CarlaEngineOsc()");

  57. }

  58. 

  59. // -----------------------------------------------------------------------

  60. 

  61. void CarlaEngineOsc::init(const char* const name)

  62. {

  63.     CARLA_SAFE_ASSERT_RETURN(fName.isEmpty(),);

  64.     CARLA_SAFE_ASSERT_RETURN(fServerPathTCP.isEmpty(),);

  65.     CARLA_SAFE_ASSERT_RETURN(fServerPathUDP.isEmpty(),);

  66.     CARLA_SAFE_ASSERT_RETURN(fServerTCP == nullptr,);

  67.     CARLA_SAFE_ASSERT_RETURN(fServerUDP == nullptr,);

  68.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0',);

  69.     carla_debug("CarlaEngineOsc::init(\"%s\")", name);

  70. 

  71.     fName = name;

  72.     fName.toBasic();

  73. 

  74.     fServerTCP = lo_server_thread_new_with_proto(nullptr, LO_TCP, osc_error_handler_TCP);

  75. 

  76.     if (fServerTCP != nullptr)

  77.     {

  78.         if (char* const tmpServerPathTCP = lo_server_thread_get_url(fServerTCP))

  79.         {

  80.             fServerPathTCP  = tmpServerPathTCP;

  81.             fServerPathTCP += fName;

  82.             std::free(tmpServerPathTCP);

  83.         }

  84. 

  85.         lo_server_thread_add_method(fServerTCP, nullptr, nullptr, osc_message_handler_TCP, this);

  86.         int ret = lo_server_thread_start(fServerTCP);

  87.         CARLA_SAFE_ASSERT(ret == 0);

  88.     }

  89. 

  90.     fServerUDP = lo_server_thread_new_with_proto(nullptr, LO_UDP, osc_error_handler_UDP);

  91. 

  92.     if (fServerUDP != nullptr)

  93.     {

  94.         if (char* const tmpServerPathUDP = lo_server_thread_get_url(fServerUDP))

  95.         {

  96.             fServerPathUDP  = tmpServerPathUDP;

  97.             fServerPathUDP += fName;

  98.             std::free(tmpServerPathUDP);

  99.         }

  100. 

  101.         lo_server_thread_add_method(fServerUDP, nullptr, nullptr, osc_message_handler_UDP, this);

  102.         int ret = lo_server_thread_start(fServerUDP);

  103.         CARLA_SAFE_ASSERT(ret == 0);

  104.     }

  105. 

  106.     CARLA_ASSERT(fName.isNotEmpty());

  107.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  108.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  109.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  110.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

  111. }

  112. 

  113. void CarlaEngineOsc::close()

  114. {

  115.     CARLA_ASSERT(fName.isNotEmpty());

  116.     CARLA_SAFE_ASSERT(fServerPathTCP.isNotEmpty());

  117.     CARLA_SAFE_ASSERT(fServerPathUDP.isNotEmpty());

  118.     CARLA_SAFE_ASSERT(fServerTCP != nullptr);

  119.     CARLA_SAFE_ASSERT(fServerUDP != nullptr);

  120.     carla_debug("CarlaEngineOsc::close()");

  121. 

  122.     fName.clear();

  123. 

  124.     if (fServerTCP != nullptr)

  125.     {

  126.         lo_server_thread_stop(fServerTCP);

  127.         lo_server_thread_del_method(fServerTCP, nullptr, nullptr);

  128.         lo_server_thread_free(fServerTCP);

  129.         fServerTCP = nullptr;

  130.     }

  131. 

  132.     if (fServerUDP != nullptr)

  133.     {

  134.         lo_server_thread_stop(fServerUDP);

  135.         lo_server_thread_del_method(fServerUDP, nullptr, nullptr);

  136.         lo_server_thread_free(fServerUDP);

  137.         fServerUDP = nullptr;

  138.     }

  139. 

  140.     fServerPathTCP.clear();

  141.     fServerPathUDP.clear();

  142. 

  143. #ifndef BUILD_BRIDGE

  144.     fControlData.free();

  145. #endif

  146. }

  147. 

  148. // -----------------------------------------------------------------------

  149. 

  150. bool isDigit(const char c);

  151. bool isDigit(const char c)

  152. {

  153.     return (c >= '0' && c <= '9');

  154. }

  155. 

  156. 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)

  157. {

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

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

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

  161. #ifndef BUILD_BRIDGE

  162.     const CarlaCriticalSection::Scope _ccsl(_cs);

  163. #endif

  164. 

  165.     if (isTCP)

  166.     {

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

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

  169.     }

  170.     else

  171.     {

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

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

  174.     }

  175. 

  176. #ifndef BUILD_BRIDGE

  177.     // Initial path check

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

  179.     {

  180.         const lo_address source = lo_message_get_source(msg);

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

  182.     }

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

  184.     {

  185.         return handleMsgUnregister();

  186.     }

  187. #endif

  188. 

  189.     const size_t nameSize(fName.length());

  190. 

  191.     // Check if message is for this client

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

  193.     {

  194.         carla_stderr("CarlaEngineOsc::handleMessage() - message not for this client -> '%s' != '/%s/'", path, fName.getBuffer());

  195.         return 1;

  196.     }

  197. 

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

  199.     uint pluginId = 0;

  200.     size_t offset;

  201. 

  202.     if (isDigit(path[nameSize+2]))

  203.     {

  204.         if (isDigit(path[nameSize+3]))

  205.         {

  206.             if (isDigit(path[nameSize+5]))

  207.             {

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

  209.                 return 1;

  210.             }

  211.             else if (isDigit(path[nameSize+4]))

  212.             {

  213.                 // 3 digits, /xyz/method

  214.                 offset    = 6;

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

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

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

  218.             }

  219.             else

  220.             {

  221.                 // 2 digits, /xy/method

  222.                 offset    = 5;

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

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

  225.             }

  226.         }

  227.         else

  228.         {

  229.             // single digit, /x/method

  230.             offset    = 4;

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

  232.         }

  233.     }

  234.     else

  235.     {

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

  237.         return 1;

  238.     }

  239. 

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

  241.     {

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

  243.         return 1;

  244.     }

  245. 

  246.     // Get plugin

  247.     CarlaPlugin* const plugin(fEngine->getPluginUnchecked(pluginId));

  248. 

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

  250.     {

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

  252.         return 1;

  253.     }

  254. 

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

  256.     char method[32];

  257.     carla_zeroChar(method, 32);

  258.     std::strncpy(method, path + (nameSize + offset), 31);

  259. 

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

  261.     {

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

  263.         return 1;

  264.     }

  265. 

  266.     // Common OSC methods (DSSI and bridge UIs)

  267.     if (std::strcmp(method, "update") == 0)

  268.     {

  269.         const lo_address source(lo_message_get_source(msg));

  270.         return handleMsgUpdate(plugin, argc, argv, types, source);

  271.     }

  272.     if (std::strcmp(method, "configure") == 0)

  273.         return handleMsgConfigure(plugin, argc, argv, types);

  274.     if (std::strcmp(method, "control") == 0)

  275.         return handleMsgControl(plugin, argc, argv, types);

  276.     if (std::strcmp(method, "program") == 0)

  277.         return handleMsgProgram(plugin, argc, argv, types);

  278.     if (std::strcmp(method, "midi") == 0)

  279.         return handleMsgMidi(plugin, argc, argv, types);

  280.     if (std::strcmp(method, "exiting") == 0)

  281.         return handleMsgExiting(plugin);

  282. 

  283. #ifndef BUILD_BRIDGE

  284.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  299.     if (std::strcmp(method, "set_parameter_midi_cc") == 0)

  300.         return handleMsgSetParameterMidiCC(plugin, argc, argv, types);

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

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

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

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

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

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

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

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

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

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

  311. 

  312.     // Plugin Bridges

  313.     if ((plugin->getHints() & PLUGIN_IS_BRIDGE) != 0 && std::strlen(method) > 11 && std::strncmp(method, "bridge_", 7) == 0)

  314.     {

  315.         const char* const bmethod(method+7);

  316. 

  317.         if (std::strcmp(bmethod, "plugin_info1") == 0)

  318.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo1, argc, argv, types);

  319.         if (std::strcmp(bmethod, "plugin_info2") == 0)

  320.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo2, argc, argv, types);

  321.         if (std::strcmp(bmethod, "audio_count") == 0)

  322.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeAudioCount, argc, argv, types);

  323.         if (std::strcmp(bmethod, "midi_count") == 0)

  324.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiCount, argc, argv, types);

  325.         if (std::strcmp(bmethod, "parameter_count") == 0)

  326.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterCount, argc, argv, types);

  327.         if (std::strcmp(bmethod, "program_count") == 0)

  328.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeProgramCount, argc, argv, types);

  329.         if (std::strcmp(bmethod, "midi_program_count") == 0)

  330.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiProgramCount, argc, argv, types);

  331.         if (std::strcmp(bmethod, "parameter_data") == 0)

  332.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterData, argc, argv, types);

  333.         if (std::strcmp(bmethod, "parameter_ranges1") == 0)

  334.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterRanges1, argc, argv, types);

  335.         if (std::strcmp(bmethod, "parameter_ranges2") == 0)

  336.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterRanges2, argc, argv, types);

  337.         if (std::strcmp(bmethod, "parameter_midi_cc") == 0)

  338.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterMidiCC, argc, argv, types);

  339.         if (std::strcmp(bmethod, "parameter_midi_channel") == 0)

  340.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterMidiChannel, argc, argv, types);

  341.         if (std::strcmp(bmethod, "parameter_value") == 0)

  342.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterValue, argc, argv, types);

  343.         if (std::strcmp(bmethod, "default_value") == 0)

  344.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeDefaultValue, argc, argv, types);

  345.         if (std::strcmp(bmethod, "current_program") == 0)

  346.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeCurrentProgram, argc, argv, types);

  347.         if (std::strcmp(bmethod, "current_midi_program") == 0)

  348.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeCurrentMidiProgram, argc, argv, types);

  349.         if (std::strcmp(bmethod, "program_name") == 0)

  350.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeProgramName, argc, argv, types);

  351.         if (std::strcmp(bmethod, "midi_program_data") == 0)

  352.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiProgramData, argc, argv, types);

  353.         if (std::strcmp(bmethod, "configure") == 0)

  354.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeConfigure, argc, argv, types);

  355.         if (std::strcmp(bmethod, "set_custom_data") == 0)

  356.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetCustomData, argc, argv, types);

  357.         if (std::strcmp(bmethod, "set_chunk_data") == 0)

  358.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetChunkData, argc, argv, types);

  359.         if (std::strcmp(bmethod, "update_now") == 0)

  360.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeUpdateNow, argc, argv, types);

  361.         if (std::strcmp(bmethod, "error") == 0)

  362.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeError, argc, argv, types);

  363.     }

  364. #endif

  365. 

  366.     // Plugin-specific methods

  367. #ifdef WANT_LV2

  368.     if (std::strcmp(method, "lv2_atom_transfer") == 0)

  369.         return handleMsgLv2AtomTransfer(plugin, argc, argv, types);

  370.     if (std::strcmp(method, "lv2_urid_map") == 0)

  371.         return handleMsgLv2UridMap(plugin, argc, argv, types);

  372. #endif

  373. 

  374.     carla_stderr("CarlaEngineOsc::handleMessage() - unsupported OSC method '%s'", method);

  375.     return 1;

  376. }

  377. 

  378. // -----------------------------------------------------------------------

  379. 

  380. #ifndef BUILD_BRIDGE

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

  382. {

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

  384.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  385. 

  386.     if (fControlData.path != nullptr)

  387.     {

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

  389.         return 1;

  390.     }

  391. 

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

  393. 

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

  395. 

  396.     {

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

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

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

  400.     }

  401. 

  402.     {

  403.         char* host = lo_url_get_hostname(url);

  404.         char* port = lo_url_get_port(url);

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

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

  407. 

  408.         std::free(host);

  409.         std::free(port);

  410.     }

  411. 

  412.     for (unsigned int i=0, count=fEngine->getCurrentPluginCount(); i < count; ++i)

  413.     {

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

  415. 

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

  417.             plugin->registerToOscClient();

  418.     }

  419. 

  420.     return 0;

  421. }

  422. 

  423. int CarlaEngineOsc::handleMsgUnregister()

  424. {

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

  426. 

  427.     if (fControlData.path == nullptr)

  428.     {

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

  430.         return 1;

  431.     }

  432. 

  433.     fControlData.free();

  434.     return 0;

  435. }

  436. #endif

  437. 

  438. // -----------------------------------------------------------------------

  439. 

  440. int CarlaEngineOsc::handleMsgUpdate(CARLA_ENGINE_OSC_HANDLE_ARGS2, const lo_address source)

  441. {

  442.     carla_debug("CarlaEngineOsc::handleMsgUpdate()");

  443.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  444. 

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

  446. 

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

  448. 

  449.     return 0;

  450. }

  451. 

  452. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  453. {

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

  455.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  456. 

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

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

  459. 

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

  461. 

  462.     return 0;

  463. }

  464. 

  465. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  466. {

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

  468.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  469. 

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

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

  472. 

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

  474. 

  475.     return 0;

  476. }

  477. 

  478. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  479. {

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

  481. 

  482.     if (argc == 2)

  483.     {

  484.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  485. 

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

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

  488. 

  489.         CARLA_SAFE_ASSERT_INT(bank >= 0, bank);

  490.         CARLA_SAFE_ASSERT_INT(program >= 0, program);

  491. 

  492.         if (bank < 0)

  493.             return 1;

  494.         if (program < 0)

  495.             return 1;

  496. 

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

  498. 

  499.         return 0;

  500.     }

  501.     else

  502.     {

  503.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  504. 

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

  506. 

  507.         CARLA_SAFE_ASSERT_INT(program >= 0, program);

  508. 

  509.         if (program < 0)

  510.             return 1;

  511. 

  512.         if (program < static_cast<int32_t>(plugin->getProgramCount()))

  513.         {

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

  515.             return 0;

  516.         }

  517. 

  518.         carla_stderr("CarlaEngineOsc::handleMsgProgram() - programId '%i' out of bounds", program);

  519.         return 1;

  520.     }

  521. }

  522. 

  523. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  524. {

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

  526.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  527. 

  528. #ifdef BUILD_BRIDGE

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

  530.     return 1;

  531. 

  532.     // unused

  533.     (void)plugin;

  534.     (void)argv;

  535. #else

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

  537.     {

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

  539.         return 1;

  540.     }

  541. 

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

  543.     uint8_t status  = data[1];

  544.     uint8_t channel = status & 0x0F;

  545. 

  546.     // Fix bad note-off

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

  548.         status = static_cast<uint8_t>(status - 0x10);

  549. 

  550.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  551.     {

  552.         const uint8_t note = data[2];

  553. 

  554.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  555. 

  556.         if (note >= MAX_MIDI_NOTE)

  557.             return 1;

  558. 

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

  560.     }

  561.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  562.     {

  563.         const uint8_t note = data[2];

  564.         const uint8_t velo = data[3];

  565. 

  566.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  567.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  568. 

  569.         if (note >= MAX_MIDI_NOTE)

  570.             return 1;

  571.         if (velo >= MAX_MIDI_VALUE)

  572.             return 1;

  573. 

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

  575.     }

  576. 

  577.     return 0;

  578. #endif

  579. }

  580. 

  581. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  582. {

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

  584. 

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

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

  587. 

  588.     // TODO

  589.     //plugin->freeOscData();

  590. 

  591.     return 0;

  592. }

  593. 

  594. // -----------------------------------------------------------------------

  595. 

  596. #ifndef BUILD_BRIDGE

  597. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  598. {

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

  600.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  601. 

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

  603. 

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

  605. 

  606.     return 0;

  607. }

  608. 

  609. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  610. {

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

  612.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  613. 

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

  615. 

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

  617. 

  618.     return 0;

  619. }

  620. 

  621. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  622. {

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

  624.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  625. 

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

  627. 

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

  629. 

  630.     return 0;

  631. }

  632. 

  633. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  634. {

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

  636.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  637. 

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

  639. 

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

  641. 

  642.     return 0;

  643. }

  644. 

  645. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  646. {

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

  648.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  649. 

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

  651. 

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

  653. 

  654.     return 0;

  655. }

  656. 

  657. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  658. {

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

  660.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  661. 

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

  663. 

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

  665. 

  666.     return 0;

  667. }

  668. 

  669. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  670. {

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

  672.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  673. 

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

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

  676. 

  677.     CARLA_SAFE_ASSERT_INT(index >= 0, index);

  678. 

  679.     if (index < 0)

  680.         return 1;

  681. 

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

  683. 

  684.     return 0;

  685. }

  686. 

  687. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  688. {

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

  690.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  691. 

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

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

  694. 

  695.     CARLA_SAFE_ASSERT_INT(index >= 0, index);

  696.     CARLA_SAFE_ASSERT_INT(cc >= -1 && cc <= 0x5F, cc);

  697. 

  698.     if (index < 0)

  699.         return 1;

  700.     if (cc < -1 || cc > 0x5F)

  701.         return 1;

  702. 

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

  704. 

  705.     return 0;

  706. }

  707. 

  708. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  709. {

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

  711.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  712. 

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

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

  715. 

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

  717.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  718. 

  719.     if (index < 0)

  720.         return 1;

  721.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  722.         return 1;

  723. 

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

  725. 

  726.     return 0;

  727. }

  728. 

  729. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  730. {

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

  732.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  733. 

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

  735. 

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

  737. 

  738.     return 0;

  739. }

  740. 

  741. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  742. {

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

  744.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  745. 

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

  747. 

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

  749. 

  750.     return 0;

  751. }

  752. 

  753. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  754. {

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

  756.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  757. 

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

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

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

  761. 

  762.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  763.     CARLA_SAFE_ASSERT_INT(note >= 0 && note < MAX_MIDI_NOTE, note);

  764.     CARLA_SAFE_ASSERT_INT(velo >= 0 && velo < MAX_MIDI_VALUE, velo);

  765. 

  766.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  767.         return 1;

  768.     if (note < 0 || note >= MAX_MIDI_NOTE)

  769.         return 1;

  770.     if (velo < 0 || velo >= MAX_MIDI_VALUE)

  771.         return 1;

  772. 

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

  774. 

  775.     return 0;

  776. }

  777. 

  778. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  779. {

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

  781.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  782. 

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

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

  785. 

  786.     CARLA_SAFE_ASSERT_INT(channel >= 0 && channel < MAX_MIDI_CHANNELS, channel);

  787.     CARLA_SAFE_ASSERT_INT(note >= 0 && note < MAX_MIDI_NOTE, note);

  788. 

  789.     if (channel < 0 || channel >= MAX_MIDI_CHANNELS)

  790.         return 1;

  791.     if (note < 0 || note >= MAX_MIDI_NOTE)

  792.         return 1;

  793. 

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

  795. 

  796.     return 0;

  797. }

  798. #endif

  799. 

  800. CARLA_BACKEND_END_NAMESPACE