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

704 lines
38KB
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 "CarlaBackendUtils.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. #include "CarlaMIDI.h"

  21. 

  22. CARLA_BACKEND_START_NAMESPACE

  23. 

  24. // -----------------------------------------------------------------------

  25. 

  26. #ifdef BUILD_BRIDGE

  27. void CarlaEngine::oscSend_bridge_plugin_info1(const PluginCategory category, const uint hints, const int64_t uniqueId) const noexcept

  28. {

  29.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  30.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  31.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  32.     carla_debug("CarlaEngine::oscSend_bridge_plugin_info1(%i:%s, %X, " P_INT64 ")", category, PluginCategory2Str(category), hints, uniqueId);

  33. 

  34.     char targetPath[std::strlen(pData->oscData->path)+21];

  35.     std::strcpy(targetPath, pData->oscData->path);

  36.     std::strcat(targetPath, "/bridge_plugin_info1");

  37.     try_lo_send(pData->oscData->target, targetPath, "iih", static_cast<int32_t>(category), static_cast<int32_t>(hints), uniqueId);

  38. }

  39. 

  40. void CarlaEngine::oscSend_bridge_plugin_info2(const char* const realName, const char* const label, const char* const maker, const char* const copyright) const noexcept

  41. {

  42.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  43.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  44.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  45.     CARLA_SAFE_ASSERT_RETURN(realName != nullptr && realName[0] != '\0',);

  46.     CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0',);

  47.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  48.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

  49.     carla_debug("CarlaEngine::oscSend_bridge_plugin_info2(\"%s\", \"%s\", \"%s\", \"%s\")", realName, label, maker, copyright);

  50. 

  51.     char targetPath[std::strlen(pData->oscData->path)+21];

  52.     std::strcpy(targetPath, pData->oscData->path);

  53.     std::strcat(targetPath, "/bridge_plugin_info2");

  54.     try_lo_send(pData->oscData->target, targetPath, "ssss", realName, label, maker, copyright);

  55. }

  56. 

  57. void CarlaEngine::oscSend_bridge_audio_count(const uint32_t ins, const uint32_t outs) const noexcept

  58. {

  59.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  60.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  61.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  62.     carla_debug("CarlaEngine::oscSend_bridge_audio_count(%i, %i)", ins, outs);

  63. 

  64.     char targetPath[std::strlen(pData->oscData->path)+20];

  65.     std::strcpy(targetPath, pData->oscData->path);

  66.     std::strcat(targetPath, "/bridge_audio_count");

  67.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  68. }

  69. 

  70. void CarlaEngine::oscSend_bridge_midi_count(const uint32_t ins, const uint32_t outs) const noexcept

  71. {

  72.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  73.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  74.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  75.     carla_debug("CarlaEngine::oscSend_bridge_midi_count(%i, %i)", ins, outs);

  76. 

  77.     char targetPath[std::strlen(pData->oscData->path)+19];

  78.     std::strcpy(targetPath, pData->oscData->path);

  79.     std::strcat(targetPath, "/bridge_midi_count");

  80.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  81. }

  82. 

  83. void CarlaEngine::oscSend_bridge_parameter_count(const uint32_t ins, const uint32_t outs) const noexcept

  84. {

  85.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  86.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  87.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  88.     carla_debug("CarlaEngine::oscSend_bridge_parameter_count(%i, %i)", ins, outs);

  89. 

  90.     char targetPath[std::strlen(pData->oscData->path)+24];

  91.     std::strcpy(targetPath, pData->oscData->path);

  92.     std::strcat(targetPath, "/bridge_parameter_count");

  93.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  94. }

  95. 

  96. void CarlaEngine::oscSend_bridge_program_count(const uint32_t count) const noexcept

  97. {

  98.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  99.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  100.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  101.     carla_debug("CarlaEngine::oscSend_bridge_program_count(%i)", count);

  102. 

  103.     char targetPath[std::strlen(pData->oscData->path)+23];

  104.     std::strcpy(targetPath, pData->oscData->path);

  105.     std::strcat(targetPath, "/bridge_program_count");

  106.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(count));

  107. }

  108. 

  109. void CarlaEngine::oscSend_bridge_midi_program_count(const uint32_t count) const noexcept

  110. {

  111.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  112.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  113.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  114.     carla_debug("CarlaEngine::oscSend_bridge_midi_program_count(%i)", count);

  115. 

  116.     char targetPath[std::strlen(pData->oscData->path)+27];

  117.     std::strcpy(targetPath, pData->oscData->path);

  118.     std::strcat(targetPath, "/bridge_midi_program_count");

  119.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(count));

  120. }

  121. 

  122. void CarlaEngine::oscSend_bridge_parameter_data(const uint32_t index, const int32_t rindex, const ParameterType type, const uint hints, const char* const name, const char* const unit) const noexcept

  123. {

  124.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  125.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  126.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  127.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  128.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

  129.     carla_debug("CarlaEngine::oscSend_bridge_parameter_data(%i, %i, %i:%s, %X, \"%s\", \"%s\")", index, rindex, type, ParameterType2Str(type), hints, name, unit);

  130. 

  131.     char targetPath[std::strlen(pData->oscData->path)+24];

  132.     std::strcpy(targetPath, pData->oscData->path);

  133.     std::strcat(targetPath, "/bridge_parameter_data");

  134.     try_lo_send(pData->oscData->target, targetPath, "iiiiss", static_cast<int32_t>(index), static_cast<int32_t>(rindex), static_cast<int32_t>(type), static_cast<int32_t>(hints), name, unit);

  135. }

  136. 

  137. void CarlaEngine::oscSend_bridge_parameter_ranges1(const uint32_t index, const float def, const float min, const float max) const noexcept

  138. {

  139.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  140.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  141.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  142.     carla_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f)", index, def, min, max);

  143. 

  144.     char targetPath[std::strlen(pData->oscData->path)+26];

  145.     std::strcpy(targetPath, pData->oscData->path);

  146.     std::strcat(targetPath, "/bridge_parameter_ranges1");

  147.     try_lo_send(pData->oscData->target, targetPath, "ifff", static_cast<int32_t>(index), def, min, max);

  148. }

  149. 

  150. void CarlaEngine::oscSend_bridge_parameter_ranges2(const uint32_t index, const float step, const float stepSmall, const float stepLarge) const noexcept

  151. {

  152.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  153.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  154.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  155.     carla_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f)", index, step, stepSmall, stepLarge);

  156. 

  157.     char targetPath[std::strlen(pData->oscData->path)+26];

  158.     std::strcpy(targetPath, pData->oscData->path);

  159.     std::strcat(targetPath, "/bridge_parameter_ranges2");

  160.     try_lo_send(pData->oscData->target, targetPath, "ifff", static_cast<int32_t>(index), step, stepSmall, stepLarge);

  161. }

  162. 

  163. void CarlaEngine::oscSend_bridge_parameter_midi_cc(const uint32_t index, const int16_t cc) const noexcept

  164. {

  165.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  166.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  167.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  168.     carla_debug("CarlaEngine::oscSend_bridge_parameter_midi_cc(%i, %i)", index, cc);

  169. 

  170.     char targetPath[std::strlen(pData->oscData->path)+26];

  171.     std::strcpy(targetPath, pData->oscData->path);

  172.     std::strcat(targetPath, "/bridge_parameter_midi_cc");

  173.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(index), static_cast<int32_t>(cc));

  174. }

  175. 

  176. void CarlaEngine::oscSend_bridge_parameter_midi_channel(const uint32_t index, const uint8_t channel) const noexcept

  177. {

  178.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  179.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  180.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  181.     carla_debug("CarlaEngine::oscSend_bridge_parameter_midi_channel(%i, %i)", index, channel);

  182. 

  183.     char targetPath[std::strlen(pData->oscData->path)+31];

  184.     std::strcpy(targetPath, pData->oscData->path);

  185.     std::strcat(targetPath, "/bridge_parameter_midi_channel");

  186.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(index), static_cast<int32_t>(channel));

  187. }

  188. 

  189. void CarlaEngine::oscSend_bridge_parameter_value(const uint32_t index, const float value) const noexcept

  190. {

  191.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  192.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  193.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  194.     carla_debug("CarlaEngine::oscSend_bridge_parameter_value(%i, %f)", index, value);

  195. 

  196.     char targetPath[std::strlen(pData->oscData->path)+24];

  197.     std::strcpy(targetPath, pData->oscData->path);

  198.     std::strcat(targetPath, "/bridge_parameter_value");

  199.     try_lo_send(pData->oscData->target, targetPath, "if", static_cast<int32_t>(index), value);

  200. }

  201. 

  202. void CarlaEngine::oscSend_bridge_default_value(const uint32_t index, const float value) const noexcept

  203. {

  204.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  205.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  206.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  207.     carla_debug("CarlaEngine::oscSend_bridge_default_value(%i, %f)", index, value);

  208. 

  209.     char targetPath[std::strlen(pData->oscData->path)+22];

  210.     std::strcpy(targetPath, pData->oscData->path);

  211.     std::strcat(targetPath, "/bridge_default_value");

  212.     try_lo_send(pData->oscData->target, targetPath, "if", static_cast<int32_t>(index), value);

  213. }

  214. 

  215. void CarlaEngine::oscSend_bridge_current_program(const int32_t index) const noexcept

  216. {

  217.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  218.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  219.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  220.     carla_debug("CarlaEngine::oscSend_bridge_current_program(%i)", index);

  221. 

  222.     char targetPath[std::strlen(pData->oscData->path)+24];

  223.     std::strcpy(targetPath, pData->oscData->path);

  224.     std::strcat(targetPath, "/bridge_current_program");

  225.     try_lo_send(pData->oscData->target, targetPath, "i", index);

  226. }

  227. 

  228. void CarlaEngine::oscSend_bridge_current_midi_program(const int32_t index) const noexcept

  229. {

  230.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  231.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  232.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  233.     carla_debug("CarlaEngine::oscSend_bridge_current_midi_program(%i)", index);

  234. 

  235.     char targetPath[std::strlen(pData->oscData->path)+30];

  236.     std::strcpy(targetPath, pData->oscData->path);

  237.     std::strcat(targetPath, "/bridge_current_midi_program");

  238.     try_lo_send(pData->oscData->target, targetPath, "i", index);

  239. }

  240. 

  241. void CarlaEngine::oscSend_bridge_program_name(const uint32_t index, const char* const name) const noexcept

  242. {

  243.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  244.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  245.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  246.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  247.     carla_debug("CarlaEngine::oscSend_bridge_program_name(%i, \"%s\")", index, name);

  248. 

  249.     char targetPath[std::strlen(pData->oscData->path)+21];

  250.     std::strcpy(targetPath, pData->oscData->path);

  251.     std::strcat(targetPath, "/bridge_program_name");

  252.     try_lo_send(pData->oscData->target, targetPath, "is", static_cast<int32_t>(index), name);

  253. }

  254. 

  255. void CarlaEngine::oscSend_bridge_midi_program_data(const uint32_t index, const uint32_t bank, const uint32_t program, const char* const name) const noexcept

  256. {

  257.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  258.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  259.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  260.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  261.     carla_debug("CarlaEngine::oscSend_bridge_midi_program_data(%i, %i, %i, \"%s\")", index, bank, program, name);

  262. 

  263.     char targetPath[std::strlen(pData->oscData->path)+26];

  264.     std::strcpy(targetPath, pData->oscData->path);

  265.     std::strcat(targetPath, "/bridge_midi_program_data");

  266.     try_lo_send(pData->oscData->target, targetPath, "iiis", static_cast<int32_t>(index), static_cast<int32_t>(bank), static_cast<int32_t>(program), name);

  267. }

  268. 

  269. void CarlaEngine::oscSend_bridge_configure(const char* const key, const char* const value) const noexcept

  270. {

  271.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  272.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  273.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  274.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  275.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  276.     carla_debug("CarlaEngine::oscSend_bridge_configure(\"%s\", \"%s\")", key, value);

  277. 

  278.     char targetPath[std::strlen(pData->oscData->path)+18];

  279.     std::strcpy(targetPath, pData->oscData->path);

  280.     std::strcat(targetPath, "/bridge_configure");

  281.     try_lo_send(pData->oscData->target, targetPath, "ss", key, value);

  282. }

  283. 

  284. void CarlaEngine::oscSend_bridge_set_custom_data(const char* const type, const char* const key, const char* const value) const noexcept

  285. {

  286.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  287.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  288.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  289.     CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  290.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  291.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  292.     carla_debug("CarlaEngine::oscSend_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  293. 

  294.     char targetPath[std::strlen(pData->oscData->path)+24];

  295.     std::strcpy(targetPath, pData->oscData->path);

  296.     std::strcat(targetPath, "/bridge_set_custom_data");

  297.     try_lo_send(pData->oscData->target, targetPath, "sss", type, key, value);

  298. }

  299. 

  300. void CarlaEngine::oscSend_bridge_set_chunk_data(const char* const chunkFile) const noexcept

  301. {

  302.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  303.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  304.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  305.     CARLA_SAFE_ASSERT_RETURN(chunkFile != nullptr && chunkFile[0] != '\0',);

  306.     carla_debug("CarlaEngine::oscSend_bridge_set_chunk_data(\"%s\")", chunkFile);

  307. 

  308.     char targetPath[std::strlen(pData->oscData->path)+23];

  309.     std::strcpy(targetPath, pData->oscData->path);

  310.     std::strcat(targetPath, "/bridge_set_chunk_data");

  311.     try_lo_send(pData->oscData->target, targetPath, "s", chunkFile);

  312. }

  313. 

  314. void CarlaEngine::oscSend_bridge_pong() const noexcept

  315. {

  316.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  317.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  318.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  319.     //carla_debug("CarlaEngine::oscSend_pong()");

  320. 

  321.     char targetPath[std::strlen(pData->oscData->path)+13];

  322.     std::strcpy(targetPath, pData->oscData->path);

  323.     std::strcat(targetPath, "/bridge_pong");

  324.     try_lo_send(pData->oscData->target, targetPath, "");

  325. }

  326. #else

  327. void CarlaEngine::oscSend_control_add_plugin_start(const uint pluginId, const char* const pluginName) const noexcept

  328. {

  329.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  330.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  331.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  332.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  333.     CARLA_SAFE_ASSERT_RETURN(pluginName != nullptr && pluginName[0] != '\0',);

  334.     carla_debug("CarlaEngine::oscSend_control_add_plugin_start(%i, \"%s\")", pluginId, pluginName);

  335. 

  336.     char targetPath[std::strlen(pData->oscData->path)+18];

  337.     std::strcpy(targetPath, pData->oscData->path);

  338.     std::strcat(targetPath, "/add_plugin_start");

  339.     try_lo_send(pData->oscData->target, targetPath, "is", static_cast<int32_t>(pluginId), pluginName);

  340. }

  341. 

  342. void CarlaEngine::oscSend_control_add_plugin_end(const uint pluginId) const noexcept

  343. {

  344.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  345.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  346.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  347.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  348.     carla_debug("CarlaEngine::oscSend_control_add_plugin_end(%i)", pluginId);

  349. 

  350.     char targetPath[std::strlen(pData->oscData->path)+16];

  351.     std::strcpy(targetPath, pData->oscData->path);

  352.     std::strcat(targetPath, "/add_plugin_end");

  353.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(pluginId));

  354. }

  355. 

  356. void CarlaEngine::oscSend_control_remove_plugin(const uint pluginId) const noexcept

  357. {

  358.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  359.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  360.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  361.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  362.     carla_debug("CarlaEngine::oscSend_control_remove_plugin(%i)", pluginId);

  363. 

  364.     char targetPath[std::strlen(pData->oscData->path)+15];

  365.     std::strcpy(targetPath, pData->oscData->path);

  366.     std::strcat(targetPath, "/remove_plugin");

  367.     try_lo_send(pData->oscData->target, targetPath, "i", static_cast<int32_t>(pluginId));

  368. }

  369. 

  370. void CarlaEngine::oscSend_control_set_plugin_info1(const uint pluginId, const PluginType type, const PluginCategory category, const uint hints, const int64_t uniqueId) const noexcept

  371. {

  372.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  373.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  374.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  375.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  376.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

  377.     carla_debug("CarlaEngine::oscSend_control_set_plugin_data(%i, %i:%s, %i:%s, %X, " P_INT64 ")", pluginId, type, PluginType2Str(type), category, PluginCategory2Str(category), hints, uniqueId);

  378. 

  379.     char targetPath[std::strlen(pData->oscData->path)+18];

  380.     std::strcpy(targetPath, pData->oscData->path);

  381.     std::strcat(targetPath, "/set_plugin_info1");

  382.     try_lo_send(pData->oscData->target, targetPath, "iiiih", static_cast<int32_t>(pluginId), static_cast<int32_t>(type), static_cast<int32_t>(category), static_cast<int32_t>(hints), static_cast<int64_t>(uniqueId));

  383. }

  384. 

  385. void CarlaEngine::oscSend_control_set_plugin_info2(const uint pluginId, const char* const realName, const char* const label, const char* const maker, const char* const copyright) const noexcept

  386. {

  387.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  388.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  389.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  390.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  391.     CARLA_SAFE_ASSERT_RETURN(realName != nullptr && realName[0] != '\0',);

  392.     CARLA_SAFE_ASSERT_RETURN(label != nullptr && label[0] != '\0',);

  393.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  394.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

  395.     carla_debug("CarlaEngine::oscSend_control_set_plugin_data(%i, \"%s\", \"%s\", \"%s\", \"%s\")", pluginId, realName, label, maker, copyright);

  396. 

  397.     char targetPath[std::strlen(pData->oscData->path)+18];

  398.     std::strcpy(targetPath, pData->oscData->path);

  399.     std::strcat(targetPath, "/set_plugin_info2");

  400.     try_lo_send(pData->oscData->target, targetPath, "issss", static_cast<int32_t>(pluginId), realName, label, maker, copyright);

  401. }

  402. 

  403. void CarlaEngine::oscSend_control_set_audio_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  404. {

  405.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  406.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  407.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  408.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  409.     carla_debug("CarlaEngine::oscSend_control_set_audio_count(%i, %i, %i)", pluginId, ins, outs);

  410. 

  411.     char targetPath[std::strlen(pData->oscData->path)+18];

  412.     std::strcpy(targetPath, pData->oscData->path);

  413.     std::strcat(targetPath, "/set_audio_count");

  414.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  415. }

  416. 

  417. void CarlaEngine::oscSend_control_set_midi_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  418. {

  419.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  420.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  421.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  422.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  423.     carla_debug("CarlaEngine::oscSend_control_set_midi_count(%i, %i, %i)", pluginId, ins, outs);

  424. 

  425.     char targetPath[std::strlen(pData->oscData->path)+18];

  426.     std::strcpy(targetPath, pData->oscData->path);

  427.     std::strcat(targetPath, "/set_midi_count");

  428.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  429. }

  430. 

  431. void CarlaEngine::oscSend_control_set_parameter_count(const uint pluginId, const uint32_t ins, const uint32_t outs) const noexcept

  432. {

  433.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  434.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  435.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  436.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  437.     carla_debug("CarlaEngine::oscSend_control_set_parameter_count(%i, %i, %i)", pluginId, ins, outs);

  438. 

  439.     char targetPath[std::strlen(pData->oscData->path)+18];

  440.     std::strcpy(targetPath, pData->oscData->path);

  441.     std::strcat(targetPath, "/set_parameter_count");

  442.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(ins), static_cast<int32_t>(outs));

  443. }

  444. 

  445. void CarlaEngine::oscSend_control_set_program_count(const uint pluginId, const uint32_t count) const noexcept

  446. {

  447.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  448.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  449.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  450.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  451.     carla_debug("CarlaEngine::oscSend_control_set_program_count(%i, %i)", pluginId, count);

  452. 

  453.     char targetPath[std::strlen(pData->oscData->path)+19];

  454.     std::strcpy(targetPath, pData->oscData->path);

  455.     std::strcat(targetPath, "/set_program_count");

  456.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  457. }

  458. 

  459. void CarlaEngine::oscSend_control_set_midi_program_count(const uint pluginId, const uint32_t count) const noexcept

  460. {

  461.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  462.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  463.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  464.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  465.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_count(%i, %i)", pluginId, count);

  466. 

  467.     char targetPath[std::strlen(pData->oscData->path)+24];

  468.     std::strcpy(targetPath, pData->oscData->path);

  469.     std::strcat(targetPath, "/set_midi_program_count");

  470.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  471. }

  472. 

  473. void CarlaEngine::oscSend_control_set_parameter_data(const uint pluginId, const uint32_t index, const ParameterType type, const uint hints, const char* const name, const char* const unit) const noexcept

  474. {

  475.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  476.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  477.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  478.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

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

  480.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

  481.     carla_debug("CarlaEngine::oscSend_control_set_parameter_data(%i, %i, %i:%s, %X, \"%s\", \"%s\")", pluginId, index, type, ParameterType2Str(type), hints, name, unit);

  482. 

  483.     char targetPath[std::strlen(pData->oscData->path)+20];

  484.     std::strcpy(targetPath, pData->oscData->path);

  485.     std::strcat(targetPath, "/set_parameter_data");

  486.     try_lo_send(pData->oscData->target, targetPath, "iiiiss", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(type), static_cast<int32_t>(hints), name, unit);

  487. }

  488. 

  489. void CarlaEngine::oscSend_control_set_parameter_ranges1(const uint pluginId, const uint32_t index, const float def, const float min, const float max) const noexcept

  490. {

  491.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  492.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  493.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  494.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  495.     CARLA_SAFE_ASSERT_RETURN(def <= min && def >= max,);

  496.     CARLA_SAFE_ASSERT_RETURN(min < max,);

  497.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges1(%i, %i, %f, %f, %f)", pluginId, index, def, min, max, def);

  498. 

  499.     char targetPath[std::strlen(pData->oscData->path)+23];

  500.     std::strcpy(targetPath, pData->oscData->path);

  501.     std::strcat(targetPath, "/set_parameter_ranges1");

  502.     try_lo_send(pData->oscData->target, targetPath, "iifff", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), def, min, max);

  503. }

  504. 

  505. void CarlaEngine::oscSend_control_set_parameter_ranges2(const uint pluginId, const uint32_t index, const float step, const float stepSmall, const float stepLarge) const noexcept

  506. {

  507.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  508.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  509.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  510.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  511.     CARLA_SAFE_ASSERT_RETURN(step <= stepSmall && step >= stepLarge,);

  512.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

  513.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges2(%i, %i, %f, %f, %f)", pluginId, index, step, stepSmall, stepLarge);

  514. 

  515.     char targetPath[std::strlen(pData->oscData->path)+23];

  516.     std::strcpy(targetPath, pData->oscData->path);

  517.     std::strcat(targetPath, "/set_parameter_ranges");

  518.     try_lo_send(pData->oscData->target, targetPath, "iifff", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), step, stepSmall, stepLarge);

  519. }

  520. 

  521. void CarlaEngine::oscSend_control_set_parameter_midi_cc(const uint pluginId, const uint32_t index, const int16_t cc) const noexcept

  522. {

  523.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  524.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  525.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  526.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  527.     CARLA_SAFE_ASSERT_RETURN(cc <= 0x5F,);

  528.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  529. 

  530.     char targetPath[std::strlen(pData->oscData->path)+23];

  531.     std::strcpy(targetPath, pData->oscData->path);

  532.     std::strcat(targetPath, "/set_parameter_midi_cc");

  533.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(cc));

  534. }

  535. 

  536. void CarlaEngine::oscSend_control_set_parameter_midi_channel(const uint pluginId, const uint32_t index, const uint8_t channel) const noexcept

  537. {

  538.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  539.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  540.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  541.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  542.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  543.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  544. 

  545.     char targetPath[std::strlen(pData->oscData->path)+28];

  546.     std::strcpy(targetPath, pData->oscData->path);

  547.     std::strcat(targetPath, "/set_parameter_midi_channel");

  548.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(channel));

  549. }

  550. 

  551. void CarlaEngine::oscSend_control_set_parameter_value(const uint pluginId, const int32_t index, const float value) const noexcept

  552. {

  553.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  554.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  555.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  556.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  557.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

  558.     carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %i:%s, %f)", pluginId, index, (index < 0) ? InternalParameterIndex2Str(static_cast<InternalParameterIndex>(index)) : "(none)", value);

  559. 

  560.     char targetPath[std::strlen(pData->oscData->path)+21];

  561.     std::strcpy(targetPath, pData->oscData->path);

  562.     std::strcat(targetPath, "/set_parameter_value");

  563.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), index, value);

  564. }

  565. 

  566. void CarlaEngine::oscSend_control_set_default_value(const uint pluginId, const uint32_t index, const float value) const noexcept

  567. {

  568.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  569.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  570.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  571.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  572.     carla_debug("CarlaEngine::oscSend_control_set_default_value(%i, %i, %f)", pluginId, index, value);

  573. 

  574.     char targetPath[std::strlen(pData->oscData->path)+19];

  575.     std::strcpy(targetPath, pData->oscData->path);

  576.     std::strcat(targetPath, "/set_default_value");

  577.     try_lo_send(pData->oscData->target, targetPath, "iif", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), value);

  578. }

  579. 

  580. void CarlaEngine::oscSend_control_set_current_program(const uint pluginId, const int32_t index) const noexcept

  581. {

  582.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  583.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  584.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  585.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  586.     carla_debug("CarlaEngine::oscSend_control_set_current_program(%i, %i)", pluginId, index);

  587. 

  588.     char targetPath[std::strlen(pData->oscData->path)+21];

  589.     std::strcpy(targetPath, pData->oscData->path);

  590.     std::strcat(targetPath, "/set_current_program");

  591.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  592. }

  593. 

  594. void CarlaEngine::oscSend_control_set_current_midi_program(const uint pluginId, const int32_t index) const noexcept

  595. {

  596.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  597.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  598.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  599.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  600.     carla_debug("CarlaEngine::oscSend_control_set_current_midi_program(%i, %i)", pluginId, index);

  601. 

  602.     char targetPath[std::strlen(pData->oscData->path)+26];

  603.     std::strcpy(targetPath, pData->oscData->path);

  604.     std::strcat(targetPath, "/set_current_midi_program");

  605.     try_lo_send(pData->oscData->target, targetPath, "ii", static_cast<int32_t>(pluginId), index);

  606. }

  607. 

  608. void CarlaEngine::oscSend_control_set_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  609. {

  610.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  611.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  612.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  613.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  614.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  615.     carla_debug("CarlaEngine::oscSend_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  616. 

  617.     char targetPath[std::strlen(pData->oscData->path)+18];

  618.     std::strcpy(targetPath, pData->oscData->path);

  619.     std::strcat(targetPath, "/set_program_name");

  620.     try_lo_send(pData->oscData->target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  621. }

  622. 

  623. void CarlaEngine::oscSend_control_set_midi_program_data(const uint pluginId, const uint32_t index, const uint32_t bank, const uint32_t program, const char* const name) const noexcept

  624. {

  625.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  626.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  627.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  628.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  629.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  630.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  631. 

  632.     char targetPath[std::strlen(pData->oscData->path)+23];

  633.     std::strcpy(targetPath, pData->oscData->path);

  634.     std::strcat(targetPath, "/set_midi_program_data");

  635.     try_lo_send(pData->oscData->target, targetPath, "iiiis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(bank), static_cast<int32_t>(program), name);

  636. }

  637. 

  638. void CarlaEngine::oscSend_control_note_on(const uint pluginId, const uint8_t channel, const uint8_t note, const uint8_t velo) const noexcept

  639. {

  640.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  641.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  642.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  643.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  644.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  645.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  646.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

  647.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  648. 

  649.     char targetPath[std::strlen(pData->oscData->path)+9];

  650.     std::strcpy(targetPath, pData->oscData->path);

  651.     std::strcat(targetPath, "/note_on");

  652.     try_lo_send(pData->oscData->target, targetPath, "iiii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note), static_cast<int32_t>(velo));

  653. }

  654. 

  655. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) const noexcept

  656. {

  657.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  658.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  659.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  660.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  661.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  662.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  663.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  664. 

  665.     char targetPath[std::strlen(pData->oscData->path)+10];

  666.     std::strcpy(targetPath, pData->oscData->path);

  667.     std::strcat(targetPath, "/note_off");

  668.     try_lo_send(pData->oscData->target, targetPath, "iii", static_cast<int32_t>(pluginId), static_cast<int32_t>(channel), static_cast<int32_t>(note));

  669. }

  670. 

  671. void CarlaEngine::oscSend_control_set_peaks(const uint pluginId) const noexcept

  672. {

  673.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  674.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  675.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  676.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  677. 

  678.     // TODO - try and see if we can get peaks[4] ref

  679.     const EnginePluginData& epData(pData->plugins[pluginId]);

  680. 

  681.     char targetPath[std::strlen(pData->oscData->path)+11];

  682.     std::strcpy(targetPath, pData->oscData->path);

  683.     std::strcat(targetPath, "/set_peaks");

  684.     try_lo_send(pData->oscData->target, targetPath, "iffff", static_cast<int32_t>(pluginId), epData.insPeak[0], epData.insPeak[1], epData.outsPeak[0], epData.outsPeak[1]);

  685. }

  686. 

  687. void CarlaEngine::oscSend_control_exit() const noexcept

  688. {

  689.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  690.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->path != nullptr && pData->oscData->path[0] != '\0',);

  691.     CARLA_SAFE_ASSERT_RETURN(pData->oscData->target != nullptr,);

  692.     carla_debug("CarlaEngine::oscSend_control_exit()");

  693. 

  694.     char targetPath[std::strlen(pData->oscData->path)+6];

  695.     std::strcpy(targetPath, pData->oscData->path);

  696.     std::strcat(targetPath, "/exit");

  697.     try_lo_send(pData->oscData->target, targetPath, "");

  698. }

  699. #endif

  700. 

  701. // -----------------------------------------------------------------------

  702. 

  703. CARLA_BACKEND_END_NAMESPACE