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

703 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 "CarlaEngineInternal.hpp"

  19. #include "CarlaMIDI.h"

  20. 

  21. CARLA_BACKEND_START_NAMESPACE

  22. 

  23. // -----------------------------------------------------------------------

  24. 

  25. #ifdef BUILD_BRIDGE

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

  27. {

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

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

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

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

  32. 

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

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

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

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

  37. }

  38. 

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

  40. {

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

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

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

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

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

  46.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  47.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  49. 

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

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

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

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

  54. }

  55. 

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

  57. {

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

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

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

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

  62. 

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

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

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

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

  67. }

  68. 

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

  70. {

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

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

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

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

  75. 

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

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

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

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

  80. }

  81. 

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

  83. {

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

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

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

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

  88. 

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

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

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

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

  93. }

  94. 

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

  96. {

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

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

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

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

  101. 

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

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

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

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

  106. }

  107. 

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

  109. {

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

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

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

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

  114. 

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

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

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

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

  119. }

  120. 

  121. 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

  122. {

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

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

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

  126.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  127.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  129. 

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

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

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

  133.     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);

  134. }

  135. 

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

  137. {

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

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

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

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

  142. 

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

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

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

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

  147. }

  148. 

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

  150. {

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

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

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

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

  155. 

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

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

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

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

  160. }

  161. 

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

  163. {

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

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

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

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

  168. 

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

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

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

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

  173. }

  174. 

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

  176. {

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

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

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

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

  181. 

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

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

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

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

  186. }

  187. 

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

  189. {

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

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

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

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

  194. 

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

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

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

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

  199. }

  200. 

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

  202. {

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

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

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

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

  207. 

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

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

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

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

  212. }

  213. 

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

  215. {

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

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

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

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

  220. 

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

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

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

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

  225. }

  226. 

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

  228. {

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

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

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

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

  233. 

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

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

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

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

  238. }

  239. 

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

  241. {

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

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

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

  245.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  247. 

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

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

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

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

  252. }

  253. 

  254. 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

  255. {

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

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

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

  259.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  261. 

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

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

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

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

  266. }

  267. 

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

  269. {

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

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

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

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

  274.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  276. 

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

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

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

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

  281. }

  282. 

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

  284. {

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

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

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

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

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

  290.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  292. 

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

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

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

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

  297. }

  298. 

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

  300. {

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

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

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

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

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

  306. 

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

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

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

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

  311. }

  312. 

  313. void CarlaEngine::oscSend_bridge_pong() const noexcept

  314. {

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

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

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

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

  319. 

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

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

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

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

  324. }

  325. #else

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

  327. {

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

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

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

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

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

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

  334. 

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

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

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

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

  339. }

  340. 

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

  342. {

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

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

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

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

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

  348. 

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

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

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

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

  353. }

  354. 

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

  356. {

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

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

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

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

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

  362. 

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

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

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

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

  367. }

  368. 

  369. 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

  370. {

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

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

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

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

  375.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

  376.     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);

  377. 

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

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

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

  381.     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));

  382. }

  383. 

  384. 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

  385. {

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

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

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

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

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

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

  392.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  393.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  395. 

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

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

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

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

  400. }

  401. 

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

  403. {

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

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

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

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

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

  409. 

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

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

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

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

  414. }

  415. 

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

  417. {

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

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

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

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

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

  423. 

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

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

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

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

  428. }

  429. 

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

  431. {

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

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

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

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

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

  437. 

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

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

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

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

  442. }

  443. 

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

  445. {

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

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

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

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

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

  451. 

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

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

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

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

  456. }

  457. 

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

  459. {

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

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

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

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

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

  465. 

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

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

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

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

  470. }

  471. 

  472. 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

  473. {

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

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

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

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

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

  479.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  481. 

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

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

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

  485.     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);

  486. }

  487. 

  488. 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

  489. {

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

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

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

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

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

  495.     CARLA_SAFE_ASSERT_RETURN(min < max,);

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

  497. 

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

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

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

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

  502. }

  503. 

  504. 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

  505. {

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

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

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

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

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

  511.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

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

  513. 

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

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

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

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

  518. }

  519. 

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

  521. {

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

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

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

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

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

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

  528. 

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

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

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

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

  533. }

  534. 

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

  536. {

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

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

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

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

  541.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  543. 

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

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

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

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

  548. }

  549. 

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

  551. {

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

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

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

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

  556.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

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

  558. 

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

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

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

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

  563. }

  564. 

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

  566. {

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

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

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

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

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

  572. 

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

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

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

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

  577. }

  578. 

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

  580. {

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

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

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

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

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

  586. 

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

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

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

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

  591. }

  592. 

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

  594. {

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

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

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

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

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

  600. 

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

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

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

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

  605. }

  606. 

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

  608. {

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

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

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

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

  613.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  615. 

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

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

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

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

  620. }

  621. 

  622. 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

  623. {

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

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

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

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

  628.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  630. 

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

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

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

  634.     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);

  635. }

  636. 

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

  638. {

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

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

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

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

  643.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  644.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  645.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

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

  647. 

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

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

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

  651.     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));

  652. }

  653. 

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

  655. {

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

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

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

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

  660.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  661.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  663. 

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

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

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

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

  668. }

  669. 

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

  671. {

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

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

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

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

  676. 

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

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

  679. 

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

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

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

  683.     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]);

  684. }

  685. 

  686. void CarlaEngine::oscSend_control_exit() const noexcept

  687. {

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

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

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

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

  692. 

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

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

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

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

  697. }

  698. #endif

  699. 

  700. // -----------------------------------------------------------------------

  701. 

  702. CARLA_BACKEND_END_NAMESPACE