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

368 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.     plugin->getRealName(bufRealName);

  64.     plugin->getLabel(bufLabel);

  65.     plugin->getMaker(bufMaker);

  66.     plugin->getCopyright(bufCopyright);

  67. 

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

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

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

  71. 

  72.     if (name == nullptr)

  73.         name = kNullString;

  74.     if (filename == nullptr)

  75.         filename = kNullString;

  76.     if (iconName == nullptr)

  77.         iconName = kNullString;

  78. 

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

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

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

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

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

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

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

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

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

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

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

  90.                 name, filename, iconName,

  91.                 bufRealName, bufLabel, bufMaker, bufCopyright);

  92. }

  93. 

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

  95. {

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

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

  98.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  100. 

  101.     uint32_t paramIns, paramOuts;

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

  103. 

  104.     if (paramIns > 49)

  105.         paramIns = 49;

  106.     if (paramOuts > 49)

  107.         paramOuts = 49;

  108. 

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

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

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

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

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

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

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

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

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

  118.                 static_cast<int32_t>(paramIns),

  119.                 static_cast<int32_t>(paramOuts),

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

  121. }

  122. 

  123. void CarlaEngineOsc::sendPluginParameterInfo(const CarlaPlugin* const plugin, const uint32_t index) const noexcept

  124. {

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

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

  127.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  129. 

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

  131.     carla_zeroChars(bufName, STR_MAX+1);

  132.     carla_zeroChars(bufUnit, STR_MAX+1);

  133. 

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

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

  136. 

  137.     plugin->getParameterName(index, bufName);

  138.     plugin->getParameterUnit(index, bufUnit);

  139. 

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

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

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

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

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

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

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

  147.                 bufName, bufUnit,

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

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

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

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

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

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

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

  155. }

  156. 

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

  158. {

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

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

  161.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  163. 

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

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

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

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

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

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

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

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

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

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

  174. }

  175. 

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

  177. {

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

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

  180.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  182. 

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

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

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

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

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

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

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

  190. }

  191. 

  192. void CarlaEngineOsc::sendPluginProgram(const CarlaPlugin* const plugin, const uint32_t index) const noexcept

  193. {

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

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

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

  197. 

  198.     char strBuf[STR_MAX+1];

  199.     carla_zeroChars(strBuf, STR_MAX+1);

  200.     plugin->getProgramName(index, strBuf);

  201. 

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

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

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

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

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

  207. }

  208. 

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

  214. 

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

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

  217. 

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

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

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

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

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

  223.                 static_cast<int32_t>(index),

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

  225. }

  226. 

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

  228. {

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

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

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

  232. 

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

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

  235. 

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

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

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

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

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

  241.                 static_cast<int32_t>(index),

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

  243. }

  244. 

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

  246. {

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

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

  249.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  251. 

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

  253. 

  254.     double iparams[7];

  255. 

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

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

  258. 

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

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

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

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

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

  264.                 iparams[0], // PARAMETER_ACTIVE

  265.                 iparams[1], // PARAMETER_DRYWET

  266.                 iparams[2], // PARAMETER_VOLUME

  267.                 iparams[3], // PARAMETER_BALANCE_LEFT

  268.                 iparams[4], // PARAMETER_BALANCE_RIGHT

  269.                 iparams[5], // PARAMETER_PANNING

  270.                 iparams[6]  // PARAMETER_CTRL_CHANNEL

  271.                );

  272. }

  273. 

  274. // -----------------------------------------------------------------------

  275. 

  276. void CarlaEngineOsc::sendPing() 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)+6];

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

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

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

  285. }

  286. 

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

  288. {

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

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

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

  292. 

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

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

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

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

  297. }

  298. 

  299. void CarlaEngineOsc::sendExit() const noexcept

  300. {

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

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

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

  304. 

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

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

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

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

  309. }

  310. 

  311. // -----------------------------------------------------------------------

  312. 

  313. void CarlaEngineOsc::sendRuntimeInfo() const noexcept

  314. {

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

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

  317. 

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

  319. 

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

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

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

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

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

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

  326.                 timeInfo.playing ? 1 : 0,

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

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

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

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

  331.                 timeInfo.bbt.beatsPerMinute);

  332. }

  333. 

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

  335. {

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

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

  338. 

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

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

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

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

  343.                 static_cast<int32_t>(pluginId),

  344.                 index,

  345.                 static_cast<double>(value));

  346. }

  347. 

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

  349. {

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

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

  352. 

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

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

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

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

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

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

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

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

  361. }

  362. 

  363. // -----------------------------------------------------------------------

  364. 

  365. CARLA_BACKEND_END_NAMESPACE

  366. 

  367. #endif // HAVE_LIBLO