source/backend/engine/CarlaEngineRtAudio.cpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #include "CarlaEngineGraph.hpp"
   5 #include "CarlaEngineInit.hpp"
   6 #include "CarlaEngineInternal.hpp"
   7 #include "CarlaBackendUtils.hpp"
   8 #include "CarlaMathUtils.hpp"
   9 #include "CarlaStringList.hpp"
  10
  11 #include "RtLinkedList.hpp"
  12
  13 #include "jackbridge/JackBridge.hpp"
  14
  15 #if defined(__clang__)
  16 # pragma clang diagnostic push
  17 # pragma clang diagnostic ignored "-Wconversion"
  18 # pragma clang diagnostic ignored "-Wdeprecated-copy"
  19 # pragma clang diagnostic ignored "-Weffc++"
  20 # pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
  21 #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  22 # pragma GCC diagnostic push
  23 # pragma GCC diagnostic ignored "-Wconversion"
  24 # pragma GCC diagnostic ignored "-Weffc++"
  25 # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
  26 #endif
  27
  28 #include "rtaudio/RtAudio.h"
  29 #include "rtmidi/RtMidi.h"
  30
  31 #if defined(__clang__)
  32 # pragma clang diagnostic pop
  33 #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  34 # pragma GCC diagnostic pop
  35 #endif
  36
  37 CARLA_BACKEND_START_NAMESPACE
  38
  39 // -------------------------------------------------------------------------------------------------------------------
  40 // Global static data
  41
  42 static CharStringListPtr         gDeviceNames;
  43 static std::vector<RtAudio::Api> gRtAudioApis;
  44
  45 // -------------------------------------------------------------------------------------------------------------------
  46
  47 static void initRtAudioAPIsIfNeeded()
  48 {
  49     static bool needsInit = true;
  50
  51     if (! needsInit)
  52         return;
  53
  54     needsInit = false;
  55
  56     // get APIs in a local var, and pass wanted ones into gRtAudioApis
  57
  58     std::vector<RtAudio::Api> apis;
  59     RtAudio::getCompiledApi(apis);
  60
  61     for (std::vector<RtAudio::Api>::const_iterator it = apis.begin(), end=apis.end(); it != end; ++it)
  62     {
  63         const RtAudio::Api& api(*it);
  64
  65         if (api == RtAudio::UNIX_JACK)
  66         {
  67 #if defined(CARLA_OS_LINUX) || defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)
  68             if ( ! jackbridge_is_ok())
  69                 continue;
  70 #else
  71             /* NOTE
  72              * RtMidi doesn't have a native MIDI backend for these OSes,
  73              * Using RtAudio JACK funcitonality is only useful when we need to access the native MIDI APIs.
  74              * (JACK audio + ALSA MIDI, or JACK audio + CoreMidi, or JACK audio + Windows MIDI)
  75              * Because RtMidi has no native MIDI support outside of win/mac/linux, we skip these RtAudio APIs.
  76              * Those OSes can use Carla's JACK support directly, which is much better than RtAudio classes.
  77              */
  78             continue;
  79 #endif
  80         }
  81
  82         gRtAudioApis.push_back(api);
  83     }
  84 }
  85
  86 static const char* getRtAudioApiName(const RtAudio::Api api) noexcept
  87 {
  88     switch (api)
  89     {
  90     case RtAudio::UNSPECIFIED:
  91         return "Unspecified";
  92     case RtAudio::LINUX_ALSA:
  93         return "ALSA";
  94     case RtAudio::LINUX_OSS:
  95         return "OSS";
  96     case RtAudio::UNIX_PULSE:
  97         return "PulseAudio";
  98     case RtAudio::UNIX_JACK:
  99 #if defined(CARLA_OS_LINUX) && defined(__LINUX_ALSA__)
 100         return "JACK with ALSA-MIDI";
 101 #elif defined(CARLA_OS_MAC)
 102         return "JACK with CoreMidi";
 103 #elif defined(CARLA_OS_WIN)
 104         return "JACK with WinMM";
 105 #else
 106         return "JACK (RtAudio)";
 107 #endif
 108     case RtAudio::MACOSX_CORE:
 109         return "CoreAudio";
 110     case RtAudio::WINDOWS_ASIO:
 111         return "ASIO";
 112     case RtAudio::WINDOWS_DS:
 113         return "DirectSound";
 114     case RtAudio::WINDOWS_WASAPI:
 115         return "WASAPI";
 116     case RtAudio::RTAUDIO_DUMMY:
 117         return "Dummy";
 118     }
 119
 120     carla_stderr("CarlaBackend::getRtAudioApiName(%i) - invalid API", api);
 121     return nullptr;
 122 }
 123
 124 static RtMidi::Api getMatchedAudioMidiAPI(const RtAudio::Api rtApi) noexcept
 125 {
 126     switch (rtApi)
 127     {
 128     case RtAudio::UNSPECIFIED:
 129         return RtMidi::UNSPECIFIED;
 130
 131     case RtAudio::LINUX_ALSA:
 132     case RtAudio::LINUX_OSS:
 133         return RtMidi::LINUX_ALSA;
 134
 135     case RtAudio::UNIX_PULSE:
 136     case RtAudio::UNIX_JACK:
 137 #if defined(CARLA_OS_LINUX) && defined(__LINUX_ALSA__)
 138         return RtMidi::LINUX_ALSA;
 139 #elif defined(CARLA_OS_MAC)
 140         return RtMidi::MACOSX_CORE;
 141 #elif defined(CARLA_OS_WIN)
 142         return RtMidi::WINDOWS_MM;
 143 #else
 144         return RtMidi::RTMIDI_DUMMY;
 145 #endif
 146
 147     case RtAudio::MACOSX_CORE:
 148         return RtMidi::MACOSX_CORE;
 149
 150     case RtAudio::WINDOWS_ASIO:
 151     case RtAudio::WINDOWS_DS:
 152     case RtAudio::WINDOWS_WASAPI:
 153         return RtMidi::WINDOWS_MM;
 154
 155     case RtAudio::RTAUDIO_DUMMY:
 156         return RtMidi::RTMIDI_DUMMY;
 157     }
 158
 159     return RtMidi::UNSPECIFIED;
 160 }
 161
 162 // -------------------------------------------------------------------------------------------------------------------
 163 // RtAudio Engine
 164
 165 class CarlaEngineRtAudio : public CarlaEngine
 166 {
 167 public:
 168     CarlaEngineRtAudio(const RtAudio::Api api)
 169         : CarlaEngine(),
 170           fAudio(api),
 171           fAudioInterleaved(false),
 172           fAudioInCount(0),
 173           fAudioOutCount(0),
 174           fLastEventTime(0),
 175           fDeviceName(),
 176           fAudioIntBufIn(nullptr),
 177           fAudioIntBufOut(nullptr),
 178           fMidiIns(),
 179           fMidiInEvents(),
 180           fMidiOuts(),
 181           fMidiOutMutex(),
 182           fMidiOutVector(EngineMidiEvent::kDataSize)
 183     {
 184         carla_debug("CarlaEngineRtAudio::CarlaEngineRtAudio(%i)", api);
 185
 186         // just to make sure
 187         pData->options.transportMode = ENGINE_TRANSPORT_MODE_INTERNAL;
 188     }
 189
 190     ~CarlaEngineRtAudio() override
 191     {
 192         CARLA_SAFE_ASSERT(fAudioInCount == 0);
 193         CARLA_SAFE_ASSERT(fAudioOutCount == 0);
 194         CARLA_SAFE_ASSERT(fLastEventTime == 0);
 195         carla_debug("CarlaEngineRtAudio::~CarlaEngineRtAudio()");
 196     }
 197
 198     // -------------------------------------
 199
 200     bool init(const char* const clientName) override
 201     {
 202         CARLA_SAFE_ASSERT_RETURN(fAudioInCount == 0, false);
 203         CARLA_SAFE_ASSERT_RETURN(fAudioOutCount == 0, false);
 204         CARLA_SAFE_ASSERT_RETURN(fLastEventTime == 0, false);
 205         CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);
 206         carla_debug("CarlaEngineRtAudio::init(\"%s\")", clientName);
 207
 208         if (pData->options.processMode != ENGINE_PROCESS_MODE_CONTINUOUS_RACK && pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY)
 209         {
 210             setLastError("Invalid process mode");
 211             return false;
 212         }
 213
 214         const bool isDummy(fAudio.getCurrentApi() == RtAudio::RtAudio::RTAUDIO_DUMMY);
 215         bool deviceSet = false;
 216         RtAudio::StreamParameters iParams, oParams;
 217
 218         if (isDummy)
 219         {
 220             if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
 221             {
 222                 setLastError("Cannot use dummy driver in Rack mode");
 223                 return false;
 224             }
 225
 226             fDeviceName = "Dummy";
 227         }
 228         else
 229         {
 230             const uint devCount(fAudio.getDeviceCount());
 231
 232             if (devCount == 0)
 233             {
 234                 setLastError("No audio devices available for this driver");
 235                 return false;
 236             }
 237
 238             if (pData->options.audioDevice != nullptr && pData->options.audioDevice[0] != '\0')
 239             {
 240                 for (uint i=0; i < devCount; ++i)
 241                 {
 242                     RtAudio::DeviceInfo devInfo(fAudio.getDeviceInfo(i));
 243
 244                     if (devInfo.probed && devInfo.outputChannels > 0 && devInfo.name == pData->options.audioDevice)
 245                     {
 246                         deviceSet   = true;
 247                         fDeviceName = devInfo.name.c_str();
 248                         iParams.deviceId  = i;
 249                         oParams.deviceId  = i;
 250                         iParams.nChannels = devInfo.inputChannels;
 251                         oParams.nChannels = devInfo.outputChannels;
 252                         break;
 253                     }
 254                 }
 255             }
 256
 257             if (! deviceSet)
 258             {
 259                 iParams.deviceId  = fAudio.getDefaultInputDevice();
 260                 oParams.deviceId  = fAudio.getDefaultOutputDevice();
 261                 iParams.nChannels = fAudio.getDeviceInfo(iParams.deviceId).inputChannels;
 262                 oParams.nChannels = fAudio.getDeviceInfo(oParams.deviceId).outputChannels;
 263
 264                 carla_stdout("No device set, using %i inputs and %i outputs", iParams.nChannels, oParams.nChannels);
 265             }
 266
 267             if (oParams.nChannels == 0 && pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
 268             {
 269                 setLastError("Current audio setup has no outputs, cannot continue");
 270                 return false;
 271             }
 272
 273             iParams.nChannels = carla_fixedValue(0U, 128U, iParams.nChannels);
 274             oParams.nChannels = carla_fixedValue(0U, 128U, oParams.nChannels);
 275             fAudioInterleaved = fAudio.getCurrentApi() == RtAudio::UNIX_PULSE;
 276         }
 277
 278         RtAudio::StreamOptions rtOptions;
 279         rtOptions.flags = RTAUDIO_SCHEDULE_REALTIME;
 280        #ifndef CARLA_OS_MAC
 281         rtOptions.flags |= RTAUDIO_MINIMIZE_LATENCY;
 282        #endif
 283         rtOptions.numberOfBuffers = pData->options.audioTripleBuffer ? 3 : 2;
 284         rtOptions.streamName = clientName;
 285         rtOptions.priority = 85;
 286
 287         if (fAudio.getCurrentApi() == RtAudio::LINUX_ALSA && ! deviceSet)
 288             rtOptions.flags |= RTAUDIO_ALSA_USE_DEFAULT;
 289         if (! fAudioInterleaved)
 290             rtOptions.flags |= RTAUDIO_NONINTERLEAVED;
 291
 292         uint bufferFrames = pData->options.audioBufferSize;
 293
 294         try {
 295             fAudio.openStream(oParams.nChannels > 0 ? &oParams : nullptr,
 296                               iParams.nChannels > 0 ? &iParams : nullptr,
 297                               RTAUDIO_FLOAT32, pData->options.audioSampleRate, &bufferFrames,
 298                               carla_rtaudio_process_callback, this, &rtOptions,
 299                               carla_rtaudio_buffer_size_callback);
 300         }
 301         catch (const RtAudioError& e) {
 302             setLastError(e.what());
 303             return false;
 304         }
 305
 306         if (! pData->init(clientName))
 307         {
 308             close();
 309             setLastError("Failed to init internal data");
 310             return false;
 311         }
 312
 313         pData->bufferSize = bufferFrames;
 314         pData->sampleRate = isDummy ? 44100.0 : fAudio.getStreamSampleRate();
 315         pData->initTime(pData->options.transportExtra);
 316
 317         fAudioInCount  = iParams.nChannels;
 318         fAudioOutCount = oParams.nChannels;
 319         fLastEventTime = 0;
 320
 321         if (fAudioInCount > 0)
 322             fAudioIntBufIn = new float[fAudioInCount*bufferFrames];
 323
 324         if (fAudioOutCount > 0)
 325             fAudioIntBufOut = new float[fAudioOutCount*bufferFrames];
 326
 327         pData->graph.create(fAudioInCount, fAudioOutCount, 0, 0);
 328
 329         try {
 330             fAudio.startStream();
 331         }
 332         catch (const RtAudioError& e)
 333         {
 334             close();
 335             setLastError(e.what());
 336             return false;
 337         }
 338
 339         patchbayRefresh(true, false, false);
 340
 341         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)
 342             refreshExternalGraphPorts<PatchbayGraph>(pData->graph.getPatchbayGraph(), false, false);
 343
 344         callback(true, true,
 345                  ENGINE_CALLBACK_ENGINE_STARTED,
 346                  0,
 347                  pData->options.processMode,
 348                  pData->options.transportMode,
 349                  static_cast<int>(pData->bufferSize),
 350                  static_cast<float>(pData->sampleRate),
 351                  getCurrentDriverName());
 352         return true;
 353     }
 354
 355     bool close() override
 356     {
 357         carla_debug("CarlaEngineRtAudio::close()");
 358
 359         bool hasError = false;
 360
 361         // stop stream first
 362         if (fAudio.isStreamOpen() && fAudio.isStreamRunning())
 363         {
 364             try {
 365                 fAudio.stopStream();
 366             }
 367             catch (const RtAudioError& e)
 368             {
 369                 setLastError(e.what());
 370                 hasError = true;
 371             }
 372         }
 373
 374         // clear engine data
 375         CarlaEngine::close();
 376
 377         pData->graph.destroy();
 378
 379         for (LinkedList<MidiInPort>::Itenerator it = fMidiIns.begin2(); it.valid(); it.next())
 380         {
 381             static MidiInPort fallback = { nullptr, { '\0' } };
 382
 383             MidiInPort& inPort(it.getValue(fallback));
 384             CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);
 385
 386             inPort.port->cancelCallback();
 387             inPort.port->closePort();
 388             delete inPort.port;
 389         }
 390
 391         fMidiIns.clear();
 392         fMidiInEvents.clear();
 393
 394         fMidiOutMutex.lock();
 395
 396         for (LinkedList<MidiOutPort>::Itenerator it = fMidiOuts.begin2(); it.valid(); it.next())
 397         {
 398             static MidiOutPort fallback = { nullptr, { '\0' } };
 399
 400             MidiOutPort& outPort(it.getValue(fallback));
 401             CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);
 402
 403             outPort.port->closePort();
 404             delete outPort.port;
 405         }
 406
 407         fMidiOuts.clear();
 408         fMidiOutMutex.unlock();
 409
 410         fAudioInCount  = 0;
 411         fAudioOutCount = 0;
 412         fLastEventTime = 0;
 413         fDeviceName.clear();
 414
 415         if (fAudioIntBufIn != nullptr)
 416         {
 417             delete[] fAudioIntBufIn;
 418             fAudioIntBufIn = nullptr;
 419         }
 420
 421         if (fAudioIntBufOut != nullptr)
 422         {
 423             delete[] fAudioIntBufOut;
 424             fAudioIntBufOut = nullptr;
 425         }
 426
 427         // close stream
 428         if (fAudio.isStreamOpen())
 429             fAudio.closeStream();
 430
 431         return !hasError;
 432     }
 433
 434     bool hasIdleOnMainThread() const noexcept override
 435     {
 436         return true;
 437     }
 438
 439     bool isRunning() const noexcept override
 440     {
 441         return fAudio.isStreamOpen();
 442     }
 443
 444     bool isOffline() const noexcept override
 445     {
 446         return false;
 447     }
 448
 449     EngineType getType() const noexcept override
 450     {
 451         return kEngineTypeRtAudio;
 452     }
 453
 454     const char* getCurrentDriverName() const noexcept override
 455     {
 456         return CARLA_BACKEND_NAMESPACE::getRtAudioApiName(fAudio.getCurrentApi());
 457     }
 458
 459     // -------------------------------------------------------------------
 460     // Patchbay
 461
 462     template<class Graph>
 463     bool refreshExternalGraphPorts(Graph* const graph, const bool sendHost, const bool sendOSC)
 464     {
 465         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);
 466
 467         char strBuf[STR_MAX+1U];
 468         strBuf[STR_MAX] = '\0';
 469
 470         ExternalGraph& extGraph(graph->extGraph);
 471
 472         // ---------------------------------------------------------------
 473         // clear last ports
 474
 475         extGraph.clear();
 476
 477         // ---------------------------------------------------------------
 478         // fill in new ones
 479
 480         // Audio In
 481         for (uint i=0; i < fAudioInCount; ++i)
 482         {
 483             std::snprintf(strBuf, STR_MAX, "capture_%i", i+1);
 484
 485             PortNameToId portNameToId;
 486             portNameToId.setData(kExternalGraphGroupAudioIn, i+1, strBuf, "");
 487
 488             extGraph.audioPorts.ins.append(portNameToId);
 489         }
 490
 491         // Audio Out
 492         for (uint i=0; i < fAudioOutCount; ++i)
 493         {
 494             std::snprintf(strBuf, STR_MAX, "playback_%i", i+1);
 495
 496             PortNameToId portNameToId;
 497             portNameToId.setData(kExternalGraphGroupAudioOut, i+1, strBuf, "");
 498
 499             extGraph.audioPorts.outs.append(portNameToId);
 500         }
 501
 502         // MIDI In
 503         try
 504         {
 505             RtMidiIn midiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), "carla-discovery-in");
 506
 507             for (uint i=0, count = midiIn.getPortCount(); i < count; ++i)
 508             {
 509                 PortNameToId portNameToId;
 510                 portNameToId.setData(kExternalGraphGroupMidiIn, i+1, midiIn.getPortName(i).c_str(), "");
 511
 512                 extGraph.midiPorts.ins.append(portNameToId);
 513             }
 514         } CARLA_SAFE_EXCEPTION("RtMidiIn discovery");
 515
 516         // MIDI Out
 517         try
 518         {
 519             RtMidiOut midiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), "carla-discovery-out");
 520
 521             for (uint i=0, count = midiOut.getPortCount(); i < count; ++i)
 522             {
 523                 PortNameToId portNameToId;
 524                 portNameToId.setData(kExternalGraphGroupMidiOut, i+1, midiOut.getPortName(i).c_str(), "");
 525
 526                 extGraph.midiPorts.outs.append(portNameToId);
 527             }
 528         } CARLA_SAFE_EXCEPTION("RtMidiOut discovery");
 529
 530         // ---------------------------------------------------------------
 531         // now refresh
 532
 533         if (sendHost || sendOSC)
 534             graph->refresh(sendHost, sendOSC, true, fDeviceName.buffer());
 535
 536         // ---------------------------------------------------------------
 537         // add midi connections
 538
 539         for (LinkedList<MidiInPort>::Itenerator it=fMidiIns.begin2(); it.valid(); it.next())
 540         {
 541             static const MidiInPort fallback = { nullptr, { '\0' } };
 542
 543             const MidiInPort& inPort(it.getValue(fallback));
 544             CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);
 545
 546             const uint portId = extGraph.midiPorts.getPortIdFromName(true, inPort.name);
 547             CARLA_SAFE_ASSERT_UINT_CONTINUE(portId < extGraph.midiPorts.ins.count(), portId);
 548
 549             ConnectionToId connectionToId;
 550             connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupMidiIn, portId, kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiIn);
 551
 552             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
 553
 554             extGraph.connections.list.append(connectionToId);
 555
 556             callback(sendHost, sendOSC,
 557                       ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED,
 558                       connectionToId.id,
 559                       0, 0, 0, 0.0f,
 560                       strBuf);
 561         }
 562
 563         fMidiOutMutex.lock();
 564
 565         for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin2(); it.valid(); it.next())
 566         {
 567             static const MidiOutPort fallback = { nullptr, { '\0' } };
 568
 569             const MidiOutPort& outPort(it.getValue(fallback));
 570             CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);
 571
 572             const uint portId = extGraph.midiPorts.getPortIdFromName(false, outPort.name);
 573             CARLA_SAFE_ASSERT_UINT_CONTINUE(portId < extGraph.midiPorts.outs.count(), portId);
 574
 575             ConnectionToId connectionToId;
 576             connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiOut, kExternalGraphGroupMidiOut, portId);
 577
 578             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", connectionToId.groupA, connectionToId.portA, connectionToId.groupB, connectionToId.portB);
 579
 580             extGraph.connections.list.append(connectionToId);
 581
 582             callback(sendHost, sendOSC,
 583                       ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED,
 584                       connectionToId.id,
 585                       0, 0, 0, 0.0f,
 586                       strBuf);
 587         }
 588
 589         fMidiOutMutex.unlock();
 590
 591         return true;
 592     }
 593
 594     bool patchbayRefresh(const bool sendHost, const bool sendOSC, const bool external) override
 595     {
 596         CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);
 597
 598         if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
 599             return refreshExternalGraphPorts<RackGraph>(pData->graph.getRackGraph(), sendHost, sendOSC);
 600
 601         if (sendHost)
 602             pData->graph.setUsingExternalHost(external);
 603         if (sendOSC)
 604             pData->graph.setUsingExternalOSC(external);
 605
 606         if (external)
 607             return refreshExternalGraphPorts<PatchbayGraph>(pData->graph.getPatchbayGraph(), sendHost, sendOSC);
 608
 609         return CarlaEngine::patchbayRefresh(sendHost, sendOSC, false);
 610     }
 611
 612     // -------------------------------------------------------------------
 613
 614 protected:
 615     void handleAudioProcessCallback(void* outputBuffer, void* inputBuffer,
 616                                     uint nframes, double streamTime, RtAudioStreamStatus status)
 617     {
 618         const PendingRtEventsRunner prt(this, nframes, true);
 619
 620         if (status & RTAUDIO_INPUT_OVERFLOW)
 621             ++pData->xruns;
 622         if (status & RTAUDIO_OUTPUT_UNDERFLOW)
 623             ++pData->xruns;
 624
 625         // get buffers from RtAudio
 626         const float* const insPtr  = (const float*)inputBuffer;
 627         /* */ float* const outsPtr =       (float*)outputBuffer;
 628
 629         // assert rtaudio buffers
 630         CARLA_SAFE_ASSERT_RETURN(outputBuffer != nullptr,);
 631
 632         // set rtaudio buffers as non-interleaved
 633         const float* inBuf[fAudioInCount];
 634         /* */ float* outBuf[fAudioOutCount];
 635
 636         if (fAudioInterleaved)
 637         {
 638             // FIXME - this looks completely wrong!
 639             float* inBuf2[fAudioInCount];
 640
 641             for (uint i=0, count=fAudioInCount; i<count; ++i)
 642             {
 643                 inBuf [i] = fAudioIntBufIn + (nframes*i);
 644                 inBuf2[i] = fAudioIntBufIn + (nframes*i);
 645             }
 646             for (uint i=0, count=fAudioOutCount; i<count; ++i)
 647                 outBuf[i] = fAudioIntBufOut + (nframes*i);
 648
 649             // init input
 650             for (uint i=0; i<nframes; ++i)
 651                 for (uint j=0; j<fAudioInCount; ++j)
 652                     inBuf2[j][i] = insPtr[i*fAudioInCount+j];
 653
 654             // clear output
 655             carla_zeroFloats(fAudioIntBufOut, fAudioOutCount*nframes);
 656         }
 657         else
 658         {
 659             for (uint i=0; i < fAudioInCount; ++i)
 660                 inBuf[i] = insPtr+(nframes*i);
 661             for (uint i=0; i < fAudioOutCount; ++i)
 662                 outBuf[i] = outsPtr+(nframes*i);
 663
 664             // clear output
 665             carla_zeroFloats(outsPtr, nframes*fAudioOutCount);
 666         }
 667
 668         // initialize events
 669         carla_zeroStructs(pData->events.in,  kMaxEngineEventInternalCount);
 670         carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
 671
 672         if (fMidiInEvents.mutex.tryLock())
 673         {
 674             uint32_t engineEventIndex = 0;
 675             fMidiInEvents.splice();
 676
 677             for (LinkedList<RtMidiEvent>::Itenerator it = fMidiInEvents.data.begin2(); it.valid(); it.next())
 678             {
 679                 static const RtMidiEvent fallback = { 0, 0, { 0 } };
 680
 681                 const RtMidiEvent& midiEvent(it.getValue(fallback));
 682                 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.size > 0);
 683
 684                 EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
 685
 686                 if (midiEvent.time < pData->timeInfo.frame)
 687                 {
 688                     engineEvent.time = 0;
 689                 }
 690                 else if (midiEvent.time >= pData->timeInfo.frame + nframes)
 691                 {
 692                     carla_stderr("MIDI Event in the future!, %i vs %i", engineEvent.time, pData->timeInfo.frame);
 693                     engineEvent.time = static_cast<uint32_t>(pData->timeInfo.frame) + nframes - 1;
 694                 }
 695                 else
 696                     engineEvent.time = static_cast<uint32_t>(midiEvent.time - pData->timeInfo.frame);
 697
 698                 engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data, 0);
 699
 700                 if (engineEventIndex >= kMaxEngineEventInternalCount)
 701                     break;
 702             }
 703
 704             fMidiInEvents.data.clear();
 705             fMidiInEvents.mutex.unlock();
 706         }
 707
 708         pData->graph.process(pData, inBuf, outBuf, nframes);
 709
 710         fMidiOutMutex.lock();
 711
 712         if (fMidiOuts.count() > 0)
 713         {
 714             uint8_t size     = 0;
 715             uint8_t mdata[3] = { 0, 0, 0 };
 716             uint8_t mdataTmp[EngineMidiEvent::kDataSize];
 717             const uint8_t* mdataPtr;
 718
 719             for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
 720             {
 721                 const EngineEvent& engineEvent(pData->events.out[i]);
 722
 723                 /**/ if (engineEvent.type == kEngineEventTypeNull)
 724                 {
 725                     break;
 726                 }
 727                 else if (engineEvent.type == kEngineEventTypeControl)
 728                 {
 729                     const EngineControlEvent& ctrlEvent(engineEvent.ctrl);
 730
 731                     size = ctrlEvent.convertToMidiData(engineEvent.channel, mdata);
 732                     mdataPtr = mdata;
 733                 }
 734                 else if (engineEvent.type == kEngineEventTypeMidi)
 735                 {
 736                     const EngineMidiEvent& midiEvent(engineEvent.midi);
 737
 738                     size = midiEvent.size;
 739                     CARLA_SAFE_ASSERT_CONTINUE(size > 0);
 740
 741                     if (size > EngineMidiEvent::kDataSize)
 742                     {
 743                         CARLA_SAFE_ASSERT_CONTINUE(midiEvent.dataExt != nullptr);
 744                         mdataPtr = midiEvent.dataExt;
 745                     }
 746                     else
 747                     {
 748                         // set first byte
 749                         mdataTmp[0] = static_cast<uint8_t>(midiEvent.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));
 750
 751                         // copy rest
 752                         carla_copy<uint8_t>(mdataTmp+1, midiEvent.data+1, size-1U);
 753
 754                         // done
 755                         mdataPtr = mdataTmp;
 756                     }
 757                 }
 758                 else
 759                 {
 760                     continue;
 761                 }
 762
 763                 if (size > 0)
 764                 {
 765                     fMidiOutVector.assign(mdataPtr, mdataPtr + size);
 766
 767                     for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin2(); 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         fMidiOutMutex.unlock();
 781
 782         if (fAudioInterleaved)
 783         {
 784             for (uint i=0; i < nframes; ++i)
 785                 for (uint j=0; j<fAudioOutCount; ++j)
 786                     outsPtr[i*fAudioOutCount+j] = outBuf[j][i];
 787         }
 788
 789         return; // unused
 790         (void)streamTime;
 791     }
 792
 793     void handleBufferSizeCallback(const uint newBufferSize)
 794     {
 795         carla_stdout("bufferSize callback %u %u", pData->bufferSize, newBufferSize);
 796         if (pData->bufferSize == newBufferSize)
 797             return;
 798
 799         if (fAudioInCount > 0)
 800         {
 801             delete[] fAudioIntBufIn;
 802             fAudioIntBufIn = new float[fAudioInCount*newBufferSize];
 803         }
 804
 805         if (fAudioOutCount > 0)
 806         {
 807             delete[] fAudioIntBufOut;
 808             fAudioIntBufOut = new float[fAudioOutCount*newBufferSize];
 809         }
 810
 811         pData->bufferSize = newBufferSize;
 812         bufferSizeChanged(newBufferSize);
 813     }
 814
 815     void handleMidiCallback(double timeStamp, std::vector<uchar>* const message)
 816     {
 817         const size_t messageSize(message->size());
 818
 819         if (messageSize == 0 || messageSize > EngineMidiEvent::kDataSize)
 820             return;
 821
 822         timeStamp /= 2;
 823
 824         if (timeStamp > 0.95)
 825             timeStamp = 0.95;
 826         else if (timeStamp < 0.0)
 827             timeStamp = 0.0;
 828
 829         RtMidiEvent midiEvent;
 830         midiEvent.time = pData->timeInfo.frame + uint64_t(timeStamp * (double)pData->bufferSize);
 831
 832         if (midiEvent.time < fLastEventTime)
 833             midiEvent.time = fLastEventTime;
 834         else
 835             fLastEventTime = midiEvent.time;
 836
 837         midiEvent.size = static_cast<uint8_t>(messageSize);
 838
 839         size_t i=0;
 840         for (; i < messageSize; ++i)
 841             midiEvent.data[i] = message->at(i);
 842         for (; i < EngineMidiEvent::kDataSize; ++i)
 843             midiEvent.data[i] = 0;
 844
 845         fMidiInEvents.append(midiEvent);
 846     }
 847
 848     // -------------------------------------------------------------------
 849
 850     bool connectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName) override
 851     {
 852         CARLA_SAFE_ASSERT_RETURN(connectionType != 0 || (portName != nullptr && portName[0] != '\0'), false);
 853         carla_debug("CarlaEngineRtAudio::connectExternalGraphPort(%u, %u, \"%s\")", connectionType, portId, portName);
 854
 855         switch (connectionType)
 856         {
 857         case kExternalGraphConnectionAudioIn1:
 858         case kExternalGraphConnectionAudioIn2:
 859         case kExternalGraphConnectionAudioOut1:
 860         case kExternalGraphConnectionAudioOut2:
 861             return CarlaEngine::connectExternalGraphPort(connectionType, portId, portName);
 862
 863         case kExternalGraphConnectionMidiInput: {
 864             CarlaString newRtMidiPortName;
 865             newRtMidiPortName += getName();
 866             newRtMidiPortName += ":";
 867             newRtMidiPortName += portName;
 868
 869             RtMidiIn* rtMidiIn;
 870
 871             try {
 872                 rtMidiIn = new RtMidiIn(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer(), 512);
 873             } CARLA_SAFE_EXCEPTION_RETURN("new RtMidiIn", false);
 874
 875             rtMidiIn->ignoreTypes();
 876             rtMidiIn->setCallback(carla_rtmidi_callback, this);
 877
 878             bool found = false;
 879             uint rtMidiPortIndex;
 880
 881             for (uint i=0, count=rtMidiIn->getPortCount(); i < count; ++i)
 882             {
 883                 if (rtMidiIn->getPortName(i) == portName)
 884                 {
 885                     found = true;
 886                     rtMidiPortIndex = i;
 887                     break;
 888                 }
 889             }
 890
 891             if (! found)
 892             {
 893                 delete rtMidiIn;
 894                 return false;
 895             }
 896
 897             try {
 898                 rtMidiIn->openPort(rtMidiPortIndex, portName);
 899             }
 900             catch(...) {
 901                 delete rtMidiIn;
 902                 return false;
 903             };
 904
 905             MidiInPort midiPort;
 906             midiPort.port = rtMidiIn;
 907
 908             std::strncpy(midiPort.name, portName, STR_MAX);
 909             midiPort.name[STR_MAX] = '\0';
 910
 911             fMidiIns.append(midiPort);
 912             return true;
 913         }   break;
 914
 915         case kExternalGraphConnectionMidiOutput: {
 916             CarlaString newRtMidiPortName;
 917             newRtMidiPortName += getName();
 918             newRtMidiPortName += ":";
 919             newRtMidiPortName += portName;
 920
 921             RtMidiOut* rtMidiOut;
 922
 923             try {
 924                 rtMidiOut = new RtMidiOut(getMatchedAudioMidiAPI(fAudio.getCurrentApi()), newRtMidiPortName.buffer());
 925             } CARLA_SAFE_EXCEPTION_RETURN("new RtMidiOut", false);
 926
 927             bool found = false;
 928             uint rtMidiPortIndex;
 929
 930             for (uint i=0, count=rtMidiOut->getPortCount(); i < count; ++i)
 931             {
 932                 if (rtMidiOut->getPortName(i) == portName)
 933                 {
 934                     found = true;
 935                     rtMidiPortIndex = i;
 936                     break;
 937                 }
 938             }
 939
 940             if (! found)
 941             {
 942                 delete rtMidiOut;
 943                 return false;
 944             }
 945
 946             try {
 947                 rtMidiOut->openPort(rtMidiPortIndex, portName);
 948             }
 949             catch(...) {
 950                 delete rtMidiOut;
 951                 return false;
 952             };
 953
 954             MidiOutPort midiPort;
 955             midiPort.port = rtMidiOut;
 956
 957             std::strncpy(midiPort.name, portName, STR_MAX);
 958             midiPort.name[STR_MAX] = '\0';
 959
 960             const CarlaMutexLocker cml(fMidiOutMutex);
 961
 962             fMidiOuts.append(midiPort);
 963             return true;
 964         }   break;
 965         }
 966
 967         return false;
 968     }
 969
 970     bool disconnectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName) override
 971     {
 972         CARLA_SAFE_ASSERT_RETURN(connectionType != 0 || (portName != nullptr && portName[0] != '\0'), false);
 973         carla_debug("CarlaEngineRtAudio::disconnectExternalGraphPort(%u, %u, \"%s\")", connectionType, portId, portName);
 974
 975         switch (connectionType)
 976         {
 977         case kExternalGraphConnectionAudioIn1:
 978         case kExternalGraphConnectionAudioIn2:
 979         case kExternalGraphConnectionAudioOut1:
 980         case kExternalGraphConnectionAudioOut2:
 981             return CarlaEngine::disconnectExternalGraphPort(connectionType, portId, portName);
 982
 983         case kExternalGraphConnectionMidiInput:
 984             for (LinkedList<MidiInPort>::Itenerator it=fMidiIns.begin2(); it.valid(); it.next())
 985             {
 986                 static MidiInPort fallback = { nullptr, { '\0' } };
 987
 988                 MidiInPort& inPort(it.getValue(fallback));
 989                 CARLA_SAFE_ASSERT_CONTINUE(inPort.port != nullptr);
 990
 991                 if (std::strncmp(inPort.name, portName, STR_MAX) != 0)
 992                     continue;
 993
 994                 inPort.port->cancelCallback();
 995                 inPort.port->closePort();
 996                 delete inPort.port;
 997
 998                 fMidiIns.remove(it);
 999                 return true;
1000             }
1001             break;
1002
1003         case kExternalGraphConnectionMidiOutput: {
1004             const CarlaMutexLocker cml(fMidiOutMutex);
1005
1006             for (LinkedList<MidiOutPort>::Itenerator it=fMidiOuts.begin2(); it.valid(); it.next())
1007             {
1008                 static MidiOutPort fallback = { nullptr, { '\0' } };
1009
1010                 MidiOutPort& outPort(it.getValue(fallback));
1011                 CARLA_SAFE_ASSERT_CONTINUE(outPort.port != nullptr);
1012
1013                 if (std::strncmp(outPort.name, portName, STR_MAX) != 0)
1014                     continue;
1015
1016                 outPort.port->closePort();
1017                 delete outPort.port;
1018
1019                 fMidiOuts.remove(it);
1020                 return true;
1021             }
1022         }   break;
1023         }
1024
1025         return false;
1026     }
1027
1028     // -------------------------------------------------------------------
1029
1030 private:
1031     RtAudio fAudio;
1032
1033     // useful info
1034     bool fAudioInterleaved;
1035     uint fAudioInCount;
1036     uint fAudioOutCount;
1037     uint64_t fLastEventTime;
1038
1039     // current device name
1040     CarlaString fDeviceName;
1041
1042     // temp buffer for interleaved audio
1043     float* fAudioIntBufIn;
1044     float* fAudioIntBufOut;
1045
1046     struct MidiInPort {
1047         RtMidiIn* port;
1048         char name[STR_MAX+1];
1049     };
1050
1051     struct MidiOutPort {
1052         RtMidiOut* port;
1053         char name[STR_MAX+1];
1054     };
1055
1056     struct RtMidiEvent {
1057         uint64_t time; // needs to compare to internal time
1058         uint8_t  size;
1059         uint8_t  data[EngineMidiEvent::kDataSize];
1060     };
1061
1062     struct RtMidiEvents {
1063         CarlaMutex mutex;
1064         RtLinkedList<RtMidiEvent>::Pool dataPool;
1065         RtLinkedList<RtMidiEvent> data;
1066         RtLinkedList<RtMidiEvent> dataPending;
1067
1068         RtMidiEvents()
1069             : mutex(),
1070               dataPool("RtMidiEvents", 512, 512),
1071               data(dataPool),
1072               dataPending(dataPool) {}
1073
1074         ~RtMidiEvents()
1075         {
1076             clear();
1077         }
1078
1079         void append(const RtMidiEvent& event)
1080         {
1081             mutex.lock();
1082             dataPending.append(event);
1083             mutex.unlock();
1084         }
1085
1086         void clear()
1087         {
1088             mutex.lock();
1089             data.clear();
1090             dataPending.clear();
1091             mutex.unlock();
1092         }
1093
1094         void splice()
1095         {
1096             if (dataPending.count() > 0)
1097                 dataPending.moveTo(data, true /* append */);
1098         }
1099     };
1100
1101     LinkedList<MidiInPort> fMidiIns;
1102     RtMidiEvents           fMidiInEvents;
1103
1104     LinkedList<MidiOutPort> fMidiOuts;
1105     CarlaMutex              fMidiOutMutex;
1106     std::vector<uint8_t>    fMidiOutVector;
1107
1108     #define handlePtr ((CarlaEngineRtAudio*)userData)
1109
1110     static int carla_rtaudio_process_callback(void* outputBuffer, void* inputBuffer, uint nframes, double streamTime, RtAudioStreamStatus status, void* userData)
1111     {
1112         handlePtr->handleAudioProcessCallback(outputBuffer, inputBuffer, nframes, streamTime, status);
1113         return 0;
1114     }
1115
1116     static bool carla_rtaudio_buffer_size_callback(unsigned int bufferSize, void* userData)
1117     {
1118         handlePtr->handleBufferSizeCallback(bufferSize);
1119         return true;
1120     }
1121
1122     static void carla_rtmidi_callback(double timeStamp, std::vector<uchar>* message, void* userData)
1123     {
1124         handlePtr->handleMidiCallback(timeStamp, message);
1125     }
1126
1127     #undef handlePtr
1128
1129     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineRtAudio)
1130 };
1131
1132 // -----------------------------------------
1133
1134 namespace EngineInit {
1135
1136 CarlaEngine* newRtAudio(const AudioApi api)
1137 {
1138     initRtAudioAPIsIfNeeded();
1139
1140     RtAudio::Api rtApi = RtAudio::UNSPECIFIED;
1141
1142     switch (api)
1143     {
1144     case AUDIO_API_NULL:
1145         rtApi = RtAudio::RTAUDIO_DUMMY;
1146         break;
1147     case AUDIO_API_JACK:
1148         rtApi = RtAudio::UNIX_JACK;
1149         break;
1150     case AUDIO_API_OSS:
1151         rtApi = RtAudio::LINUX_OSS;
1152         break;
1153     case AUDIO_API_ALSA:
1154         rtApi = RtAudio::LINUX_ALSA;
1155         break;
1156     case AUDIO_API_PULSEAUDIO:
1157         rtApi = RtAudio::UNIX_PULSE;
1158         break;
1159     case AUDIO_API_COREAUDIO:
1160         rtApi = RtAudio::MACOSX_CORE;
1161         break;
1162     case AUDIO_API_ASIO:
1163         rtApi = RtAudio::WINDOWS_ASIO;
1164         break;
1165     case AUDIO_API_DIRECTSOUND:
1166         rtApi = RtAudio::WINDOWS_DS;
1167         break;
1168     case AUDIO_API_WASAPI:
1169         rtApi = RtAudio::WINDOWS_WASAPI;
1170         break;
1171     }
1172
1173     return new CarlaEngineRtAudio(rtApi);
1174 }
1175
1176 uint getRtAudioApiCount()
1177 {
1178     initRtAudioAPIsIfNeeded();
1179
1180     return static_cast<uint>(gRtAudioApis.size());
1181 }
1182
1183 const char* getRtAudioApiName(const uint index)
1184 {
1185     initRtAudioAPIsIfNeeded();
1186
1187     CARLA_SAFE_ASSERT_RETURN(index < gRtAudioApis.size(), nullptr);
1188
1189     return CARLA_BACKEND_NAMESPACE::getRtAudioApiName(gRtAudioApis[index]);
1190 }
1191
1192 const char* const* getRtAudioApiDeviceNames(const uint index)
1193 {
1194     initRtAudioAPIsIfNeeded();
1195
1196     if (index >= gRtAudioApis.size())
1197         return nullptr;
1198
1199     const RtAudio::Api& api(gRtAudioApis[index]);
1200     CarlaStringList devNames;
1201
1202     try {
1203         RtAudio rtAudio(api);
1204
1205         const uint devCount(rtAudio.getDeviceCount());
1206
1207         if (devCount == 0)
1208             return nullptr;
1209
1210         for (uint i=0; i < devCount; ++i)
1211         {
1212             RtAudio::DeviceInfo devInfo(rtAudio.getDeviceInfo(i));
1213
1214             if (devInfo.probed && devInfo.outputChannels > 0 /*&& (devInfo.nativeFormats & RTAUDIO_FLOAT32) != 0*/)
1215                 devNames.append(devInfo.name.c_str());
1216         }
1217
1218     } CARLA_SAFE_EXCEPTION_RETURN("RtAudio device names", nullptr);
1219
1220     gDeviceNames = devNames.toCharStringListPtr();
1221
1222     return gDeviceNames;
1223 }
1224
1225 const EngineDriverDeviceInfo* getRtAudioDeviceInfo(const uint index, const char* const deviceName)
1226 {
1227     initRtAudioAPIsIfNeeded();
1228
1229     if (index >= gRtAudioApis.size())
1230         return nullptr;
1231
1232     static EngineDriverDeviceInfo devInfo = { 0x0, nullptr, nullptr };
1233     static uint32_t dummyBufferSizes[]    = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 0 };
1234     static double   dummySampleRates[]    = { 22050.0, 32000.0, 44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0, 0.0 };
1235
1236     // reset
1237     devInfo.hints = 0x0;
1238
1239     // cleanup
1240     if (devInfo.bufferSizes != nullptr && devInfo.bufferSizes != dummyBufferSizes)
1241     {
1242         delete[] devInfo.bufferSizes;
1243         devInfo.bufferSizes = nullptr;
1244     }
1245     if (devInfo.sampleRates != nullptr && devInfo.sampleRates != dummySampleRates)
1246     {
1247         delete[] devInfo.sampleRates;
1248         devInfo.sampleRates = nullptr;
1249     }
1250
1251     const RtAudio::Api& api(gRtAudioApis[index]);
1252
1253     if (api == RtAudio::UNIX_JACK)
1254     {
1255         devInfo.bufferSizes = nullptr;
1256         devInfo.sampleRates = nullptr;
1257         return &devInfo;
1258     }
1259
1260     RtAudio::DeviceInfo rtAudioDevInfo;
1261
1262     try {
1263         RtAudio rtAudio(api);
1264
1265         const uint devCount(rtAudio.getDeviceCount());
1266
1267         if (devCount == 0)
1268             return nullptr;
1269
1270         uint i;
1271         for (i=0; i < devCount; ++i)
1272         {
1273             rtAudioDevInfo = rtAudio.getDeviceInfo(i);
1274
1275             if (rtAudioDevInfo.name == deviceName)
1276                 break;
1277         }
1278
1279         if (i == devCount)
1280             rtAudioDevInfo = rtAudio.getDeviceInfo(rtAudio.getDefaultOutputDevice());
1281
1282     } CARLA_SAFE_EXCEPTION_RETURN("RtAudio device discovery", nullptr);
1283
1284     // a few APIs can do triple buffer
1285     switch (api)
1286     {
1287     case RtAudio::LINUX_ALSA:
1288     case RtAudio::LINUX_OSS:
1289     case RtAudio::WINDOWS_DS:
1290         devInfo.hints |= ENGINE_DRIVER_DEVICE_CAN_TRIPLE_BUFFER;
1291         break;
1292     default:
1293         break;
1294     }
1295
1296     // always use default buffer sizes
1297     devInfo.bufferSizes = dummyBufferSizes;
1298
1299     // valid sample rates
1300     if (const size_t sampleRatesCount = rtAudioDevInfo.sampleRates.size())
1301     {
1302         double* const sampleRates(new double[sampleRatesCount+1]);
1303
1304         for (size_t i=0; i < sampleRatesCount; ++i)
1305             sampleRates[i] = rtAudioDevInfo.sampleRates[i];
1306         sampleRates[sampleRatesCount] = 0.0;
1307
1308         devInfo.sampleRates = sampleRates;
1309     }
1310     else
1311     {
1312         devInfo.sampleRates = dummySampleRates;
1313     }
1314
1315     return &devInfo;
1316 }
1317
1318 }
1319
1320 // -----------------------------------------
1321
1322 CARLA_BACKEND_END_NAMESPACE