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

296 lines
13KB
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 "CarlaEngineOsc.hpp"

  19. 

  20. #ifdef HAVE_LIBLO

  21. 

  22. #include "CarlaBackendUtils.hpp"

  23. #include "CarlaEngine.hpp"

  24. #include "CarlaPlugin.hpp"

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

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

  29. 

  30. void CarlaEngineOsc::sendCallback(const EngineCallbackOpcode action, const uint pluginId,

  31.                                   const int value1, const int value2, const int value3,

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

  33. {

  34.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  35.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  36.     carla_debug("CarlaEngineOsc::sendCallback(%i:%s, %i, %i, %i, %i, %f, \"%s\")",

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

  38. 

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

  40. 

  41.     char targetPath[std::strlen(fControlDataTCP.path)+10];

  42.     std::strcpy(targetPath, fControlDataTCP.path);

  43.     std::strcat(targetPath, "/cb");

  44.     try_lo_send(fControlDataTCP.target, targetPath, "iiiiifs",

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

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

  47. }

  48. 

  49. void CarlaEngineOsc::sendPluginInit(const uint pluginId, const char* const pluginName) const noexcept

  50. {

  51.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  52.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

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

  54.     carla_debug("CarlaEngineOsc::sendadd_plugin_start(%i, \"%s\")", pluginId, pluginName);

  55. 

  56.     char targetPath[std::strlen(fControlDataTCP.path)+18];

  57.     std::strcpy(targetPath, fControlDataTCP.path);

  58.     std::strcat(targetPath, "/init");

  59.     try_lo_send(fControlDataTCP.target, targetPath, "is", static_cast<int32_t>(pluginId), pluginName);

  60. }

  61. 

  62. void CarlaEngineOsc::sendPluginInfo(const CarlaPlugin* const plugin) const noexcept

  63. {

  64.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  65.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  66.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  67.     carla_debug("CarlaEngineOsc::sendPluginInfo(%p)", plugin);

  68. 

  69.     char bufName[STR_MAX+1], bufLabel[STR_MAX+1], bufMaker[STR_MAX+1], bufCopyright[STR_MAX+1];

  70.     carla_zeroChars(bufName, STR_MAX+1);

  71.     carla_zeroChars(bufLabel, STR_MAX+1);

  72.     carla_zeroChars(bufMaker, STR_MAX+1);

  73.     carla_zeroChars(bufCopyright, STR_MAX+1);

  74. 

  75.     plugin->getRealName(bufName);

  76.     plugin->getLabel(bufLabel);

  77.     plugin->getMaker(bufMaker);

  78.     plugin->getCopyright(bufCopyright);

  79. 

  80.     char targetPath[std::strlen(fControlDataTCP.path)+10];

  81.     std::strcpy(targetPath, fControlDataTCP.path);

  82.     std::strcat(targetPath, "/info");

  83.     try_lo_send(fControlDataTCP.target, targetPath, "iiiihssss",

  84.                 static_cast<int32_t>(plugin->getId()),

  85.                 static_cast<int32_t>(plugin->getType()),

  86.                 static_cast<int32_t>(plugin->getCategory()),

  87.                 static_cast<int32_t>(plugin->getHints()),

  88.                 static_cast<int64_t>(plugin->getUniqueId()),

  89.                 bufName, bufLabel, bufMaker, bufCopyright);

  90. }

  91. 

  92. void CarlaEngineOsc::sendPluginPortCount(const CarlaPlugin* const plugin) const noexcept

  93. {

  94.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  95.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  96.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  97.     carla_debug("CarlaEngineOsc::sendPluginInfo(%p)", plugin);

  98. 

  99.     uint32_t paramIns, paramOuts;

  100.     plugin->getParameterCountInfo(paramIns, paramOuts);

  101. 

  102.     if (paramIns > 49)

  103.         paramIns = 49;

  104.     if (paramOuts > 49)

  105.         paramOuts = 49;

  106. 

  107.     char targetPath[std::strlen(fControlDataTCP.path)+7];

  108.     std::strcpy(targetPath, fControlDataTCP.path);

  109.     std::strcat(targetPath, "/ports");

  110.     try_lo_send(fControlDataTCP.target, targetPath, "iiiiiiii",

  111.                 static_cast<int32_t>(plugin->getId()),

  112.                 static_cast<int32_t>(plugin->getAudioInCount()),

  113.                 static_cast<int32_t>(plugin->getAudioOutCount()),

  114.                 static_cast<int32_t>(plugin->getMidiInCount()),

  115.                 static_cast<int32_t>(plugin->getMidiOutCount()),

  116.                 static_cast<int32_t>(paramIns),

  117.                 static_cast<int32_t>(paramOuts),

  118.                 static_cast<int32_t>(plugin->getParameterCount()));

  119. }

  120. 

  121. void CarlaEngineOsc::sendPluginParameterInfo(const CarlaPlugin* const plugin, const uint32_t parameterId) const noexcept

  122. {

  123.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  124.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  125.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  126.     carla_debug("CarlaEngineOsc::sendPluginInfo(%p, %u)", plugin, parameterId);

  127. 

  128.     char bufName[STR_MAX+1], bufUnit[STR_MAX+1];

  129.     carla_zeroChars(bufName, STR_MAX+1);

  130.     carla_zeroChars(bufUnit, STR_MAX+1);

  131. 

  132.     const ParameterData& paramData(plugin->getParameterData(parameterId));

  133.     const ParameterRanges& paramRanges(plugin->getParameterRanges(parameterId));

  134. 

  135.     plugin->getParameterName(parameterId, bufName);

  136.     plugin->getParameterUnit(parameterId, bufUnit);

  137. 

  138.     char targetPath[std::strlen(fControlDataTCP.path)+20];

  139.     std::strcpy(targetPath, fControlDataTCP.path);

  140.     std::strcat(targetPath, "/param");

  141.     try_lo_send(fControlDataTCP.target, targetPath, "iiiiiissfffffff",

  142.                 static_cast<int32_t>(plugin->getId()), static_cast<int32_t>(parameterId),

  143.                 static_cast<int32_t>(paramData.type), static_cast<int32_t>(paramData.hints),

  144.                 static_cast<int32_t>(paramData.midiChannel), static_cast<int32_t>(paramData.midiCC),

  145.                 bufName, bufUnit,

  146.                 static_cast<double>(paramRanges.def),

  147.                 static_cast<double>(paramRanges.min),

  148.                 static_cast<double>(paramRanges.max),

  149.                 static_cast<double>(paramRanges.step),

  150.                 static_cast<double>(paramRanges.stepSmall),

  151.                 static_cast<double>(paramRanges.stepLarge),

  152.                 static_cast<double>(plugin->getParameterValue(parameterId)));

  153. }

  154. 

  155. void CarlaEngineOsc::sendPluginInternalParameterValues(const CarlaPlugin* const plugin) const noexcept

  156. {

  157.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  158.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  159.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  160.     carla_debug("CarlaEngineOsc::sendPluginInternalParameterValues(%p)", plugin);

  161. 

  162.     static_assert(PARAMETER_ACTIVE == -2 && PARAMETER_MAX == -9);

  163. 

  164.     double iparams[7];

  165. 

  166.     for (int32_t i = 0; i < 7; ++i)

  167.         iparams[i] = plugin->getInternalParameterValue(PARAMETER_ACTIVE - i);

  168. 

  169.     char targetPath[std::strlen(fControlDataTCP.path)+18];

  170.     std::strcpy(targetPath, fControlDataTCP.path);

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

  172.     try_lo_send(fControlDataTCP.target, targetPath, "ifffffff",

  173.                 static_cast<int32_t>(plugin->getId()),

  174.                 iparams[0], // PARAMETER_ACTIVE

  175.                 iparams[1], // PARAMETER_DRYWET

  176.                 iparams[2], // PARAMETER_VOLUME

  177.                 iparams[3], // PARAMETER_BALANCE_LEFT

  178.                 iparams[4], // PARAMETER_BALANCE_RIGHT

  179.                 iparams[5], // PARAMETER_PANNING

  180.                 iparams[6]  // PARAMETER_CTRL_CHANNEL

  181.                );

  182. }

  183. 

  184. #if 0

  185. void CarlaEngineOsc::sendset_program_count(const uint pluginId, const uint32_t count) const noexcept

  186. {

  187.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  188.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  189.     carla_debug("CarlaEngineOsc::sendset_program_count(%i, %i)", pluginId, count);

  190. 

  191.     char targetPath[std::strlen(fControlDataTCP.path)+19];

  192.     std::strcpy(targetPath, fControlDataTCP.path);

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

  194.     try_lo_send(fControlDataTCP.target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  195. }

  196. 

  197. void CarlaEngineOsc::sendset_midi_program_count(const uint pluginId, const uint32_t count) const noexcept

  198. {

  199.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  200.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  201.     carla_debug("CarlaEngineOsc::sendset_midi_program_count(%i, %i)", pluginId, count);

  202. 

  203.     char targetPath[std::strlen(fControlDataTCP.path)+24];

  204.     std::strcpy(targetPath, fControlDataTCP.path);

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

  206.     try_lo_send(fControlDataTCP.target, targetPath, "ii", static_cast<int32_t>(pluginId), static_cast<int32_t>(count));

  207. }

  208. 

  209. void CarlaEngineOsc::sendset_program_name(const uint pluginId, const uint32_t index, const char* const name) const noexcept

  210. {

  211.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  212.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  213.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  214.     carla_debug("CarlaEngineOsc::sendset_program_name(%i, %i, \"%s\")", pluginId, index, name);

  215. 

  216.     char targetPath[std::strlen(fControlDataTCP.path)+18];

  217.     std::strcpy(targetPath, fControlDataTCP.path);

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

  219.     try_lo_send(fControlDataTCP.target, targetPath, "iis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), name);

  220. }

  221. 

  222. void CarlaEngineOsc::sendset_midi_program_data(const uint pluginId, const uint32_t index, const uint32_t bank, const uint32_t program, const char* const name) const noexcept

  223. {

  224.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  225.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  226.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  227.     carla_debug("CarlaEngineOsc::sendset_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  228. 

  229.     char targetPath[std::strlen(fControlDataTCP.path)+23];

  230.     std::strcpy(targetPath, fControlDataTCP.path);

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

  232.     try_lo_send(fControlDataTCP.target, targetPath, "iiiis", static_cast<int32_t>(pluginId), static_cast<int32_t>(index), static_cast<int32_t>(bank), static_cast<int32_t>(program), name);

  233. }

  234. #endif

  235. 

  236. // -----------------------------------------------------------------------

  237. 

  238. // FIXME use UDP

  239. 

  240. void CarlaEngineOsc::sendRuntimeInfo() const noexcept

  241. {

  242.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  243.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  244.     carla_debug("CarlaEngineOsc::sendRuntimeInfo()");

  245. 

  246.     const EngineTimeInfo timeInfo(fEngine->getTimeInfo());

  247. 

  248.     char targetPath[std::strlen(fControlDataTCP.path)+18];

  249.     std::strcpy(targetPath, fControlDataTCP.path);

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

  251.     try_lo_send(fControlDataTCP.target, targetPath, "fiihiiif",

  252.                 static_cast<double>(fEngine->getDSPLoad()),

  253.                 static_cast<int32_t>(fEngine->getTotalXruns()),

  254.                 timeInfo.playing ? 1 : 0,

  255.                 static_cast<int64_t>(timeInfo.frame),

  256.                 static_cast<int32_t>(timeInfo.bbt.bar),

  257.                 static_cast<int32_t>(timeInfo.bbt.beat),

  258.                 static_cast<int32_t>(timeInfo.bbt.tick),

  259.                 timeInfo.bbt.beatsPerMinute);

  260. }

  261. 

  262. void CarlaEngineOsc::sendParameterValue(const uint pluginId, const uint32_t index, const float value) const noexcept

  263. {

  264.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  265.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  266. 

  267.     char targetPath[std::strlen(fControlDataTCP.path)+21];

  268.     std::strcpy(targetPath, fControlDataTCP.path);

  269.     std::strcat(targetPath, "/param_fixme");

  270.     try_lo_send(fControlDataTCP.target, targetPath, "iif",

  271.                 static_cast<int32_t>(pluginId),

  272.                 index,

  273.                 static_cast<double>(value));

  274. }

  275. 

  276. void CarlaEngineOsc::sendPeaks(const uint pluginId, const float peaks[4]) const noexcept

  277. {

  278.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.path != nullptr && fControlDataTCP.path[0] != '\0',);

  279.     CARLA_SAFE_ASSERT_RETURN(fControlDataTCP.target != nullptr,);

  280. 

  281.     char targetPath[std::strlen(fControlDataTCP.path)+11];

  282.     std::strcpy(targetPath, fControlDataTCP.path);

  283.     std::strcat(targetPath, "/peaks");

  284.     try_lo_send(fControlDataTCP.target, targetPath, "iffff", static_cast<int32_t>(pluginId),

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

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

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

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

  289. }

  290. 

  291. // -----------------------------------------------------------------------

  292. 

  293. CARLA_BACKEND_END_NAMESPACE

  294. 

  295. #endif // HAVE_LIBLO