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.
2815 Commits
16 Branches
275MB
Tree: 4018cdff82
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4018cdff82'
${ noResults }
Carla/source/backend/engine/CarlaEngineRtAudio.cpp

1238 lines
39KB
Raw Blame History 

  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. 

  18. #include "CarlaEngineGraph.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. #include "CarlaBackendUtils.hpp"

  21. #include "CarlaMathUtils.hpp"

  22. #include "CarlaStringList.hpp"

  23. 

  24. #include "RtLinkedList.hpp"

  25. 

  26. #include "jackbridge/JackBridge.hpp"

  27. #include "juce_audio_basics.h"

  28. 

  29. #include "rtaudio/RtAudio.h"

  30. #include "rtmidi/RtMidi.h"

  31. 

  32. using juce::jmax;

  33. using juce::AudioSampleBuffer;

  34. using juce::FloatVectorOperations;

  35. 

  36. CARLA_BACKEND_START_NAMESPACE

  37. 

  38. // -------------------------------------------------------------------------------------------------------------------

  39. // Global static data

  40. 

  41. static CharStringListPtr         gDeviceNames;

  42. static std::vector<RtAudio::Api> gRtAudioApis;

  43. 

  44. // -------------------------------------------------------------------------------------------------------------------

  45. 

  46. static void initRtAudioAPIsIfNeeded()

  47. {

  48.     static bool needsInit = true;

  49. 

  50.     if (! needsInit)

  51.         return;

  52. 

  53.     needsInit = false;

  54. 

  55.     // get APIs in a local var, and pass wanted ones into gRtAudioApis

  56. 

  57.     std::vector<RtAudio::Api> apis;

  58.     RtAudio::getCompiledApi(apis);

  59. 

  60.     for (std::vector<RtAudio::Api>::iterator it = apis.begin(), end = apis.end(); it != end; ++it)

  61.     {

  62.         const RtAudio::Api& api(*it);

  63. 

  64.         if (api == RtAudio::MACOSX_CORE)

  65.             continue;

  66.         if (api == RtAudio::WINDOWS_ASIO)

  67.             continue;

  68.         if (api == RtAudio::WINDOWS_DS)

  69.             continue;

  70.         if (api == RtAudio::WINDOWS_WASAPI)

  71.             continue;

  72.         if (api == RtAudio::UNIX_JACK && ! jackbridge_is_ok())

  73.             continue;

  74. 

  75.         gRtAudioApis.push_back(api);

  76.     }

  77. }

  78. 

  79. static const char* getRtAudioApiName(const RtAudio::Api api) noexcept

  80. {

  81.     switch (api)

  82.     {

  83.     case RtAudio::UNSPECIFIED:

  84.         return "Unspecified";

  85.     case RtAudio::LINUX_ALSA:

  86.         return "ALSA";

  87.     case RtAudio::LINUX_PULSE:

  88.         return "PulseAudio";

  89.     case RtAudio::LINUX_OSS:

  90.         return "OSS";

  91.     case RtAudio::UNIX_JACK:

  92. #if defined(CARLA_OS_WIN)

  93.         return "JACK with WinMM";

  94. #elif defined(CARLA_OS_MAC)

  95.         return "JACK with CoreMidi";

  96. #elif defined(CARLA_OS_LINUX)

  97.         return "JACK with ALSA-MIDI";

  98. #else

  99.         return "JACK (RtAudio)";

  100. #endif

  101.     case RtAudio::MACOSX_CORE:

  102.         return "CoreAudio";

  103.     case RtAudio::WINDOWS_ASIO:

  104.         return "ASIO";

  105.     case RtAudio::WINDOWS_DS:

  106.         return "DirectSound";

  107.     case RtAudio::WINDOWS_WASAPI:

  108.         return "WASAPI";

  109.     case RtAudio::RTAUDIO_DUMMY:

  110.         return "Dummy";

  111.     }

  112. 

  113.     carla_stderr("CarlaBackend::getRtAudioApiName(%i) - invalid API", api);

  114.     return nullptr;

  115. }

  116. 

  117. static RtMidi::Api getMatchedAudioMidiAPI(const RtAudio::Api rtApi) noexcept

  118. {

  119.     switch (rtApi)

  120.     {

  121.     case RtAudio::UNSPECIFIED:

  122.         return RtMidi::UNSPECIFIED;

  123. 

  124.     case RtAudio::LINUX_ALSA:

  125.     case RtAudio::LINUX_OSS:

  126.     case RtAudio::LINUX_PULSE:

  127.         return RtMidi::LINUX_ALSA;

  128. 

  129.     case RtAudio::UNIX_JACK:

  130. #if defined(CARLA_OS_WIN)

  131.         return RtMidi::WINDOWS_MM;

  132. #elif defined(CARLA_OS_MAC)

  133.         return RtMidi::MACOSX_CORE;

  134. #elif defined(CARLA_OS_LINUX)

  135.         return RtMidi::LINUX_ALSA;

  136. #else

  137.         return RtMidi::UNIX_JACK;

  138. #endif

  139. 

  140.     case RtAudio::MACOSX_CORE:

  141.         return RtMidi::MACOSX_CORE;

  142. 

  143.     case RtAudio::WINDOWS_ASIO:

  144.     case RtAudio::WINDOWS_DS:

  145.     case RtAudio::WINDOWS_WASAPI:

  146.         return RtMidi::WINDOWS_MM;

  147. 

  148.     case RtAudio::RTAUDIO_DUMMY:

  149.         return RtMidi::RTMIDI_DUMMY;

  150.     }

  151. 

  152.     return RtMidi::UNSPECIFIED;

  153. }

  154. 

  155. // -------------------------------------------------------------------------------------------------------------------

  156. // RtAudio Engine

  157. 

  158. class CarlaEngineRtAudio : public CarlaEngine

  159. {

  160. public:

  161.     CarlaEngineRtAudio(const RtAudio::Api api)

  162.         : CarlaEngine(),

  163.           fAudio(api),

  164.           fAudioInterleaved(false),

  165.           fAudioInCount(0),

  166.           fAudioOutCount(0),

  167.           fLastEventTime(0),

  168.           fDeviceName(),

  169.           fAudioIntBufIn(),

  170.           fAudioIntBufOut(),

  171.           fMidiIns(),

  172.           fMidiInEvents(),

  173.           fMidiOuts(),

  174.           fMidiOutMutex(),

  175.           fMidiOutVector(3),

  176.           leakDetector_CarlaEngineRtAudio()

  177.     {

  178.         carla_debug("CarlaEngineRtAudio::CarlaEngineRtAudio(%i)", api);

  179. 

  180.         // just to make sure

  181.         pData->options.transportMode = ENGINE_TRANSPORT_MODE_INTERNAL;

  182.     }

  183. 

  184.     ~CarlaEngineRtAudio() override

  185.     {

  186.         CARLA_SAFE_ASSERT(fAudioInCount == 0);

  187.         CARLA_SAFE_ASSERT(fAudioOutCount == 0);

  188.         CARLA_SAFE_ASSERT(fLastEventTime == 0);

  189.         carla_debug("CarlaEngineRtAudio::~CarlaEngineRtAudio()");

  190.     }

  191. 

  192.     // -------------------------------------

  193. 

  194.     bool init(const char* const clientName) override

  195.     {

  196.         CARLA_SAFE_ASSERT_RETURN(fAudioInCount == 0, false);

  197.         CARLA_SAFE_ASSERT_RETURN(fAudioOutCount == 0, false);

  198.         CARLA_SAFE_ASSERT_RETURN(fLastEventTime == 0, false);

  199.         CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);

  200.         carla_debug("CarlaEngineRtAudio::init(\"%s\")", clientName);

  201. 

  202.         if (pData->options.processMode != ENGINE_PROCESS_MODE_CONTINUOUS_RACK && pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  203.         {

  204.             setLastError("Invalid process mode");

  205.             return false;

  206.         }

  207. 

  208.         const uint devCount(fAudio.getDeviceCount());

  209. 

  210.         if (devCount == 0)

  211.         {

  212.             setLastError("No audio devices available for this driver");

  213.             return false;

  214.         }

  215. 

  216.         RtAudio::StreamParameters iParams, oParams;

  217.         bool deviceSet = false;

  218. 

  219.         if (pData->options.audioDevice != nullptr && pData->options.audioDevice[0] != '\0')

  220.         {

  221.             for (uint i=0; i < devCount; ++i)

  222.             {

  223.                 RtAudio::DeviceInfo devInfo(fAudio.getDeviceInfo(i));

  224. 

  225.                 if (devInfo.probed && devInfo.outputChannels > 0 && devInfo.name == pData->options.audioDevice)

  226.                 {

  227.                     deviceSet   = true;

  228.                     fDeviceName = devInfo.name.c_str();

  229.                     iParams.deviceId  = i;

  230.                     oParams.deviceId  = i;

  231.                     iParams.nChannels = devInfo.inputChannels;

  232.                     oParams.nChannels = devInfo.outputChannels;

  233.                     break;

  234.                 }

  235.             }

  236.         }

  237. 

  238.         if (! deviceSet)

  239.         {

  240.             iParams.deviceId  = fAudio.getDefaultInputDevice();

  241.             oParams.deviceId  = fAudio.getDefaultOutputDevice();

  242.             iParams.nChannels = fAudio.getDeviceInfo(iParams.deviceId).inputChannels;

  243.             oParams.nChannels = fAudio.getDeviceInfo(oParams.deviceId).outputChannels;

  244. 

  245.             carla_stdout("No device set, using %i inputs and %i outputs", iParams.nChannels, oParams.nChannels);

  246.         }

  247. 

  248.         if (oParams.nChannels == 0)

  249.         {

  250.             setLastError("Current audio setup has no outputs, cannot continue");

  251.             return false;

  252.         }

  253. 

  254.         iParams.nChannels = carla_fixValue(0U, 128U, iParams.nChannels);

  255.         oParams.nChannels = carla_fixValue(0U, 128U, oParams.nChannels);

  256.         fAudioInterleaved = fAudio.getCurrentApi() == RtAudio::LINUX_PULSE;

  257. 

  258.         RtAudio::StreamOptions rtOptions;

  259.         rtOptions.flags = RTAUDIO_MINIMIZE_LATENCY | RTAUDIO_HOG_DEVICE | RTAUDIO_SCHEDULE_REALTIME;

  260.         rtOptions.numberOfBuffers = pData->options.audioNumPeriods;

  261.         rtOptions.streamName = clientName;

  262.         rtOptions.priority = 85;

  263. 

  264.         if (fAudio.getCurrentApi() == RtAudio::LINUX_ALSA && ! deviceSet)

  265.             rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;

  266.         if (! fAudioInterleaved)

  267.             rtOptions.flags |= RTAUDIO_NONINTERLEAVED;

  268. 

  269.         uint bufferFrames = pData->options.audioBufferSize;

  270. 

  271.         try {

  272.             fAudio.openStream(&oParams, (iParams.nChannels > 0) ? &iParams : nullptr, RTAUDIO_FLOAT32, pData->options.audioSampleRate, &bufferFrames, carla_rtaudio_process_callback, this, &rtOptions);

  273.         }

  274.         catch (const RtAudioError& e) {

  275.             setLastError(e.what());

  276.             return false;

  277.         }

  278. 

  279.         if (! pData->init(clientName))

  280.         {

  281.             close();

  282.             setLastError("Failed to init internal data");

  283.             return false;

  284.         }

  285. 

  286.         pData->bufferSize = bufferFrames;

  287.         pData->sampleRate = fAudio.getStreamSampleRate();

  288. 

  289.         fAudioInCount  = iParams.nChannels;

  290.         fAudioOutCount = oParams.nChannels;

  291.         fLastEventTime = 0;

  292. 

  293.         fAudioIntBufIn.setSize(static_cast<int>(fAudioInCount), static_cast<int>(bufferFrames));

  294.         fAudioIntBufOut.setSize(static_cast<int>(fAudioOutCount), static_cast<int>(bufferFrames));

  295. 

  296.         pData->graph.create(fAudioInCount, fAudioOutCount);

  297. 

  298.         try {

  299.             fAudio.startStream();

  300.         }

  301.         catch (const RtAudioError& e)

  302.         {

  303.             close();

  304.             setLastError(e.what());

  305.             return false;

  306.         }

  307. 

  308.         patchbayRefresh(false);

  309. 

  310.         callback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, getCurrentDriverName());

  311.         return true;

  312.     }

  313. 

  314.     bool close() override

  315.     {

  316.         CARLA_SAFE_ASSERT(fAudioOutCount != 0);

  317.         carla_debug("CarlaEngineRtAudio::close()");

  318. 

  319.         bool hasError = false;

  320. 

  321.         // stop stream first

  322.         if (fAudio.isStreamOpen() && fAudio.isStreamRunning())

  323.         {

  324.             try {

  325.                 fAudio.stopStream();

  326.             }

  327.             catch (const RtAudioError& e)

  328.             {

  329.                 setLastError(e.what());

  330.                 hasError = true;

  331.             }

  332.         }

  333. 

  334.         // clear engine data

  335.         CarlaEngine::close();

  336. 

  337.         pData->graph.destroy();

  338. 

  339.         for (LinkedList<MidiInPort>::Itenerator it = fMidiIns.begin(); it.valid(); it.next())

  340.         {

  341.             static MidiInPort fallback = { nullptr, { '\0' } };

  342. 

  343.             MidiInPort& inPort(it.getValue(fallback));

  344.             CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);

  345. 

  346.             inPort.port->cancelCallback();

  347.             inPort.port->closePort();

  348.             delete inPort.port;

  349.         }

  350. 

  351.         fMidiIns.clear();

  352.         fMidiInEvents.clear();

  353. 

  354.         fMidiOutMutex.lock();

  355. 

  356.         for (LinkedList<MidiOutPort>::Itenerator it = fMidiOuts.begin(); it.valid(); it.next())

  357.         {

  358.             static MidiOutPort fallback = { nullptr, { '\0' } };

  359. 

  360.             MidiOutPort& outPort(it.getValue(fallback));

  361.             CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);

  362. 

  363.             outPort.port->closePort();

  364.             delete outPort.port;

  365.         }

  366. 

  367.         fMidiOuts.clear();

  368.         fMidiOutMutex.unlock();

  369. 

  370.         fAudioInCount  = 0;

  371.         fAudioOutCount = 0;

  372.         fLastEventTime = 0;

  373.         fDeviceName.clear();

  374. 

  375.         // close stream

  376.         if (fAudio.isStreamOpen())

  377.             fAudio.closeStream();

  378. 

  379.         return !hasError;

  380.     }

  381. 

  382.     bool isRunning() const noexcept override

  383.     {

  384.         return fAudio.isStreamOpen();

  385.     }

  386. 

  387.     bool isOffline() const noexcept override

  388.     {

  389.         return false;

  390.     }

  391. 

  392.     EngineType getType() const noexcept override

  393.     {

  394.         return kEngineTypeRtAudio;

  395.     }

  396. 

  397.     const char* getCurrentDriverName() const noexcept override

  398.     {

  399.         return CarlaBackend::getRtAudioApiName(fAudio.getCurrentApi());

  400.     }

  401. 

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

  403.     // Patchbay

  404. 

  405.     bool patchbayRefresh(const bool /*external*/) override

  406.     {

  407.         CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);

  408. 

  409.         if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  410.             patchbayRefreshRack();

  411.         else

  412.             patchbayRefreshPatchbay();

  413. 

  414.         return true;

  415.     }

  416. 

  417.     void patchbayRefreshRack()

  418.     {

  419.         RackGraph* const graph(pData->graph.getRackGraph());

  420.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  421. 

  422.         graph->refreshConnections(fDeviceName.buffer());

  423. 

  424.         char strBuf[STR_MAX+1];

  425.         strBuf[STR_MAX] = '\0';

  426. 

  427.         // Audio In

  428.         {

  429.             if (fDeviceName.isNotEmpty())

  430.                 std::snprintf(strBuf, STR_MAX, "Capture (%s)", fDeviceName.buffer());

  431.             else

  432.                 std::strncpy(strBuf, "Capture", STR_MAX);

  433. 

  434.             callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_AUDIO_IN, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);

  435. 

  436.             for (uint i=0; i < fAudioInCount; ++i)

  437.             {

  438.                 std::snprintf(strBuf, STR_MAX, "capture_%i", i+1);

  439.                 callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_AUDIO_IN, static_cast<int>(i)+1, PATCHBAY_PORT_TYPE_AUDIO, 0.0f, strBuf);

  440.             }

  441.         }

  442. 

  443.         // Audio Out

  444.         {

  445.             if (fDeviceName.isNotEmpty())

  446.                 std::snprintf(strBuf, STR_MAX, "Playback (%s)", fDeviceName.buffer());

  447.             else

  448.                 std::strncpy(strBuf, "Playback", STR_MAX);

  449. 

  450.             callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_AUDIO_OUT, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);

  451. 

  452.             for (uint i=0; i < fAudioOutCount; ++i)

  453.             {

  454.                 std::snprintf(strBuf, STR_MAX, "playback_%i", i+1);

  455.                 callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_AUDIO_OUT, static_cast<int>(i)+1, PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, strBuf);

  456.             }

  457.         }

  458. 

  459.         // MIDI In

  460.         {

  461.             RtMidiIn midiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), "carla-discovery");

  462. 

  463.             callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_MIDI_IN, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Readable MIDI ports");

  464. 

  465.             for (uint i=0, count = midiIn.getPortCount(); i < count; ++i)

  466.             {

  467.                 std::string portName(midiIn.getPortName(i));

  468. 

  469.                 std::snprintf(strBuf, STR_MAX, "Readable MIDI ports:%s", portName.c_str());

  470. 

  471.                 PortNameToId portNameToId;

  472.                 portNameToId.setData(RACK_GRAPH_GROUP_MIDI_IN, i+1, portName.c_str(), strBuf);

  473. 

  474.                 callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, portNameToId.group, static_cast<int>(portNameToId.port), PATCHBAY_PORT_TYPE_MIDI, 0.0f, portNameToId.name);

  475. 

  476.                 graph->midi.ins.append(portNameToId);

  477.             }

  478.         }

  479. 

  480.         // MIDI Out

  481.         {

  482.             RtMidiOut midiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), "carla-discovery");

  483. 

  484.             callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_MIDI_OUT, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Writable MIDI ports");

  485. 

  486.             for (uint i=0, count = midiOut.getPortCount(); i < count; ++i)

  487.             {

  488.                 std::string portName(midiOut.getPortName(i));

  489. 

  490.                 std::snprintf(strBuf, STR_MAX, "Writable MIDI ports:%s", portName.c_str());

  491. 

  492.                 PortNameToId portNameToId;

  493.                 portNameToId.setData(RACK_GRAPH_GROUP_MIDI_OUT, i+1, portName.c_str(), strBuf);

  494. 

  495.                 callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, portNameToId.group, static_cast<int>(portNameToId.port), PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT, 0.0f, portNameToId.name);

  496. 

  497.                 graph->midi.outs.append(portNameToId);

  498.             }

  499.         }

  500. 

  501.         // Connections

  502.         graph->audio.mutex.lock();

  503. 

  504.         for (LinkedList<uint>::Itenerator it = graph->audio.connectedIn1.begin(); it.valid(); it.next())

  505.         {

  506.             const uint& portId(it.getValue(0));

  507.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  508.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  509. 

  510.             ConnectionToId connectionToId;

  511.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_AUDIO_IN, portId, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_IN1);

  512. 

  513.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  514. 

  515.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  516. 

  517.             graph->connections.list.append(connectionToId);

  518.         }

  519. 

  520.         for (LinkedList<uint>::Itenerator it = graph->audio.connectedIn2.begin(); it.valid(); it.next())

  521.         {

  522.             const uint& portId(it.getValue(0));

  523.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  524.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  525. 

  526.             ConnectionToId connectionToId;

  527.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_AUDIO_IN, portId, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_IN2);

  528. 

  529.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  530. 

  531.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  532. 

  533.             graph->connections.list.append(connectionToId);

  534.         }

  535. 

  536.         for (LinkedList<uint>::Itenerator it = graph->audio.connectedOut1.begin(); it.valid(); it.next())

  537.         {

  538.             const uint& portId(it.getValue(0));

  539.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  540.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  541. 

  542.             ConnectionToId connectionToId;

  543.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT1, RACK_GRAPH_GROUP_AUDIO_OUT, portId);

  544. 

  545.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  546. 

  547.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  548. 

  549.             graph->connections.list.append(connectionToId);

  550.         }

  551. 

  552.         for (LinkedList<uint>::Itenerator it = graph->audio.connectedOut2.begin(); it.valid(); it.next())

  553.         {

  554.             const uint& portId(it.getValue(0));

  555.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  556.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  557. 

  558.             ConnectionToId connectionToId;

  559.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT2, RACK_GRAPH_GROUP_AUDIO_OUT, portId);

  560. 

  561.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  562. 

  563.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  564. 

  565.             graph->connections.list.append(connectionToId);

  566.         }

  567. 

  568.         graph->audio.mutex.unlock();

  569. 

  570.         for (LinkedList<MidiInPort>::Itenerator it=fMidiIns.begin(); it.valid(); it.next())

  571.         {

  572.             static const MidiInPort fallback = { nullptr, { '\0' } };

  573. 

  574.             const MidiInPort& inPort(it.getValue(fallback));

  575.             CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);

  576. 

  577.             const uint portId(graph->midi.getPortId(true, inPort.name));

  578.             CARLA_SAFE_ASSERT_CONTINUE(portId < graph->midi.ins.count());

  579. 

  580.             ConnectionToId connectionToId;

  581.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_MIDI_IN, portId, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_MIDI_IN);

  582. 

  583.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  584. 

  585.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  586. 

  587.             graph->connections.list.append(connectionToId);

  588.         }

  589. 

  590.         fMidiOutMutex.lock();

  591. 

  592.         for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin(); it.valid(); it.next())

  593.         {

  594.             static const MidiOutPort fallback = { nullptr, { '\0' } };

  595. 

  596.             const MidiOutPort& outPort(it.getValue(fallback));

  597.             CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);

  598. 

  599.             const uint portId(graph->midi.getPortId(false, outPort.name));

  600.             CARLA_SAFE_ASSERT_CONTINUE(portId < graph->midi.outs.count());

  601. 

  602.             ConnectionToId connectionToId;

  603.             connectionToId.setData(++(graph->connections.lastId), RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_MIDI_OUT, RACK_GRAPH_GROUP_MIDI_OUT, portId);

  604. 

  605.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);

  606. 

  607.             callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  608. 

  609.             graph->connections.list.append(connectionToId);

  610.         }

  611. 

  612.         fMidiOutMutex.unlock();

  613.     }

  614. 

  615.     void patchbayRefreshPatchbay() noexcept

  616.     {

  617.         PatchbayGraph* const graph(pData->graph.getPatchbayGraph());

  618.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  619. 

  620.         graph->refreshConnections(fDeviceName.buffer());

  621.     }

  622. 

  623.     // -------------------------------------------------------------------

  624. 

  625. protected:

  626.     void handleAudioProcessCallback(void* outputBuffer, void* inputBuffer, uint nframes, double streamTime, RtAudioStreamStatus status)

  627.     {

  628.         const PendingRtEventsRunner prt(this);

  629. 

  630.         // get buffers from RtAudio

  631.         const float* const insPtr  = (const float*)inputBuffer;

  632.         /* */ float* const outsPtr =       (float*)outputBuffer;

  633. 

  634.         // assert rtaudio buffers

  635.         CARLA_SAFE_ASSERT_RETURN(outputBuffer      != nullptr,);

  636.         CARLA_SAFE_ASSERT_RETURN(pData->bufferSize == nframes,);

  637. 

  638.         // set rtaudio buffers as non-interleaved

  639.         const float* inBuf[fAudioInCount];

  640.         /* */ float* outBuf[fAudioOutCount];

  641. 

  642.         if (fAudioInterleaved)

  643.         {

  644.             float* inBuf2[fAudioInCount];

  645. 

  646.             for (int i=0, count=static_cast<int>(fAudioInCount); i<count; ++i)

  647.             {

  648.                 inBuf [i] = fAudioIntBufIn.getReadPointer(i);

  649.                 inBuf2[i] = fAudioIntBufIn.getWritePointer(i);

  650.             }

  651.             for (int i=0, count=static_cast<int>(fAudioOutCount); i<count; ++i)

  652.                 outBuf[i] = fAudioIntBufOut.getWritePointer(i);

  653. 

  654.             // init input

  655.             for (uint i=0; i<nframes; ++i)

  656.                 for (uint j=0; j<fAudioInCount; ++j)

  657.                     inBuf2[j][i] = insPtr[i*fAudioInCount+j];

  658. 

  659.             // clear output

  660.             fAudioIntBufOut.clear();

  661.         }

  662.         else

  663.         {

  664.             for (uint i=0; i < fAudioInCount; ++i)

  665.                 inBuf[i] = insPtr+(nframes*i);

  666.             for (uint i=0; i < fAudioOutCount; ++i)

  667.                 outBuf[i] = outsPtr+(nframes*i);

  668. 

  669.             // clear output

  670.             FloatVectorOperations::clear(outsPtr, static_cast<int>(nframes*fAudioOutCount));

  671.         }

  672. 

  673.         // initialize events

  674.         carla_zeroStruct<EngineEvent>(pData->events.in,  kMaxEngineEventInternalCount);

  675.         carla_zeroStruct<EngineEvent>(pData->events.out, kMaxEngineEventInternalCount);

  676. 

  677.         if (fMidiInEvents.mutex.tryLock())

  678.         {

  679.             uint32_t engineEventIndex = 0;

  680.             fMidiInEvents.splice();

  681. 

  682.             for (LinkedList<RtMidiEvent>::Itenerator it = fMidiInEvents.data.begin(); it.valid(); it.next())

  683.             {

  684.                 static const RtMidiEvent fallback = { 0, 0, { 0 } };

  685. 

  686.                 const RtMidiEvent& midiEvent(it.getValue(fallback));

  687.                 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.size > 0);

  688. 

  689.                 EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);

  690. 

  691.                 if (midiEvent.time < pData->timeInfo.frame)

  692.                 {

  693.                     engineEvent.time = 0;

  694.                 }

  695.                 else if (midiEvent.time >= pData->timeInfo.frame + nframes)

  696.                 {

  697.                     carla_stderr("MIDI Event in the future!, %i vs %i", engineEvent.time, pData->timeInfo.frame);

  698.                     engineEvent.time = static_cast<uint32_t>(pData->timeInfo.frame) + nframes - 1;

  699.                 }

  700.                 else

  701.                     engineEvent.time = static_cast<uint32_t>(midiEvent.time - pData->timeInfo.frame);

  702. 

  703.                 engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data);

  704. 

  705.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  706.                     break;

  707.             }

  708. 

  709.             fMidiInEvents.data.clear();

  710.             fMidiInEvents.mutex.unlock();

  711.         }

  712. 

  713.         pData->graph.process(pData, inBuf, outBuf, nframes);

  714. 

  715.         fMidiOutMutex.lock();

  716. 

  717.         if (fMidiOuts.count() > 0)

  718.         {

  719.             uint8_t        size    = 0;

  720.             uint8_t        data[3] = { 0, 0, 0 };

  721.             const uint8_t* dataPtr = data;

  722. 

  723.             for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)

  724.             {

  725.                 const EngineEvent& engineEvent(pData->events.out[i]);

  726. 

  727.                 if (engineEvent.type == kEngineEventTypeNull)

  728.                     break;

  729. 

  730.                 else if (engineEvent.type == kEngineEventTypeControl)

  731.                 {

  732.                     const EngineControlEvent& ctrlEvent(engineEvent.ctrl);

  733.                     ctrlEvent.convertToMidiData(engineEvent.channel, size, data);

  734.                     dataPtr = data;

  735.                 }

  736.                 else if (engineEvent.type == kEngineEventTypeMidi)

  737.                 {

  738.                     const EngineMidiEvent& midiEvent(engineEvent.midi);

  739. 

  740.                     size = midiEvent.size;

  741. 

  742.                     if (size > EngineMidiEvent::kDataSize && midiEvent.dataExt != nullptr)

  743.                         dataPtr = midiEvent.dataExt;

  744.                     else

  745.                         dataPtr = midiEvent.data;

  746.                 }

  747.                 else

  748.                 {

  749.                     continue;

  750.                 }

  751. 

  752.                 if (size > 0)

  753.                 {

  754.                     fMidiOutVector.assign(dataPtr, dataPtr + size);

  755. 

  756.                     for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin(); it.valid(); it.next())

  757.                     {

  758.                         static MidiOutPort fallback = { nullptr, { '\0' } };

  759. 

  760.                         MidiOutPort& outPort(it.getValue(fallback));

  761.                         CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);

  762. 

  763.                         outPort.port->sendMessage(&fMidiOutVector);

  764.                     }

  765.                 }

  766.             }

  767.         }

  768. 

  769.         if (fAudioInterleaved)

  770.         {

  771.             for (uint i=0; i < nframes; ++i)

  772.                 for (uint j=0; j<fAudioOutCount; ++j)

  773.                     outsPtr[i*fAudioOutCount+j] = outBuf[j][i];

  774.         }

  775. 

  776.         fMidiOutMutex.unlock();

  777. 

  778.         return; // unused

  779.         (void)streamTime; (void)status;

  780.     }

  781. 

  782.     void handleMidiCallback(double timeStamp, std::vector<uchar>* const message)

  783.     {

  784.         const size_t messageSize(message->size());

  785. 

  786.         if (messageSize == 0 || messageSize > EngineMidiEvent::kDataSize)

  787.             return;

  788. 

  789.         timeStamp /= 2;

  790. 

  791.         if (timeStamp > 0.95)

  792.             timeStamp = 0.95;

  793.         else if (timeStamp < 0.0)

  794.             timeStamp = 0.0;

  795. 

  796.         RtMidiEvent midiEvent;

  797.         midiEvent.time = pData->timeInfo.frame + uint64_t(timeStamp * (double)pData->bufferSize);

  798. 

  799.         if (midiEvent.time < fLastEventTime)

  800.             midiEvent.time = fLastEventTime;

  801.         else

  802.             fLastEventTime = midiEvent.time;

  803. 

  804.         midiEvent.size = static_cast<uint8_t>(messageSize);

  805. 

  806.         size_t i=0;

  807.         for (; i < messageSize; ++i)

  808.             midiEvent.data[i] = message->at(i);

  809.         for (; i < EngineMidiEvent::kDataSize; ++i)

  810.             midiEvent.data[i] = 0;

  811. 

  812.         fMidiInEvents.append(midiEvent);

  813.     }

  814. 

  815.     // -------------------------------------------------------------------

  816. 

  817.     bool connectRackMidiInPort(const char* const portName) override

  818.     {

  819.         CARLA_SAFE_ASSERT_RETURN(portName != nullptr && portName[0] != '\0', false);

  820.         carla_debug("CarlaEngineRtAudio::connectRackMidiInPort(\"%s\")", portName);

  821. 

  822.         RackGraph* const graph(pData->graph.getRackGraph());

  823.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);

  824.         CARLA_SAFE_ASSERT_RETURN(graph->midi.ins.count() > 0, false);

  825. 

  826.         CarlaString newRtMidiPortName;

  827.         newRtMidiPortName += getName();

  828.         newRtMidiPortName += ":";

  829.         newRtMidiPortName += portName;

  830. 

  831.         RtMidiIn* const rtMidiIn(new RtMidiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer(), 512));

  832.         rtMidiIn->ignoreTypes();

  833.         rtMidiIn->setCallback(carla_rtmidi_callback, this);

  834. 

  835.         bool found = false;

  836.         uint rtMidiPortIndex;

  837. 

  838.         for (uint i=0, count=rtMidiIn->getPortCount(); i < count; ++i)

  839.         {

  840.             if (rtMidiIn->getPortName(i) == portName)

  841.             {

  842.                 found = true;

  843.                 rtMidiPortIndex = i;

  844.                 break;

  845.             }

  846.         }

  847. 

  848.         if (! found)

  849.         {

  850.             delete rtMidiIn;

  851.             return false;

  852.         }

  853. 

  854.         try {

  855.             rtMidiIn->openPort(rtMidiPortIndex, portName);

  856.         }

  857.         catch(...) {

  858.             delete rtMidiIn;

  859.             return false;

  860.         };

  861. 

  862.         MidiInPort midiPort;

  863.         midiPort.port = rtMidiIn;

  864. 

  865.         std::strncpy(midiPort.name, portName, STR_MAX);

  866.         midiPort.name[STR_MAX] = '\0';

  867. 

  868.         fMidiIns.append(midiPort);

  869.         return true;

  870.     }

  871. 

  872.     bool connectRackMidiOutPort(const char* const portName) override

  873.     {

  874.         CARLA_SAFE_ASSERT_RETURN(portName != nullptr && portName[0] != '\0', false);

  875.         carla_debug("CarlaEngineRtAudio::connectRackMidiOutPort(\"%s\")", portName);

  876. 

  877.         RackGraph* const graph(pData->graph.getRackGraph());

  878.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);

  879.         CARLA_SAFE_ASSERT_RETURN(graph->midi.ins.count() > 0, false);

  880. 

  881.         CarlaString newRtMidiPortName;

  882.         newRtMidiPortName += getName();

  883.         newRtMidiPortName += ":";

  884.         newRtMidiPortName += portName;

  885. 

  886.         RtMidiOut* const rtMidiOut(new RtMidiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer()));

  887. 

  888.         bool found = false;

  889.         uint rtMidiPortIndex;

  890. 

  891.         for (uint i=0, count=rtMidiOut->getPortCount(); i < count; ++i)

  892.         {

  893.             if (rtMidiOut->getPortName(i) == portName)

  894.             {

  895.                 found = true;

  896.                 rtMidiPortIndex = i;

  897.                 break;

  898.             }

  899.         }

  900. 

  901.         if (! found)

  902.         {

  903.             delete rtMidiOut;

  904.             return false;

  905.         }

  906. 

  907.         try {

  908.             rtMidiOut->openPort(rtMidiPortIndex, portName);

  909.         }

  910.         catch(...) {

  911.             delete rtMidiOut;

  912.             return false;

  913.         };

  914. 

  915.         MidiOutPort midiPort;

  916.         midiPort.port = rtMidiOut;

  917. 

  918.         std::strncpy(midiPort.name, portName, STR_MAX);

  919.         midiPort.name[STR_MAX] = '\0';

  920. 

  921.         const CarlaMutexLocker cml(fMidiOutMutex);

  922. 

  923.         fMidiOuts.append(midiPort);

  924.         return true;

  925.     }

  926. 

  927.     bool disconnectRackMidiInPort(const char* const portName) override

  928.     {

  929.         CARLA_SAFE_ASSERT_RETURN(portName != nullptr && portName[0] != '\0', false);

  930.         carla_debug("CarlaEngineRtAudio::disconnectRackMidiInPort(\"%s\")", portName);

  931. 

  932.         RackGraph* const graph(pData->graph.getRackGraph());

  933.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);

  934.         CARLA_SAFE_ASSERT_RETURN(graph->midi.ins.count() > 0, false);

  935. 

  936.         for (LinkedList<MidiInPort>::Itenerator it=fMidiIns.begin(); it.valid(); it.next())

  937.         {

  938.             static MidiInPort fallback = { nullptr, { '\0' } };

  939. 

  940.             MidiInPort& inPort(it.getValue(fallback));

  941.             CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);

  942. 

  943.             if (std::strncmp(inPort.name, portName, STR_MAX) != 0)

  944.                 continue;

  945. 

  946.             inPort.port->cancelCallback();

  947.             inPort.port->closePort();

  948.             delete inPort.port;

  949. 

  950.             fMidiIns.remove(it);

  951.             return true;

  952.         }

  953. 

  954.         return false;

  955.     }

  956. 

  957.     bool disconnectRackMidiOutPort(const char* const portName) override

  958.     {

  959.         CARLA_SAFE_ASSERT_RETURN(portName != nullptr && portName[0] != '\0', false);

  960.         carla_debug("CarlaEngineRtAudio::disconnectRackMidiOutPort(\"%s\")", portName);

  961. 

  962.         RackGraph* const graph(pData->graph.getRackGraph());

  963.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);

  964.         CARLA_SAFE_ASSERT_RETURN(graph->midi.outs.count() > 0, false);

  965. 

  966.         const CarlaMutexLocker cml(fMidiOutMutex);

  967. 

  968.         for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin(); it.valid(); it.next())

  969.         {

  970.             static MidiOutPort fallback = { nullptr, { '\0' } };

  971. 

  972.             MidiOutPort& outPort(it.getValue(fallback));

  973.             CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);

  974. 

  975.             if (std::strncmp(outPort.name, portName, STR_MAX) != 0)

  976.                 continue;

  977. 

  978.             outPort.port->closePort();

  979.             delete outPort.port;

  980. 

  981.             fMidiOuts.remove(it);

  982.             return true;

  983.         }

  984. 

  985.         return false;

  986.     }

  987. 

  988.     // -------------------------------------------------------------------

  989. 

  990. private:

  991.     RtAudio fAudio;

  992. 

  993.     // useful info

  994.     bool fAudioInterleaved;

  995.     uint fAudioInCount;

  996.     uint fAudioOutCount;

  997.     uint64_t fLastEventTime;

  998. 

  999.     // current device name

  1000.     CarlaString fDeviceName;

  1001. 

  1002.     // temp buffer for interleaved audio

  1003.     AudioSampleBuffer fAudioIntBufIn;

  1004.     AudioSampleBuffer fAudioIntBufOut;

  1005. 

  1006.     struct MidiInPort {

  1007.         RtMidiIn* port;

  1008.         char name[STR_MAX+1];

  1009.     };

  1010. 

  1011.     struct MidiOutPort {

  1012.         RtMidiOut* port;

  1013.         char name[STR_MAX+1];

  1014.     };

  1015. 

  1016.     struct RtMidiEvent {

  1017.         uint64_t time; // needs to compare to internal time

  1018.         uint8_t  size;

  1019.         uint8_t  data[EngineMidiEvent::kDataSize];

  1020.     };

  1021. 

  1022.     struct RtMidiEvents {

  1023.         CarlaMutex mutex;

  1024.         RtLinkedList<RtMidiEvent>::Pool dataPool;

  1025.         RtLinkedList<RtMidiEvent> data;

  1026.         RtLinkedList<RtMidiEvent> dataPending;

  1027. 

  1028.         RtMidiEvents()

  1029.             : mutex(),

  1030.               dataPool(512, 512),

  1031.               data(dataPool),

  1032.               dataPending(dataPool) {}

  1033. 

  1034.         ~RtMidiEvents()

  1035.         {

  1036.             clear();

  1037.         }

  1038. 

  1039.         void append(const RtMidiEvent& event)

  1040.         {

  1041.             mutex.lock();

  1042.             dataPending.append(event);

  1043.             mutex.unlock();

  1044.         }

  1045. 

  1046.         void clear()

  1047.         {

  1048.             mutex.lock();

  1049.             data.clear();

  1050.             dataPending.clear();

  1051.             mutex.unlock();

  1052.         }

  1053. 

  1054.         void splice()

  1055.         {

  1056.             if (dataPending.count() > 0)

  1057.                 dataPending.moveTo(data, true /* append */);

  1058.         }

  1059.     };

  1060. 

  1061.     LinkedList<MidiInPort> fMidiIns;

  1062.     RtMidiEvents           fMidiInEvents;

  1063. 

  1064.     LinkedList<MidiOutPort> fMidiOuts;

  1065.     CarlaMutex              fMidiOutMutex;

  1066.     std::vector<uint8_t>    fMidiOutVector;

  1067. 

  1068.     #define handlePtr ((CarlaEngineRtAudio*)userData)

  1069. 

  1070.     static int carla_rtaudio_process_callback(void* outputBuffer, void* inputBuffer, uint nframes, double streamTime, RtAudioStreamStatus status, void* userData)

  1071.     {

  1072.         handlePtr->handleAudioProcessCallback(outputBuffer, inputBuffer, nframes, streamTime, status);

  1073.         return 0;

  1074.     }

  1075. 

  1076.     static void carla_rtmidi_callback(double timeStamp, std::vector<uchar>* message, void* userData)

  1077.     {

  1078.         handlePtr->handleMidiCallback(timeStamp, message);

  1079.     }

  1080. 

  1081.     #undef handlePtr

  1082. 

  1083.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)

  1084. };

  1085. 

  1086. // -----------------------------------------

  1087. 

  1088. CarlaEngine* CarlaEngine::newRtAudio(const AudioApi api)

  1089. {

  1090.     initRtAudioAPIsIfNeeded();

  1091. 

  1092.     RtAudio::Api rtApi(RtAudio::UNSPECIFIED);

  1093. 

  1094.     switch (api)

  1095.     {

  1096.     case AUDIO_API_NULL:

  1097.         rtApi = RtAudio::RTAUDIO_DUMMY;

  1098.         break;

  1099.     case AUDIO_API_JACK:

  1100.         rtApi = RtAudio::UNIX_JACK;

  1101.         break;

  1102.     case AUDIO_API_ALSA:

  1103.         rtApi = RtAudio::LINUX_ALSA;

  1104.         break;

  1105.     case AUDIO_API_OSS:

  1106.         rtApi = RtAudio::LINUX_OSS;

  1107.         break;

  1108.     case AUDIO_API_PULSE:

  1109.         rtApi = RtAudio::LINUX_PULSE;

  1110.         break;

  1111.     case AUDIO_API_CORE:

  1112.         rtApi = RtAudio::MACOSX_CORE;

  1113.         break;

  1114.     case AUDIO_API_ASIO:

  1115.         rtApi = RtAudio::WINDOWS_ASIO;

  1116.         break;

  1117.     case AUDIO_API_DS:

  1118.         rtApi = RtAudio::WINDOWS_DS;

  1119.         break;

  1120.     }

  1121. 

  1122.     return new CarlaEngineRtAudio(rtApi);

  1123. }

  1124. 

  1125. uint CarlaEngine::getRtAudioApiCount()

  1126. {

  1127.     initRtAudioAPIsIfNeeded();

  1128. 

  1129.     return static_cast<uint>(gRtAudioApis.size());

  1130. }

  1131. 

  1132. const char* CarlaEngine::getRtAudioApiName(const uint index)

  1133. {

  1134.     initRtAudioAPIsIfNeeded();

  1135. 

  1136.     CARLA_SAFE_ASSERT_RETURN(index < gRtAudioApis.size(), nullptr);

  1137. 

  1138.     return CarlaBackend::getRtAudioApiName(gRtAudioApis[index]);

  1139. }

  1140. 

  1141. const char* const* CarlaEngine::getRtAudioApiDeviceNames(const uint index)

  1142. {

  1143.     initRtAudioAPIsIfNeeded();

  1144. 

  1145.     if (index >= gRtAudioApis.size())

  1146.         return nullptr;

  1147. 

  1148.     const RtAudio::Api& api(gRtAudioApis[index]);

  1149. 

  1150.     RtAudio rtAudio(api);

  1151. 

  1152.     const uint devCount(rtAudio.getDeviceCount());

  1153. 

  1154.     if (devCount == 0)

  1155.         return nullptr;

  1156. 

  1157.     CarlaStringList devNames;

  1158. 

  1159.     for (uint i=0; i < devCount; ++i)

  1160.     {

  1161.         RtAudio::DeviceInfo devInfo(rtAudio.getDeviceInfo(i));

  1162. 

  1163.         if (devInfo.probed && devInfo.outputChannels > 0 /*&& (devInfo.nativeFormats & RTAUDIO_FLOAT32) != 0*/)

  1164.             devNames.append(devInfo.name.c_str());

  1165.     }

  1166. 

  1167.     gDeviceNames = devNames.toCharStringListPtr();

  1168. 

  1169.     return gDeviceNames;

  1170. }

  1171. 

  1172. const EngineDriverDeviceInfo* CarlaEngine::getRtAudioDeviceInfo(const uint index, const char* const deviceName)

  1173. {

  1174.     initRtAudioAPIsIfNeeded();

  1175. 

  1176.     if (index >= gRtAudioApis.size())

  1177.         return nullptr;

  1178. 

  1179.     const RtAudio::Api& api(gRtAudioApis[index]);

  1180. 

  1181.     RtAudio rtAudio(api);

  1182. 

  1183.     const uint devCount(rtAudio.getDeviceCount());

  1184. 

  1185.     if (devCount == 0)

  1186.         return nullptr;

  1187. 

  1188.     uint i;

  1189.     RtAudio::DeviceInfo rtAudioDevInfo;

  1190. 

  1191.     for (i=0; i < devCount; ++i)

  1192.     {

  1193.         rtAudioDevInfo = rtAudio.getDeviceInfo(i);

  1194. 

  1195.         if (rtAudioDevInfo.name == deviceName)

  1196.             break;

  1197.     }

  1198. 

  1199.     if (i == devCount)

  1200.         return nullptr;

  1201. 

  1202.     static EngineDriverDeviceInfo devInfo = { 0x0, nullptr, nullptr };

  1203.     static uint32_t dummyBufferSizes[]    = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 0 };

  1204.     static double   dummySampleRates[]    = { 22050.0, 32000.0, 44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0, 0.0 };

  1205. 

  1206.     // reset

  1207.     devInfo.hints = 0x0;

  1208.     devInfo.bufferSizes = dummyBufferSizes;

  1209. 

  1210.     // cleanup

  1211.     if (devInfo.sampleRates != nullptr && devInfo.sampleRates != dummySampleRates)

  1212.     {

  1213.         delete[] devInfo.sampleRates;

  1214.         devInfo.sampleRates = nullptr;

  1215.     }

  1216. 

  1217.     if (size_t sampleRatesCount = rtAudioDevInfo.sampleRates.size())

  1218.     {

  1219.         double* const sampleRates(new double[sampleRatesCount+1]);

  1220. 

  1221.         for (size_t j=0; j < sampleRatesCount; ++j)

  1222.             sampleRates[j] = rtAudioDevInfo.sampleRates[j];

  1223.         sampleRates[sampleRatesCount] = 0.0;

  1224. 

  1225.         devInfo.sampleRates = sampleRates;

  1226.     }

  1227.     else

  1228.     {

  1229.         devInfo.sampleRates = dummySampleRates;

  1230.     }

  1231. 

  1232.     return &devInfo;

  1233. }

  1234. 

  1235. // -----------------------------------------

  1236. 

  1237. CARLA_BACKEND_END_NAMESPACE