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.
2565 Commits
16 Branches
257MB
Tree: cd30c7f7e1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cd30c7f7e1'
${ noResults }
Carla/source/backend/engine/CarlaEngineOscSend.cpp

404 lines
23KB
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. #ifndef BUILD_BRIDGE

  27. void CarlaEngine::oscSend_control_add_plugin_start(const uint pluginId, const char* const pluginName) 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_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

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

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

  35. 

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

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

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

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

  40. }

  41. 

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

  43. {

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

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

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

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

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

  49. 

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

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

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

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

  54. }

  55. 

  56. void CarlaEngine::oscSend_control_remove_plugin(const uint pluginId) 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_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

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

  63. 

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

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

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

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

  68. }

  69. 

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

  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_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

  76.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

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

  78. 

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

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

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

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

  83. }

  84. 

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

  86. {

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

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

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

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

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

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

  93.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  94.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  96. 

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

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

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

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

  101. }

  102. 

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

  104. {

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

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

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

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

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

  110. 

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

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

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

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

  115. }

  116. 

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

  118. {

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

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

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

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

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

  124. 

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

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

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

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

  129. }

  130. 

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

  132. {

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

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

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

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

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

  138. 

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

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

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

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

  143. }

  144. 

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

  146. {

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

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

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

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

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

  152. 

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

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

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

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

  157. }

  158. 

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

  160. {

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

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

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

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

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

  166. 

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

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

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

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

  171. }

  172. 

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

  174. {

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

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

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

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

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

  180.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  182. 

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

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

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

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

  187. }

  188. 

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

  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_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount,);

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

  196.     CARLA_SAFE_ASSERT_RETURN(min < max,);

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

  198. 

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

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

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

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

  203. }

  204. 

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

  206. {

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

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

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

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

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

  212.     CARLA_SAFE_ASSERT_RETURN(stepSmall <= stepLarge,);

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

  214. 

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

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

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

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

  219. }

  220. 

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

  222. {

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

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

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

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

  227.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL,);

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

  229. 

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

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

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

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

  234. }

  235. 

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

  237. {

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

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

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

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

  242.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  244. 

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

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

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

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

  249. }

  250. 

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

  252. {

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

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

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

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

  257.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

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

  259. 

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

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

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

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

  264. }

  265. 

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

  267. {

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

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

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

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

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

  273. 

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

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

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

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

  278. }

  279. 

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

  281. {

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

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

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

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

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

  287. 

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

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

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

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

  292. }

  293. 

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

  295. {

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

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

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

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

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

  301. 

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

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

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

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

  306. }

  307. 

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

  309. {

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

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

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

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

  314.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  316. 

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

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

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

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

  321. }

  322. 

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

  324. {

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

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

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

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

  329.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  331. 

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

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

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

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

  336. }

  337. 

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

  339. {

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

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

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

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

  344.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  345.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  346.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

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

  348. 

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

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

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

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

  353. }

  354. 

  355. void CarlaEngine::oscSend_control_note_off(const uint pluginId, const uint8_t channel, const uint8_t note) 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_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  362.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  364. 

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

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

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

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

  369. }

  370. 

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

  372. {

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

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

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

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

  377. 

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

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

  380. 

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

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

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

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

  385. }

  386. 

  387. void CarlaEngine::oscSend_control_exit() const noexcept

  388. {

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

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

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

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

  393. 

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

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

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

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

  398. }

  399. #endif // BUILD_BRIDGE

  400. 

  401. // -----------------------------------------------------------------------

  402. 

  403. CARLA_BACKEND_END_NAMESPACE