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

407 lines
17KB
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. static const char* const kNullString = "";

  29. 

  30. // -----------------------------------------------------------------------

  31. 

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

  33.                                   const int value1, const int value2, const int value3,

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

  35. {

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

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

  38.     carla_stdout("CarlaEngineOsc::sendCallback(%i:%s, %i, %i, %i, %i, %f, \"%s\")",

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

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

  41. 

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

  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 : kNullString);

  48. }

  49. 

  50. void CarlaEngineOsc::sendPluginInfo(const CarlaPluginPtr& plugin) 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(plugin != nullptr,);

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

  56. 

  57.     char bufRealName[STR_MAX+1], bufLabel[STR_MAX+1], bufMaker[STR_MAX+1], bufCopyright[STR_MAX+1];

  58.     carla_zeroChars(bufRealName, STR_MAX+1);

  59.     carla_zeroChars(bufLabel, STR_MAX+1);

  60.     carla_zeroChars(bufMaker, STR_MAX+1);

  61.     carla_zeroChars(bufCopyright, STR_MAX+1);

  62. 

  63.     if (! plugin->getRealName(bufRealName))

  64.         bufRealName[0] = '\0';

  65.     if (! plugin->getLabel(bufLabel))

  66.         bufLabel[0] = '\0';

  67.     if (! plugin->getMaker(bufMaker))

  68.         bufMaker[0] = '\0';

  69.     if (! plugin->getCopyright(bufCopyright))

  70.         bufCopyright[0] = '\0';

  71. 

  72.     const char* name = plugin->getName();

  73.     const char* filename = plugin->getFilename();

  74.     const char* iconName = plugin->getIconName();

  75. 

  76.     if (name == nullptr)

  77.         name = kNullString;

  78.     if (filename == nullptr)

  79.         filename = kNullString;

  80.     if (iconName == nullptr)

  81.         iconName = kNullString;

  82. 

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

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

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

  86.     try_lo_send(fControlDataTCP.target, targetPath, "iiiihiisssssss",

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

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

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

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

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

  92.                 static_cast<int64_t>(plugin->getOptionsAvailable()),

  93.                 static_cast<int64_t>(plugin->getOptionsEnabled()),

  94.                 name, filename, iconName,

  95.                 bufRealName, bufLabel, bufMaker, bufCopyright);

  96. }

  97. 

  98. void CarlaEngineOsc::sendPluginPortCount(const CarlaPluginPtr& plugin) const noexcept

  99. {

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

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

  102.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  103.     carla_stdout("CarlaEngineOsc::sendPluginPortCount(%p)", plugin.get());

  104. 

  105.     uint32_t paramIns, paramOuts;

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

  107. 

  108.     if (paramIns > 49)

  109.         paramIns = 49;

  110.     if (paramOuts > 49)

  111.         paramOuts = 49;

  112. 

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

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

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

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

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

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

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

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

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

  122.                 static_cast<int32_t>(paramIns),

  123.                 static_cast<int32_t>(paramOuts),

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

  125. }

  126. 

  127. void CarlaEngineOsc::sendPluginParameterInfo(const CarlaPluginPtr& plugin, const uint32_t index) const noexcept

  128. {

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

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

  131.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  132.     carla_debug("CarlaEngineOsc::sendPluginParameterInfo(%p, %u)", plugin.get(), index);

  133. 

  134.     char bufName[STR_MAX+1], bufUnit[STR_MAX+1], bufComment[STR_MAX+1], bufGroupName[STR_MAX+1];

  135.     carla_zeroChars(bufName, STR_MAX+1);

  136.     carla_zeroChars(bufUnit, STR_MAX+1);

  137.     carla_zeroChars(bufComment, STR_MAX+1);

  138.     carla_zeroChars(bufGroupName, STR_MAX+1);

  139. 

  140.     if (! plugin->getParameterName(index, bufName))

  141.         bufName[0] = '\0';

  142.     if (! plugin->getParameterUnit(index, bufUnit))

  143.         bufUnit[0] = '\0';

  144.     if (! plugin->getParameterComment(index, bufComment))

  145.         bufComment[0] = '\0';

  146.     if (! plugin->getParameterGroupName(index, bufGroupName))

  147.         bufGroupName[0] = '\0';

  148. 

  149.     const ParameterData& paramData(plugin->getParameterData(index));

  150.     const ParameterRanges& paramRanges(plugin->getParameterRanges(index));

  151. 

  152.     const int32_t pluginId = static_cast<int32_t>(plugin->getId());

  153.     const int32_t paramId  = static_cast<int32_t>(index);

  154. 

  155.     char targetPath[std::strlen(fControlDataTCP.path)+13];

  156. 

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

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

  159.     try_lo_send(fControlDataTCP.target, targetPath, "iissss",

  160.                 pluginId, 

  161.                 paramId,

  162.                 bufName, 

  163.                 bufUnit, 

  164.                 bufComment, 

  165.                 bufGroupName);

  166. 

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

  168.     std::strcat(targetPath, "/paramData");

  169.     try_lo_send(fControlDataTCP.target, targetPath, "iiiiiifff",

  170.                 pluginId, 

  171.                 paramId,

  172.                 static_cast<int32_t>(paramData.type), 

  173.                 static_cast<int32_t>(paramData.hints),

  174.                 static_cast<int32_t>(paramData.midiChannel),

  175.                 static_cast<int32_t>(paramData.mappedControlIndex),

  176.                 static_cast<double>(paramData.mappedMinimum), 

  177.                 static_cast<double>(paramData.mappedMaximum),

  178.                 static_cast<double>(plugin->getParameterValue(index)));

  179. 

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

  181.     std::strcat(targetPath, "/paramRanges");

  182.     try_lo_send(fControlDataTCP.target, targetPath, "iiffffff",

  183.                 pluginId, 

  184.                 paramId,

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

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

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

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

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

  190.                 static_cast<double>(paramRanges.stepLarge));

  191. }

  192. 

  193. void CarlaEngineOsc::sendPluginDataCount(const CarlaPluginPtr& plugin) const noexcept

  194. {

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

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

  197.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  198.     carla_stdout("CarlaEngineOsc::sendPluginDataCount(%p)", plugin.get());

  199. 

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

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

  202.     std::strcat(targetPath, "/count");

  203.     try_lo_send(fControlDataTCP.target, targetPath, "iiiiii",

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

  205.                 static_cast<int32_t>(plugin->getProgramCount()),

  206.                 static_cast<int32_t>(plugin->getMidiProgramCount()),

  207.                 static_cast<int32_t>(plugin->getCustomDataCount()),

  208.                 static_cast<int32_t>(plugin->getCurrentProgram()),

  209.                 static_cast<int32_t>(plugin->getCurrentMidiProgram()));

  210. }

  211. 

  212. void CarlaEngineOsc::sendPluginProgramCount(const CarlaPluginPtr& plugin) const noexcept

  213. {

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

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

  216.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  217.     carla_stdout("CarlaEngineOsc::sendPluginDataCount(%p)", plugin.get());

  218. 

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

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

  221.     std::strcat(targetPath, "/pcount");

  222.     try_lo_send(fControlDataTCP.target, targetPath, "iii",

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

  224.                 static_cast<int32_t>(plugin->getProgramCount()),

  225.                 static_cast<int32_t>(plugin->getMidiProgramCount()));

  226. }

  227. 

  228. void CarlaEngineOsc::sendPluginProgram(const CarlaPluginPtr& plugin, const uint32_t index) const noexcept

  229. {

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

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

  232.     carla_stdout("CarlaEngineOsc::sendPluginProgram(%p, %u)", plugin.get(), index);

  233. 

  234.     char strBuf[STR_MAX+1];

  235.     carla_zeroChars(strBuf, STR_MAX+1);

  236.     if (! plugin->getProgramName(index, strBuf))

  237.         strBuf[0] = '\0';

  238. 

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

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

  241.     std::strcat(targetPath, "/prog");

  242.     try_lo_send(fControlDataTCP.target, targetPath, "iis",

  243.                 static_cast<int32_t>(plugin->getId()), static_cast<int32_t>(index), strBuf);

  244. }

  245. 

  246. void CarlaEngineOsc::sendPluginMidiProgram(const CarlaPluginPtr& plugin, const uint32_t index) const noexcept

  247. {

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

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

  250.     carla_stdout("CarlaEngineOsc::sendPluginProgram(%p, %u)", plugin.get(), index);

  251. 

  252.     const MidiProgramData& mpdata(plugin->getMidiProgramData(index));

  253.     CARLA_SAFE_ASSERT_RETURN(mpdata.name != nullptr,);

  254. 

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

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

  257.     std::strcat(targetPath, "/mprog");

  258.     try_lo_send(fControlDataTCP.target, targetPath, "iiiis",

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

  260.                 static_cast<int32_t>(index),

  261.                 static_cast<int32_t>(mpdata.bank), static_cast<int32_t>(mpdata.program), mpdata.name);

  262. }

  263. 

  264. void CarlaEngineOsc::sendPluginCustomData(const CarlaPluginPtr& plugin, const uint32_t index) const noexcept

  265. {

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

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

  268.     carla_stdout("CarlaEngineOsc::sendPluginCustomData(%p, %u)", plugin.get(), index);

  269. 

  270.     const CustomData& cdata(plugin->getCustomData(index));

  271.     CARLA_SAFE_ASSERT_RETURN(cdata.isValid(),);

  272. 

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

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

  275.     std::strcat(targetPath, "/cdata");

  276.     try_lo_send(fControlDataTCP.target, targetPath, "iisss",

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

  278.                 static_cast<int32_t>(index),

  279.                 cdata.type, cdata.key, cdata.value);

  280. }

  281. 

  282. void CarlaEngineOsc::sendPluginInternalParameterValues(const CarlaPluginPtr& plugin) const noexcept

  283. {

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

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

  286.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  288. 

  289. #ifdef CARLA_PROPER_CPP11_SUPPORT

  290.     static_assert(PARAMETER_ACTIVE == -2 && PARAMETER_MAX == -9, "Incorrect data");

  291. #endif

  292. 

  293.     double iparams[7];

  294. 

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

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

  297. 

  298.     char targetPath[std::strlen(fControlDataTCP.path)+9];

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

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

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

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

  303.                 iparams[0], // PARAMETER_ACTIVE

  304.                 iparams[1], // PARAMETER_DRYWET

  305.                 iparams[2], // PARAMETER_VOLUME

  306.                 iparams[3], // PARAMETER_BALANCE_LEFT

  307.                 iparams[4], // PARAMETER_BALANCE_RIGHT

  308.                 iparams[5], // PARAMETER_PANNING

  309.                 iparams[6]  // PARAMETER_CTRL_CHANNEL

  310.                );

  311. }

  312. 

  313. // -----------------------------------------------------------------------

  314. 

  315. void CarlaEngineOsc::sendPing() const noexcept

  316. {

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

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

  319. 

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

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

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

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

  324. }

  325. 

  326. void CarlaEngineOsc::sendResponse(const int messageId, const char* const error) const noexcept

  327. {

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

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

  330.     carla_debug("CarlaEngineOsc::sendResponse()");

  331. 

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

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

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

  335.     try_lo_send(fControlDataTCP.target, targetPath, "is", messageId, error);

  336. }

  337. 

  338. void CarlaEngineOsc::sendExit() const noexcept

  339. {

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

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

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

  343. 

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

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

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

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

  348. }

  349. 

  350. // -----------------------------------------------------------------------

  351. 

  352. void CarlaEngineOsc::sendRuntimeInfo() const noexcept

  353. {

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

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

  356. 

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

  358. 

  359.     char targetPath[std::strlen(fControlDataUDP.path)+9];

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

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

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

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

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

  365.                 timeInfo.playing ? 1 : 0,

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

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

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

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

  370.                 timeInfo.bbt.beatsPerMinute);

  371. }

  372. 

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

  374. {

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

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

  377. 

  378.     char targetPath[std::strlen(fControlDataUDP.path)+7];

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

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

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

  382.                 static_cast<int32_t>(pluginId),

  383.                 index,

  384.                 static_cast<double>(value));

  385. }

  386. 

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

  388. {

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

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

  391. 

  392.     char targetPath[std::strlen(fControlDataUDP.path)+7];

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

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

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

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

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

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

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

  400. }

  401. 

  402. // -----------------------------------------------------------------------

  403. 

  404. CARLA_BACKEND_END_NAMESPACE

  405. 

  406. #endif // HAVE_LIBLO