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.

1163 lines
35KB

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