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

1171 lines
37KB
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::FloatVectorOperations;

  33. 

  34. CARLA_BACKEND_START_NAMESPACE

  35. 

  36. // -------------------------------------------------------------------------------------------------------------------

  37. // Global static data

  38. 

  39. static CharStringListPtr         gDeviceNames;

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

  41. 

  42. // -------------------------------------------------------------------------------------------------------------------

  43. 

  44. static void initRtAudioAPIsIfNeeded()

  45. {

  46.     static bool needsInit = true;

  47. 

  48.     if (! needsInit)

  49.         return;

  50. 

  51.     needsInit = false;

  52. 

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

  54. 

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

  56.     RtAudio::getCompiledApi(apis);

  57. 

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

  59.     {

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

  61. 

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

  63.             continue;

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

  65.             continue;

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

  67.             continue;

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

  69.             continue;

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

  71.             continue;

  72. 

  73.         gRtAudioApis.push_back(api);

  74.     }

  75. }

  76. 

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

  78. {

  79.     switch (api)

  80.     {

  81.     case RtAudio::UNSPECIFIED:

  82.         return "Unspecified";

  83.     case RtAudio::LINUX_ALSA:

  84.         return "ALSA";

  85.     case RtAudio::LINUX_PULSE:

  86.         return "PulseAudio";

  87.     case RtAudio::LINUX_OSS:

  88.         return "OSS";

  89.     case RtAudio::UNIX_JACK:

  90. #if defined(CARLA_OS_WIN)

  91.         return "JACK with WinMM";

  92. #elif defined(CARLA_OS_MAC)

  93.         return "JACK with CoreMidi";

  94. #elif defined(CARLA_OS_LINUX)

  95.         return "JACK with ALSA-MIDI";

  96. #else

  97.         return "JACK (RtAudio)";

  98. #endif

  99.     case RtAudio::MACOSX_CORE:

  100.         return "CoreAudio";

  101.     case RtAudio::WINDOWS_ASIO:

  102.         return "ASIO";

  103.     case RtAudio::WINDOWS_DS:

  104.         return "DirectSound";

  105.     case RtAudio::WINDOWS_WASAPI:

  106.         return "WASAPI";

  107.     case RtAudio::RTAUDIO_DUMMY:

  108.         return "Dummy";

  109.     }

  110. 

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

  112.     return nullptr;

  113. }

  114. 

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

  116. {

  117.     switch (rtApi)

  118.     {

  119.     case RtAudio::UNSPECIFIED:

  120.         return RtMidi::UNSPECIFIED;

  121. 

  122.     case RtAudio::LINUX_ALSA:

  123.     case RtAudio::LINUX_OSS:

  124.     case RtAudio::LINUX_PULSE:

  125.         return RtMidi::LINUX_ALSA;

  126. 

  127.     case RtAudio::UNIX_JACK:

  128. #if defined(CARLA_OS_WIN)

  129.         return RtMidi::WINDOWS_MM;

  130. #elif defined(CARLA_OS_MAC)

  131.         return RtMidi::MACOSX_CORE;

  132. #elif defined(CARLA_OS_LINUX)

  133.         return RtMidi::LINUX_ALSA;

  134. #else

  135.         return RtMidi::UNIX_JACK;

  136. #endif

  137. 

  138.     case RtAudio::MACOSX_CORE:

  139.         return RtMidi::MACOSX_CORE;

  140. 

  141.     case RtAudio::WINDOWS_ASIO:

  142.     case RtAudio::WINDOWS_DS:

  143.     case RtAudio::WINDOWS_WASAPI:

  144.         return RtMidi::WINDOWS_MM;

  145. 

  146.     case RtAudio::RTAUDIO_DUMMY:

  147.         return RtMidi::RTMIDI_DUMMY;

  148.     }

  149. 

  150.     return RtMidi::UNSPECIFIED;

  151. }

  152. 

  153. // -------------------------------------------------------------------------------------------------------------------

  154. // RtAudio Engine

  155. 

  156. class CarlaEngineRtAudio : public CarlaEngine

  157. {

  158. public:

  159.     CarlaEngineRtAudio(const RtAudio::Api api)

  160.         : CarlaEngine(),

  161.           fAudio(api),

  162.           fAudioInCount(0),

  163.           fAudioOutCount(0),

  164.           fLastEventTime(0),

  165.           fDeviceName(),

  166.           fMidiIns(),

  167.           fMidiInEvents(),

  168.           fMidiOuts(),

  169.           fMidiOutMutex(),

  170.           fMidiOutVector(3),

  171.           leakDetector_CarlaEngineRtAudio()

  172.     {

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

  174. 

  175.         // just to make sure

  176.         pData->options.transportMode = ENGINE_TRANSPORT_MODE_INTERNAL;

  177.     }

  178. 

  179.     ~CarlaEngineRtAudio() override

  180.     {

  181.         CARLA_SAFE_ASSERT(fAudioInCount == 0);

  182.         CARLA_SAFE_ASSERT(fAudioOutCount == 0);

  183.         CARLA_SAFE_ASSERT(fLastEventTime == 0);

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

  185.     }

  186. 

  187.     // -------------------------------------

  188. 

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

  190.     {

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

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

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

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

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

  196. 

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

  198.         {

  199.             setLastError("Invalid process mode");

  200.             return false;

  201.         }

  202. 

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

  204. 

  205.         if (devCount == 0)

  206.         {

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

  208.             return false;

  209.         }

  210. 

  211.         RtAudio::StreamParameters iParams, oParams;

  212.         bool deviceSet = false;

  213. 

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

  215.         {

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

  217.             {

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

  219. 

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

  221.                 {

  222.                     deviceSet   = true;

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

  224.                     iParams.deviceId  = i;

  225.                     oParams.deviceId  = i;

  226.                     iParams.nChannels = devInfo.inputChannels;

  227.                     oParams.nChannels = devInfo.outputChannels;

  228.                     break;

  229.                 }

  230.             }

  231.         }

  232. 

  233.         if (! deviceSet)

  234.         {

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

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

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

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

  239. 

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

  241.         }

  242. 

  243.         if (oParams.nChannels == 0)

  244.         {

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

  246.             return false;

  247.         }

  248. 

  249.         RtAudio::StreamOptions rtOptions;

  250.         rtOptions.flags = RTAUDIO_MINIMIZE_LATENCY | RTAUDIO_HOG_DEVICE | RTAUDIO_SCHEDULE_REALTIME | RTAUDIO_NONINTERLEAVED;

  251.         rtOptions.streamName = clientName;

  252.         rtOptions.priority = 85;

  253. 

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

  255.             rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;

  256. 

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

  258. 

  259.         try {

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

  261.         }

  262.         catch (const RtAudioError& e) {

  263.             setLastError(e.what());

  264.             return false;

  265.         }

  266. 

  267.         pData->bufferSize = bufferFrames;

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

  269. 

  270.         fAudioInCount  = iParams.nChannels;

  271.         fAudioOutCount = oParams.nChannels;

  272.         fLastEventTime = 0;

  273. 

  274.         pData->graph.create(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK, pData->sampleRate, pData->bufferSize, fAudioInCount, fAudioOutCount);

  275. 

  276.         try {

  277.             fAudio.startStream();

  278.         }

  279.         catch (const RtAudioError& e)

  280.         {

  281.             close();

  282.             setLastError(e.what());

  283.             return false;

  284.         }

  285. 

  286.         CarlaEngine::init(clientName);

  287. 

  288.         patchbayRefresh();

  289. 

  290.         return true;

  291.     }

  292. 

  293.     bool close() override

  294.     {

  295.         CARLA_SAFE_ASSERT(fAudioOutCount != 0);

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

  297. 

  298.         bool hasError = !CarlaEngine::close();

  299. 

  300.         if (fAudio.isStreamOpen())

  301.         {

  302.             if (fAudio.isStreamRunning())

  303.             {

  304.                 try {

  305.                     fAudio.stopStream();

  306.                 }

  307.                 catch (const RtAudioError& e)

  308.                 {

  309.                     if (! hasError)

  310.                     {

  311.                         setLastError(e.what());

  312.                         hasError = true;

  313.                     }

  314.                 }

  315.             }

  316. 

  317.             fAudio.closeStream();

  318.         }

  319. 

  320.         pData->graph.destroy();

  321. 

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

  323.         {

  324.             MidiInPort& inPort(it.getValue());

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

  326. 

  327.             inPort.port->cancelCallback();

  328.             inPort.port->closePort();

  329.             delete inPort.port;

  330.         }

  331. 

  332.         fMidiIns.clear();

  333.         fMidiInEvents.clear();

  334. 

  335.         fMidiOutMutex.lock();

  336. 

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

  338.         {

  339.             MidiOutPort& outPort(it.getValue());

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

  341. 

  342.             outPort.port->closePort();

  343.             delete outPort.port;

  344.         }

  345. 

  346.         fMidiOuts.clear();

  347.         fMidiOutMutex.unlock();

  348. 

  349.         fAudioInCount  = 0;

  350.         fAudioOutCount = 0;

  351.         fLastEventTime = 0;

  352.         fDeviceName.clear();

  353. 

  354.         return !hasError;

  355.     }

  356. 

  357.     bool isRunning() const noexcept override

  358.     {

  359.         return fAudio.isStreamRunning();

  360.     }

  361. 

  362.     bool isOffline() const noexcept override

  363.     {

  364.         return false;

  365.     }

  366. 

  367.     EngineType getType() const noexcept override

  368.     {

  369.         return kEngineTypeRtAudio;

  370.     }

  371. 

  372.     const char* getCurrentDriverName() const noexcept override

  373.     {

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

  375.     }

  376. 

  377.     // -------------------------------------------------------------------

  378.     // Patchbay

  379. 

  380.     bool patchbayRefresh() override

  381.     {

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

  383. 

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

  385.             patchbayRefreshRack();

  386.         else

  387.             patchbayRefreshPatchbay();

  388. 

  389.         return true;

  390.     }

  391. 

  392.     void patchbayRefreshRack()

  393.     {

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

  395.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  396. 

  397.         graph->connections.clear();

  398. 

  399.         char strBuf[STR_MAX+1];

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

  401. 

  402.         // Main

  403.         {

  404.             callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, RACK_GRAPH_GROUP_CARLA, PATCHBAY_ICON_CARLA, -1, 0.0f, getName());

  405. 

  406.             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");

  407.             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");

  408.             callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT1, PATCHBAY_PORT_TYPE_AUDIO,                        0.0f, "audio-out1");

  409.             callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_AUDIO_OUT2, PATCHBAY_PORT_TYPE_AUDIO,                        0.0f, "audio-out2");

  410.             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");

  411.             callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, RACK_GRAPH_GROUP_CARLA, RACK_GRAPH_CARLA_PORT_MIDI_OUT,   PATCHBAY_PORT_TYPE_MIDI,                         0.0f, "midi-out");

  412.         }

  413. 

  414.         // Audio In

  415.         {

  416.             if (fDeviceName.isNotEmpty())

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

  418.             else

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

  420. 

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

  422. 

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

  424.             {

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

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

  427.             }

  428.         }

  429. 

  430.         // Audio Out

  431.         {

  432.             if (fDeviceName.isNotEmpty())

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

  434.             else

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

  436. 

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

  438. 

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

  440.             {

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

  442.                 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);

  443.             }

  444.         }

  445. 

  446.         // MIDI In

  447.         {

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

  449. 

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

  451. 

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

  453.             {

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

  455. 

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

  457. 

  458.                 PortNameToId portNameToId;

  459.                 portNameToId.setData(RACK_GRAPH_GROUP_MIDI_IN, i, portName.c_str(), strBuf);

  460. 

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

  462. 

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

  464.             }

  465.         }

  466. 

  467.         // MIDI Out

  468.         {

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

  470. 

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

  472. 

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

  474.             {

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

  476. 

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

  478. 

  479.                 PortNameToId portNameToId;

  480.                 portNameToId.setData(RACK_GRAPH_GROUP_MIDI_OUT, i, portName.c_str(), strBuf);

  481. 

  482.                 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);

  483. 

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

  485.             }

  486.         }

  487. 

  488.         // Connections

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

  490. 

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

  492.         {

  493.             const uint& portId(it.getValue());

  494.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  495. 

  496.             ConnectionToId connectionToId;

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

  498. 

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

  500. 

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

  502. 

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

  504.         }

  505. 

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

  507.         {

  508.             const uint& portId(it.getValue());

  509.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  510. 

  511.             ConnectionToId connectionToId;

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

  513. 

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

  515. 

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

  517. 

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

  519.         }

  520. 

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

  522.         {

  523.             const uint& portId(it.getValue());

  524.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  525. 

  526.             ConnectionToId connectionToId;

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

  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.connectedOut2.begin(); it.valid(); it.next())

  537.         {

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

  539.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  540. 

  541.             ConnectionToId connectionToId;

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

  543. 

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

  545. 

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

  547. 

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

  549.         }

  550. 

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

  552. 

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

  554.         {

  555.             const MidiInPort& inPort(it.getValue());

  556. 

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

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

  559. 

  560.             ConnectionToId connectionToId;

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

  562. 

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

  564. 

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

  566. 

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

  568.         }

  569. 

  570.         fMidiOutMutex.lock();

  571. 

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

  573.         {

  574.             const MidiOutPort& outPort(it.getValue());

  575. 

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

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

  578. 

  579.             ConnectionToId connectionToId;

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

  581. 

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

  583. 

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

  585. 

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

  587.         }

  588. 

  589.         fMidiOutMutex.unlock();

  590.     }

  591. 

  592.     void patchbayRefreshPatchbay() noexcept

  593.     {

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

  595.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  596.     }

  597. 

  598.     // -------------------------------------------------------------------

  599. 

  600. protected:

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

  602.     {

  603.         // get buffers from RtAudio

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

  605.               float* const outsPtr =       (float*)outputBuffer;

  606. 

  607.         // assert rtaudio buffers

  608.         CARLA_SAFE_ASSERT_RETURN(outputBuffer      != nullptr, runPendingRtEvents());

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

  610. 

  611.         // initialize rtaudio input

  612.         const float* inBuf[fAudioInCount];

  613. 

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

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

  616. 

  617.         // initialize rtaudio output

  618.         float* outBuf[fAudioOutCount];

  619. 

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

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

  622. 

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

  624. 

  625.         // initialize events

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

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

  628. 

  629.         if (fMidiInEvents.mutex.tryLock())

  630.         {

  631.             uint32_t engineEventIndex = 0;

  632.             fMidiInEvents.splice();

  633. 

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

  635.             {

  636.                 const RtMidiEvent& midiEvent(it.getValue());

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

  638. 

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

  640.                 {

  641.                     engineEvent.time = 0;

  642.                 }

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

  644.                 {

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

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

  647.                 }

  648.                 else

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

  650. 

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

  652. 

  653.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  654.                     break;

  655.             }

  656. 

  657.             fMidiInEvents.data.clear();

  658.             fMidiInEvents.mutex.unlock();

  659.         }

  660. 

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

  662. 

  663.         fMidiOutMutex.lock();

  664. 

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

  666.         {

  667.             uint8_t        size    = 0;

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

  669.             const uint8_t* dataPtr = data;

  670. 

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

  672.             {

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

  674. 

  675.                 if (engineEvent.type == kEngineEventTypeNull)

  676.                     break;

  677. 

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

  679.                 {

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

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

  682.                     dataPtr = data;

  683.                 }

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

  685.                 {

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

  687. 

  688.                     size = midiEvent.size;

  689. 

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

  691.                         dataPtr = midiEvent.dataExt;

  692.                     else

  693.                         dataPtr = midiEvent.data;

  694.                 }

  695.                 else

  696.                 {

  697.                     continue;

  698.                 }

  699. 

  700.                 if (size > 0)

  701.                 {

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

  703. 

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

  705.                     {

  706.                         MidiOutPort& outPort(it.getValue());

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

  708. 

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

  710.                     }

  711.                 }

  712.             }

  713.         }

  714. 

  715.         fMidiOutMutex.unlock();

  716. 

  717.         runPendingRtEvents();

  718.         return;

  719. 

  720.         // unused

  721.         (void)streamTime;

  722.         (void)status;

  723.     }

  724. 

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

  726.     {

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

  728. 

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

  730.             return;

  731. 

  732.         timeStamp /= 2;

  733. 

  734.         if (timeStamp > 0.95)

  735.             timeStamp = 0.95;

  736.         else if (timeStamp < 0.0)

  737.             timeStamp = 0.0;

  738. 

  739.         RtMidiEvent midiEvent;

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

  741. 

  742.         if (midiEvent.time < fLastEventTime)

  743.             midiEvent.time = fLastEventTime;

  744.         else

  745.             fLastEventTime = midiEvent.time;

  746. 

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

  748. 

  749.         size_t i=0;

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

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

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

  753.             midiEvent.data[i] = 0;

  754. 

  755.         fMidiInEvents.append(midiEvent);

  756.     }

  757. 

  758.     // -------------------------------------------------------------------

  759. 

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

  761.     {

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

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

  764. 

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

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

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

  768. 

  769.         CarlaString newRtMidiPortName;

  770.         newRtMidiPortName += getName();

  771.         newRtMidiPortName += ":";

  772.         newRtMidiPortName += portName;

  773. 

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

  775.         rtMidiIn->ignoreTypes();

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

  777. 

  778.         bool found = false;

  779.         uint rtMidiPortIndex;

  780. 

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

  782.         {

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

  784.             {

  785.                 found = true;

  786.                 rtMidiPortIndex = i;

  787.                 break;

  788.             }

  789.         }

  790. 

  791.         if (! found)

  792.         {

  793.             delete rtMidiIn;

  794.             return false;

  795.         }

  796. 

  797.         try {

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

  799.         }

  800.         catch(...) {

  801.             delete rtMidiIn;

  802.             return false;

  803.         };

  804. 

  805.         MidiInPort midiPort;

  806.         midiPort.port = rtMidiIn;

  807. 

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

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

  810. 

  811.         fMidiIns.append(midiPort);

  812.         return true;

  813.     }

  814. 

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

  816.     {

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

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

  819. 

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

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

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

  823. 

  824.         CarlaString newRtMidiPortName;

  825.         newRtMidiPortName += getName();

  826.         newRtMidiPortName += ":";

  827.         newRtMidiPortName += portName;

  828. 

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

  830. 

  831.         bool found = false;

  832.         uint rtMidiPortIndex;

  833. 

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

  835.         {

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

  837.             {

  838.                 found = true;

  839.                 rtMidiPortIndex = i;

  840.                 break;

  841.             }

  842.         }

  843. 

  844.         if (! found)

  845.         {

  846.             delete rtMidiOut;

  847.             return false;

  848.         }

  849. 

  850.         try {

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

  852.         }

  853.         catch(...) {

  854.             delete rtMidiOut;

  855.             return false;

  856.         };

  857. 

  858.         MidiOutPort midiPort;

  859.         midiPort.port = rtMidiOut;

  860. 

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

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

  863. 

  864.         const CarlaMutexLocker cml(fMidiOutMutex);

  865. 

  866.         fMidiOuts.append(midiPort);

  867.         return true;

  868.     }

  869. 

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

  871.     {

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

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

  874. 

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

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

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

  878. 

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

  880.         {

  881.             MidiInPort& inPort(it.getValue());

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

  883. 

  884.             if (std::strcmp(inPort.name, portName) != 0)

  885.                 continue;

  886. 

  887.             inPort.port->cancelCallback();

  888.             inPort.port->closePort();

  889.             delete inPort.port;

  890. 

  891.             fMidiIns.remove(it);

  892.             return true;

  893.         }

  894. 

  895.         return false;

  896.     }

  897. 

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

  899.     {

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

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

  902. 

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

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

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

  906. 

  907.         const CarlaMutexLocker cml(fMidiOutMutex);

  908. 

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

  910.         {

  911.             MidiOutPort& outPort(it.getValue());

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

  913. 

  914.             if (std::strcmp(outPort.name, portName) != 0)

  915.                 continue;

  916. 

  917.             outPort.port->closePort();

  918.             delete outPort.port;

  919. 

  920.             fMidiOuts.remove(it);

  921.             return true;

  922.         }

  923. 

  924.         return false;

  925.     }

  926. 

  927.     // -------------------------------------------------------------------

  928. 

  929. private:

  930.     RtAudio fAudio;

  931. 

  932.     // useful info

  933.     uint fAudioInCount;

  934.     uint fAudioOutCount;

  935.     uint64_t fLastEventTime;

  936. 

  937.     // current device name

  938.     CarlaString fDeviceName;

  939. 

  940.     struct MidiInPort {

  941.         RtMidiIn* port;

  942.         char name[STR_MAX+1];

  943.     };

  944. 

  945.     struct MidiOutPort {

  946.         RtMidiOut* port;

  947.         char name[STR_MAX+1];

  948.     };

  949. 

  950.     struct RtMidiEvent {

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

  952.         uint8_t  size;

  953.         uint8_t  data[EngineMidiEvent::kDataSize];

  954.     };

  955. 

  956.     struct RtMidiEvents {

  957.         CarlaMutex mutex;

  958.         RtLinkedList<RtMidiEvent>::Pool dataPool;

  959.         RtLinkedList<RtMidiEvent> data;

  960.         RtLinkedList<RtMidiEvent> dataPending;

  961. 

  962.         RtMidiEvents()

  963.             : mutex(),

  964.               dataPool(512, 512),

  965.               data(dataPool),

  966.               dataPending(dataPool) {}

  967. 

  968.         ~RtMidiEvents()

  969.         {

  970.             clear();

  971.         }

  972. 

  973.         void append(const RtMidiEvent& event)

  974.         {

  975.             mutex.lock();

  976.             dataPending.append(event);

  977.             mutex.unlock();

  978.         }

  979. 

  980.         void clear()

  981.         {

  982.             mutex.lock();

  983.             data.clear();

  984.             dataPending.clear();

  985.             mutex.unlock();

  986.         }

  987. 

  988.         void splice()

  989.         {

  990.             dataPending.spliceAppendTo(data);

  991.         }

  992.     };

  993. 

  994.     LinkedList<MidiInPort> fMidiIns;

  995.     RtMidiEvents           fMidiInEvents;

  996. 

  997.     LinkedList<MidiOutPort> fMidiOuts;

  998.     CarlaMutex              fMidiOutMutex;

  999.     std::vector<uint8_t>    fMidiOutVector;

  1000. 

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

  1002. 

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

  1004.     {

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

  1006.         return 0;

  1007.     }

  1008. 

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

  1010.     {

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

  1012.     }

  1013. 

  1014.     #undef handlePtr

  1015. 

  1016.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)

  1017. };

  1018. 

  1019. // -----------------------------------------

  1020. 

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

  1022. {

  1023.     initRtAudioAPIsIfNeeded();

  1024. 

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

  1026. 

  1027.     switch (api)

  1028.     {

  1029.     case AUDIO_API_NULL:

  1030.         rtApi = RtAudio::RTAUDIO_DUMMY;

  1031.         break;

  1032.     case AUDIO_API_JACK:

  1033.         rtApi = RtAudio::UNIX_JACK;

  1034.         break;

  1035.     case AUDIO_API_ALSA:

  1036.         rtApi = RtAudio::LINUX_ALSA;

  1037.         break;

  1038.     case AUDIO_API_OSS:

  1039.         rtApi = RtAudio::LINUX_OSS;

  1040.         break;

  1041.     case AUDIO_API_PULSE:

  1042.         rtApi = RtAudio::LINUX_PULSE;

  1043.         break;

  1044.     case AUDIO_API_CORE:

  1045.         rtApi = RtAudio::MACOSX_CORE;

  1046.         break;

  1047.     case AUDIO_API_ASIO:

  1048.         rtApi = RtAudio::WINDOWS_ASIO;

  1049.         break;

  1050.     case AUDIO_API_DS:

  1051.         rtApi = RtAudio::WINDOWS_DS;

  1052.         break;

  1053.     }

  1054. 

  1055.     return new CarlaEngineRtAudio(rtApi);

  1056. }

  1057. 

  1058. uint CarlaEngine::getRtAudioApiCount()

  1059. {

  1060.     initRtAudioAPIsIfNeeded();

  1061. 

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

  1063. }

  1064. 

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

  1066. {

  1067.     initRtAudioAPIsIfNeeded();

  1068. 

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

  1070. 

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

  1072. }

  1073. 

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

  1075. {

  1076.     initRtAudioAPIsIfNeeded();

  1077. 

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

  1079.         return nullptr;

  1080. 

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

  1082. 

  1083.     RtAudio rtAudio(api);

  1084. 

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

  1086. 

  1087.     if (devCount == 0)

  1088.         return nullptr;

  1089. 

  1090.     CarlaStringList devNames;

  1091. 

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

  1093.     {

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

  1095. 

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

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

  1098.     }

  1099. 

  1100.     gDeviceNames = devNames.toCharStringListPtr();

  1101. 

  1102.     return gDeviceNames;

  1103. }

  1104. 

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

  1106. {

  1107.     initRtAudioAPIsIfNeeded();

  1108. 

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

  1110.         return nullptr;

  1111. 

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

  1113. 

  1114.     RtAudio rtAudio(api);

  1115. 

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

  1117. 

  1118.     if (devCount == 0)

  1119.         return nullptr;

  1120. 

  1121.     uint i;

  1122.     RtAudio::DeviceInfo rtAudioDevInfo;

  1123. 

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

  1125.     {

  1126.         rtAudioDevInfo = rtAudio.getDeviceInfo(i);

  1127. 

  1128.         if (rtAudioDevInfo.name == deviceName)

  1129.             break;

  1130.     }

  1131. 

  1132.     if (i == devCount)

  1133.         return nullptr;

  1134. 

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

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

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

  1138. 

  1139.     // reset

  1140.     devInfo.hints = 0x0;

  1141.     devInfo.bufferSizes = dummyBufferSizes;

  1142. 

  1143.     // cleanup

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

  1145.     {

  1146.         delete[] devInfo.sampleRates;

  1147.         devInfo.sampleRates = nullptr;

  1148.     }

  1149. 

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

  1151.     {

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

  1153. 

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

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

  1156.         sampleRates[sampleRatesCount] = 0.0;

  1157. 

  1158.         devInfo.sampleRates = sampleRates;

  1159.     }

  1160.     else

  1161.     {

  1162.         devInfo.sampleRates = dummySampleRates;

  1163.     }

  1164. 

  1165.     return &devInfo;

  1166. }

  1167. 

  1168. // -----------------------------------------

  1169. 

  1170. CARLA_BACKEND_END_NAMESPACE