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

814 lines
26KB
Raw Blame History 

  1. /*

  2.  * Carla Engine OSC

  3.  * Copyright (C) 2012-2013 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 GPL.txt file

  16.  */

  17. 

  18. #include "CarlaEngineOsc.hpp"

  19. 

  20. #include "CarlaEngine.hpp"

  21. #include "CarlaPlugin.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. CARLA_BACKEND_START_NAMESPACE

  25. 

  26. #ifndef BUILD_BRIDGE

  27. // -------------------------------------------------------------------

  28. // Bridge Helper, defined in plugin/CarlaBlugin.cpp

  29. 

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

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

  32. #endif

  33. 

  34. // -----------------------------------------------------------------------

  35. 

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

  37.     : kEngine(engine),

  38.       fServerTCP(nullptr),

  39.       fServerUDP(nullptr)

  40. {

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

  42.     CARLA_ASSERT(engine != nullptr);

  43. }

  44. 

  45. CarlaEngineOsc::~CarlaEngineOsc()

  46. {

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

  48.     CARLA_ASSERT(fName.isEmpty());

  49.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  50.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  51.     CARLA_ASSERT(fServerTCP == nullptr);

  52.     CARLA_ASSERT(fServerUDP == nullptr);

  53. }

  54. 

  55. // -----------------------------------------------------------------------

  56. 

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

  58. {

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

  60.     CARLA_ASSERT(fName.isEmpty());

  61.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  62.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  63.     CARLA_ASSERT(fServerTCP == nullptr);

  64.     CARLA_ASSERT(fServerUDP == nullptr);

  65.     CARLA_ASSERT(name != nullptr);

  66. 

  67.     fName = name;

  68.     fName.toBasic();

  69. 

  70.     fServerTCP = lo_server_new_with_proto(nullptr, LO_TCP, osc_error_handler_TCP);

  71. 

  72.     if (fServerTCP != nullptr)

  73.     {

  74.         if (char* const tmpServerPathTCP = lo_server_get_url(fServerTCP))

  75.         {

  76.             fServerPathTCP  = tmpServerPathTCP;

  77.             fServerPathTCP += fName;

  78.             std::free(tmpServerPathTCP);

  79.         }

  80. 

  81.         lo_server_add_method(fServerTCP, nullptr, nullptr, osc_message_handler_TCP, this);

  82.     }

  83. 

  84.     fServerUDP = lo_server_new_with_proto(nullptr, LO_UDP, osc_error_handler_UDP);

  85. 

  86.     if (fServerUDP != nullptr)

  87.     {

  88.         if (char* const tmpServerPathUDP = lo_server_get_url(fServerUDP))

  89.         {

  90.             fServerPathUDP  = tmpServerPathUDP;

  91.             fServerPathUDP += fName;

  92.             std::free(tmpServerPathUDP);

  93.         }

  94. 

  95.         lo_server_add_method(fServerUDP, nullptr, nullptr, osc_message_handler_UDP, this);

  96.     }

  97. 

  98.     CARLA_ASSERT(fName.isNotEmpty());

  99.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  100.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  101.     CARLA_ASSERT(fServerTCP != nullptr);

  102.     CARLA_ASSERT(fServerUDP != nullptr);

  103. }

  104. 

  105. void CarlaEngineOsc::idle()

  106. {

  107.     if (fServerTCP != nullptr)

  108.     {

  109.         while (lo_server_recv_noblock(fServerTCP, 0) != 0) {}

  110.     }

  111. 

  112.     if (fServerUDP != nullptr)

  113.     {

  114.         while (lo_server_recv_noblock(fServerUDP, 0) != 0) {}

  115.     }

  116. }

  117. 

  118. void CarlaEngineOsc::close()

  119. {

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

  121.     CARLA_ASSERT(fName.isNotEmpty());

  122.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  123.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  124.     CARLA_ASSERT(fServerTCP != nullptr);

  125.     CARLA_ASSERT(fServerUDP != nullptr);

  126. 

  127.     fName.clear();

  128. 

  129.     if (fServerTCP != nullptr)

  130.     {

  131.         lo_server_del_method(fServerTCP, nullptr, nullptr);

  132.         lo_server_free(fServerTCP);

  133.         fServerTCP = nullptr;

  134.     }

  135. 

  136.     if (fServerUDP != nullptr)

  137.     {

  138.         lo_server_del_method(fServerUDP, nullptr, nullptr);

  139.         lo_server_free(fServerUDP);

  140.         fServerUDP = nullptr;

  141.     }

  142. 

  143.     fServerPathTCP.clear();

  144.     fServerPathUDP.clear();

  145. 

  146. #ifndef BUILD_BRIDGE

  147.     fControlData.free();

  148. #endif

  149. 

  150.     CARLA_ASSERT(fName.isEmpty());

  151.     CARLA_ASSERT(fServerPathTCP.isEmpty());

  152.     CARLA_ASSERT(fServerPathUDP.isEmpty());

  153.     CARLA_ASSERT(fServerTCP == nullptr);

  154.     CARLA_ASSERT(fServerUDP == nullptr);

  155. }

  156. 

  157. // -----------------------------------------------------------------------

  158. 

  159. bool isDigit(const char c)

  160. {

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

  162. }

  163. 

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

  165. {

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

  167.     CARLA_ASSERT(fName.isNotEmpty());

  168.     CARLA_ASSERT(fServerPathTCP.isNotEmpty());

  169.     CARLA_ASSERT(fServerPathUDP.isNotEmpty());

  170.     CARLA_ASSERT(fServerTCP != nullptr);

  171.     CARLA_ASSERT(fServerUDP != nullptr);

  172.     CARLA_ASSERT(path != nullptr);

  173. 

  174.     if (path == nullptr)

  175.     {

  176.         carla_stderr("CarlaEngineOsc::handleMessage() - got invalid path");

  177.         return 1;

  178.     }

  179. 

  180.     if (fName.isEmpty())

  181.     {

  182.         carla_stderr("CarlaEngineOsc::handleMessage(%s, \"%s\", ...) - received message but client is offline", bool2str(isTCP), path);

  183.         return 1;

  184.     }

  185. 

  186. #ifndef BUILD_BRIDGE

  187.     // Initial path check

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

  189.     {

  190.         const lo_address source = lo_message_get_source(msg);

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

  192.     }

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

  194.     {

  195.         return handleMsgUnregister();

  196.     }

  197. #endif

  198. 

  199.     const size_t nameSize = fName.length();

  200. 

  201.     // Check if message is for this client

  202.     if (std::strlen(path) <= nameSize || std::strncmp(path+1, (const char*)fName, nameSize) != 0)

  203.     {

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

  205.         return 1;

  206.     }

  207. 

  208.     // Get plugin id from message

  209.     // eg, /carla/23/method

  210. 

  211.     unsigned int pluginId = 0;

  212.     size_t offset;

  213. 

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

  215.     {

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

  217.         {

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

  219.             {

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

  221.                 return 1;

  222.             }

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

  224.             {

  225.                 // 3 digits, /xyz/method

  226.                 offset    = 6;

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

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

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

  230.             }

  231.             else

  232.             {

  233.                 // 2 digits, /xy/method

  234.                 offset    = 5;

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

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

  237.             }

  238.         }

  239.         else

  240.         {

  241.             // single digit, /x/method

  242.             offset    = 4;

  243.             pluginId += path[nameSize+2]-'0';

  244.         }

  245.     }

  246.     else

  247.     {

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

  249.         return 1;

  250.     }

  251. 

  252.     if (pluginId > kEngine->currentPluginCount())

  253.     {

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

  255.         return 1;

  256.     }

  257. 

  258.     // Get plugin

  259.     CarlaPlugin* const plugin = kEngine->getPluginUnchecked(pluginId);

  260. 

  261.     if (plugin == nullptr || plugin->id() != pluginId)

  262.     {

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

  264.         return 1;

  265.     }

  266. 

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

  268.     char method[32] = { 0 };

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

  270. 

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

  272.     {

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

  274.         return 1;

  275.     }

  276. 

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

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

  279.     {

  280.         const lo_address source = lo_message_get_source(msg);

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

  282.     }

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

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

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

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

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

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

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

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

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

  292.         return handleMsgExiting(plugin);

  293. 

  294. #ifndef BUILD_BRIDGE

  295.     // Internal methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  322. 

  323.     // Plugin Bridges

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

  325.     {

  326.         if (std::strcmp(method+7, "set_peaks") == 0)

  327.             return handleMsgBridgeSetPeaks(plugin, argc, argv, types);

  328.         if (std::strcmp(method+7, "audio_count") == 0)

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

  330.         if (std::strcmp(method+7, "midi_count") == 0)

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

  332.         if (std::strcmp(method+7, "parameter_count") == 0)

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

  334.         if (std::strcmp(method+7, "program_count") == 0)

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

  336.         if (std::strcmp(method+7, "midi_program_count") == 0)

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

  338.         if (std::strcmp(method+7, "plugin_info") == 0)

  339.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgePluginInfo, argc, argv, types);

  340.         if (std::strcmp(method+7, "parameter_info") == 0)

  341.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterInfo, argc, argv, types);

  342.         if (std::strcmp(method+7, "parameter_data") == 0)

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

  344.         if (std::strcmp(method+7, "parameter_ranges") == 0)

  345.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeParameterRanges, argc, argv, types);

  346.         if (std::strcmp(method+7, "program_info") == 0)

  347.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeProgramInfo, argc, argv, types);

  348.         if (std::strcmp(method+7, "midi_program_info") == 0)

  349.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeMidiProgramInfo, argc, argv, types);

  350.         if (std::strcmp(method+7, "configure") == 0)

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

  352.         if (std::strcmp(method+7, "set_parameter_value") == 0)

  353.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetParameterValue, argc, argv, types);

  354.         if (std::strcmp(method+7, "set_default_value") == 0)

  355.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetDefaultValue, argc, argv, types);

  356.         if (std::strcmp(method+7, "set_program") == 0)

  357.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetProgram, argc, argv, types);

  358.         if (std::strcmp(method+7, "set_midi_program") == 0)

  359.             return CarlaPluginSetOscBridgeInfo(plugin, kPluginBridgeSetMidiProgram, argc, argv, types);

  360.         if (std::strcmp(method+7, "set_custom_data") == 0)

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

  362.         if (std::strcmp(method+7, "set_chunk_data") == 0)

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

  364.         if (std::strcmp(method+7, "update") == 0)

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

  366.         if (std::strcmp(method+7, "error") == 0)

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

  368.     }

  369. #endif

  370. 

  371.     // Plugin-specific methods, FIXME

  372. #if 0 //def WANT_LV2

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

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

  375.     if (std::strcmp(method, "lv2_event_transfer") == 0)

  376.         return handleMsgLv2EventTransfer(plugin, argc, argv, types);

  377. #endif

  378. 

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

  380.     return 1;

  381. }

  382. 

  383. // -----------------------------------------------------------------------

  384. 

  385. #ifndef BUILD_BRIDGE

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

  387. {

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

  389.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  390. 

  391.     if (fControlData.path != nullptr)

  392.     {

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

  394.         return 1;

  395.     }

  396. 

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

  398. 

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

  400. 

  401.     {

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

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

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

  405.     }

  406. 

  407.     {

  408.         char* host = lo_url_get_hostname(url);

  409.         char* port = lo_url_get_port(url);

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

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

  412. 

  413.         std::free(host);

  414.         std::free(port);

  415.     }

  416. 

  417.     for (unsigned short i=0; i < kEngine->currentPluginCount(); i++)

  418.     {

  419.         CarlaPlugin* const plugin = kEngine->getPluginUnchecked(i);

  420. 

  421.         if (plugin && plugin->enabled())

  422.             plugin->registerToOscClient();

  423.     }

  424. 

  425.     return 0;

  426. }

  427. 

  428. int CarlaEngineOsc::handleMsgUnregister()

  429. {

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

  431. 

  432.     if (fControlData.path == nullptr)

  433.     {

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

  435.         return 1;

  436.     }

  437. 

  438.     fControlData.free();

  439.     return 0;

  440. }

  441. #endif

  442. 

  443. // -----------------------------------------------------------------------

  444. 

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

  446. {

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

  448.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "s");

  449. 

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

  451. 

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

  453. 

  454.     return 0;

  455. }

  456. 

  457. int CarlaEngineOsc::handleMsgConfigure(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  458. {

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

  460.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ss");

  461. 

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

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

  464. 

  465.     plugin->setCustomData(CUSTOM_DATA_STRING, key, value, false);

  466. 

  467.     return 0;

  468. }

  469. 

  470. int CarlaEngineOsc::handleMsgControl(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  471. {

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

  473.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  474. 

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

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

  477. 

  478.     plugin->setParameterValueByRIndex(rindex, value, false, true, true);

  479. 

  480.     return 0;

  481. }

  482. 

  483. int CarlaEngineOsc::handleMsgProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  484. {

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

  486. 

  487.     if (argc == 2)

  488.     {

  489.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  490. 

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

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

  493. 

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

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

  496. 

  497.         if (bank < 0)

  498.             return 1;

  499.         if (program < 0)

  500.             return 1;

  501. 

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

  503. 

  504.         return 0;

  505.     }

  506.     else

  507.     {

  508.         CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  509. 

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

  511. 

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

  513. 

  514.         if (program < 0)

  515.             return 1;

  516. 

  517.         if (program < static_cast<int32_t>(plugin->programCount()))

  518.         {

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

  520.             return 0;

  521.         }

  522. 

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

  524.         return 1;

  525.     }

  526. }

  527. 

  528. int CarlaEngineOsc::handleMsgMidi(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  529. {

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

  531.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "m");

  532. 

  533.     if (plugin->midiInCount() == 0)

  534.     {

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

  536.         return 1;

  537.     }

  538. 

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

  540.     uint8_t status  = data[1];

  541.     uint8_t channel = status & 0x0F;

  542. 

  543.     // Fix bad note-off

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

  545.         status -= 0x10;

  546. 

  547.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  548.     {

  549.         const uint8_t note = data[2];

  550. 

  551.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  552. 

  553.         if (note >= MAX_MIDI_NOTE)

  554.             return 1;

  555. 

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

  557.     }

  558.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  559.     {

  560.         const uint8_t note = data[2];

  561.         const uint8_t velo = data[3];

  562. 

  563.         CARLA_SAFE_ASSERT_INT(note < MAX_MIDI_NOTE, note);

  564.         CARLA_SAFE_ASSERT_INT(velo < MAX_MIDI_VALUE, velo);

  565. 

  566.         if (note >= MAX_MIDI_NOTE)

  567.             return 1;

  568.         if (velo >= MAX_MIDI_VALUE)

  569.             return 1;

  570. 

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

  572.     }

  573. 

  574.     return 0;

  575. }

  576. 

  577. int CarlaEngineOsc::handleMsgExiting(CARLA_ENGINE_OSC_HANDLE_ARGS1)

  578. {

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

  580. 

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

  582.     kEngine->callback(CALLBACK_SHOW_GUI, plugin->id(), 0, 0, 0.0f, nullptr);

  583. 

  584.     plugin->freeOscData();

  585. 

  586.     return 0;

  587. }

  588. 

  589. // -----------------------------------------------------------------------

  590. 

  591. #ifndef BUILD_BRIDGE

  592. int CarlaEngineOsc::handleMsgSetActive(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  593. {

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

  595.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  596. 

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

  598. 

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

  600. 

  601.     return 0;

  602. }

  603. 

  604. int CarlaEngineOsc::handleMsgSetDryWet(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  605. {

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

  607.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  608. 

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

  610. 

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

  612. 

  613.     return 0;

  614. }

  615. 

  616. int CarlaEngineOsc::handleMsgSetVolume(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  617. {

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

  619.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  620. 

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

  622. 

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

  624. 

  625.     return 0;

  626. }

  627. 

  628. int CarlaEngineOsc::handleMsgSetBalanceLeft(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  629. {

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

  631.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  632. 

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

  634. 

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

  636. 

  637.     return 0;

  638. }

  639. 

  640. int CarlaEngineOsc::handleMsgSetBalanceRight(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  641. {

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

  643.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  644. 

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

  646. 

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

  648. 

  649.     return 0;

  650. }

  651. 

  652. int CarlaEngineOsc::handleMsgSetPanning(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  653. {

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

  655.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "f");

  656. 

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

  658. 

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

  660. 

  661.     return 0;

  662. }

  663. 

  664. int CarlaEngineOsc::handleMsgSetParameterValue(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  665. {

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

  667.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "if");

  668. 

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

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

  671. 

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

  673. 

  674.     if (index < 0)

  675.         return 1;

  676. 

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

  678. 

  679.     return 0;

  680. }

  681. 

  682. int CarlaEngineOsc::handleMsgSetParameterMidiCC(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  683. {

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

  685.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  686. 

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

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

  689. 

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

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

  692. 

  693.     if (index < 0)

  694.         return 1;

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

  696.         return 1;

  697. 

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

  699. 

  700.     return 0;

  701. }

  702. 

  703. int CarlaEngineOsc::handleMsgSetParameterMidiChannel(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  704. {

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

  706.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  707. 

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

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

  710. 

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

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

  713. 

  714.     if (index < 0)

  715.         return 1;

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

  717.         return 1;

  718. 

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

  720. 

  721.     return 0;

  722. }

  723. 

  724. int CarlaEngineOsc::handleMsgSetProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  725. {

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

  727.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  728. 

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

  730. 

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

  732. 

  733.     return 0;

  734. }

  735. 

  736. int CarlaEngineOsc::handleMsgSetMidiProgram(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  737. {

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

  739.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(1, "i");

  740. 

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

  742. 

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

  744. 

  745.     return 0;

  746. }

  747. 

  748. int CarlaEngineOsc::handleMsgNoteOn(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  749. {

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

  751.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(3, "iii");

  752. 

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

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

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

  756. 

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

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

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

  760. 

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

  762.         return 1;

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

  764.         return 1;

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

  766.         return 1;

  767. 

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

  769. 

  770.     return 0;

  771. }

  772. 

  773. int CarlaEngineOsc::handleMsgNoteOff(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  774. {

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

  776.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(2, "ii");

  777. 

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

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

  780. 

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

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

  783. 

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

  785.         return 1;

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

  787.         return 1;

  788. 

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

  790. 

  791.     return 0;

  792. }

  793. 

  794. // FIXME - remove once IPC audio is implemented

  795. int CarlaEngineOsc::handleMsgBridgeSetPeaks(CARLA_ENGINE_OSC_HANDLE_ARGS2)

  796. {

  797.     CARLA_ENGINE_OSC_CHECK_OSC_TYPES(4, "ffff");

  798. 

  799.     const float in1  = argv[0]->f;

  800.     const float in2  = argv[1]->f;

  801.     const float out1 = argv[2]->f;

  802.     const float out2 = argv[3]->f;

  803. 

  804.     float const inPeaks[CarlaEngine::MAX_PEAKS] = { in1, in2 };

  805.     float const outPeaks[CarlaEngine::MAX_PEAKS] = { out1, out2 };

  806. 

  807.     kEngine->setPeaks(plugin->id(), inPeaks, outPeaks);

  808. 

  809.     return 0;

  810. }

  811. #endif

  812. 

  813. CARLA_BACKEND_END_NAMESPACE