falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
4810 Commits
17 Branches
940MB
Tree: 699193f3d5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '699193f3d5'
${ noResults }
Carla/source/backend/engine/CarlaEngineOscSend.cpp

476 lines
25KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2019 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 "CarlaDefines.h"

  19. 

  20. #ifdef HAVE_LIBLO

  21. 

  22. #include "CarlaBackendUtils.hpp"

  23. #include "CarlaEngineInternal.hpp"

  24. #include "CarlaMIDI.h"

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

  28. // -----------------------------------------------------------------------

  29. 

  30. #ifndef BUILD_BRIDGE

  31. void CarlaEngine::oscSend_control_callback(const EngineCallbackOpcode action, const uint pluginId,

  32.                                            const int value1, const int value2, const int value3,

  33.                                            const float valuef, const char* const valueStr) const noexcept

  34. {

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

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

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

  38.     carla_debug("CarlaEngine::oscSend_control_callback(%i:%s, %i, %i, %i, %i, %f, \"%s\")",

  39.                 action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valuef, valueStr);

  40. 

  41.     static const char* const kFakeNullString = "(null)";

  42. 

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

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

  45.     std::strcat(targetPath, "/callback");

  46.     try_lo_send(pData->oscData->target, targetPath, "iiiiifs",

  47.                 action, pluginId, value1, value2, value3, static_cast<double>(valuef),

  48.                 valueStr != nullptr ? valueStr : kFakeNullString);

  49. }

  50. 

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

  52. {

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

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

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

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

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

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

  59. 

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

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

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

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

  64. }

  65. 

  66. #if 0

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

  68. {

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

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

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

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

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

  74. 

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

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

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

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

  79. }

  80. 

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

  82. {

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

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

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

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

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

  88. 

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

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

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

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

  93. }

  94. #endif

  95. 

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

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

  102.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

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

  104. 

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

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

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

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

  109. }

  110. 

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

  112. {

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

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

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

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

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

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

  119.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  120.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  122. 

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

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

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

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

  127. }

  128. 

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

  130. {

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

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

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

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

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

  136. 

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

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

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

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

  141. }

  142. 

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

  144. {

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

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

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

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

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

  150. 

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

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

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

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

  155. }

  156. 

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

  158. {

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

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

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

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

  163.     CARLA_SAFE_ASSERT_RETURN(ins < 50,);

  164.     CARLA_SAFE_ASSERT_RETURN(outs < 50,);

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

  166. 

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

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

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

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

  171. }

  172. 

  173. void CarlaEngine::oscSend_control_set_program_count(const uint pluginId, const uint32_t count) 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(count <= 50,);

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

  181. 

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

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

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

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

  186. }

  187. 

  188. void CarlaEngine::oscSend_control_set_midi_program_count(const uint pluginId, const uint32_t count) 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_SAFE_ASSERT_RETURN(pluginId <= pData->curPluginCount,);

  194.     CARLA_SAFE_ASSERT_RETURN(count <= 50,);

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

  196. 

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

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

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

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

  201. }

  202. 

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

  204. {

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

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

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

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

  209.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

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

  211.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  213. 

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

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

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

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

  218. }

  219. 

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

  221. {

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

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

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

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

  226.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

  227.     CARLA_SAFE_ASSERT(def >= min && def <= max);

  228.     CARLA_SAFE_ASSERT(min < max);

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

  230. 

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

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

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

  234.     try_lo_send(pData->oscData->target, targetPath, "iifff",

  235.                 static_cast<int32_t>(pluginId),

  236.                 static_cast<int32_t>(index),

  237.                 static_cast<double>(def),

  238.                 static_cast<double>(min),

  239.                 static_cast<double>(max));

  240. }

  241. 

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

  243. {

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

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

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

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

  248.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

  249.     CARLA_SAFE_ASSERT(step >= stepSmall && step <= stepLarge);

  250.     CARLA_SAFE_ASSERT(stepSmall <= stepLarge);

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

  252. 

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

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

  255.     std::strcat(targetPath, "/set_parameter_ranges2");

  256.     try_lo_send(pData->oscData->target, targetPath, "iifff",

  257.                 static_cast<int32_t>(pluginId),

  258.                 static_cast<int32_t>(index),

  259.                 static_cast<double>(step),

  260.                 static_cast<double>(stepSmall),

  261.                 static_cast<double>(stepLarge));

  262. }

  263. 

  264. #if 0

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

  266. {

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

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

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

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

  271.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

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

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

  274. 

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

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

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

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

  279. }

  280. 

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

  282. {

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

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

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

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

  287.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

  288.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  290. 

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

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

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

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

  295. }

  296. #endif

  297. 

  298. void CarlaEngine::oscSend_control_set_output_parameter_value(const uint pluginId, const int32_t index, const float value) const noexcept

  299. {

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

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

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

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

  304.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

  305.     CARLA_SAFE_ASSERT_RETURN(index != PARAMETER_NULL,);

  306.     carla_debug("CarlaEngine::oscSend_control_set_output_parameter_value(%i, %i:%s, %f)", pluginId, index,

  307.                 (index < 0) ? InternalParameterIndex2Str(static_cast<InternalParameterIndex>(index)) : "(none)", value);

  308. 

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

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

  311.     std::strcat(targetPath, "/set_output_parameter_value");

  312.     try_lo_send(pData->oscData->target, targetPath, "iif",

  313.                 static_cast<int32_t>(pluginId),

  314.                 index,

  315.                 static_cast<double>(value));

  316. }

  317. 

  318. #if 0

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

  320. {

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

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

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

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

  325.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

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

  327. 

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

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

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

  331.     try_lo_send(pData->oscData->target, targetPath, "iif",

  332.                 static_cast<int32_t>(pluginId),

  333.                 static_cast<int32_t>(index),

  334.                 static_cast<double>(value));

  335. }

  336. 

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

  338. {

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

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

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

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

  343.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

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

  345. 

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

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

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

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

  350. }

  351. 

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

  353. {

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

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

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

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

  358.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

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

  360. 

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

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

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

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

  365. }

  366. #endif

  367. 

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

  369. {

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

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

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

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

  374.     CARLA_SAFE_ASSERT_RETURN(index < 50,);

  375.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  377. 

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

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

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

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

  382. }

  383. 

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

  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(index < 50,);

  391.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  393. 

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

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

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

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

  398. }

  399. 

  400. #if 0

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

  402. {

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

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

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

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

  407.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  408.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

  409.     CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);

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

  411. 

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

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

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

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

  416. }

  417. 

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

  419. {

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

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

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

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

  424.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  425.     CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);

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

  427. 

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

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

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

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

  432. }

  433. #endif

  434. 

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

  436. {

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

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

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

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

  441. 

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

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

  444. 

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

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

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

  448.     try_lo_send(pData->oscData->target, targetPath, "iffff", static_cast<int32_t>(pluginId),

  449.                 static_cast<double>(epData.peaks[0]),

  450.                 static_cast<double>(epData.peaks[1]),

  451.                 static_cast<double>(epData.peaks[2]),

  452.                 static_cast<double>(epData.peaks[3]));

  453. }

  454. 

  455. #if 0

  456. void CarlaEngine::oscSend_control_exit() const noexcept

  457. {

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

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

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

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

  462. 

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

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

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

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

  467. }

  468. #endif

  469. #endif // BUILD_BRIDGE

  470. 

  471. // -----------------------------------------------------------------------

  472. 

  473. CARLA_BACKEND_END_NAMESPACE

  474. 

  475. #endif // HAVE_LIBLO