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

320 lines
14KB
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_stdout("CarlaEngineOsc::sendCallback(%i:%s, %i, %i, %i, %i, %f, \"%s\")",

  37.                 action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3,

  38.                  static_cast<double>(valuef), valueStr);

  39. 

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

  41. 

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

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

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

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

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

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

  48. }

  49. 

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

  51. {

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

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

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

  55.     carla_stdout("CarlaEngineOsc::sendPluginInit(%i, \"%s\")", pluginId, pluginName);

  56. 

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

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

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

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

  61. }

  62. 

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

  64. {

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

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

  67.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  68.     carla_stdout("CarlaEngineOsc::sendPluginInfo(%p)", plugin);

  69. 

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

  71.     carla_zeroChars(bufName, STR_MAX+1);

  72.     carla_zeroChars(bufLabel, STR_MAX+1);

  73.     carla_zeroChars(bufMaker, STR_MAX+1);

  74.     carla_zeroChars(bufCopyright, STR_MAX+1);

  75. 

  76.     plugin->getRealName(bufName);

  77.     plugin->getLabel(bufLabel);

  78.     plugin->getMaker(bufMaker);

  79.     plugin->getCopyright(bufCopyright);

  80. 

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

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

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

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

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

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

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

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

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

  90.                 bufName, bufLabel, bufMaker, bufCopyright);

  91. }

  92. 

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

  94. {

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

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

  97.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  98.     carla_stdout("CarlaEngineOsc::sendPluginInfo(%p)", plugin);

  99. 

  100.     uint32_t paramIns, paramOuts;

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

  102. 

  103.     if (paramIns > 49)

  104.         paramIns = 49;

  105.     if (paramOuts > 49)

  106.         paramOuts = 49;

  107. 

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

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

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

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

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

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

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

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

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

  117.                 static_cast<int32_t>(paramIns),

  118.                 static_cast<int32_t>(paramOuts),

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

  120. }

  121. 

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

  123. {

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

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

  126.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  128. 

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

  130.     carla_zeroChars(bufName, STR_MAX+1);

  131.     carla_zeroChars(bufUnit, STR_MAX+1);

  132. 

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

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

  135. 

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

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

  138. 

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

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

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

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

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

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

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

  146.                 bufName, bufUnit,

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

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

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

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

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

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

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

  154. }

  155. 

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

  157. {

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

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

  160.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  162. 

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

  164. 

  165.     double iparams[7];

  166. 

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

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

  169. 

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

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

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

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

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

  175.                 iparams[0], // PARAMETER_ACTIVE

  176.                 iparams[1], // PARAMETER_DRYWET

  177.                 iparams[2], // PARAMETER_VOLUME

  178.                 iparams[3], // PARAMETER_BALANCE_LEFT

  179.                 iparams[4], // PARAMETER_BALANCE_RIGHT

  180.                 iparams[5], // PARAMETER_PANNING

  181.                 iparams[6]  // PARAMETER_CTRL_CHANNEL

  182.                );

  183. }

  184. 

  185. #if 0

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

  187. {

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

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

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

  191. 

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

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

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

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

  196. }

  197. 

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

  199. {

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

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

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

  203. 

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

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

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

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

  208. }

  209. 

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

  211. {

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

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

  214.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  216. 

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

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

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

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

  221. }

  222. 

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

  224. {

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

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

  227.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  229. 

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

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

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

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

  234. }

  235. #endif

  236. 

  237. // -----------------------------------------------------------------------

  238. 

  239. void CarlaEngineOsc::sendPing() const noexcept

  240. {

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

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

  243. 

  244.     char targetPath[std::strlen(fControlDataTCP.path)+6];

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

  246.     std::strcat(targetPath, "/ping");

  247.     try_lo_send(fControlDataTCP.target, targetPath, "");

  248. }

  249. 

  250. void CarlaEngineOsc::sendExit() const noexcept

  251. {

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

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

  254.     carla_debug("CarlaEngineOsc::sendExit()");

  255. 

  256.     char targetPath[std::strlen(fControlDataTCP.path)+6];

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

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

  259.     try_lo_send(fControlDataTCP.target, targetPath, "");

  260. }

  261. 

  262. // -----------------------------------------------------------------------

  263. 

  264. void CarlaEngineOsc::sendRuntimeInfo() const noexcept

  265. {

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

  267.     CARLA_SAFE_ASSERT_RETURN(fControlDataUDP.target != nullptr,);

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

  269. 

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

  271. 

  272.     char targetPath[std::strlen(fControlDataUDP.path)+18];

  273.     std::strcpy(targetPath, fControlDataUDP.path);

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

  275.     try_lo_send(fControlDataUDP.target, targetPath, "fiihiiif",

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

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

  278.                 timeInfo.playing ? 1 : 0,

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

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

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

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

  283.                 timeInfo.bbt.beatsPerMinute);

  284. }

  285. 

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

  287. {

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

  289.     CARLA_SAFE_ASSERT_RETURN(fControlDataUDP.target != nullptr,);

  290. 

  291.     char targetPath[std::strlen(fControlDataUDP.path)+21];

  292.     std::strcpy(targetPath, fControlDataUDP.path);

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

  294.     try_lo_send(fControlDataUDP.target, targetPath, "iif",

  295.                 static_cast<int32_t>(pluginId),

  296.                 index,

  297.                 static_cast<double>(value));

  298. }

  299. 

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

  301. {

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

  303.     CARLA_SAFE_ASSERT_RETURN(fControlDataUDP.target != nullptr,);

  304. 

  305.     char targetPath[std::strlen(fControlDataUDP.path)+11];

  306.     std::strcpy(targetPath, fControlDataUDP.path);

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

  308.     try_lo_send(fControlDataUDP.target, targetPath, "iffff", static_cast<int32_t>(pluginId),

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

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

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

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

  313. }

  314. 

  315. // -----------------------------------------------------------------------

  316. 

  317. CARLA_BACKEND_END_NAMESPACE

  318. 

  319. #endif // HAVE_LIBLO