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

1249 lines
40KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngineGraph.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. #include "CarlaBackendUtils.hpp"

  21. #include "CarlaMathUtils.hpp"

  22. #include "CarlaStringList.hpp"

  23. 

  24. #include "RtLinkedList.hpp"

  25. 

  26. #include "jackbridge/JackBridge.hpp"

  27. #include "juce_audio_basics.h"

  28. 

  29. #include "rtaudio/RtAudio.h"

  30. #include "rtmidi/RtMidi.h"

  31. 

  32. using juce::jmax;

  33. using juce::AudioSampleBuffer;

  34. using juce::FloatVectorOperations;

  35. 

  36. CARLA_BACKEND_START_NAMESPACE

  37. 

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

  39. // Global static data

  40. 

  41. static CharStringListPtr         gDeviceNames;

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

  43. 

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

  45. 

  46. static void initRtAudioAPIsIfNeeded()

  47. {

  48.     static bool needsInit = true;

  49. 

  50.     if (! needsInit)

  51.         return;

  52. 

  53.     needsInit = false;

  54. 

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

  56. 

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

  58.     RtAudio::getCompiledApi(apis);

  59. 

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

  61.     {

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

  63. 

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

  65.             continue;

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

  67.             continue;

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

  69.             continue;

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

  71.             continue;

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

  73.             continue;

  74. 

  75.         gRtAudioApis.push_back(api);

  76.     }

  77. }

  78. 

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

  80. {

  81.     switch (api)

  82.     {

  83.     case RtAudio::UNSPECIFIED:

  84.         return "Unspecified";

  85.     case RtAudio::LINUX_ALSA:

  86.         return "ALSA";

  87.     case RtAudio::LINUX_PULSE:

  88.         return "PulseAudio";

  89.     case RtAudio::LINUX_OSS:

  90.         return "OSS";

  91.     case RtAudio::UNIX_JACK:

  92. #if defined(CARLA_OS_WIN)

  93.         return "JACK with WinMM";

  94. #elif defined(CARLA_OS_MAC)

  95.         return "JACK with CoreMidi";

  96. #elif defined(CARLA_OS_LINUX)

  97.         return "JACK with ALSA-MIDI";

  98. #else

  99.         return "JACK (RtAudio)";

  100. #endif

  101.     case RtAudio::MACOSX_CORE:

  102.         return "CoreAudio";

  103.     case RtAudio::WINDOWS_ASIO:

  104.         return "ASIO";

  105.     case RtAudio::WINDOWS_DS:

  106.         return "DirectSound";

  107.     case RtAudio::WINDOWS_WASAPI:

  108.         return "WASAPI";

  109.     case RtAudio::RTAUDIO_DUMMY:

  110.         return "Dummy";

  111.     }

  112. 

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

  114.     return nullptr;

  115. }

  116. 

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

  118. {

  119.     switch (rtApi)

  120.     {

  121.     case RtAudio::UNSPECIFIED:

  122.         return RtMidi::UNSPECIFIED;

  123. 

  124.     case RtAudio::LINUX_ALSA:

  125.     case RtAudio::LINUX_OSS:

  126.     case RtAudio::LINUX_PULSE:

  127.         return RtMidi::LINUX_ALSA;

  128. 

  129.     case RtAudio::UNIX_JACK:

  130. #if defined(CARLA_OS_WIN)

  131.         return RtMidi::WINDOWS_MM;

  132. #elif defined(CARLA_OS_MAC)

  133.         return RtMidi::MACOSX_CORE;

  134. #elif defined(CARLA_OS_LINUX)

  135.         return RtMidi::LINUX_ALSA;

  136. #else

  137.         return RtMidi::UNIX_JACK;

  138. #endif

  139. 

  140.     case RtAudio::MACOSX_CORE:

  141.         return RtMidi::MACOSX_CORE;

  142. 

  143.     case RtAudio::WINDOWS_ASIO:

  144.     case RtAudio::WINDOWS_DS:

  145.     case RtAudio::WINDOWS_WASAPI:

  146.         return RtMidi::WINDOWS_MM;

  147. 

  148.     case RtAudio::RTAUDIO_DUMMY:

  149.         return RtMidi::RTMIDI_DUMMY;

  150.     }

  151. 

  152.     return RtMidi::UNSPECIFIED;

  153. }

  154. 

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

  156. // RtAudio Engine

  157. 

  158. class CarlaEngineRtAudio : public CarlaEngine

  159. {

  160. public:

  161.     CarlaEngineRtAudio(const RtAudio::Api api)

  162.         : CarlaEngine(),

  163.           fAudio(api),

  164.           fAudioInterleaved(false),

  165.           fAudioInCount(0),

  166.           fAudioOutCount(0),

  167.           fLastEventTime(0),

  168.           fDeviceName(),

  169.           fAudioIntBufIn(),

  170.           fAudioIntBufOut(),

  171.           fMidiIns(),

  172.           fMidiInEvents(),

  173.           fMidiOuts(),

  174.           fMidiOutMutex(),

  175.           fMidiOutVector(3),

  176.           leakDetector_CarlaEngineRtAudio()

  177.     {

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

  179. 

  180.         // just to make sure

  181.         pData->options.transportMode = ENGINE_TRANSPORT_MODE_INTERNAL;

  182.     }

  183. 

  184.     ~CarlaEngineRtAudio() override

  185.     {

  186.         CARLA_SAFE_ASSERT(fAudioInCount == 0);

  187.         CARLA_SAFE_ASSERT(fAudioOutCount == 0);

  188.         CARLA_SAFE_ASSERT(fLastEventTime == 0);

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

  190.     }

  191. 

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

  193. 

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

  195.     {

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

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

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

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

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

  201. 

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

  203.         {

  204.             setLastError("Invalid process mode");

  205.             return false;

  206.         }

  207. 

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

  209. 

  210.         if (devCount == 0)

  211.         {

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

  213.             return false;

  214.         }

  215. 

  216.         RtAudio::StreamParameters iParams, oParams;

  217.         bool deviceSet = false;

  218. 

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

  220.         {

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

  222.             {

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

  224. 

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

  226.                 {

  227.                     deviceSet   = true;

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

  229.                     iParams.deviceId  = i;

  230.                     oParams.deviceId  = i;

  231.                     iParams.nChannels = devInfo.inputChannels;

  232.                     oParams.nChannels = devInfo.outputChannels;

  233.                     break;

  234.                 }

  235.             }

  236.         }

  237. 

  238.         if (! deviceSet)

  239.         {

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

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

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

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

  244. 

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

  246.         }

  247. 

  248.         if (oParams.nChannels == 0)

  249.         {

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

  251.             return false;

  252.         }

  253. 

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

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

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

  257. 

  258.         RtAudio::StreamOptions rtOptions;

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

  260.         rtOptions.streamName = clientName;

  261.         rtOptions.priority = 85;

  262. 

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

  264.             rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;

  265.         if (! fAudioInterleaved)

  266.             rtOptions.flags |= RTAUDIO_NONINTERLEAVED;

  267. 

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

  269. 

  270.         try {

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

  272.         }

  273.         catch (const RtAudioError& e) {

  274.             setLastError(e.what());

  275.             return false;

  276.         }

  277. 

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

  279.         {

  280.             close();

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

  282.             return false;

  283.         }

  284. 

  285.         pData->bufferSize = bufferFrames;

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

  287. 

  288.         fAudioInCount  = iParams.nChannels;

  289.         fAudioOutCount = oParams.nChannels;

  290.         fLastEventTime = 0;

  291. 

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

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

  294. 

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

  296. 

  297.         try {

  298.             fAudio.startStream();

  299.         }

  300.         catch (const RtAudioError& e)

  301.         {

  302.             close();

  303.             setLastError(e.what());

  304.             return false;

  305.         }

  306. 

  307.         patchbayRefresh(false);

  308. 

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

  310.         return true;

  311.     }

  312. 

  313.     bool close() override

  314.     {

  315.         CARLA_SAFE_ASSERT(fAudioOutCount != 0);

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

  317. 

  318.         bool hasError = false;

  319. 

  320.         // stop stream first

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

  322.         {

  323.             try {

  324.                 fAudio.stopStream();

  325.             }

  326.             catch (const RtAudioError& e)

  327.             {

  328.                 setLastError(e.what());

  329.                 hasError = true;

  330.             }

  331.         }

  332. 

  333.         // clear engine data

  334.         CarlaEngine::close();

  335. 

  336.         pData->graph.destroy();

  337. 

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

  339.         {

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

  341. 

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

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

  344. 

  345.             inPort.port->cancelCallback();

  346.             inPort.port->closePort();

  347.             delete inPort.port;

  348.         }

  349. 

  350.         fMidiIns.clear();

  351.         fMidiInEvents.clear();

  352. 

  353.         fMidiOutMutex.lock();

  354. 

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

  356.         {

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

  358. 

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

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

  361. 

  362.             outPort.port->closePort();

  363.             delete outPort.port;

  364.         }

  365. 

  366.         fMidiOuts.clear();

  367.         fMidiOutMutex.unlock();

  368. 

  369.         fAudioInCount  = 0;

  370.         fAudioOutCount = 0;

  371.         fLastEventTime = 0;

  372.         fDeviceName.clear();

  373. 

  374.         // close stream

  375.         if (fAudio.isStreamOpen())

  376.             fAudio.closeStream();

  377. 

  378.         return !hasError;

  379.     }

  380. 

  381.     bool isRunning() const noexcept override

  382.     {

  383.         return fAudio.isStreamOpen();

  384.     }

  385. 

  386.     bool isOffline() const noexcept override

  387.     {

  388.         return false;

  389.     }

  390. 

  391.     EngineType getType() const noexcept override

  392.     {

  393.         return kEngineTypeRtAudio;

  394.     }

  395. 

  396.     const char* getCurrentDriverName() const noexcept override

  397.     {

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

  399.     }

  400. 

  401.     // -------------------------------------------------------------------

  402.     // Patchbay

  403. 

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

  405.     {

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

  407. 

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

  409.             patchbayRefreshRack();

  410.         else

  411.             patchbayRefreshPatchbay();

  412. 

  413.         return true;

  414.     }

  415. 

  416.     void patchbayRefreshRack()

  417.     {

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

  419.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  420. 

  421.         graph->connections.clear();

  422. 

  423.         char strBuf[STR_MAX+1];

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

  425. 

  426.         // Main

  427.         {

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

  429. 

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

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

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

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

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

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

  436.         }

  437. 

  438.         // Audio In

  439.         {

  440.             if (fDeviceName.isNotEmpty())

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

  442.             else

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

  444. 

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

  446. 

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

  448.             {

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

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

  451.             }

  452.         }

  453. 

  454.         // Audio Out

  455.         {

  456.             if (fDeviceName.isNotEmpty())

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

  458.             else

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

  460. 

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

  462. 

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

  464.             {

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

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

  467.             }

  468.         }

  469. 

  470.         // MIDI In

  471.         {

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

  473. 

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

  475. 

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

  477.             {

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

  479. 

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

  481. 

  482.                 PortNameToId portNameToId;

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

  484. 

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

  486. 

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

  488.             }

  489.         }

  490. 

  491.         // MIDI Out

  492.         {

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

  494. 

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

  496. 

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

  498.             {

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

  500. 

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

  502. 

  503.                 PortNameToId portNameToId;

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

  505. 

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

  507. 

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

  509.             }

  510.         }

  511. 

  512.         // Connections

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

  514. 

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

  516.         {

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

  518.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  519.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  520. 

  521.             ConnectionToId connectionToId;

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

  523. 

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

  525. 

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

  527. 

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

  529.         }

  530. 

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

  532.         {

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

  534.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  535.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioInCount);

  536. 

  537.             ConnectionToId connectionToId;

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

  539. 

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

  541. 

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

  543. 

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

  545.         }

  546. 

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

  548.         {

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

  550.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  551.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  552. 

  553.             ConnectionToId connectionToId;

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

  555. 

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

  557. 

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

  559. 

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

  561.         }

  562. 

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

  564.         {

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

  566.             CARLA_SAFE_ASSERT_CONTINUE(portId != 0);

  567.             CARLA_SAFE_ASSERT_CONTINUE(portId < fAudioOutCount);

  568. 

  569.             ConnectionToId connectionToId;

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

  571. 

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

  573. 

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

  575. 

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

  577.         }

  578. 

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

  580. 

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

  582.         {

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

  584. 

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

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

  587. 

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

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

  590. 

  591.             ConnectionToId connectionToId;

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

  593. 

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

  595. 

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

  597. 

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

  599.         }

  600. 

  601.         fMidiOutMutex.lock();

  602. 

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

  604.         {

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

  606. 

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

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

  609. 

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

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

  612. 

  613.             ConnectionToId connectionToId;

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

  615. 

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

  617. 

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

  619. 

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

  621.         }

  622. 

  623.         fMidiOutMutex.unlock();

  624.     }

  625. 

  626.     void patchbayRefreshPatchbay() noexcept

  627.     {

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

  629.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  630. 

  631.         graph->refreshConnections(this);

  632.     }

  633. 

  634.     // -------------------------------------------------------------------

  635. 

  636. protected:

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

  638.     {

  639.         const PendingRtEventsRunner prt(this);

  640. 

  641.         // get buffers from RtAudio

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

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

  644. 

  645.         // assert rtaudio buffers

  646.         CARLA_SAFE_ASSERT_RETURN(outputBuffer      != nullptr,);

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

  648. 

  649.         // set rtaudio buffers as non-interleaved

  650.         const float* inBuf[fAudioInCount];

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

  652. 

  653.         if (fAudioInterleaved)

  654.         {

  655.             float* inBuf2[fAudioInCount];

  656. 

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

  658.             {

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

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

  661.             }

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

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

  664. 

  665.             // init input

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

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

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

  669. 

  670.             // clear output

  671.             fAudioIntBufOut.clear();

  672.         }

  673.         else

  674.         {

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

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

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

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

  679. 

  680.             // clear output

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

  682.         }

  683. 

  684.         // initialize events

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

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

  687. 

  688.         if (fMidiInEvents.mutex.tryLock())

  689.         {

  690.             uint32_t engineEventIndex = 0;

  691.             fMidiInEvents.splice();

  692. 

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

  694.             {

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

  696. 

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

  698.                 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.size > 0);

  699. 

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

  701. 

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

  703.                 {

  704.                     engineEvent.time = 0;

  705.                 }

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

  707.                 {

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

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

  710.                 }

  711.                 else

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

  713. 

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

  715. 

  716.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  717.                     break;

  718.             }

  719. 

  720.             fMidiInEvents.data.clear();

  721.             fMidiInEvents.mutex.unlock();

  722.         }

  723. 

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

  725. 

  726.         fMidiOutMutex.lock();

  727. 

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

  729.         {

  730.             uint8_t        size    = 0;

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

  732.             const uint8_t* dataPtr = data;

  733. 

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

  735.             {

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

  737. 

  738.                 if (engineEvent.type == kEngineEventTypeNull)

  739.                     break;

  740. 

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

  742.                 {

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

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

  745.                     dataPtr = data;

  746.                 }

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

  748.                 {

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

  750. 

  751.                     size = midiEvent.size;

  752. 

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

  754.                         dataPtr = midiEvent.dataExt;

  755.                     else

  756.                         dataPtr = midiEvent.data;

  757.                 }

  758.                 else

  759.                 {

  760.                     continue;

  761.                 }

  762. 

  763.                 if (size > 0)

  764.                 {

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

  766. 

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

  768.                     {

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

  770. 

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

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

  773. 

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

  775.                     }

  776.                 }

  777.             }

  778.         }

  779. 

  780.         if (fAudioInterleaved)

  781.         {

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

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

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

  785.         }

  786. 

  787.         fMidiOutMutex.unlock();

  788. 

  789.         return; // unused

  790.         (void)streamTime; (void)status;

  791.     }

  792. 

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

  794.     {

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

  796. 

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

  798.             return;

  799. 

  800.         timeStamp /= 2;

  801. 

  802.         if (timeStamp > 0.95)

  803.             timeStamp = 0.95;

  804.         else if (timeStamp < 0.0)

  805.             timeStamp = 0.0;

  806. 

  807.         RtMidiEvent midiEvent;

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

  809. 

  810.         if (midiEvent.time < fLastEventTime)

  811.             midiEvent.time = fLastEventTime;

  812.         else

  813.             fLastEventTime = midiEvent.time;

  814. 

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

  816. 

  817.         size_t i=0;

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

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

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

  821.             midiEvent.data[i] = 0;

  822. 

  823.         fMidiInEvents.append(midiEvent);

  824.     }

  825. 

  826.     // -------------------------------------------------------------------

  827. 

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

  829.     {

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

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

  832. 

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

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

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

  836. 

  837.         CarlaString newRtMidiPortName;

  838.         newRtMidiPortName += getName();

  839.         newRtMidiPortName += ":";

  840.         newRtMidiPortName += portName;

  841. 

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

  843.         rtMidiIn->ignoreTypes();

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

  845. 

  846.         bool found = false;

  847.         uint rtMidiPortIndex;

  848. 

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

  850.         {

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

  852.             {

  853.                 found = true;

  854.                 rtMidiPortIndex = i;

  855.                 break;

  856.             }

  857.         }

  858. 

  859.         if (! found)

  860.         {

  861.             delete rtMidiIn;

  862.             return false;

  863.         }

  864. 

  865.         try {

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

  867.         }

  868.         catch(...) {

  869.             delete rtMidiIn;

  870.             return false;

  871.         };

  872. 

  873.         MidiInPort midiPort;

  874.         midiPort.port = rtMidiIn;

  875. 

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

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

  878. 

  879.         fMidiIns.append(midiPort);

  880.         return true;

  881.     }

  882. 

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

  884.     {

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

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

  887. 

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

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

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

  891. 

  892.         CarlaString newRtMidiPortName;

  893.         newRtMidiPortName += getName();

  894.         newRtMidiPortName += ":";

  895.         newRtMidiPortName += portName;

  896. 

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

  898. 

  899.         bool found = false;

  900.         uint rtMidiPortIndex;

  901. 

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

  903.         {

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

  905.             {

  906.                 found = true;

  907.                 rtMidiPortIndex = i;

  908.                 break;

  909.             }

  910.         }

  911. 

  912.         if (! found)

  913.         {

  914.             delete rtMidiOut;

  915.             return false;

  916.         }

  917. 

  918.         try {

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

  920.         }

  921.         catch(...) {

  922.             delete rtMidiOut;

  923.             return false;

  924.         };

  925. 

  926.         MidiOutPort midiPort;

  927.         midiPort.port = rtMidiOut;

  928. 

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

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

  931. 

  932.         const CarlaMutexLocker cml(fMidiOutMutex);

  933. 

  934.         fMidiOuts.append(midiPort);

  935.         return true;

  936.     }

  937. 

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

  939.     {

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

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

  942. 

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

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

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

  946. 

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

  948.         {

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

  950. 

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

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

  953. 

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

  955.                 continue;

  956. 

  957.             inPort.port->cancelCallback();

  958.             inPort.port->closePort();

  959.             delete inPort.port;

  960. 

  961.             fMidiIns.remove(it);

  962.             return true;

  963.         }

  964. 

  965.         return false;

  966.     }

  967. 

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

  969.     {

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

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

  972. 

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

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

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

  976. 

  977.         const CarlaMutexLocker cml(fMidiOutMutex);

  978. 

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

  980.         {

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

  982. 

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

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

  985. 

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

  987.                 continue;

  988. 

  989.             outPort.port->closePort();

  990.             delete outPort.port;

  991. 

  992.             fMidiOuts.remove(it);

  993.             return true;

  994.         }

  995. 

  996.         return false;

  997.     }

  998. 

  999.     // -------------------------------------------------------------------

  1000. 

  1001. private:

  1002.     RtAudio fAudio;

  1003. 

  1004.     // useful info

  1005.     bool fAudioInterleaved;

  1006.     uint fAudioInCount;

  1007.     uint fAudioOutCount;

  1008.     uint64_t fLastEventTime;

  1009. 

  1010.     // current device name

  1011.     CarlaString fDeviceName;

  1012. 

  1013.     // temp buffer for interleaved audio

  1014.     AudioSampleBuffer fAudioIntBufIn;

  1015.     AudioSampleBuffer fAudioIntBufOut;

  1016. 

  1017.     struct MidiInPort {

  1018.         RtMidiIn* port;

  1019.         char name[STR_MAX+1];

  1020.     };

  1021. 

  1022.     struct MidiOutPort {

  1023.         RtMidiOut* port;

  1024.         char name[STR_MAX+1];

  1025.     };

  1026. 

  1027.     struct RtMidiEvent {

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

  1029.         uint8_t  size;

  1030.         uint8_t  data[EngineMidiEvent::kDataSize];

  1031.     };

  1032. 

  1033.     struct RtMidiEvents {

  1034.         CarlaMutex mutex;

  1035.         RtLinkedList<RtMidiEvent>::Pool dataPool;

  1036.         RtLinkedList<RtMidiEvent> data;

  1037.         RtLinkedList<RtMidiEvent> dataPending;

  1038. 

  1039.         RtMidiEvents()

  1040.             : mutex(),

  1041.               dataPool(512, 512),

  1042.               data(dataPool),

  1043.               dataPending(dataPool) {}

  1044. 

  1045.         ~RtMidiEvents()

  1046.         {

  1047.             clear();

  1048.         }

  1049. 

  1050.         void append(const RtMidiEvent& event)

  1051.         {

  1052.             mutex.lock();

  1053.             dataPending.append(event);

  1054.             mutex.unlock();

  1055.         }

  1056. 

  1057.         void clear()

  1058.         {

  1059.             mutex.lock();

  1060.             data.clear();

  1061.             dataPending.clear();

  1062.             mutex.unlock();

  1063.         }

  1064. 

  1065.         void splice()

  1066.         {

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

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

  1069.         }

  1070.     };

  1071. 

  1072.     LinkedList<MidiInPort> fMidiIns;

  1073.     RtMidiEvents           fMidiInEvents;

  1074. 

  1075.     LinkedList<MidiOutPort> fMidiOuts;

  1076.     CarlaMutex              fMidiOutMutex;

  1077.     std::vector<uint8_t>    fMidiOutVector;

  1078. 

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

  1080. 

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

  1082.     {

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

  1084.         return 0;

  1085.     }

  1086. 

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

  1088.     {

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

  1090.     }

  1091. 

  1092.     #undef handlePtr

  1093. 

  1094.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)

  1095. };

  1096. 

  1097. // -----------------------------------------

  1098. 

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

  1100. {

  1101.     initRtAudioAPIsIfNeeded();

  1102. 

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

  1104. 

  1105.     switch (api)

  1106.     {

  1107.     case AUDIO_API_NULL:

  1108.         rtApi = RtAudio::RTAUDIO_DUMMY;

  1109.         break;

  1110.     case AUDIO_API_JACK:

  1111.         rtApi = RtAudio::UNIX_JACK;

  1112.         break;

  1113.     case AUDIO_API_ALSA:

  1114.         rtApi = RtAudio::LINUX_ALSA;

  1115.         break;

  1116.     case AUDIO_API_OSS:

  1117.         rtApi = RtAudio::LINUX_OSS;

  1118.         break;

  1119.     case AUDIO_API_PULSE:

  1120.         rtApi = RtAudio::LINUX_PULSE;

  1121.         break;

  1122.     case AUDIO_API_CORE:

  1123.         rtApi = RtAudio::MACOSX_CORE;

  1124.         break;

  1125.     case AUDIO_API_ASIO:

  1126.         rtApi = RtAudio::WINDOWS_ASIO;

  1127.         break;

  1128.     case AUDIO_API_DS:

  1129.         rtApi = RtAudio::WINDOWS_DS;

  1130.         break;

  1131.     }

  1132. 

  1133.     return new CarlaEngineRtAudio(rtApi);

  1134. }

  1135. 

  1136. uint CarlaEngine::getRtAudioApiCount()

  1137. {

  1138.     initRtAudioAPIsIfNeeded();

  1139. 

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

  1141. }

  1142. 

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

  1144. {

  1145.     initRtAudioAPIsIfNeeded();

  1146. 

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

  1148. 

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

  1150. }

  1151. 

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

  1153. {

  1154.     initRtAudioAPIsIfNeeded();

  1155. 

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

  1157.         return nullptr;

  1158. 

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

  1160. 

  1161.     RtAudio rtAudio(api);

  1162. 

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

  1164. 

  1165.     if (devCount == 0)

  1166.         return nullptr;

  1167. 

  1168.     CarlaStringList devNames;

  1169. 

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

  1171.     {

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

  1173. 

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

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

  1176.     }

  1177. 

  1178.     gDeviceNames = devNames.toCharStringListPtr();

  1179. 

  1180.     return gDeviceNames;

  1181. }

  1182. 

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

  1184. {

  1185.     initRtAudioAPIsIfNeeded();

  1186. 

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

  1188.         return nullptr;

  1189. 

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

  1191. 

  1192.     RtAudio rtAudio(api);

  1193. 

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

  1195. 

  1196.     if (devCount == 0)

  1197.         return nullptr;

  1198. 

  1199.     uint i;

  1200.     RtAudio::DeviceInfo rtAudioDevInfo;

  1201. 

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

  1203.     {

  1204.         rtAudioDevInfo = rtAudio.getDeviceInfo(i);

  1205. 

  1206.         if (rtAudioDevInfo.name == deviceName)

  1207.             break;

  1208.     }

  1209. 

  1210.     if (i == devCount)

  1211.         return nullptr;

  1212. 

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

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

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

  1216. 

  1217.     // reset

  1218.     devInfo.hints = 0x0;

  1219.     devInfo.bufferSizes = dummyBufferSizes;

  1220. 

  1221.     // cleanup

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

  1223.     {

  1224.         delete[] devInfo.sampleRates;

  1225.         devInfo.sampleRates = nullptr;

  1226.     }

  1227. 

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

  1229.     {

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

  1231. 

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

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

  1234.         sampleRates[sampleRatesCount] = 0.0;

  1235. 

  1236.         devInfo.sampleRates = sampleRates;

  1237.     }

  1238.     else

  1239.     {

  1240.         devInfo.sampleRates = dummySampleRates;

  1241.     }

  1242. 

  1243.     return &devInfo;

  1244. }

  1245. 

  1246. // -----------------------------------------

  1247. 

  1248. CARLA_BACKEND_END_NAMESPACE