juce_MidiDevices.h

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   The code included in this file is provided under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
   To use, copy, modify, and/or distribute this software for any purpose with or
   without fee is hereby granted provided that the above copyright notice and
   this permission notice appear in all copies.
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
class MidiDeviceListConnectionBroadcaster;
 
class MidiDeviceListConnection
{
public:
    using Key = uint64_t;
 
    MidiDeviceListConnection() = default;
 
    MidiDeviceListConnection (const MidiDeviceListConnection&) = delete;
    MidiDeviceListConnection (MidiDeviceListConnection&& other) noexcept
        : broadcaster (std::exchange (other.broadcaster, nullptr)),
          key (std::exchange (other.key, Key{}))
    {
    }
 
    MidiDeviceListConnection& operator= (const MidiDeviceListConnection&) = delete;
    MidiDeviceListConnection& operator= (MidiDeviceListConnection&& other) noexcept
    {
        MidiDeviceListConnection (std::move (other)).swap (*this);
        return *this;
    }
 
    ~MidiDeviceListConnection() noexcept;
 
    void reset() noexcept
    {
        MidiDeviceListConnection().swap (*this);
    }
 
    static MidiDeviceListConnection make (std::function<void()>);
 
private:
    MidiDeviceListConnection (MidiDeviceListConnectionBroadcaster* b, const Key k)
        : broadcaster (b), key (k) {}
 
    void swap (MidiDeviceListConnection& other) noexcept
    {
        std::swap (other.broadcaster, broadcaster);
        std::swap (other.key, key);
    }
 
    MidiDeviceListConnectionBroadcaster* broadcaster = nullptr;
    Key key = {};
};
 
//==============================================================================
struct MidiDeviceInfo
{
    MidiDeviceInfo() = default;
 
    MidiDeviceInfo (const String& deviceName, const String& deviceIdentifier)
        : name (deviceName), identifier (deviceIdentifier)
    {
    }
 
    String name;
 
    String identifier;
 
    //==============================================================================
    auto tie() const { return std::tie (name, identifier); }
    bool operator== (const MidiDeviceInfo& other) const noexcept   { return tie() == other.tie(); }
    bool operator!= (const MidiDeviceInfo& other) const noexcept   { return tie() != other.tie(); }
};
 
class MidiInputCallback;
 
//==============================================================================
class JUCE_API  MidiInput  final
{
public:
    //==============================================================================
    static Array<MidiDeviceInfo> getAvailableDevices();
 
    static MidiDeviceInfo getDefaultDevice();
 
    static std::unique_ptr<MidiInput> openDevice (const String& deviceIdentifier, MidiInputCallback* callback);
 
   #if JUCE_LINUX || JUCE_BSD || JUCE_MAC || JUCE_IOS || DOXYGEN
    static std::unique_ptr<MidiInput> createNewDevice (const String& deviceName, MidiInputCallback* callback);
   #endif
 
    //==============================================================================
    ~MidiInput();
 
    void start();
 
    void stop();
 
    MidiDeviceInfo getDeviceInfo() const noexcept    { return deviceInfo; }
 
    String getIdentifier() const noexcept            { return deviceInfo.identifier; }
 
    String getName() const noexcept                  { return deviceInfo.name; }
 
    void setName (const String& newName) noexcept    { deviceInfo.name = newName; }
 
    //==============================================================================
   #ifndef DOXYGEN
    [[deprecated ("Use getAvailableDevices instead.")]]
    static StringArray getDevices();
    [[deprecated ("Use getDefaultDevice instead.")]]
    static int getDefaultDeviceIndex();
    [[deprecated ("Use openDevice that takes a device identifier instead.")]]
    static std::unique_ptr<MidiInput> openDevice (int, MidiInputCallback*);
   #endif
 
    class Pimpl;
 
private:
    //==============================================================================
    explicit MidiInput (const String&, const String&);
 
    MidiDeviceInfo deviceInfo;
 
    std::unique_ptr<Pimpl> internal;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MidiInput)
};
 
//==============================================================================
class JUCE_API  MidiInputCallback
{
public:
    virtual ~MidiInputCallback()  = default;
 
    virtual void handleIncomingMidiMessage (MidiInput* source,
                                            const MidiMessage& message) = 0;
 
    virtual void handlePartialSysexMessage (MidiInput* source,
                                            const uint8* messageData,
                                            int numBytesSoFar,
                                            double timestamp);
};
 
//==============================================================================
class JUCE_API  MidiOutput  final  : private Thread
{
public:
    //==============================================================================
    static Array<MidiDeviceInfo> getAvailableDevices();
 
    static MidiDeviceInfo getDefaultDevice();
 
    static std::unique_ptr<MidiOutput> openDevice (const String& deviceIdentifier);
 
   #if JUCE_LINUX || JUCE_BSD || JUCE_MAC || JUCE_IOS || DOXYGEN
    static std::unique_ptr<MidiOutput> createNewDevice (const String& deviceName);
   #endif
 
    //==============================================================================
    ~MidiOutput() override;
 
    MidiDeviceInfo getDeviceInfo() const noexcept    { return deviceInfo; }
 
    String getIdentifier() const noexcept            { return deviceInfo.identifier; }
 
    String getName() const noexcept                  { return deviceInfo.name; }
 
    void setName (const String& newName) noexcept    { deviceInfo.name = newName; }
 
    //==============================================================================
    void sendMessageNow (const MidiMessage& message);
 
    void sendBlockOfMessagesNow (const MidiBuffer& buffer);
 
    void sendBlockOfMessages (const MidiBuffer& buffer,
                              double millisecondCounterToStartAt,
                              double samplesPerSecondForBuffer);
 
    void clearAllPendingMessages();
 
    void startBackgroundThread();
 
    void stopBackgroundThread();
 
    bool isBackgroundThreadRunning() const noexcept  { return isThreadRunning(); }
 
    //==============================================================================
   #ifndef DOXYGEN
    [[deprecated ("Use getAvailableDevices instead.")]]
    static StringArray getDevices();
    [[deprecated ("Use getDefaultDevice instead.")]]
    static int getDefaultDeviceIndex();
    [[deprecated ("Use openDevice that takes a device identifier instead.")]]
    static std::unique_ptr<MidiOutput> openDevice (int);
   #endif
 
    class Pimpl;
 
private:
    //==============================================================================
    struct PendingMessage
    {
        PendingMessage (const void* data, int len, double timeStamp)
            : message (data, len, timeStamp)
        {
        }
 
        MidiMessage message;
        PendingMessage* next;
    };
 
    //==============================================================================
    explicit MidiOutput (const String&, const String&);
    void run() override;
 
    MidiDeviceInfo deviceInfo;
 
    std::unique_ptr<Pimpl> internal;
 
    CriticalSection lock;
    PendingMessage* firstMessage = nullptr;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MidiOutput)
};
 
} // namespace juce