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

1241 lines
38KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2018 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. 

  28. #include "rtaudio/RtAudio.h"

  29. #include "rtmidi/RtMidi.h"

  30. 

  31. CARLA_BACKEND_START_NAMESPACE

  32. 

  33. // -------------------------------------------------------------------------------------------------------------------

  34. // Global static data

  35. 

  36. static CharStringListPtr         gDeviceNames;

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

  38. 

  39. // -------------------------------------------------------------------------------------------------------------------

  40. 

  41. static void initRtAudioAPIsIfNeeded()

  42. {

  43.     static bool needsInit = true;

  44. 

  45.     if (! needsInit)

  46.         return;

  47. 

  48.     needsInit = false;

  49. 

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

  51. 

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

  53.     RtAudio::getCompiledApi(apis);

  54. 

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

  56.     {

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

  58. 

  59.         if (api == RtAudio::UNIX_JACK)

  60.         {

  61. #if defined(CARLA_OS_LINUX) || defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  62.             if ( ! jackbridge_is_ok())

  63.                 continue;

  64. #else

  65.             /* NOTE

  66.              * RtMidi doesn't have a native MIDI backend for these OSes,

  67.              * Using RtAudio JACK funcitonality is only useful when we need to access the native MIDI APIs.

  68.              * (JACK audio + ALSA MIDI, or JACK audio + CoreMidi, or JACK audio + Windows MIDI)

  69.              * Because RtMidi has no native MIDI support outside of win/mac/linux, we skip these RtAudio APIs.

  70.              * Those OSes can use Carla's JACK support directly, which is much better than RtAudio classes.

  71.              */

  72.             continue;

  73. #endif

  74.         }

  75. 

  76.         gRtAudioApis.push_back(api);

  77.     }

  78. }

  79. 

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

  81. {

  82.     switch (api)

  83.     {

  84.     case RtAudio::UNSPECIFIED:

  85.         return "Unspecified";

  86.     case RtAudio::LINUX_ALSA:

  87.         return "ALSA";

  88.     case RtAudio::LINUX_OSS:

  89.         return "OSS";

  90.     case RtAudio::UNIX_PULSE:

  91.         return "PulseAudio";

  92.     case RtAudio::UNIX_JACK:

  93. #if defined(CARLA_OS_LINUX)

  94.         return "JACK with ALSA-MIDI";

  95. #elif defined(CARLA_OS_MAC)

  96.         return "JACK with CoreMidi";

  97. #elif defined(CARLA_OS_WIN)

  98.         return "JACK with WinMM";

  99. #else

  100.         return "JACK (RtAudio)";

  101. #endif

  102.     case RtAudio::MACOSX_CORE:

  103.         return "CoreAudio";

  104.     case RtAudio::WINDOWS_ASIO:

  105.         return "ASIO";

  106.     case RtAudio::WINDOWS_DS:

  107.         return "DirectSound";

  108.     case RtAudio::WINDOWS_WASAPI:

  109.         return "WASAPI";

  110.     case RtAudio::RTAUDIO_DUMMY:

  111.         return "Dummy";

  112.     }

  113. 

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

  115.     return nullptr;

  116. }

  117. 

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

  119. {

  120.     switch (rtApi)

  121.     {

  122.     case RtAudio::UNSPECIFIED:

  123.         return RtMidi::UNSPECIFIED;

  124. 

  125.     case RtAudio::LINUX_ALSA:

  126.     case RtAudio::LINUX_OSS:

  127.         return RtMidi::LINUX_ALSA;

  128. 

  129.     case RtAudio::UNIX_PULSE:

  130.     case RtAudio::UNIX_JACK:

  131. #if defined(CARLA_OS_LINUX)

  132.         return RtMidi::LINUX_ALSA;

  133. #elif defined(CARLA_OS_MAC)

  134.         return RtMidi::MACOSX_CORE;

  135. #elif defined(CARLA_OS_WIN)

  136.         return RtMidi::WINDOWS_MM;

  137. #else

  138.         return RtMidi::RTMIDI_DUMMY;

  139. #endif

  140. 

  141.     case RtAudio::MACOSX_CORE:

  142.         return RtMidi::MACOSX_CORE;

  143. 

  144.     case RtAudio::WINDOWS_ASIO:

  145.     case RtAudio::WINDOWS_DS:

  146.     case RtAudio::WINDOWS_WASAPI:

  147.         return RtMidi::WINDOWS_MM;

  148. 

  149.     case RtAudio::RTAUDIO_DUMMY:

  150.         return RtMidi::RTMIDI_DUMMY;

  151.     }

  152. 

  153.     return RtMidi::UNSPECIFIED;

  154. }

  155. 

  156. // -------------------------------------------------------------------------------------------------------------------

  157. // RtAudio Engine

  158. 

  159. class CarlaEngineRtAudio : public CarlaEngine

  160. {

  161. public:

  162.     CarlaEngineRtAudio(const RtAudio::Api api)

  163.         : CarlaEngine(),

  164.           fAudio(api),

  165.           fAudioInterleaved(false),

  166.           fAudioInCount(0),

  167.           fAudioOutCount(0),

  168.           fLastEventTime(0),

  169.           fDeviceName(),

  170.           fAudioIntBufIn(nullptr),

  171.           fAudioIntBufOut(nullptr),

  172.           fMidiIns(),

  173.           fMidiInEvents(),

  174.           fMidiOuts(),

  175.           fMidiOutMutex(),

  176.           fMidiOutVector(EngineMidiEvent::kDataSize)

  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 bool isDummy(fAudio.getCurrentApi() == RtAudio::RtAudio::RTAUDIO_DUMMY);

  209.         bool deviceSet = false;

  210.         RtAudio::StreamParameters iParams, oParams;

  211. 

  212.         if (isDummy)

  213.         {

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

  215.             {

  216.                 setLastError("Cannot use dummy driver in Rack mode");

  217.                 return false;

  218.             }

  219. 

  220.             fDeviceName = "Dummy";

  221.         }

  222.         else

  223.         {

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

  225. 

  226.             if (devCount == 0)

  227.             {

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

  229.                 return false;

  230.             }

  231. 

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

  233.             {

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

  235.                 {

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

  237. 

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

  239.                     {

  240.                         deviceSet   = true;

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

  242.                         iParams.deviceId  = i;

  243.                         oParams.deviceId  = i;

  244.                         iParams.nChannels = devInfo.inputChannels;

  245.                         oParams.nChannels = devInfo.outputChannels;

  246.                         break;

  247.                     }

  248.                 }

  249.             }

  250. 

  251.             if (! deviceSet)

  252.             {

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

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

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

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

  257. 

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

  259.             }

  260. 

  261.             if (oParams.nChannels == 0 && pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  262.             {

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

  264.                 return false;

  265.             }

  266. 

  267.             iParams.nChannels = carla_fixedValue(0U, 128U, iParams.nChannels);

  268.             oParams.nChannels = carla_fixedValue(0U, 128U, oParams.nChannels);

  269.             fAudioInterleaved = fAudio.getCurrentApi() == RtAudio::UNIX_PULSE;

  270.         }

  271. 

  272.         RtAudio::StreamOptions rtOptions;

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

  274.         rtOptions.numberOfBuffers = pData->options.audioTripleBuffer ? 3 : 2;

  275.         rtOptions.streamName = clientName;

  276.         rtOptions.priority = 85;

  277. 

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

  279.             rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;

  280.         if (! fAudioInterleaved)

  281.             rtOptions.flags |= RTAUDIO_NONINTERLEAVED;

  282. 

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

  284. 

  285.         try {

  286.             fAudio.openStream(oParams.nChannels > 0 ? &oParams : nullptr,

  287.                               iParams.nChannels > 0 ? &iParams : nullptr,

  288.                               RTAUDIO_FLOAT32, pData->options.audioSampleRate, &bufferFrames,

  289.                               carla_rtaudio_process_callback, this, &rtOptions);

  290.         }

  291.         catch (const RtAudioError& e) {

  292.             setLastError(e.what());

  293.             return false;

  294.         }

  295. 

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

  297.         {

  298.             close();

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

  300.             return false;

  301.         }

  302. 

  303.         pData->bufferSize = bufferFrames;

  304.         pData->sampleRate = isDummy ? 44100.0 : fAudio.getStreamSampleRate();

  305.         pData->initTime(pData->options.transportExtra);

  306. 

  307.         fAudioInCount  = iParams.nChannels;

  308.         fAudioOutCount = oParams.nChannels;

  309.         fLastEventTime = 0;

  310. 

  311.         if (fAudioInCount > 0)

  312.             fAudioIntBufIn = new float[fAudioInCount*bufferFrames];

  313. 

  314.         if (fAudioOutCount > 0)

  315.             fAudioIntBufOut = new float[fAudioOutCount*bufferFrames];

  316. 

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

  318. 

  319.         try {

  320.             fAudio.startStream();

  321.         }

  322.         catch (const RtAudioError& e)

  323.         {

  324.             close();

  325.             setLastError(e.what());

  326.             return false;

  327.         }

  328. 

  329.         patchbayRefresh(false);

  330. 

  331.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  332.             refreshExternalGraphPorts<PatchbayGraph>(pData->graph.getPatchbayGraph(), false);

  333. 

  334.         callback(ENGINE_CALLBACK_ENGINE_STARTED, 0,

  335.                  pData->options.processMode, pData->options.transportMode,

  336.                  pData->sampleRate, getCurrentDriverName());

  337.         return true;

  338.     }

  339. 

  340.     bool close() override

  341.     {

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

  343. 

  344.         bool hasError = false;

  345. 

  346.         // stop stream first

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

  348.         {

  349.             try {

  350.                 fAudio.stopStream();

  351.             }

  352.             catch (const RtAudioError& e)

  353.             {

  354.                 setLastError(e.what());

  355.                 hasError = true;

  356.             }

  357.         }

  358. 

  359.         // clear engine data

  360.         CarlaEngine::close();

  361. 

  362.         pData->graph.destroy();

  363. 

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

  365.         {

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

  367. 

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

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

  370. 

  371.             inPort.port->cancelCallback();

  372.             inPort.port->closePort();

  373.             delete inPort.port;

  374.         }

  375. 

  376.         fMidiIns.clear();

  377.         fMidiInEvents.clear();

  378. 

  379.         fMidiOutMutex.lock();

  380. 

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

  382.         {

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

  384. 

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

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

  387. 

  388.             outPort.port->closePort();

  389.             delete outPort.port;

  390.         }

  391. 

  392.         fMidiOuts.clear();

  393.         fMidiOutMutex.unlock();

  394. 

  395.         fAudioInCount  = 0;

  396.         fAudioOutCount = 0;

  397.         fLastEventTime = 0;

  398.         fDeviceName.clear();

  399. 

  400.         if (fAudioIntBufIn != nullptr)

  401.         {

  402.             delete[] fAudioIntBufIn;

  403.             fAudioIntBufIn = nullptr;

  404.         }

  405. 

  406.         if (fAudioIntBufOut != nullptr)

  407.         {

  408.             delete[] fAudioIntBufOut;

  409.             fAudioIntBufOut = nullptr;

  410.         }

  411. 

  412.         // close stream

  413.         if (fAudio.isStreamOpen())

  414.             fAudio.closeStream();

  415. 

  416.         return !hasError;

  417.     }

  418. 

  419.     bool isRunning() const noexcept override

  420.     {

  421.         return fAudio.isStreamOpen();

  422.     }

  423. 

  424.     bool isOffline() const noexcept override

  425.     {

  426.         return false;

  427.     }

  428. 

  429.     EngineType getType() const noexcept override

  430.     {

  431.         return kEngineTypeRtAudio;

  432.     }

  433. 

  434.     const char* getCurrentDriverName() const noexcept override

  435.     {

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

  437.     }

  438. 

  439.     // -------------------------------------------------------------------

  440.     // Patchbay

  441. 

  442.     template<class Graph>

  443.     bool refreshExternalGraphPorts(Graph* const graph, const bool sendCallback)

  444.     {

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

  446. 

  447.         char strBuf[STR_MAX+1];

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

  449. 

  450.         ExternalGraph& extGraph(graph->extGraph);

  451. 

  452.         // ---------------------------------------------------------------

  453.         // clear last ports

  454. 

  455.         extGraph.clear();

  456. 

  457.         // ---------------------------------------------------------------

  458.         // fill in new ones

  459. 

  460.         // Audio In

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

  462.         {

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

  464. 

  465.             PortNameToId portNameToId;

  466.             portNameToId.setData(kExternalGraphGroupAudioIn, i+1, strBuf, "");

  467. 

  468.             extGraph.audioPorts.ins.append(portNameToId);

  469.         }

  470. 

  471.         // Audio Out

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

  473.         {

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

  475. 

  476.             PortNameToId portNameToId;

  477.             portNameToId.setData(kExternalGraphGroupAudioOut, i+1, strBuf, "");

  478. 

  479.             extGraph.audioPorts.outs.append(portNameToId);

  480.         }

  481. 

  482.         // MIDI In

  483.         try

  484.         {

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

  486. 

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

  488.             {

  489.                 PortNameToId portNameToId;

  490.                 portNameToId.setData(kExternalGraphGroupMidiIn, i+1, midiIn.getPortName(i).c_str(), "");

  491. 

  492.                 extGraph.midiPorts.ins.append(portNameToId);

  493.             }

  494.         } CARLA_SAFE_EXCEPTION("RtMidiIn discovery");

  495. 

  496.         // MIDI Out

  497.         try

  498.         {

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

  500. 

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

  502.             {

  503.                 PortNameToId portNameToId;

  504.                 portNameToId.setData(kExternalGraphGroupMidiOut, i+1, midiOut.getPortName(i).c_str(), "");

  505. 

  506.                 extGraph.midiPorts.outs.append(portNameToId);

  507.             }

  508.         } CARLA_SAFE_EXCEPTION("RtMidiOut discovery");

  509. 

  510.         // ---------------------------------------------------------------

  511.         // now refresh

  512. 

  513.         if (sendCallback)

  514.             graph->refresh(fDeviceName.buffer());

  515. 

  516.         // ---------------------------------------------------------------

  517.         // add midi connections

  518. 

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

  520.         {

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

  522. 

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

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

  525. 

  526.             const uint portId(extGraph.midiPorts.getPortId(true, inPort.name));

  527.             CARLA_SAFE_ASSERT_CONTINUE(portId < extGraph.midiPorts.ins.count());

  528. 

  529.             ConnectionToId connectionToId;

  530.             connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupMidiIn, portId, kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiIn);

  531. 

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

  533. 

  534.             extGraph.connections.list.append(connectionToId);

  535. 

  536.             if (sendCallback)

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

  538.         }

  539. 

  540.         fMidiOutMutex.lock();

  541. 

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

  543.         {

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

  545. 

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

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

  548. 

  549.             const uint portId(extGraph.midiPorts.getPortId(false, outPort.name));

  550.             CARLA_SAFE_ASSERT_CONTINUE(portId < extGraph.midiPorts.outs.count());

  551. 

  552.             ConnectionToId connectionToId;

  553.             connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiOut, kExternalGraphGroupMidiOut, portId);

  554. 

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

  556. 

  557.             extGraph.connections.list.append(connectionToId);

  558. 

  559.             if (sendCallback)

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

  561.         }

  562. 

  563.         fMidiOutMutex.unlock();

  564. 

  565.         return true;

  566.     }

  567. 

  568.     bool patchbayRefresh(const bool external) override

  569.     {

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

  571. 

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

  573.             return refreshExternalGraphPorts<RackGraph>(pData->graph.getRackGraph(), true);

  574. 

  575.         pData->graph.setUsingExternal(external);

  576. 

  577.         if (external)

  578.             return refreshExternalGraphPorts<PatchbayGraph>(pData->graph.getPatchbayGraph(), true);

  579. 

  580.         return CarlaEngine::patchbayRefresh(false);

  581.     }

  582. 

  583.     // -------------------------------------------------------------------

  584. 

  585. protected:

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

  587.     {

  588.         const PendingRtEventsRunner prt(this, nframes);

  589. 

  590.         // get buffers from RtAudio

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

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

  593. 

  594.         // assert rtaudio buffers

  595.         CARLA_SAFE_ASSERT_RETURN(outputBuffer      != nullptr,);

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

  597. 

  598.         // set rtaudio buffers as non-interleaved

  599.         const float* inBuf[fAudioInCount];

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

  601. 

  602.         if (fAudioInterleaved)

  603.         {

  604.             float* inBuf2[fAudioInCount];

  605. 

  606.             for (uint i=0, count=fAudioInCount; i<count; ++i)

  607.             {

  608.                 inBuf [i] = fAudioIntBufIn + (nframes*i);

  609.                 inBuf2[i] = fAudioIntBufIn + (nframes*i);

  610.             }

  611.             for (uint i=0, count=fAudioOutCount; i<count; ++i)

  612.                 outBuf[i] = fAudioIntBufOut + (nframes*i);

  613. 

  614.             // init input

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

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

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

  618. 

  619.             // clear output

  620.             carla_zeroFloats(fAudioIntBufOut, fAudioOutCount*nframes);

  621.         }

  622.         else

  623.         {

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

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

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

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

  628. 

  629.             // clear output

  630.             carla_zeroFloats(outsPtr, nframes*fAudioOutCount);

  631.         }

  632. 

  633.         // initialize events

  634.         carla_zeroStructs(pData->events.in,  kMaxEngineEventInternalCount);

  635.         carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);

  636. 

  637.         if (fMidiInEvents.mutex.tryLock())

  638.         {

  639.             uint32_t engineEventIndex = 0;

  640.             fMidiInEvents.splice();

  641. 

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

  643.             {

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

  645. 

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

  647.                 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.size > 0);

  648. 

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

  650. 

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

  652.                 {

  653.                     engineEvent.time = 0;

  654.                 }

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

  656.                 {

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

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

  659.                 }

  660.                 else

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

  662. 

  663.                 engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data, 0);

  664. 

  665.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  666.                     break;

  667.             }

  668. 

  669.             fMidiInEvents.data.clear();

  670.             fMidiInEvents.mutex.unlock();

  671.         }

  672. 

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

  674. 

  675.         fMidiOutMutex.lock();

  676. 

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

  678.         {

  679.             uint8_t size     = 0;

  680.             uint8_t mdata[3] = { 0, 0, 0 };

  681.             uint8_t mdataTmp[EngineMidiEvent::kDataSize];

  682.             const uint8_t* mdataPtr;

  683. 

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

  685.             {

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

  687. 

  688.                 /**/ if (engineEvent.type == kEngineEventTypeNull)

  689.                 {

  690.                     break;

  691.                 }

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

  693.                 {

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

  695. 

  696.                     size = ctrlEvent.convertToMidiData(engineEvent.channel, mdata);

  697.                     mdataPtr = mdata;

  698.                 }

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

  700.                 {

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

  702. 

  703.                     size = midiEvent.size;

  704.                     CARLA_SAFE_ASSERT_CONTINUE(size > 0);

  705. 

  706.                     if (size > EngineMidiEvent::kDataSize)

  707.                     {

  708.                         CARLA_SAFE_ASSERT_CONTINUE(midiEvent.dataExt != nullptr);

  709.                         mdataPtr = midiEvent.dataExt;

  710.                     }

  711.                     else

  712.                     {

  713.                         // set first byte

  714.                         mdataTmp[0] = static_cast<uint8_t>(midiEvent.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));

  715. 

  716.                         // copy rest

  717.                         carla_copy<uint8_t>(mdataTmp+1, midiEvent.data+1, size-1);

  718. 

  719.                         // done

  720.                         mdataPtr = mdataTmp;

  721.                     }

  722.                 }

  723.                 else

  724.                 {

  725.                     continue;

  726.                 }

  727. 

  728.                 if (size > 0)

  729.                 {

  730.                     fMidiOutVector.assign(mdataPtr, mdataPtr + size);

  731. 

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

  733.                     {

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

  735. 

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

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

  738. 

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

  740.                     }

  741.                 }

  742.             }

  743.         }

  744. 

  745.         fMidiOutMutex.unlock();

  746. 

  747.         if (fAudioInterleaved)

  748.         {

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

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

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

  752.         }

  753. 

  754.         return; // unused

  755.         (void)streamTime; (void)status;

  756.     }

  757. 

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

  759.     {

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

  761. 

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

  763.             return;

  764. 

  765.         timeStamp /= 2;

  766. 

  767.         if (timeStamp > 0.95)

  768.             timeStamp = 0.95;

  769.         else if (timeStamp < 0.0)

  770.             timeStamp = 0.0;

  771. 

  772.         RtMidiEvent midiEvent;

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

  774. 

  775.         if (midiEvent.time < fLastEventTime)

  776.             midiEvent.time = fLastEventTime;

  777.         else

  778.             fLastEventTime = midiEvent.time;

  779. 

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

  781. 

  782.         size_t i=0;

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

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

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

  786.             midiEvent.data[i] = 0;

  787. 

  788.         fMidiInEvents.append(midiEvent);

  789.     }

  790. 

  791.     // -------------------------------------------------------------------

  792. 

  793.     bool connectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName) override

  794.     {

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

  796.         carla_debug("CarlaEngineRtAudio::connectExternalGraphPort(%u, %u, \"%s\")", connectionType, portId, portName);

  797. 

  798.         switch (connectionType)

  799.         {

  800.         case kExternalGraphConnectionAudioIn1:

  801.         case kExternalGraphConnectionAudioIn2:

  802.         case kExternalGraphConnectionAudioOut1:

  803.         case kExternalGraphConnectionAudioOut2:

  804.             return CarlaEngine::connectExternalGraphPort(connectionType, portId, portName);

  805. 

  806.         case kExternalGraphConnectionMidiInput: {

  807.             CarlaString newRtMidiPortName;

  808.             newRtMidiPortName += getName();

  809.             newRtMidiPortName += ":";

  810.             newRtMidiPortName += portName;

  811. 

  812.             RtMidiIn* rtMidiIn;

  813. 

  814.             try {

  815.                 rtMidiIn = new RtMidiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer(), 512);

  816.             } CARLA_SAFE_EXCEPTION_RETURN("new RtMidiIn", false);

  817. 

  818.             rtMidiIn->ignoreTypes();

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

  820. 

  821.             bool found = false;

  822.             uint rtMidiPortIndex;

  823. 

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

  825.             {

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

  827.                 {

  828.                     found = true;

  829.                     rtMidiPortIndex = i;

  830.                     break;

  831.                 }

  832.             }

  833. 

  834.             if (! found)

  835.             {

  836.                 delete rtMidiIn;

  837.                 return false;

  838.             }

  839. 

  840.             try {

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

  842.             }

  843.             catch(...) {

  844.                 delete rtMidiIn;

  845.                 return false;

  846.             };

  847. 

  848.             MidiInPort midiPort;

  849.             midiPort.port = rtMidiIn;

  850. 

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

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

  853. 

  854.             fMidiIns.append(midiPort);

  855.             return true;

  856.         }   break;

  857. 

  858.         case kExternalGraphConnectionMidiOutput: {

  859.             CarlaString newRtMidiPortName;

  860.             newRtMidiPortName += getName();

  861.             newRtMidiPortName += ":";

  862.             newRtMidiPortName += portName;

  863. 

  864.             RtMidiOut* rtMidiOut;

  865. 

  866.             try {

  867.                 rtMidiOut = new RtMidiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer());

  868.             } CARLA_SAFE_EXCEPTION_RETURN("new RtMidiOut", false);

  869. 

  870.             bool found = false;

  871.             uint rtMidiPortIndex;

  872. 

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

  874.             {

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

  876.                 {

  877.                     found = true;

  878.                     rtMidiPortIndex = i;

  879.                     break;

  880.                 }

  881.             }

  882. 

  883.             if (! found)

  884.             {

  885.                 delete rtMidiOut;

  886.                 return false;

  887.             }

  888. 

  889.             try {

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

  891.             }

  892.             catch(...) {

  893.                 delete rtMidiOut;

  894.                 return false;

  895.             };

  896. 

  897.             MidiOutPort midiPort;

  898.             midiPort.port = rtMidiOut;

  899. 

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

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

  902. 

  903.             const CarlaMutexLocker cml(fMidiOutMutex);

  904. 

  905.             fMidiOuts.append(midiPort);

  906.             return true;

  907.         }   break;

  908.         }

  909. 

  910.         return false;

  911.     }

  912. 

  913.     bool disconnectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName) override

  914.     {

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

  916.         carla_debug("CarlaEngineRtAudio::disconnectExternalGraphPort(%u, %u, \"%s\")", connectionType, portId, portName);

  917. 

  918.         switch (connectionType)

  919.         {

  920.         case kExternalGraphConnectionAudioIn1:

  921.         case kExternalGraphConnectionAudioIn2:

  922.         case kExternalGraphConnectionAudioOut1:

  923.         case kExternalGraphConnectionAudioOut2:

  924.             return CarlaEngine::disconnectExternalGraphPort(connectionType, portId, portName);

  925. 

  926.         case kExternalGraphConnectionMidiInput:

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

  928.             {

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

  930. 

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

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

  933. 

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

  935.                     continue;

  936. 

  937.                 inPort.port->cancelCallback();

  938.                 inPort.port->closePort();

  939.                 delete inPort.port;

  940. 

  941.                 fMidiIns.remove(it);

  942.                 return true;

  943.             }

  944.             break;

  945. 

  946.         case kExternalGraphConnectionMidiOutput: {

  947.             const CarlaMutexLocker cml(fMidiOutMutex);

  948. 

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

  950.             {

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

  952. 

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

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

  955. 

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

  957.                     continue;

  958. 

  959.                 outPort.port->closePort();

  960.                 delete outPort.port;

  961. 

  962.                 fMidiOuts.remove(it);

  963.                 return true;

  964.             }

  965.         }   break;

  966.         }

  967. 

  968.         return false;

  969.     }

  970. 

  971.     // -------------------------------------------------------------------

  972. 

  973. private:

  974.     RtAudio fAudio;

  975. 

  976.     // useful info

  977.     bool fAudioInterleaved;

  978.     uint fAudioInCount;

  979.     uint fAudioOutCount;

  980.     uint64_t fLastEventTime;

  981. 

  982.     // current device name

  983.     CarlaString fDeviceName;

  984. 

  985.     // temp buffer for interleaved audio

  986.     float* fAudioIntBufIn;

  987.     float* fAudioIntBufOut;

  988. 

  989.     struct MidiInPort {

  990.         RtMidiIn* port;

  991.         char name[STR_MAX+1];

  992.     };

  993. 

  994.     struct MidiOutPort {

  995.         RtMidiOut* port;

  996.         char name[STR_MAX+1];

  997.     };

  998. 

  999.     struct RtMidiEvent {

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

  1001.         uint8_t  size;

  1002.         uint8_t  data[EngineMidiEvent::kDataSize];

  1003.     };

  1004. 

  1005.     struct RtMidiEvents {

  1006.         CarlaMutex mutex;

  1007.         RtLinkedList<RtMidiEvent>::Pool dataPool;

  1008.         RtLinkedList<RtMidiEvent> data;

  1009.         RtLinkedList<RtMidiEvent> dataPending;

  1010. 

  1011.         RtMidiEvents()

  1012.             : mutex(),

  1013.               dataPool(512, 512),

  1014.               data(dataPool),

  1015.               dataPending(dataPool) {}

  1016. 

  1017.         ~RtMidiEvents()

  1018.         {

  1019.             clear();

  1020.         }

  1021. 

  1022.         void append(const RtMidiEvent& event)

  1023.         {

  1024.             mutex.lock();

  1025.             dataPending.append(event);

  1026.             mutex.unlock();

  1027.         }

  1028. 

  1029.         void clear()

  1030.         {

  1031.             mutex.lock();

  1032.             data.clear();

  1033.             dataPending.clear();

  1034.             mutex.unlock();

  1035.         }

  1036. 

  1037.         void splice()

  1038.         {

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

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

  1041.         }

  1042.     };

  1043. 

  1044.     LinkedList<MidiInPort> fMidiIns;

  1045.     RtMidiEvents           fMidiInEvents;

  1046. 

  1047.     LinkedList<MidiOutPort> fMidiOuts;

  1048.     CarlaMutex              fMidiOutMutex;

  1049.     std::vector<uint8_t>    fMidiOutVector;

  1050. 

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

  1052. 

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

  1054.     {

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

  1056.         return 0;

  1057.     }

  1058. 

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

  1060.     {

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

  1062.     }

  1063. 

  1064.     #undef handlePtr

  1065. 

  1066.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)

  1067. };

  1068. 

  1069. // -----------------------------------------

  1070. 

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

  1072. {

  1073.     initRtAudioAPIsIfNeeded();

  1074. 

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

  1076. 

  1077.     switch (api)

  1078.     {

  1079.     case AUDIO_API_NULL:

  1080.         rtApi = RtAudio::RTAUDIO_DUMMY;

  1081.         break;

  1082.     case AUDIO_API_JACK:

  1083.         rtApi = RtAudio::UNIX_JACK;

  1084.         break;

  1085.     case AUDIO_API_OSS:

  1086.         rtApi = RtAudio::LINUX_OSS;

  1087.         break;

  1088.     case AUDIO_API_ALSA:

  1089.         rtApi = RtAudio::LINUX_ALSA;

  1090.         break;

  1091.     case AUDIO_API_PULSEAUDIO:

  1092.         rtApi = RtAudio::UNIX_PULSE;

  1093.         break;

  1094.     case AUDIO_API_COREAUDIO:

  1095.         rtApi = RtAudio::MACOSX_CORE;

  1096.         break;

  1097.     case AUDIO_API_ASIO:

  1098.         rtApi = RtAudio::WINDOWS_ASIO;

  1099.         break;

  1100.     case AUDIO_API_DIRECTSOUND:

  1101.         rtApi = RtAudio::WINDOWS_DS;

  1102.         break;

  1103.     case AUDIO_API_WASAPI:

  1104.         rtApi = RtAudio::WINDOWS_WASAPI;

  1105.         break;

  1106.     }

  1107. 

  1108.     return new CarlaEngineRtAudio(rtApi);

  1109. }

  1110. 

  1111. uint CarlaEngine::getRtAudioApiCount()

  1112. {

  1113.     initRtAudioAPIsIfNeeded();

  1114. 

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

  1116. }

  1117. 

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

  1119. {

  1120.     initRtAudioAPIsIfNeeded();

  1121. 

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

  1123. 

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

  1125. }

  1126. 

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

  1128. {

  1129.     initRtAudioAPIsIfNeeded();

  1130. 

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

  1132.         return nullptr;

  1133. 

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

  1135.     CarlaStringList devNames;

  1136. 

  1137.     try {

  1138.         RtAudio rtAudio(api);

  1139. 

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

  1141. 

  1142.         if (devCount == 0)

  1143.             return nullptr;

  1144. 

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

  1146.         {

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

  1148. 

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

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

  1151.         }

  1152. 

  1153.     } CARLA_SAFE_EXCEPTION_RETURN("RtAudio device names", nullptr);

  1154. 

  1155.     gDeviceNames = devNames.toCharStringListPtr();

  1156. 

  1157.     return gDeviceNames;

  1158. }

  1159. 

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

  1161. {

  1162.     initRtAudioAPIsIfNeeded();

  1163. 

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

  1165.         return nullptr;

  1166. 

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

  1168.     RtAudio::DeviceInfo rtAudioDevInfo;

  1169. 

  1170.     try {

  1171.         RtAudio rtAudio(api);

  1172. 

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

  1174. 

  1175.         if (devCount == 0)

  1176.             return nullptr;

  1177. 

  1178.         uint i;

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

  1180.         {

  1181.             rtAudioDevInfo = rtAudio.getDeviceInfo(i);

  1182. 

  1183.             if (rtAudioDevInfo.name == deviceName)

  1184.                 break;

  1185.         }

  1186. 

  1187.         if (i == devCount)

  1188.             return nullptr;

  1189. 

  1190.     } CARLA_SAFE_EXCEPTION_RETURN("RtAudio device discovery", nullptr);

  1191. 

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

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

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

  1195. 

  1196.     // reset

  1197.     devInfo.hints = 0x0;

  1198.     devInfo.bufferSizes = dummyBufferSizes;

  1199. 

  1200.     // cleanup

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

  1202.     {

  1203.         delete[] devInfo.sampleRates;

  1204.         devInfo.sampleRates = nullptr;

  1205.     }

  1206. 

  1207.     // a few APIs can do triple buffer

  1208.     switch (api)

  1209.     {

  1210.     case RtAudio::LINUX_ALSA:

  1211.     case RtAudio::LINUX_OSS:

  1212.     case RtAudio::WINDOWS_DS:

  1213.         devInfo.hints |= ENGINE_DRIVER_DEVICE_CAN_TRIPLE_BUFFER;

  1214.         break;

  1215.     default:

  1216.         break;

  1217.     }

  1218. 

  1219.     // valid sample rates

  1220.     if (const size_t sampleRatesCount = rtAudioDevInfo.sampleRates.size())

  1221.     {

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

  1223. 

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

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

  1226.         sampleRates[sampleRatesCount] = 0.0;

  1227. 

  1228.         devInfo.sampleRates = sampleRates;

  1229.     }

  1230.     else

  1231.     {

  1232.         devInfo.sampleRates = dummySampleRates;

  1233.     }

  1234. 

  1235.     return &devInfo;

  1236. }

  1237. 

  1238. // -----------------------------------------

  1239. 

  1240. CARLA_BACKEND_END_NAMESPACE