source/modules/juce_audio_devices/native/juce_linux_Midi.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    The code included in this file is provided under the terms of the ISC license
  11    http://www.isc.org/downloads/software-support-policy/isc-license. Permission
  12    To use, copy, modify, and/or distribute this software for any purpose with or
  13    without fee is hereby granted provided that the above copyright notice and
  14    this permission notice appear in all copies.
  15
  16    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  17    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  18    DISCLAIMED.
  19
  20   ==============================================================================
  21 */
  22
  23 namespace juce
  24 {
  25
  26 #if JUCE_ALSA
  27
  28 //==============================================================================
  29 class AlsaClient  : public ReferenceCountedObject
  30 {
  31 public:
  32     AlsaClient()
  33     {
  34         jassert (instance == nullptr);
  35
  36         snd_seq_open (&handle, "default", SND_SEQ_OPEN_DUPLEX, 0);
  37
  38         if (handle != nullptr)
  39         {
  40             snd_seq_nonblock (handle, SND_SEQ_NONBLOCK);
  41             snd_seq_set_client_name (handle, getAlsaMidiName().toRawUTF8());
  42             clientId = snd_seq_client_id (handle);
  43
  44             // It's good idea to pre-allocate a good number of elements
  45             ports.ensureStorageAllocated (32);
  46         }
  47     }
  48
  49     ~AlsaClient()
  50     {
  51         jassert (instance != nullptr);
  52         instance = nullptr;
  53
  54         jassert (activeCallbacks.get() == 0);
  55
  56         if (inputThread)
  57             inputThread->stopThread (3000);
  58
  59         if (handle != nullptr)
  60             snd_seq_close (handle);
  61     }
  62
  63     static String getAlsaMidiName()
  64     {
  65         #ifdef JUCE_ALSA_MIDI_NAME
  66          return JUCE_ALSA_MIDI_NAME;
  67         #else
  68          if (auto* app = JUCEApplicationBase::getInstance())
  69              return app->getApplicationName();
  70
  71          return "JUCE";
  72         #endif
  73     }
  74
  75     using Ptr = ReferenceCountedObjectPtr<AlsaClient>;
  76
  77     //==============================================================================
  78     // represents an input or output port of the supplied AlsaClient
  79     struct Port
  80     {
  81         Port (AlsaClient& c, bool forInput) noexcept
  82             : client (c), isInput (forInput)
  83         {}
  84
  85         ~Port()
  86         {
  87             if (isValid())
  88             {
  89                 if (isInput)
  90                     enableCallback (false);
  91                 else
  92                     snd_midi_event_free (midiParser);
  93
  94                 snd_seq_delete_simple_port (client.get(), portId);
  95             }
  96         }
  97
  98         void connectWith (int sourceClient, int sourcePort) const noexcept
  99         {
 100             if (isInput)
 101                 snd_seq_connect_from (client.get(), portId, sourceClient, sourcePort);
 102             else
 103                 snd_seq_connect_to (client.get(), portId, sourceClient, sourcePort);
 104         }
 105
 106         bool isValid() const noexcept
 107         {
 108             return client.get() != nullptr && portId >= 0;
 109         }
 110
 111         void setupInput (MidiInput* input, MidiInputCallback* cb)
 112         {
 113             jassert (cb != nullptr && input != nullptr);
 114             callback = cb;
 115             midiInput = input;
 116         }
 117
 118         void setupOutput()
 119         {
 120             jassert (! isInput);
 121             snd_midi_event_new ((size_t) maxEventSize, &midiParser);
 122         }
 123
 124         void enableCallback (bool enable)
 125         {
 126             const auto oldValue = callbackEnabled.exchange (enable);
 127
 128             if (oldValue != enable)
 129             {
 130                 if (enable)
 131                     client.registerCallback();
 132                 else
 133                     client.unregisterCallback();
 134             }
 135         }
 136
 137         bool sendMessageNow (const MidiMessage& message)
 138         {
 139             if (message.getRawDataSize() > maxEventSize)
 140             {
 141                 maxEventSize = message.getRawDataSize();
 142                 snd_midi_event_free (midiParser);
 143                 snd_midi_event_new ((size_t) maxEventSize, &midiParser);
 144             }
 145
 146             snd_seq_event_t event;
 147             snd_seq_ev_clear (&event);
 148
 149             auto numBytes = (long) message.getRawDataSize();
 150             auto* data = message.getRawData();
 151
 152             auto seqHandle = client.get();
 153             bool success = true;
 154
 155             while (numBytes > 0)
 156             {
 157                 auto numSent = snd_midi_event_encode (midiParser, data, numBytes, &event);
 158
 159                 if (numSent <= 0)
 160                 {
 161                     success = numSent == 0;
 162                     break;
 163                 }
 164
 165                 numBytes -= numSent;
 166                 data += numSent;
 167
 168                 snd_seq_ev_set_source (&event, (unsigned char) portId);
 169                 snd_seq_ev_set_subs (&event);
 170                 snd_seq_ev_set_direct (&event);
 171
 172                 if (snd_seq_event_output_direct (seqHandle, &event) < 0)
 173                 {
 174                     success = false;
 175                     break;
 176                 }
 177             }
 178
 179             snd_midi_event_reset_encode (midiParser);
 180             return success;
 181         }
 182
 183
 184         bool operator== (const Port& lhs) const noexcept
 185         {
 186             return portId != -1 && portId == lhs.portId;
 187         }
 188
 189         void createPort (const String& name, bool enableSubscription)
 190         {
 191             if (auto seqHandle = client.get())
 192             {
 193                 const unsigned int caps =
 194                     isInput ? (SND_SEQ_PORT_CAP_WRITE | (enableSubscription ? SND_SEQ_PORT_CAP_SUBS_WRITE : 0))
 195                             : (SND_SEQ_PORT_CAP_READ  | (enableSubscription ? SND_SEQ_PORT_CAP_SUBS_READ : 0));
 196
 197                 portName = name;
 198                 portId = snd_seq_create_simple_port (seqHandle, portName.toUTF8(), caps,
 199                                                      SND_SEQ_PORT_TYPE_MIDI_GENERIC |
 200                                                      SND_SEQ_PORT_TYPE_APPLICATION);
 201             }
 202         }
 203
 204         void handleIncomingMidiMessage (const MidiMessage& message) const
 205         {
 206             if (callbackEnabled)
 207                 callback->handleIncomingMidiMessage (midiInput, message);
 208         }
 209
 210         void handlePartialSysexMessage (const uint8* messageData, int numBytesSoFar, double timeStamp)
 211         {
 212             if (callbackEnabled)
 213                 callback->handlePartialSysexMessage (midiInput, messageData, numBytesSoFar, timeStamp);
 214         }
 215
 216         int getPortId() const               { return portId; }
 217         const String& getPortName() const   { return portName; }
 218
 219     private:
 220         AlsaClient& client;
 221
 222         MidiInputCallback* callback = nullptr;
 223         snd_midi_event_t* midiParser = nullptr;
 224         MidiInput* midiInput = nullptr;
 225
 226         String portName;
 227
 228         int maxEventSize = 4096, portId = -1;
 229         std::atomic<bool> callbackEnabled { false };
 230         bool isInput = false;
 231     };
 232
 233     static Ptr getInstance()
 234     {
 235         if (instance == nullptr)
 236             instance = new AlsaClient();
 237
 238         return instance;
 239     }
 240
 241     void registerCallback()
 242     {
 243         if (inputThread == nullptr)
 244             inputThread.reset (new MidiInputThread (*this));
 245
 246         if (++activeCallbacks == 1)
 247             inputThread->startThread();
 248     }
 249
 250     void unregisterCallback()
 251     {
 252         jassert (activeCallbacks.get() > 0);
 253
 254         if (--activeCallbacks == 0 && inputThread->isThreadRunning())
 255             inputThread->signalThreadShouldExit();
 256     }
 257
 258     void handleIncomingMidiMessage (snd_seq_event* event, const MidiMessage& message)
 259     {
 260         const ScopedLock sl (callbackLock);
 261
 262         if (auto* port = ports[event->dest.port])
 263             port->handleIncomingMidiMessage (message);
 264     }
 265
 266     void handlePartialSysexMessage (snd_seq_event* event, const uint8* messageData, int numBytesSoFar, double timeStamp)
 267     {
 268         const ScopedLock sl (callbackLock);
 269
 270         if (auto* port = ports[event->dest.port])
 271             port->handlePartialSysexMessage (messageData, numBytesSoFar, timeStamp);
 272     }
 273
 274     snd_seq_t* get() const noexcept     { return handle; }
 275     int getId() const noexcept          { return clientId; }
 276
 277     Port* createPort (const String& name, bool forInput, bool enableSubscription)
 278     {
 279         const ScopedLock sl (callbackLock);
 280
 281         auto port = new Port (*this, forInput);
 282         port->createPort (name, enableSubscription);
 283         ports.set (port->getPortId(), port);
 284         incReferenceCount();
 285         return port;
 286     }
 287
 288     void deletePort (Port* port)
 289     {
 290         const ScopedLock sl (callbackLock);
 291
 292         ports.set (port->getPortId(), nullptr);
 293         decReferenceCount();
 294     }
 295
 296 private:
 297     snd_seq_t* handle = nullptr;
 298     int clientId = 0;
 299     OwnedArray<Port> ports;
 300     Atomic<int> activeCallbacks;
 301     CriticalSection callbackLock;
 302
 303     static AlsaClient* instance;
 304
 305     //==============================================================================
 306     class MidiInputThread   : public Thread
 307     {
 308     public:
 309         MidiInputThread (AlsaClient& c)
 310             : Thread ("JUCE MIDI Input"), client (c)
 311         {
 312             jassert (client.get() != nullptr);
 313         }
 314
 315         void run() override
 316         {
 317             auto seqHandle = client.get();
 318
 319             const int maxEventSize = 16 * 1024;
 320             snd_midi_event_t* midiParser;
 321
 322             if (snd_midi_event_new (maxEventSize, &midiParser) >= 0)
 323             {
 324                 auto numPfds = snd_seq_poll_descriptors_count (seqHandle, POLLIN);
 325                 HeapBlock<pollfd> pfd (numPfds);
 326                 snd_seq_poll_descriptors (seqHandle, pfd, (unsigned int) numPfds, POLLIN);
 327
 328                 HeapBlock<uint8> buffer (maxEventSize);
 329
 330                 while (! threadShouldExit())
 331                 {
 332                     if (poll (pfd, (nfds_t) numPfds, 100) > 0) // there was a "500" here which is a bit long when we exit the program and have to wait for a timeout on this poll call
 333                     {
 334                         if (threadShouldExit())
 335                             break;
 336
 337                         do
 338                         {
 339                             snd_seq_event_t* inputEvent = nullptr;
 340
 341                             if (snd_seq_event_input (seqHandle, &inputEvent) >= 0)
 342                             {
 343                                 // xxx what about SYSEXes that are too big for the buffer?
 344                                 auto numBytes = snd_midi_event_decode (midiParser, buffer,
 345                                                                        maxEventSize, inputEvent);
 346
 347                                 snd_midi_event_reset_decode (midiParser);
 348
 349                                 concatenator.pushMidiData (buffer, (int) numBytes,
 350                                                            Time::getMillisecondCounter() * 0.001,
 351                                                            inputEvent, client);
 352
 353                                 snd_seq_free_event (inputEvent);
 354                             }
 355                         }
 356                         while (snd_seq_event_input_pending (seqHandle, 0) > 0);
 357                     }
 358                 }
 359
 360                 snd_midi_event_free (midiParser);
 361             }
 362         }
 363
 364     private:
 365         AlsaClient& client;
 366         MidiDataConcatenator concatenator { 2048 };
 367     };
 368
 369     std::unique_ptr<MidiInputThread> inputThread;
 370 };
 371
 372 AlsaClient* AlsaClient::instance = nullptr;
 373
 374 //==============================================================================
 375 static String getFormattedPortIdentifier (int clientId, int portId)
 376 {
 377     return String (clientId) + "-" + String (portId);
 378 }
 379
 380 static AlsaClient::Port* iterateMidiClient (const AlsaClient::Ptr& client,
 381                                             snd_seq_client_info_t* clientInfo,
 382                                             bool forInput,
 383                                             Array<MidiDeviceInfo>& devices,
 384                                             const String& deviceIdentifierToOpen)
 385 {
 386     AlsaClient::Port* port = nullptr;
 387
 388     auto seqHandle = client->get();
 389     snd_seq_port_info_t* portInfo = nullptr;
 390
 391     snd_seq_port_info_alloca (&portInfo);
 392     jassert (portInfo != nullptr);
 393     auto numPorts = snd_seq_client_info_get_num_ports (clientInfo);
 394     auto sourceClient = snd_seq_client_info_get_client (clientInfo);
 395
 396     snd_seq_port_info_set_client (portInfo, sourceClient);
 397     snd_seq_port_info_set_port (portInfo, -1);
 398
 399     while (--numPorts >= 0)
 400     {
 401         if (snd_seq_query_next_port (seqHandle, portInfo) == 0
 402             && (snd_seq_port_info_get_capability (portInfo)
 403                 & (forInput ? SND_SEQ_PORT_CAP_SUBS_READ : SND_SEQ_PORT_CAP_SUBS_WRITE)) != 0)
 404         {
 405             String portName (snd_seq_port_info_get_name (portInfo));
 406             auto portID = snd_seq_port_info_get_port (portInfo);
 407
 408             MidiDeviceInfo device (portName, getFormattedPortIdentifier (sourceClient, portID));
 409             devices.add (device);
 410
 411             if (deviceIdentifierToOpen.isNotEmpty() && deviceIdentifierToOpen == device.identifier)
 412             {
 413                 if (portID != -1)
 414                 {
 415                     port = client->createPort (portName, forInput, false);
 416                     jassert (port->isValid());
 417                     port->connectWith (sourceClient, portID);
 418                     break;
 419                 }
 420             }
 421         }
 422     }
 423
 424     return port;
 425 }
 426
 427 static AlsaClient::Port* iterateMidiDevices (bool forInput,
 428                                              Array<MidiDeviceInfo>& devices,
 429                                              const String& deviceIdentifierToOpen)
 430 {
 431     AlsaClient::Port* port = nullptr;
 432     auto client = AlsaClient::getInstance();
 433
 434     if (auto seqHandle = client->get())
 435     {
 436         snd_seq_system_info_t* systemInfo = nullptr;
 437         snd_seq_client_info_t* clientInfo = nullptr;
 438
 439         snd_seq_system_info_alloca (&systemInfo);
 440         jassert (systemInfo != nullptr);
 441
 442         if (snd_seq_system_info (seqHandle, systemInfo) == 0)
 443         {
 444             snd_seq_client_info_alloca (&clientInfo);
 445             jassert (clientInfo != nullptr);
 446
 447             auto numClients = snd_seq_system_info_get_cur_clients (systemInfo);
 448
 449             while (--numClients >= 0)
 450             {
 451                 if (snd_seq_query_next_client (seqHandle, clientInfo) == 0)
 452                 {
 453                     port = iterateMidiClient (client, clientInfo, forInput,
 454                                               devices, deviceIdentifierToOpen);
 455
 456                     if (port != nullptr)
 457                         break;
 458                 }
 459             }
 460         }
 461     }
 462
 463     return port;
 464 }
 465
 466 struct AlsaPortPtr
 467 {
 468     explicit AlsaPortPtr (AlsaClient::Port* p)
 469         : ptr (p) {}
 470
 471     ~AlsaPortPtr() noexcept { AlsaClient::getInstance()->deletePort (ptr); }
 472
 473     AlsaClient::Port* ptr = nullptr;
 474 };
 475
 476 //==============================================================================
 477 class MidiInput::Pimpl : public AlsaPortPtr
 478 {
 479 public:
 480     using AlsaPortPtr::AlsaPortPtr;
 481 };
 482
 483 Array<MidiDeviceInfo> MidiInput::getAvailableDevices()
 484 {
 485     Array<MidiDeviceInfo> devices;
 486     iterateMidiDevices (true, devices, {});
 487
 488     return devices;
 489 }
 490
 491 MidiDeviceInfo MidiInput::getDefaultDevice()
 492 {
 493     return getAvailableDevices().getFirst();
 494 }
 495
 496 std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
 497 {
 498     if (deviceIdentifier.isEmpty())
 499         return {};
 500
 501     Array<MidiDeviceInfo> devices;
 502     auto* port = iterateMidiDevices (true, devices, deviceIdentifier);
 503
 504     if (port == nullptr || ! port->isValid())
 505         return {};
 506
 507     jassert (port->isValid());
 508
 509     std::unique_ptr<MidiInput> midiInput (new MidiInput (port->getPortName(), deviceIdentifier));
 510
 511     port->setupInput (midiInput.get(), callback);
 512     midiInput->internal = std::make_unique<Pimpl> (port);
 513
 514     return midiInput;
 515 }
 516
 517 std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String& deviceName, MidiInputCallback* callback)
 518 {
 519     auto client = AlsaClient::getInstance();
 520     auto* port = client->createPort (deviceName, true, true);
 521
 522     if (port == nullptr || ! port->isValid())
 523         return {};
 524
 525     std::unique_ptr<MidiInput> midiInput (new MidiInput (deviceName, getFormattedPortIdentifier (client->getId(), port->getPortId())));
 526
 527     port->setupInput (midiInput.get(), callback);
 528     midiInput->internal = std::make_unique<Pimpl> (port);
 529
 530     return midiInput;
 531 }
 532
 533 StringArray MidiInput::getDevices()
 534 {
 535     StringArray deviceNames;
 536
 537     for (auto& d : getAvailableDevices())
 538         deviceNames.add (d.name);
 539
 540     deviceNames.appendNumbersToDuplicates (true, true);
 541
 542     return deviceNames;
 543 }
 544
 545 int MidiInput::getDefaultDeviceIndex()
 546 {
 547     return 0;
 548 }
 549
 550 std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
 551 {
 552     return openDevice (getAvailableDevices()[index].identifier, callback);
 553 }
 554
 555 MidiInput::MidiInput (const String& deviceName, const String& deviceIdentifier)
 556     : deviceInfo (deviceName, deviceIdentifier)
 557 {
 558 }
 559
 560 MidiInput::~MidiInput()
 561 {
 562     stop();
 563 }
 564
 565 void MidiInput::start()
 566 {
 567     internal->ptr->enableCallback (true);
 568 }
 569
 570 void MidiInput::stop()
 571 {
 572     internal->ptr->enableCallback (false);
 573 }
 574
 575 //==============================================================================
 576 class MidiOutput::Pimpl : public AlsaPortPtr
 577 {
 578 public:
 579     using AlsaPortPtr::AlsaPortPtr;
 580 };
 581
 582 Array<MidiDeviceInfo> MidiOutput::getAvailableDevices()
 583 {
 584     Array<MidiDeviceInfo> devices;
 585     iterateMidiDevices (false, devices, {});
 586
 587     return devices;
 588 }
 589
 590 MidiDeviceInfo MidiOutput::getDefaultDevice()
 591 {
 592     return getAvailableDevices().getFirst();
 593 }
 594
 595 std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String& deviceIdentifier)
 596 {
 597     if (deviceIdentifier.isEmpty())
 598         return {};
 599
 600     Array<MidiDeviceInfo> devices;
 601     auto* port = iterateMidiDevices (false, devices, deviceIdentifier);
 602
 603     if (port == nullptr || ! port->isValid())
 604         return {};
 605
 606     std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (port->getPortName(), deviceIdentifier));
 607
 608     port->setupOutput();
 609     midiOutput->internal = std::make_unique<Pimpl> (port);
 610
 611     return midiOutput;
 612 }
 613
 614 std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String& deviceName)
 615 {
 616     auto client = AlsaClient::getInstance();
 617     auto* port = client->createPort (deviceName, false, true);
 618
 619     if (port == nullptr || ! port->isValid())
 620         return {};
 621
 622     std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (deviceName, getFormattedPortIdentifier (client->getId(), port->getPortId())));
 623
 624     port->setupOutput();
 625     midiOutput->internal = std::make_unique<Pimpl> (port);
 626
 627     return midiOutput;
 628 }
 629
 630 StringArray MidiOutput::getDevices()
 631 {
 632     StringArray deviceNames;
 633
 634     for (auto& d : getAvailableDevices())
 635         deviceNames.add (d.name);
 636
 637     deviceNames.appendNumbersToDuplicates (true, true);
 638
 639     return deviceNames;
 640 }
 641
 642 int MidiOutput::getDefaultDeviceIndex()
 643 {
 644     return 0;
 645 }
 646
 647 std::unique_ptr<MidiOutput> MidiOutput::openDevice (int index)
 648 {
 649     return openDevice (getAvailableDevices()[index].identifier);
 650 }
 651
 652 MidiOutput::~MidiOutput()
 653 {
 654     stopBackgroundThread();
 655 }
 656
 657 void MidiOutput::sendMessageNow (const MidiMessage& message)
 658 {
 659     internal->ptr->sendMessageNow (message);
 660 }
 661
 662 //==============================================================================
 663 #else
 664
 665 class MidiInput::Pimpl {};
 666
 667 // (These are just stub functions if ALSA is unavailable...)
 668 MidiInput::MidiInput (const String& deviceName, const String& deviceID)
 669     : deviceInfo (deviceName, deviceID)
 670 {
 671 }
 672
 673 MidiInput::~MidiInput()                                                                   {}
 674 void MidiInput::start()                                                                   {}
 675 void MidiInput::stop()                                                                    {}
 676 Array<MidiDeviceInfo> MidiInput::getAvailableDevices()                                    { return {}; }
 677 MidiDeviceInfo MidiInput::getDefaultDevice()                                              { return {}; }
 678 std::unique_ptr<MidiInput> MidiInput::openDevice (const String&, MidiInputCallback*)      { return {}; }
 679 std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String&, MidiInputCallback*) { return {}; }
 680 StringArray MidiInput::getDevices()                                                       { return {}; }
 681 int MidiInput::getDefaultDeviceIndex()                                                    { return 0;}
 682 std::unique_ptr<MidiInput> MidiInput::openDevice (int, MidiInputCallback*)                { return {}; }
 683
 684 class MidiOutput::Pimpl {};
 685
 686 MidiOutput::~MidiOutput()                                                                 {}
 687 void MidiOutput::sendMessageNow (const MidiMessage&)                                      {}
 688 Array<MidiDeviceInfo> MidiOutput::getAvailableDevices()                                   { return {}; }
 689 MidiDeviceInfo MidiOutput::getDefaultDevice()                                             { return {}; }
 690 std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String&)                        { return {}; }
 691 std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String&)                   { return {}; }
 692 StringArray MidiOutput::getDevices()                                                      { return {}; }
 693 int MidiOutput::getDefaultDeviceIndex()                                                   { return 0;}
 694 std::unique_ptr<MidiOutput> MidiOutput::openDevice (int)                                  { return {}; }
 695
 696 #endif
 697
 698 } // namespace juce