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.

1221 lines
38KB

  1. /*
  2. * Carla Plugin Host
  3. * Copyright (C) 2011-2014 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. #include "CarlaEngineInternal.hpp"
  18. #include "CarlaBackendUtils.hpp"
  19. #include "CarlaMathUtils.hpp"
  20. #include "RtLinkedList.hpp"
  21. #include "jackbridge/JackBridge.hpp"
  22. #include "rtaudio/RtAudio.h"
  23. #include "rtmidi/RtMidi.h"
  24. CARLA_BACKEND_START_NAMESPACE
  25. #if 0
  26. } // Fix editor indentation
  27. #endif
  28. // -------------------------------------------------------------------------------------------------------------------
  29. // Global static data
  30. static const char** gRetNames = nullptr;
  31. static std::vector<RtAudio::Api> gRtAudioApis;
  32. struct RtAudioCleanup {
  33. RtAudioCleanup() noexcept {}
  34. ~RtAudioCleanup()
  35. {
  36. if (gRetNames != nullptr)
  37. {
  38. delete[] gRetNames;
  39. gRetNames = nullptr;
  40. }
  41. gRtAudioApis.clear();
  42. }
  43. };
  44. // -------------------------------------------------------------------------------------------------------------------
  45. static void initRtAudioAPIsIfNeeded()
  46. {
  47. static const RtAudioCleanup sRtAudioCleanup;
  48. static bool needsInit = true;
  49. if (! needsInit)
  50. return;
  51. needsInit = false;
  52. RtAudio::getCompiledApi(gRtAudioApis);
  53. std::vector<RtAudio::Api>::iterator it;
  54. // remove JACK if not available
  55. if (! jackbridge_is_ok())
  56. {
  57. it = std::find(gRtAudioApis.begin(), gRtAudioApis.end(), RtAudio::UNIX_JACK);
  58. if (it != gRtAudioApis.end()) gRtAudioApis.erase(it);
  59. }
  60. #if 0//def HAVE_JUCE
  61. // prefer juce to handle some APIs
  62. it = std::find(gRtAudioApis.begin(), gRtAudioApis.end(), RtAudio::LINUX_ALSA);
  63. if (it != gRtAudioApis.end()) gRtAudioApis.erase(it);
  64. it = std::find(gRtAudioApis.begin(), gRtAudioApis.end(), RtAudio::MACOSX_CORE);
  65. if (it != gRtAudioApis.end()) gRtAudioApis.erase(it);
  66. it = std::find(gRtAudioApis.begin(), gRtAudioApis.end(), RtAudio::WINDOWS_ASIO);
  67. if (it != gRtAudioApis.end()) gRtAudioApis.erase(it);
  68. it = std::find(gRtAudioApis.begin(), gRtAudioApis.end(), RtAudio::WINDOWS_DS);
  69. if (it != gRtAudioApis.end()) gRtAudioApis.erase(it);
  70. #endif
  71. }
  72. static const char* getRtAudioApiName(const RtAudio::Api api) noexcept
  73. {
  74. switch (api)
  75. {
  76. case RtAudio::UNSPECIFIED:
  77. return "Unspecified";
  78. case RtAudio::LINUX_ALSA:
  79. return "ALSA";
  80. case RtAudio::LINUX_PULSE:
  81. return "PulseAudio";
  82. case RtAudio::LINUX_OSS:
  83. return "OSS";
  84. case RtAudio::UNIX_JACK:
  85. #if defined(CARLA_OS_WIN)
  86. return "JACK with WinMM";
  87. #elif defined(CARLA_OS_MAC)
  88. return "JACK with CoreMidi";
  89. #elif defined(CARLA_OS_LINUX)
  90. return "JACK with ALSA-MIDI";
  91. #else
  92. return "JACK (RtAudio)";
  93. #endif
  94. case RtAudio::MACOSX_CORE:
  95. return "CoreAudio";
  96. case RtAudio::WINDOWS_ASIO:
  97. return "ASIO";
  98. case RtAudio::WINDOWS_DS:
  99. return "DirectSound";
  100. case RtAudio::RTAUDIO_DUMMY:
  101. return "Dummy";
  102. }
  103. carla_stderr("CarlaBackend::getRtAudioApiName(%i) - invalid API", api);
  104. return nullptr;
  105. }
  106. static RtMidi::Api getMatchedAudioMidiAPI(const RtAudio::Api rtApi) noexcept
  107. {
  108. switch (rtApi)
  109. {
  110. case RtAudio::UNSPECIFIED:
  111. return RtMidi::UNSPECIFIED;
  112. case RtAudio::LINUX_ALSA:
  113. case RtAudio::LINUX_OSS:
  114. case RtAudio::LINUX_PULSE:
  115. return RtMidi::LINUX_ALSA;
  116. case RtAudio::UNIX_JACK:
  117. #if defined(CARLA_OS_WIN)
  118. return RtMidi::WINDOWS_MM;
  119. #elif defined(CARLA_OS_MAC)
  120. return RtMidi::MACOSX_CORE;
  121. #elif defined(CARLA_OS_LINUX)
  122. return RtMidi::LINUX_ALSA;
  123. #else
  124. return RtMidi::UNIX_JACK;
  125. #endif
  126. case RtAudio::MACOSX_CORE:
  127. return RtMidi::MACOSX_CORE;
  128. case RtAudio::WINDOWS_ASIO:
  129. case RtAudio::WINDOWS_DS:
  130. return RtMidi::WINDOWS_MM;
  131. case RtAudio::RTAUDIO_DUMMY:
  132. return RtMidi::RTMIDI_DUMMY;
  133. }
  134. return RtMidi::UNSPECIFIED;
  135. }
  136. // -------------------------------------------------------------------------------------------------------------------
  137. // RtAudio Engine
  138. class CarlaEngineRtAudio : public CarlaEngine
  139. {
  140. public:
  141. CarlaEngineRtAudio(const RtAudio::Api api)
  142. : CarlaEngine(),
  143. fAudio(api),
  144. fAudioInBuf(nullptr),
  145. fAudioInCount(0),
  146. fAudioOutBuf(nullptr),
  147. fAudioOutCount(0),
  148. fLastEventTime(0),
  149. fDummyMidiIn(getMatchedAudioMidiAPI(api), "Carla"),
  150. fDummyMidiOut(getMatchedAudioMidiAPI(api), "Carla")
  151. {
  152. carla_debug("CarlaEngineRtAudio::CarlaEngineRtAudio(%i)", api);
  153. // just to make sure
  154. pData->options.transportMode = ENGINE_TRANSPORT_MODE_INTERNAL;
  155. }
  156. ~CarlaEngineRtAudio() override
  157. {
  158. CARLA_SAFE_ASSERT(fAudioInBuf == nullptr);
  159. CARLA_SAFE_ASSERT(fAudioInCount == 0);
  160. CARLA_SAFE_ASSERT(fAudioOutBuf == nullptr);
  161. CARLA_SAFE_ASSERT(fAudioOutCount == 0);
  162. carla_debug("CarlaEngineRtAudio::~CarlaEngineRtAudio()");
  163. fUsedMidiIns.clear();
  164. fUsedMidiOuts.clear();
  165. }
  166. // -------------------------------------
  167. bool init(const char* const clientName) override
  168. {
  169. CARLA_SAFE_ASSERT_RETURN(fAudioInBuf == nullptr, false);
  170. CARLA_SAFE_ASSERT_RETURN(fAudioInCount == 0, false);
  171. CARLA_SAFE_ASSERT_RETURN(fAudioOutBuf == nullptr, false);
  172. CARLA_SAFE_ASSERT_RETURN(fAudioOutCount == 0, false);
  173. CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);
  174. carla_debug("CarlaEngineRtAudio::init(\"%s\")", clientName);
  175. if (pData->options.processMode != ENGINE_PROCESS_MODE_CONTINUOUS_RACK && pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)
  176. {
  177. setLastError("Invalid process mode");
  178. return false;
  179. }
  180. const uint devCount(fAudio.getDeviceCount());
  181. if (devCount == 0)
  182. {
  183. setLastError("No audio devices available for this driver");
  184. return false;
  185. }
  186. RtAudio::StreamParameters iParams, oParams;
  187. bool deviceSet = false;
  188. if (pData->options.audioDevice != nullptr && pData->options.audioDevice[0] != '\0')
  189. {
  190. for (uint i=0; i < devCount; ++i)
  191. {
  192. RtAudio::DeviceInfo devInfo(fAudio.getDeviceInfo(i));
  193. if (devInfo.probed && devInfo.outputChannels > 0 && devInfo.name == pData->options.audioDevice)
  194. {
  195. deviceSet = true;
  196. fDeviceName = devInfo.name.c_str();
  197. iParams.deviceId = i;
  198. oParams.deviceId = i;
  199. iParams.nChannels = devInfo.inputChannels;
  200. oParams.nChannels = devInfo.outputChannels;
  201. break;
  202. }
  203. }
  204. }
  205. if (! deviceSet)
  206. {
  207. iParams.deviceId = fAudio.getDefaultInputDevice();
  208. oParams.deviceId = fAudio.getDefaultOutputDevice();
  209. iParams.nChannels = fAudio.getDeviceInfo(iParams.deviceId).inputChannels;
  210. oParams.nChannels = fAudio.getDeviceInfo(oParams.deviceId).outputChannels;
  211. carla_stdout("No device set, using %i inputs and %i outputs", iParams.nChannels, oParams.nChannels);
  212. }
  213. if (oParams.nChannels == 0)
  214. {
  215. setLastError("Current audio setup has no outputs, cannot continue");
  216. return false;
  217. }
  218. RtAudio::StreamOptions rtOptions;
  219. rtOptions.flags = RTAUDIO_MINIMIZE_LATENCY | RTAUDIO_HOG_DEVICE | RTAUDIO_SCHEDULE_REALTIME | RTAUDIO_NONINTERLEAVED;
  220. rtOptions.streamName = clientName;
  221. rtOptions.priority = 85;
  222. if (fAudio.getCurrentApi() == RtAudio::LINUX_ALSA && ! deviceSet)
  223. rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;
  224. uint bufferFrames = pData->options.audioBufferSize;
  225. try {
  226. fAudio.openStream(&oParams, (iParams.nChannels > 0) ? &iParams : nullptr, RTAUDIO_FLOAT32, pData->options.audioSampleRate, &bufferFrames, carla_rtaudio_process_callback, this, &rtOptions);
  227. }
  228. catch (const RtError& e) {
  229. setLastError(e.what());
  230. return false;
  231. }
  232. pData->bufferSize = bufferFrames;
  233. pData->sampleRate = fAudio.getStreamSampleRate();
  234. fAudioInCount = iParams.nChannels;
  235. if (fAudioInCount > 0)
  236. {
  237. fAudioInBuf = new float*[fAudioInCount];
  238. // set as null first
  239. for (uint i=0; i < fAudioInCount; ++i)
  240. fAudioInBuf[i] = nullptr;
  241. for (uint i=0; i < fAudioInCount; ++i)
  242. {
  243. fAudioInBuf[i] = new float[pData->bufferSize];
  244. FLOAT_CLEAR(fAudioInBuf[i], pData->bufferSize);
  245. }
  246. }
  247. fAudioOutCount = oParams.nChannels;
  248. if (fAudioOutCount > 0)
  249. {
  250. fAudioOutBuf = new float*[fAudioOutCount];
  251. // set as null first
  252. for (uint i=0; i < fAudioOutCount; ++i)
  253. fAudioOutBuf[i] = nullptr;
  254. for (uint i=0; i < fAudioOutCount; ++i)
  255. {
  256. fAudioOutBuf[i] = new float[pData->bufferSize];
  257. FLOAT_CLEAR(fAudioOutBuf[i], pData->bufferSize);
  258. }
  259. }
  260. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  261. {
  262. pData->audio.inCount = 2;
  263. pData->audio.outCount = 2;
  264. }
  265. else
  266. {
  267. pData->audio.inCount = 0;
  268. pData->audio.outCount = 0;
  269. }
  270. pData->audio.create(pData->bufferSize);
  271. try {
  272. fAudio.startStream();
  273. }
  274. catch (const RtError& e)
  275. {
  276. close();
  277. setLastError(e.what());
  278. return false;
  279. }
  280. CarlaEngine::init(clientName);
  281. pData->audio.isReady = true;
  282. patchbayRefresh();
  283. return true;
  284. }
  285. bool close() override
  286. {
  287. CARLA_SAFE_ASSERT(fAudioOutBuf != nullptr);
  288. CARLA_SAFE_ASSERT(fAudioOutCount != 0);
  289. carla_debug("CarlaEngineRtAudio::close()");
  290. pData->audio.isReady = false;
  291. bool hasError = !CarlaEngine::close();
  292. if (fAudio.isStreamOpen())
  293. {
  294. if (fAudio.isStreamRunning())
  295. {
  296. try {
  297. fAudio.stopStream();
  298. }
  299. catch (const RtError& e)
  300. {
  301. if (! hasError)
  302. {
  303. setLastError(e.what());
  304. hasError = true;
  305. }
  306. }
  307. }
  308. fAudio.closeStream();
  309. }
  310. if (fAudioInBuf != nullptr)
  311. {
  312. for (uint i=0; i < fAudioInCount; ++i)
  313. {
  314. if (fAudioInBuf[i] != nullptr)
  315. {
  316. delete[] fAudioInBuf[i];
  317. fAudioInBuf[i] = nullptr;
  318. }
  319. }
  320. delete[] fAudioInBuf;
  321. fAudioInBuf = nullptr;
  322. }
  323. fAudioInCount = 0;
  324. if (fAudioOutBuf != nullptr)
  325. {
  326. for (uint i=0; i < fAudioOutCount; ++i)
  327. {
  328. if (fAudioOutBuf[i] != nullptr)
  329. {
  330. delete[] fAudioOutBuf[i];
  331. fAudioOutBuf[i] = nullptr;
  332. }
  333. }
  334. delete[] fAudioOutBuf;
  335. fAudioOutBuf = nullptr;
  336. }
  337. fAudioOutCount = 0;
  338. for (LinkedList<MidiPort>::Itenerator it = fMidiIns.begin(); it.valid(); it.next())
  339. {
  340. MidiPort& port(it.getValue());
  341. RtMidiIn* const midiInPort((RtMidiIn*)port.rtmidi);
  342. midiInPort->cancelCallback();
  343. delete midiInPort;
  344. }
  345. for (LinkedList<MidiPort>::Itenerator it = fMidiOuts.begin(); it.valid(); it.next())
  346. {
  347. MidiPort& port(it.getValue());
  348. RtMidiOut* const midiOutPort((RtMidiOut*)port.rtmidi);
  349. delete midiOutPort;
  350. }
  351. fLastEventTime = 0;
  352. fDeviceName.clear();
  353. fMidiIns.clear();
  354. fMidiOuts.clear();
  355. fMidiInEvents.clear();
  356. //fMidiOutEvents.clear();
  357. return !hasError;
  358. }
  359. bool isRunning() const noexcept override
  360. {
  361. return fAudio.isStreamRunning();
  362. }
  363. bool isOffline() const noexcept override
  364. {
  365. return false;
  366. }
  367. EngineType getType() const noexcept override
  368. {
  369. return kEngineTypeRtAudio;
  370. }
  371. const char* getCurrentDriverName() const noexcept override
  372. {
  373. return CarlaBackend::getRtAudioApiName(fAudio.getCurrentApi());
  374. }
  375. // -------------------------------------------------------------------
  376. // Patchbay
  377. bool patchbayRefresh() noexcept override
  378. {
  379. CARLA_SAFE_ASSERT_RETURN(pData->audio.isReady, false);
  380. fUsedMidiIns.clear();
  381. fUsedMidiOuts.clear();
  382. if (pData->graph.isRack)
  383. patchbayRefreshRack();
  384. else
  385. patchbayRefreshPatchbay();
  386. return true;
  387. }
  388. void patchbayRefreshRack() noexcept
  389. {
  390. RackGraph* const rack(pData->graph.rack);
  391. rack->lastConnectionId = 0;
  392. rack->usedConnections.clear();
  393. char strBuf[STR_MAX+1];
  394. strBuf[STR_MAX] = '\0';
  395. // Main
  396. {
  397. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_CARLA, PATCHBAY_ICON_CARLA, -1, 0.0f, getName());
  398. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_IN1, PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, "audio-in1");
  399. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_IN2, PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, "audio-in2");
  400. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT1, PATCHBAY_PORT_TYPE_AUDIO, 0.0f, "audio-out1");
  401. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT2, PATCHBAY_PORT_TYPE_AUDIO, 0.0f, "audio-out2");
  402. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_MIDI_IN, PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT, 0.0f, "midi-in");
  403. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_MIDI_OUT, PATCHBAY_PORT_TYPE_MIDI, 0.0f, "midi-out");
  404. }
  405. // Audio In
  406. {
  407. if (fDeviceName.isNotEmpty())
  408. std::snprintf(strBuf, STR_MAX, "Capture (%s)", fDeviceName.buffer());
  409. else
  410. std::strncpy(strBuf, "Capture", STR_MAX);
  411. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_AUDIO_IN, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);
  412. for (uint i=0; i < fAudioInCount; ++i)
  413. {
  414. std::snprintf(strBuf, STR_MAX, "capture_%i", i+1);
  415. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_AUDIO_IN, static_cast<int>(i), PATCHBAY_PORT_TYPE_AUDIO, 0.0f, strBuf);
  416. }
  417. }
  418. // Audio Out
  419. {
  420. if (fDeviceName.isNotEmpty())
  421. std::snprintf(strBuf, STR_MAX, "Playback (%s)", fDeviceName.buffer());
  422. else
  423. std::strncpy(strBuf, "Playback", STR_MAX);
  424. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_AUDIO_OUT, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);
  425. for (uint i=0; i < fAudioOutCount; ++i)
  426. {
  427. std::snprintf(strBuf, STR_MAX, "playback_%i", i+1);
  428. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_AUDIO_OUT, static_cast<int>(i), PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, strBuf);
  429. }
  430. }
  431. // MIDI In
  432. {
  433. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_MIDI_IN, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Readable MIDI ports");
  434. for (uint i=0, count=fDummyMidiIn.getPortCount(); i < count; ++i)
  435. {
  436. PortNameToId portNameToId;
  437. portNameToId.port = static_cast<int>(i);
  438. std::strncpy(portNameToId.name, fDummyMidiIn.getPortName(i).c_str(), STR_MAX);
  439. portNameToId.name[STR_MAX] = '\0';
  440. fUsedMidiIns.append(portNameToId);
  441. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_MIDI_IN, portNameToId.port, PATCHBAY_PORT_TYPE_MIDI, 0.0f, portNameToId.name);
  442. }
  443. }
  444. // MIDI Out
  445. {
  446. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_MIDI_OUT, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Writable MIDI ports");
  447. for (uint i=0, count=fDummyMidiOut.getPortCount(); i < count; ++i)
  448. {
  449. PortNameToId portNameToId;
  450. portNameToId.port = static_cast<int>(i);
  451. std::strncpy(portNameToId.name, fDummyMidiOut.getPortName(i).c_str(), STR_MAX);
  452. portNameToId.name[STR_MAX] = '\0';
  453. fUsedMidiOuts.append(portNameToId);
  454. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_MIDI_OUT, portNameToId.port, PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT, 0.0f, portNameToId.name);
  455. }
  456. }
  457. // Connections
  458. rack->connectLock.lock();
  459. for (LinkedList<int>::Itenerator it = rack->connectedIn1.begin(); it.valid(); it.next())
  460. {
  461. const int& port(it.getValue());
  462. CARLA_SAFE_ASSERT_CONTINUE(port >= 0 && port < static_cast<int>(fAudioInCount));
  463. ConnectionToId connectionToId;
  464. connectionToId.id = rack->lastConnectionId;
  465. connectionToId.groupA = RACK_GRAPH_GROUP_AUDIO_IN;
  466. connectionToId.portA = port;
  467. connectionToId.groupB = RACK_GRAPH_GROUP_CARLA;
  468. connectionToId.portB = RACK_GRAPH_CARLA_PORT_AUDIO_IN1;
  469. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  470. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  471. rack->usedConnections.append(connectionToId);
  472. ++rack->lastConnectionId;
  473. }
  474. for (LinkedList<int>::Itenerator it = rack->connectedIn2.begin(); it.valid(); it.next())
  475. {
  476. const int& port(it.getValue());
  477. CARLA_SAFE_ASSERT_CONTINUE(port >= 0 && port < static_cast<int>(fAudioInCount));
  478. ConnectionToId connectionToId;
  479. connectionToId.id = rack->lastConnectionId;
  480. connectionToId.groupA = RACK_GRAPH_GROUP_AUDIO_IN;
  481. connectionToId.portA = port;
  482. connectionToId.groupB = RACK_GRAPH_GROUP_CARLA;
  483. connectionToId.portB = RACK_GRAPH_CARLA_PORT_AUDIO_IN2;
  484. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  485. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  486. rack->usedConnections.append(connectionToId);
  487. ++rack->lastConnectionId;
  488. }
  489. for (LinkedList<int>::Itenerator it = rack->connectedOut1.begin(); it.valid(); it.next())
  490. {
  491. const int& port(it.getValue());
  492. CARLA_SAFE_ASSERT_CONTINUE(port >= 0 && port < static_cast<int>(fAudioOutCount));
  493. ConnectionToId connectionToId;
  494. connectionToId.id = rack->lastConnectionId;
  495. connectionToId.groupA = RACK_GRAPH_GROUP_CARLA;
  496. connectionToId.portA = RACK_GRAPH_CARLA_PORT_AUDIO_OUT1;
  497. connectionToId.groupB = RACK_GRAPH_GROUP_AUDIO_OUT;
  498. connectionToId.portB = port;
  499. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  500. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  501. rack->usedConnections.append(connectionToId);
  502. ++rack->lastConnectionId;
  503. }
  504. for (LinkedList<int>::Itenerator it = rack->connectedOut2.begin(); it.valid(); it.next())
  505. {
  506. const int& port(it.getValue());
  507. CARLA_SAFE_ASSERT_CONTINUE(port >= 0 && port < static_cast<int>(fAudioOutCount));
  508. ConnectionToId connectionToId;
  509. connectionToId.id = rack->lastConnectionId;
  510. connectionToId.groupA = RACK_GRAPH_GROUP_CARLA;
  511. connectionToId.portA = RACK_GRAPH_CARLA_PORT_AUDIO_OUT2;
  512. connectionToId.groupB = RACK_GRAPH_GROUP_AUDIO_OUT;
  513. connectionToId.portB = port;
  514. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  515. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  516. rack->usedConnections.append(connectionToId);
  517. ++rack->lastConnectionId;
  518. }
  519. rack->connectLock.unlock();
  520. for (LinkedList<MidiPort>::Itenerator it=fMidiIns.begin(); it.valid(); it.next())
  521. {
  522. const MidiPort& midiPort(it.getValue());
  523. ConnectionToId connectionToId;
  524. connectionToId.id = rack->lastConnectionId;
  525. connectionToId.groupA = RACK_GRAPH_GROUP_MIDI_IN;
  526. connectionToId.portA = midiPort.portId;
  527. connectionToId.groupB = RACK_GRAPH_GROUP_CARLA;
  528. connectionToId.portB = RACK_GRAPH_CARLA_PORT_MIDI_IN;
  529. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  530. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  531. rack->usedConnections.append(connectionToId);
  532. ++rack->lastConnectionId;
  533. }
  534. for (LinkedList<MidiPort>::Itenerator it=fMidiOuts.begin(); it.valid(); it.next())
  535. {
  536. const MidiPort& midiPort(it.getValue());
  537. ConnectionToId connectionToId;
  538. connectionToId.id = rack->lastConnectionId;
  539. connectionToId.groupA = RACK_GRAPH_GROUP_CARLA;
  540. connectionToId.portA = RACK_GRAPH_CARLA_PORT_MIDI_OUT;
  541. connectionToId.groupB = RACK_GRAPH_GROUP_MIDI_OUT;
  542. connectionToId.portB = midiPort.portId;
  543. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
  544. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, rack->lastConnectionId, 0, 0, 0.0f, strBuf);
  545. rack->usedConnections.append(connectionToId);
  546. ++rack->lastConnectionId;
  547. }
  548. }
  549. void patchbayRefreshPatchbay() noexcept
  550. {
  551. }
  552. // -------------------------------------------------------------------
  553. protected:
  554. void handleAudioProcessCallback(void* outputBuffer, void* inputBuffer, uint nframes, double streamTime, RtAudioStreamStatus status)
  555. {
  556. // get buffers from RtAudio
  557. float* const insPtr = (float*)inputBuffer;
  558. float* const outsPtr = (float*)outputBuffer;
  559. // assert rtaudio buffers
  560. CARLA_SAFE_ASSERT_RETURN(outputBuffer != nullptr,);
  561. CARLA_SAFE_ASSERT_RETURN(nframes == pData->bufferSize,);
  562. if (! pData->audio.isReady)
  563. return runPendingRtEvents();
  564. // initialize rtaudio input
  565. for (uint i=0; i < fAudioInCount; ++i)
  566. FLOAT_COPY(fAudioInBuf[i], insPtr+(nframes*i), nframes);
  567. // initialize rtaudio output
  568. for (uint i=0; i < fAudioOutCount; ++i)
  569. FLOAT_CLEAR(fAudioOutBuf[i], nframes);
  570. // initialize input events
  571. carla_zeroStruct<EngineEvent>(pData->events.in, kMaxEngineEventInternalCount);
  572. if (fMidiInEvents.mutex.tryLock())
  573. {
  574. uint32_t engineEventIndex = 0;
  575. fMidiInEvents.splice();
  576. for (LinkedList<RtMidiEvent>::Itenerator it = fMidiInEvents.data.begin(); it.valid(); it.next())
  577. {
  578. const RtMidiEvent& midiEvent(it.getValue());
  579. EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
  580. if (midiEvent.time < pData->timeInfo.frame)
  581. {
  582. engineEvent.time = 0;
  583. }
  584. else if (midiEvent.time >= pData->timeInfo.frame + nframes)
  585. {
  586. carla_stderr("MIDI Event in the future!, %i vs %i", engineEvent.time, pData->timeInfo.frame);
  587. engineEvent.time = static_cast<uint32_t>(pData->timeInfo.frame) + nframes - 1;
  588. }
  589. else
  590. engineEvent.time = static_cast<uint32_t>(midiEvent.time - pData->timeInfo.frame);
  591. engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data);
  592. if (engineEventIndex >= kMaxEngineEventInternalCount)
  593. break;
  594. }
  595. fMidiInEvents.data.clear();
  596. fMidiInEvents.mutex.unlock();
  597. }
  598. if (pData->graph.isRack)
  599. {
  600. pData->processRackFull(fAudioInBuf, fAudioInCount, fAudioOutBuf, fAudioOutCount, nframes, false);
  601. }
  602. else
  603. {
  604. }
  605. // output audio
  606. for (uint i=0; i < fAudioOutCount; ++i)
  607. FLOAT_COPY(outsPtr+(nframes*i), fAudioOutBuf[i], nframes);
  608. // output events
  609. {
  610. // TODO
  611. //fMidiOutEvents...
  612. }
  613. runPendingRtEvents();
  614. return;
  615. // unused
  616. (void)streamTime;
  617. (void)status;
  618. }
  619. void handleMidiCallback(double timeStamp, std::vector<uchar>* const message)
  620. {
  621. if (! pData->audio.isReady)
  622. return;
  623. const size_t messageSize(message->size());
  624. if (messageSize == 0 || messageSize > EngineMidiEvent::kDataSize)
  625. return;
  626. timeStamp /= 2;
  627. if (timeStamp > 0.95)
  628. timeStamp = 0.95;
  629. else if (timeStamp < 0.0)
  630. timeStamp = 0.0;
  631. RtMidiEvent midiEvent;
  632. midiEvent.time = pData->timeInfo.frame + uint64_t(timeStamp * (double)pData->bufferSize);
  633. if (midiEvent.time < fLastEventTime)
  634. midiEvent.time = fLastEventTime;
  635. else
  636. fLastEventTime = midiEvent.time;
  637. midiEvent.size = static_cast<uint8_t>(messageSize);
  638. size_t i=0;
  639. for (; i < messageSize; ++i)
  640. midiEvent.data[i] = message->at(i);
  641. for (; i < EngineMidiEvent::kDataSize; ++i)
  642. midiEvent.data[i] = 0;
  643. fMidiInEvents.append(midiEvent);
  644. }
  645. // -------------------------------------------------------------------
  646. bool connectRackMidiInPort(const int portId) override
  647. {
  648. CARLA_SAFE_ASSERT_RETURN(fUsedMidiIns.count() > 0, false);
  649. CARLA_SAFE_ASSERT_RETURN(portId >= 0, false);
  650. CARLA_SAFE_ASSERT_RETURN(static_cast<size_t>(portId) < fUsedMidiIns.count(), false);
  651. carla_debug("CarlaEngineRtAudio::connectRackMidiInPort(%i)", portId);
  652. const PortNameToId fallback = { 0, { '\0' } };
  653. const char* const portName(fUsedMidiIns.getAt(static_cast<size_t>(portId), fallback).name);
  654. char newPortName[STR_MAX+1];
  655. std::snprintf(newPortName, STR_MAX, "%s:in-%i", getName(), portId+1);
  656. bool found = false;
  657. uint rtMidiPortIndex;
  658. RtMidiIn* const rtMidiIn(new RtMidiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newPortName, 512));
  659. rtMidiIn->ignoreTypes();
  660. rtMidiIn->setCallback(carla_rtmidi_callback, this);
  661. for (uint i=0, count=rtMidiIn->getPortCount(); i < count; ++i)
  662. {
  663. if (rtMidiIn->getPortName(i) == portName)
  664. {
  665. found = true;
  666. rtMidiPortIndex = i;
  667. break;
  668. }
  669. }
  670. if (! found)
  671. {
  672. delete rtMidiIn;
  673. return false;
  674. }
  675. rtMidiIn->openPort(rtMidiPortIndex, newPortName+(std::strlen(getName())+1));
  676. MidiPort midiPort;
  677. midiPort.portId = portId;
  678. midiPort.rtmidi = rtMidiIn;
  679. fMidiIns.append(midiPort);
  680. return true;
  681. }
  682. bool connectRackMidiOutPort(const int portId) override
  683. {
  684. CARLA_SAFE_ASSERT_RETURN(fUsedMidiOuts.count() > 0, false);
  685. CARLA_SAFE_ASSERT_RETURN(portId >= 0, false);
  686. CARLA_SAFE_ASSERT_RETURN(static_cast<size_t>(portId) < fUsedMidiOuts.count(), false);
  687. carla_debug("CarlaEngineRtAudio::connectRackMidiOutPort(%i)", portId);
  688. const PortNameToId fallback = { 0, { '\0' } };
  689. const char* const portName(fUsedMidiOuts.getAt(static_cast<size_t>(portId), fallback).name);
  690. char newPortName[STR_MAX+1];
  691. std::snprintf(newPortName, STR_MAX, "%s:out-%i", getName(), portId+1);
  692. bool found = false;
  693. uint rtMidiPortIndex;
  694. RtMidiOut* const rtMidiOut(new RtMidiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newPortName));
  695. for (uint i=0, count=rtMidiOut->getPortCount(); i < count; ++i)
  696. {
  697. if (rtMidiOut->getPortName(i) == portName)
  698. {
  699. found = true;
  700. rtMidiPortIndex = i;
  701. break;
  702. }
  703. }
  704. if (! found)
  705. {
  706. delete rtMidiOut;
  707. return false;
  708. }
  709. rtMidiOut->openPort(rtMidiPortIndex, newPortName+(std::strlen(getName())+1));
  710. MidiPort midiPort;
  711. midiPort.portId = portId;
  712. midiPort.rtmidi = rtMidiOut;
  713. fMidiOuts.append(midiPort);
  714. return true;
  715. }
  716. bool disconnectRackMidiInPort(const int portId) override
  717. {
  718. CARLA_SAFE_ASSERT_RETURN(fUsedMidiIns.count() > 0, false);
  719. CARLA_SAFE_ASSERT_RETURN(portId >= 0, false);
  720. CARLA_SAFE_ASSERT_RETURN(static_cast<size_t>(portId) < fUsedMidiIns.count(), false);
  721. carla_debug("CarlaEngineRtAudio::connectRackMidiInPort(%i)", portId);
  722. for (LinkedList<MidiPort>::Itenerator it=fMidiOuts.begin(); it.valid(); it.next())
  723. {
  724. MidiPort& midiPort(it.getValue());
  725. if (midiPort.portId == portId)
  726. {
  727. RtMidiOut* const midiOutPort((RtMidiOut*)midiPort.rtmidi);
  728. delete midiOutPort;
  729. fMidiOuts.remove(it);
  730. return true;
  731. }
  732. }
  733. return false;
  734. }
  735. bool disconnectRackMidiOutPort(const int portId) override
  736. {
  737. CARLA_SAFE_ASSERT_RETURN(fUsedMidiOuts.count() > 0, false);
  738. CARLA_SAFE_ASSERT_RETURN(portId >= 0, false);
  739. CARLA_SAFE_ASSERT_RETURN(static_cast<size_t>(portId) < fUsedMidiOuts.count(), false);
  740. carla_debug("CarlaEngineRtAudio::disconnectRackMidiOutPort(%i)", portId);
  741. for (LinkedList<MidiPort>::Itenerator it=fMidiIns.begin(); it.valid(); it.next())
  742. {
  743. MidiPort& midiPort(it.getValue());
  744. if (midiPort.portId == portId)
  745. {
  746. RtMidiIn* const midiInPort((RtMidiIn*)midiPort.rtmidi);
  747. midiInPort->cancelCallback();
  748. delete midiInPort;
  749. fMidiIns.remove(it);
  750. return true;
  751. }
  752. }
  753. return false;
  754. }
  755. // -------------------------------------------------------------------
  756. private:
  757. RtAudio fAudio;
  758. // audio copy to split and de-interleave rtaudio buffers
  759. float** fAudioInBuf;
  760. uint fAudioInCount;
  761. float** fAudioOutBuf;
  762. uint fAudioOutCount;
  763. // useful info
  764. uint64_t fLastEventTime;
  765. // current device name
  766. CarlaString fDeviceName;
  767. // dummy rtmidi to scan available ports
  768. RtMidiIn fDummyMidiIn;
  769. RtMidiOut fDummyMidiOut;
  770. LinkedList<PortNameToId> fUsedMidiIns;
  771. LinkedList<PortNameToId> fUsedMidiOuts;
  772. struct MidiPort {
  773. RtMidi* rtmidi;
  774. int portId;
  775. };
  776. LinkedList<MidiPort> fMidiIns;
  777. LinkedList<MidiPort> fMidiOuts;
  778. struct RtMidiEvent {
  779. uint64_t time; // needs to compare to internal time
  780. uint8_t size;
  781. uint8_t data[EngineMidiEvent::kDataSize];
  782. };
  783. struct RtMidiEvents {
  784. CarlaMutex mutex;
  785. RtLinkedList<RtMidiEvent>::Pool dataPool;
  786. RtLinkedList<RtMidiEvent> data;
  787. RtLinkedList<RtMidiEvent> dataPending;
  788. RtMidiEvents()
  789. : dataPool(512, 512),
  790. data(dataPool),
  791. dataPending(dataPool) {}
  792. ~RtMidiEvents()
  793. {
  794. clear();
  795. }
  796. void append(const RtMidiEvent& event)
  797. {
  798. mutex.lock();
  799. dataPending.append(event);
  800. mutex.unlock();
  801. }
  802. void clear()
  803. {
  804. mutex.lock();
  805. data.clear();
  806. dataPending.clear();
  807. mutex.unlock();
  808. }
  809. void splice()
  810. {
  811. dataPending.spliceAppendTo(data);
  812. }
  813. };
  814. RtMidiEvents fMidiInEvents;
  815. //RtMidiEvents fMidiOutEvents;
  816. #define handlePtr ((CarlaEngineRtAudio*)userData)
  817. static int carla_rtaudio_process_callback(void* outputBuffer, void* inputBuffer, uint nframes, double streamTime, RtAudioStreamStatus status, void* userData)
  818. {
  819. handlePtr->handleAudioProcessCallback(outputBuffer, inputBuffer, nframes, streamTime, status);
  820. return 0;
  821. }
  822. static void carla_rtmidi_callback(double timeStamp, std::vector<uchar>* message, void* userData)
  823. {
  824. handlePtr->handleMidiCallback(timeStamp, message);
  825. }
  826. #undef handlePtr
  827. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)
  828. };
  829. // -----------------------------------------
  830. CarlaEngine* CarlaEngine::newRtAudio(const AudioApi api)
  831. {
  832. initRtAudioAPIsIfNeeded();
  833. RtAudio::Api rtApi(RtAudio::UNSPECIFIED);
  834. switch (api)
  835. {
  836. case AUDIO_API_NULL:
  837. rtApi = RtAudio::RTAUDIO_DUMMY;
  838. break;
  839. case AUDIO_API_JACK:
  840. rtApi = RtAudio::UNIX_JACK;
  841. break;
  842. case AUDIO_API_ALSA:
  843. rtApi = RtAudio::LINUX_ALSA;
  844. break;
  845. case AUDIO_API_OSS:
  846. rtApi = RtAudio::LINUX_OSS;
  847. break;
  848. case AUDIO_API_PULSE:
  849. rtApi = RtAudio::LINUX_PULSE;
  850. break;
  851. case AUDIO_API_CORE:
  852. rtApi = RtAudio::MACOSX_CORE;
  853. break;
  854. case AUDIO_API_ASIO:
  855. rtApi = RtAudio::WINDOWS_ASIO;
  856. break;
  857. case AUDIO_API_DS:
  858. rtApi = RtAudio::WINDOWS_DS;
  859. break;
  860. }
  861. return new CarlaEngineRtAudio(rtApi);
  862. }
  863. uint CarlaEngine::getRtAudioApiCount()
  864. {
  865. initRtAudioAPIsIfNeeded();
  866. return static_cast<uint>(gRtAudioApis.size());
  867. }
  868. const char* CarlaEngine::getRtAudioApiName(const uint index)
  869. {
  870. initRtAudioAPIsIfNeeded();
  871. if (index >= gRtAudioApis.size())
  872. return nullptr;
  873. return CarlaBackend::getRtAudioApiName(gRtAudioApis[index]);
  874. }
  875. const char* const* CarlaEngine::getRtAudioApiDeviceNames(const uint index)
  876. {
  877. initRtAudioAPIsIfNeeded();
  878. if (index >= gRtAudioApis.size())
  879. return nullptr;
  880. const RtAudio::Api& api(gRtAudioApis[index]);
  881. RtAudio rtAudio(api);
  882. const uint devCount(rtAudio.getDeviceCount());
  883. if (devCount == 0)
  884. return nullptr;
  885. LinkedList<const char*> devNames;
  886. for (uint i=0; i < devCount; ++i)
  887. {
  888. RtAudio::DeviceInfo devInfo(rtAudio.getDeviceInfo(i));
  889. if (devInfo.probed && devInfo.outputChannels > 0 /*&& (devInfo.nativeFormats & RTAUDIO_FLOAT32) != 0*/)
  890. devNames.append(carla_strdup(devInfo.name.c_str()));
  891. }
  892. const size_t realDevCount(devNames.count());
  893. if (gRetNames != nullptr)
  894. {
  895. for (int i=0; gRetNames[i] != nullptr; ++i)
  896. delete[] gRetNames[i];
  897. delete[] gRetNames;
  898. }
  899. gRetNames = new const char*[realDevCount+1];
  900. for (size_t i=0; i < realDevCount; ++i)
  901. gRetNames[i] = devNames.getAt(i, nullptr);
  902. gRetNames[realDevCount] = nullptr;
  903. devNames.clear();
  904. return gRetNames;
  905. }
  906. const EngineDriverDeviceInfo* CarlaEngine::getRtAudioDeviceInfo(const uint index, const char* const deviceName)
  907. {
  908. initRtAudioAPIsIfNeeded();
  909. if (index >= gRtAudioApis.size())
  910. return nullptr;
  911. const RtAudio::Api& api(gRtAudioApis[index]);
  912. RtAudio rtAudio(api);
  913. const uint devCount(rtAudio.getDeviceCount());
  914. if (devCount == 0)
  915. return nullptr;
  916. uint i;
  917. RtAudio::DeviceInfo rtAudioDevInfo;
  918. for (i=0; i < devCount; ++i)
  919. {
  920. rtAudioDevInfo = rtAudio.getDeviceInfo(i);
  921. if (rtAudioDevInfo.name == deviceName)
  922. break;
  923. }
  924. if (i == devCount)
  925. return nullptr;
  926. static EngineDriverDeviceInfo devInfo = { 0x0, nullptr, nullptr };
  927. static uint32_t dummyBufferSizes[11] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 0 };
  928. static double dummySampleRates[14] = { 22050.0, 32000.0, 44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0, 0.0 };
  929. // reset
  930. devInfo.hints = 0x0;
  931. devInfo.bufferSizes = dummyBufferSizes;
  932. // cleanup
  933. if (devInfo.sampleRates != nullptr && devInfo.sampleRates != dummySampleRates)
  934. {
  935. delete[] devInfo.sampleRates;
  936. devInfo.sampleRates = nullptr;
  937. }
  938. if (size_t sampleRatesCount = rtAudioDevInfo.sampleRates.size())
  939. {
  940. double* const sampleRates(new double[sampleRatesCount+1]);
  941. for (size_t j=0; j < sampleRatesCount; ++j)
  942. sampleRates[j] = rtAudioDevInfo.sampleRates[j];
  943. sampleRates[sampleRatesCount] = 0.0;
  944. devInfo.sampleRates = sampleRates;
  945. }
  946. else
  947. {
  948. devInfo.sampleRates = dummySampleRates;
  949. }
  950. return &devInfo;
  951. }
  952. // -----------------------------------------
  953. CARLA_BACKEND_END_NAMESPACE