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

375 lines
16KB
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)+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 : kNullString);

  48. }

  49. 

  50. void CarlaEngineOsc::sendPluginInfo(const CarlaPlugin* const 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);

  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)+10];

  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 CarlaPlugin* const 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);

  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 CarlaPlugin* const 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, index);

  133. 

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

  135.     carla_zeroChars(bufName, STR_MAX+1);

  136.     carla_zeroChars(bufUnit, STR_MAX+1);

  137. 

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

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

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

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

  142. 

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

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

  145. 

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

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

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

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

  150.                 static_cast<int32_t>(plugin->getId()), static_cast<int32_t>(index),

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

  152.                 static_cast<int32_t>(paramData.mappedControlIndex), static_cast<int32_t>(paramData.midiChannel),

  153.                 bufName, bufUnit,

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

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

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

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

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

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

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

  161. }

  162. 

  163. void CarlaEngineOsc::sendPluginDataCount(const CarlaPlugin* const plugin) const noexcept

  164. {

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

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

  167.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  169. 

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

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

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

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

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

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

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

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

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

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

  180. }

  181. 

  182. void CarlaEngineOsc::sendPluginProgramCount(const CarlaPlugin* const plugin) const noexcept

  183. {

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

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

  186.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  188. 

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

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

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

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

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

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

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

  196. }

  197. 

  198. void CarlaEngineOsc::sendPluginProgram(const CarlaPlugin* const plugin, const uint32_t index) 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_stdout("CarlaEngineOsc::sendPluginProgram(%p, %u)", plugin, index);

  203. 

  204.     char strBuf[STR_MAX+1];

  205.     carla_zeroChars(strBuf, STR_MAX+1);

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

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

  208. 

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

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

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

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

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

  214. }

  215. 

  216. void CarlaEngineOsc::sendPluginMidiProgram(const CarlaPlugin* const plugin, const uint32_t index) const noexcept

  217. {

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

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

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

  221. 

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

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

  224. 

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

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

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

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

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

  230.                 static_cast<int32_t>(index),

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

  232. }

  233. 

  234. void CarlaEngineOsc::sendPluginCustomData(const CarlaPlugin* const plugin, const uint32_t index) const noexcept

  235. {

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

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

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

  239. 

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

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

  242. 

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

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

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

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

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

  248.                 static_cast<int32_t>(index),

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

  250. }

  251. 

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

  253. {

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

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

  256.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  258. 

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

  260. 

  261.     double iparams[7];

  262. 

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

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

  265. 

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

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

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

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

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

  271.                 iparams[0], // PARAMETER_ACTIVE

  272.                 iparams[1], // PARAMETER_DRYWET

  273.                 iparams[2], // PARAMETER_VOLUME

  274.                 iparams[3], // PARAMETER_BALANCE_LEFT

  275.                 iparams[4], // PARAMETER_BALANCE_RIGHT

  276.                 iparams[5], // PARAMETER_PANNING

  277.                 iparams[6]  // PARAMETER_CTRL_CHANNEL

  278.                );

  279. }

  280. 

  281. // -----------------------------------------------------------------------

  282. 

  283. void CarlaEngineOsc::sendPing() const noexcept

  284. {

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

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

  287. 

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

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

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

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

  292. }

  293. 

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

  295. {

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

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

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

  299. 

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

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

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

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

  304. }

  305. 

  306. void CarlaEngineOsc::sendExit() const noexcept

  307. {

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

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

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

  311. 

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

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

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

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

  316. }

  317. 

  318. // -----------------------------------------------------------------------

  319. 

  320. void CarlaEngineOsc::sendRuntimeInfo() const noexcept

  321. {

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

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

  324. 

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

  326. 

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

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

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

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

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

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

  333.                 timeInfo.playing ? 1 : 0,

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

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

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

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

  338.                 timeInfo.bbt.beatsPerMinute);

  339. }

  340. 

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

  342. {

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

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

  345. 

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

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

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

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

  350.                 static_cast<int32_t>(pluginId),

  351.                 index,

  352.                 static_cast<double>(value));

  353. }

  354. 

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

  356. {

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

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

  359. 

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

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

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

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

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

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

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

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

  368. }

  369. 

  370. // -----------------------------------------------------------------------

  371. 

  372. CARLA_BACKEND_END_NAMESPACE

  373. 

  374. #endif // HAVE_LIBLO