expo-juce 0.3.0 → 0.3.2

package/ios/juce_modules/juce_audio_devices/audio_io/juce_AudioDeviceManager.h

@@ -0,0 +1,586 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE framework.
+   Copyright (c) Raw Material Software Limited
+
+   JUCE is an open source framework subject to commercial or open source
+   licensing.
+
+   By downloading, installing, or using the JUCE framework, or combining the
+   JUCE framework with any other source code, object code, content or any other
+   copyrightable work, you agree to the terms of the JUCE End User Licence
+   Agreement, and all incorporated terms including the JUCE Privacy Policy and
+   the JUCE Website Terms of Service, as applicable, which will bind you. If you
+   do not agree to the terms of these agreements, we will not license the JUCE
+   framework to you, and you must discontinue the installation or download
+   process and cease use of the JUCE framework.
+
+   JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
+   JUCE Privacy Policy: https://juce.com/juce-privacy-policy
+   JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
+
+   Or:
+
+   You may also use this code under the terms of the AGPLv3:
+   https://www.gnu.org/licenses/agpl-3.0.en.html
+
+   THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
+   WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    Manages the state of some audio and midi i/o devices.
+
+    This class keeps tracks of a currently-selected audio device, through
+    with which it continuously streams data from an audio callback, as well as
+    one or more midi inputs.
+
+    The idea is that your application will create one global instance of this object,
+    and let it take care of creating and deleting specific types of audio devices
+    internally. So when the device is changed, your callbacks will just keep running
+    without having to worry about this.
+
+    The manager can save and reload all of its device settings as XML, which
+    makes it very easy for you to save and reload the audio setup of your
+    application.
+
+    And to make it easy to let the user change its settings, there's a component
+    to do just that - the AudioDeviceSelectorComponent class, which contains a set of
+    device selection/sample-rate/latency controls.
+
+    To use an AudioDeviceManager, create one, and use initialise() to set it up. Then
+    call addAudioCallback() to register your audio callback with it, and use that to process
+    your audio data.
+
+    The manager also acts as a handy hub for incoming midi messages, allowing a
+    listener to register for messages from either a specific midi device, or from whatever
+    the current default midi input device is. The listener then doesn't have to worry about
+    re-registering with different midi devices if they are changed or deleted.
+
+    And yet another neat trick is that amount of CPU time being used is measured and
+    available with the getCpuUsage() method.
+
+    The AudioDeviceManager is a ChangeBroadcaster, and will send a change message to
+    listeners whenever one of its settings is changed.
+
+    @see AudioDeviceSelectorComponent, AudioIODevice, AudioIODeviceType
+
+    @tags{Audio}
+*/
+class JUCE_API  AudioDeviceManager  : public ChangeBroadcaster
+{
+public:
+    //==============================================================================
+    /** Creates a default AudioDeviceManager.
+
+        Initially no audio device will be selected. You should call the initialise() method
+        and register an audio callback with setAudioCallback() before it'll be able to
+        actually make any noise.
+    */
+    AudioDeviceManager();
+
+    /** Destructor. */
+    ~AudioDeviceManager() override;
+
+    //==============================================================================
+    /**
+        This structure holds a set of properties describing the current audio setup.
+
+        An AudioDeviceManager uses this class to save/load its current settings, and to
+        specify your preferred options when opening a device.
+
+        @see AudioDeviceManager::setAudioDeviceSetup(), AudioDeviceManager::initialise()
+    */
+    struct JUCE_API  AudioDeviceSetup
+    {
+        /** The name of the audio device used for output.
+            The name has to be one of the ones listed by the AudioDeviceManager's currently
+            selected device type.
+            This may be the same as the input device.
+        */
+        String outputDeviceName;
+
+        /** The name of the audio device used for input.
+            This may be the same as the output device.
+        */
+        String inputDeviceName;
+
+        /** The current sample rate.
+            This rate is used for both the input and output devices.
+            A value of 0 indicates that you don't care what rate is used, and the
+            device will choose a sensible rate for you.
+        */
+        double sampleRate = 0;
+
+        /** The buffer size, in samples.
+            This buffer size is used for both the input and output devices.
+            A value of 0 indicates the default buffer size.
+        */
+        int bufferSize = 0;
+
+        /** The set of active input channels.
+            The bits that are set in this array indicate the channels of the
+            input device that are active.
+            If useDefaultInputChannels is true, this value is ignored.
+        */
+        BigInteger inputChannels;
+
+        /** If this is true, it indicates that the inputChannels array
+            should be ignored, and instead, the device's default channels
+            should be used.
+        */
+        bool useDefaultInputChannels = true;
+
+        /** The set of active output channels.
+            The bits that are set in this array indicate the channels of the
+            input device that are active.
+            If useDefaultOutputChannels is true, this value is ignored.
+        */
+        BigInteger outputChannels;
+
+        /** If this is true, it indicates that the outputChannels array
+            should be ignored, and instead, the device's default channels
+            should be used.
+        */
+        bool useDefaultOutputChannels = true;
+
+        bool operator== (const AudioDeviceSetup&) const;
+        bool operator!= (const AudioDeviceSetup&) const;
+    };
+
+
+    //==============================================================================
+    /** Opens a set of audio devices ready for use.
+
+        This will attempt to open either a default audio device, or one that was
+        previously saved as XML.
+
+        @param numInputChannelsNeeded       the maximum number of input channels your app would like to
+                                            use (the actual number of channels opened may be less than
+                                            the number requested)
+        @param numOutputChannelsNeeded      the maximum number of output channels your app would like to
+                                            use (the actual number of channels opened may be less than
+                                            the number requested)
+        @param savedState                   either a previously-saved state that was produced
+                                            by createStateXml(), or nullptr if you want the manager
+                                            to choose the best device to open.
+        @param selectDefaultDeviceOnFailure if true, then if the device specified in the XML
+                                            fails to open, then a default device will be used
+                                            instead. If false, then on failure, no device is
+                                            opened.
+        @param preferredDefaultDeviceName   if this is not empty, and there's a device with this
+                                            name, then that will be used as the default device
+                                            (assuming that there wasn't one specified in the XML).
+                                            The string can actually be a simple wildcard, containing "*"
+                                            and "?" characters
+        @param preferredSetupOptions        if this is non-null, the structure will be used as the
+                                            set of preferred settings when opening the device. If you
+                                            use this parameter, the preferredDefaultDeviceName
+                                            field will be ignored. If you set the outputDeviceName
+                                            or inputDeviceName data members of the AudioDeviceSetup
+                                            to empty strings, then a default device will be used.
+
+
+        @returns an error message if anything went wrong, or an empty string if it worked ok.
+    */
+    String initialise (int numInputChannelsNeeded,
+                       int numOutputChannelsNeeded,
+                       const XmlElement* savedState,
+                       bool selectDefaultDeviceOnFailure,
+                       const String& preferredDefaultDeviceName = String(),
+                       const AudioDeviceSetup* preferredSetupOptions = nullptr);
+
+    /** Resets everything to a default device setup, clearing any stored settings. */
+    String initialiseWithDefaultDevices (int numInputChannelsNeeded,
+                                         int numOutputChannelsNeeded);
+
+    /** Returns some XML representing the current state of the manager.
+
+        This stores the current device, its samplerate, block size, etc, and
+        can be restored later with initialise().
+
+        Note that this can return a null pointer if no settings have been explicitly changed
+        (i.e. if the device manager has just been left in its default state).
+    */
+    std::unique_ptr<XmlElement> createStateXml() const;
+
+    //==============================================================================
+    /** Returns the current device properties that are in use.
+        @see setAudioDeviceSetup
+    */
+    AudioDeviceSetup getAudioDeviceSetup() const;
+
+    /** Returns the current device properties that are in use.
+        This is an old method, kept around for compatibility, but you should prefer the new
+        version which returns the result rather than taking an out-parameter.
+        @see getAudioDeviceSetup()
+    */
+    void getAudioDeviceSetup (AudioDeviceSetup& result) const;
+
+    /** Changes the current device or its settings.
+
+        If you want to change a device property, like the current sample rate or
+        block size, you can call getAudioDeviceSetup() to retrieve the current
+        settings, then tweak the appropriate fields in the AudioDeviceSetup structure,
+        and pass it back into this method to apply the new settings.
+
+        @param newSetup             the settings that you'd like to use.
+                                    If you don't need an input or output device, set the
+                                    inputDeviceName or outputDeviceName data members respectively
+                                    to empty strings. Note that this behaviour differs from
+                                    the behaviour of initialise().
+        @param treatAsChosenDevice  if this is true and if the device opens correctly, these new
+                                    settings will be taken as having been explicitly chosen by the
+                                    user, and the next time createStateXml() is called, these settings
+                                    will be returned. If it's false, then the device is treated as a
+                                    temporary or default device, and a call to createStateXml() will
+                                    return either the last settings that were made with treatAsChosenDevice
+                                    as true, or the last XML settings that were passed into initialise().
+        @returns an error message if anything went wrong, or an empty string if it worked ok.
+
+        @see getAudioDeviceSetup
+    */
+    String setAudioDeviceSetup (const AudioDeviceSetup& newSetup, bool treatAsChosenDevice);
+
+
+    /** Returns the currently-active audio device. */
+    AudioIODevice* getCurrentAudioDevice() const noexcept               { return currentAudioDevice.get(); }
+
+    /** Returns the type of audio device currently in use.
+        @see setCurrentAudioDeviceType
+    */
+    String getCurrentAudioDeviceType() const                            { return currentDeviceType; }
+
+    /** Returns the currently active audio device type object.
+        Don't keep a copy of this pointer - it's owned by the device manager and could
+        change at any time.
+    */
+    AudioIODeviceType* getCurrentDeviceTypeObject() const;
+
+    /** Changes the class of audio device being used.
+
+        This switches between, e.g. ASIO and DirectSound. On the Mac you probably won't ever call
+        this because there's only one type: CoreAudio.
+
+        For a list of types, see getAvailableDeviceTypes().
+    */
+    void setCurrentAudioDeviceType (const String& type, bool treatAsChosenDevice);
+
+    /** Returns the current audio device workgroup, if supported. */
+    AudioWorkgroup getDeviceAudioWorkgroup() const;
+
+    /** Closes the currently-open device.
+        You can call restartLastAudioDevice() later to reopen it in the same state
+        that it was just in.
+    */
+    void closeAudioDevice();
+
+    /** Tries to reload the last audio device that was running.
+
+        Note that this only reloads the last device that was running before
+        closeAudioDevice() was called - it doesn't reload any kind of saved-state,
+        and can only be called after a device has been opened with setAudioDeviceSetup().
+
+        If a device is already open, this call will do nothing.
+    */
+    void restartLastAudioDevice();
+
+    //==============================================================================
+    /** Registers an audio callback to be used.
+
+        The manager will redirect callbacks from whatever audio device is currently
+        in use to all registered callback objects. If more than one callback is
+        active, they will all be given the same input data, and their outputs will
+        be summed.
+
+        If necessary, this method will invoke audioDeviceAboutToStart() on the callback
+        object before returning.
+
+        To remove a callback, use removeAudioCallback().
+    */
+    void addAudioCallback (AudioIODeviceCallback* newCallback);
+
+    /** Deregisters a previously added callback.
+
+        If necessary, this method will invoke audioDeviceStopped() on the callback
+        object before returning.
+
+        @see addAudioCallback
+    */
+    void removeAudioCallback (AudioIODeviceCallback* callback);
+
+    //==============================================================================
+    /** Returns the average proportion of available CPU being spent inside the audio callbacks.
+        @returns  A value between 0 and 1.0 to indicate the approximate proportion of CPU
+                  time spent in the callbacks.
+    */
+    double getCpuUsage() const;
+
+    //==============================================================================
+    /** Enables or disables a midi input device.
+
+        The list of devices can be obtained with the MidiInput::getAvailableDevices() method.
+
+        Any incoming messages from enabled input devices will be forwarded on to all the
+        listeners that have been registered with the addMidiInputDeviceCallback() method. They
+        can either register for messages from a particular device, or from just the "default"
+        midi input.
+
+        Routing the midi input via an AudioDeviceManager means that when a listener
+        registers for the default midi input, this default device can be changed by the
+        manager without the listeners having to know about it or re-register.
+
+        It also means that a listener can stay registered for a midi input that is disabled
+        or not present, so that when the input is re-enabled, the listener will start
+        receiving messages again.
+
+        @see addMidiInputDeviceCallback, isMidiInputDeviceEnabled
+    */
+    void setMidiInputDeviceEnabled (const String& deviceIdentifier, bool enabled);
+
+    /** Returns true if a given midi input device is being used.
+
+        @see setMidiInputDeviceEnabled
+    */
+    bool isMidiInputDeviceEnabled (const String& deviceIdentifier) const;
+
+    /** Registers a listener for callbacks when midi events arrive from a midi input.
+
+        The device identifier can be empty to indicate that it wants to receive all incoming
+        events from all the enabled MIDI inputs. Or it can be the identifier of one of the
+        MIDI input devices if it just wants the events from that device. (see
+        MidiInput::getAvailableDevices() for the list of devices).
+
+        Only devices which are enabled (see the setMidiInputDeviceEnabled() method) will have their
+        events forwarded on to listeners.
+    */
+    void addMidiInputDeviceCallback (const String& deviceIdentifier,
+                                     MidiInputCallback* callback);
+
+    /** Removes a listener that was previously registered with addMidiInputDeviceCallback(). */
+    void removeMidiInputDeviceCallback (const String& deviceIdentifier,
+                                        MidiInputCallback* callback);
+
+    //==============================================================================
+    /** Sets a midi output device to use as the default.
+
+        The list of devices can be obtained with the MidiOutput::getAvailableDevices() method.
+
+        The specified device will be opened automatically and can be retrieved with the
+        getDefaultMidiOutput() method.
+
+        Pass in an empty string to deselect all devices. For the default device, you
+        can use MidiOutput::getDefaultDevice().
+
+        @see getDefaultMidiOutput, getDefaultMidiOutputIdentifier
+    */
+    void setDefaultMidiOutputDevice (const String& deviceIdentifier);
+
+    /** Returns the name of the default midi output.
+
+        @see setDefaultMidiOutputDevice, getDefaultMidiOutput
+    */
+    const String& getDefaultMidiOutputIdentifier() const noexcept   { return defaultMidiOutputDeviceInfo.identifier; }
+
+    /** Returns the current default midi output device. If no device has been selected, or the
+        device can't be opened, this will return nullptr.
+
+        @see getDefaultMidiOutputIdentifier
+    */
+    MidiOutput* getDefaultMidiOutput() const noexcept               { return defaultMidiOutput.get(); }
+
+    //==============================================================================
+    /** Returns a list of the types of device supported. */
+    const OwnedArray<AudioIODeviceType>& getAvailableDeviceTypes();
+
+    /** Creates a list of available types.
+
+        This will add a set of new AudioIODeviceType objects to the specified list, to
+        represent each available types of device.
+
+        You can override this if your app needs to do something specific, like avoid
+        using DirectSound devices, etc.
+    */
+    virtual void createAudioDeviceTypes (OwnedArray<AudioIODeviceType>& types);
+
+    /** Adds a new device type to the list of types. */
+    void addAudioDeviceType (std::unique_ptr<AudioIODeviceType> newDeviceType);
+
+    /** Removes a previously added device type from the manager. */
+    void removeAudioDeviceType (AudioIODeviceType* deviceTypeToRemove);
+
+    //==============================================================================
+    /** Plays a beep through the current audio device.
+
+        This is here to allow the audio setup UI panels to easily include a "test"
+        button so that the user can check where the audio is coming from.
+    */
+    void playTestSound();
+
+    //==============================================================================
+    /**
+        A simple reference-counted struct that holds a level-meter value that can be read
+        using getCurrentLevel().
+
+        This is used to ensure that the level processing code is only executed when something
+        holds a reference to one of these objects and will be bypassed otherwise.
+
+        @see getInputLevelGetter, getOutputLevelGetter
+    */
+    struct LevelMeter    : public ReferenceCountedObject
+    {
+        LevelMeter() noexcept;
+        double getCurrentLevel() const noexcept;
+
+        using Ptr = ReferenceCountedObjectPtr<LevelMeter>;
+
+    private:
+        friend class AudioDeviceManager;
+
+        Atomic<float> level { 0 };
+        void updateLevel (const float* const*, int numChannels, int numSamples) noexcept;
+    };
+
+    /** Returns a reference-counted object that can be used to get the current input level.
+
+        You need to store this object locally to ensure that the reference count is incremented
+        and decremented properly. The current input level value can be read using getCurrentLevel().
+    */
+    LevelMeter::Ptr getInputLevelGetter() noexcept          { return inputLevelGetter; }
+
+    /** Returns a reference-counted object that can be used to get the current output level.
+
+        You need to store this object locally to ensure that the reference count is incremented
+        and decremented properly. The current output level value can be read using getCurrentLevel().
+    */
+    LevelMeter::Ptr getOutputLevelGetter() noexcept         { return outputLevelGetter; }
+
+    //==============================================================================
+    /** Returns the a lock that can be used to synchronise access to the audio callback.
+        Obviously while this is locked, you're blocking the audio thread from running, so
+        it must only be used for very brief periods when absolutely necessary.
+    */
+    CriticalSection& getAudioCallbackLock() noexcept        { return audioCallbackLock; }
+
+    /** Returns the a lock that can be used to synchronise access to the midi callback.
+        Obviously while this is locked, you're blocking the midi system from running, so
+        it must only be used for very brief periods when absolutely necessary.
+    */
+    CriticalSection& getMidiCallbackLock() noexcept         { return midiCallbackLock; }
+
+    //==============================================================================
+    /** Returns the number of under- or over runs reported.
+
+        This method will use the underlying device's native getXRunCount if it supports
+        it. Otherwise it will estimate the number of under-/overruns by measuring the
+        time it spent in the audio callback.
+    */
+    int getXRunCount() const noexcept;
+
+    //==============================================================================
+   #ifndef DOXYGEN
+    [[deprecated ("Use setMidiInputDeviceEnabled instead.")]]
+    void setMidiInputEnabled (const String&, bool);
+    [[deprecated ("Use isMidiInputDeviceEnabled instead.")]]
+    bool isMidiInputEnabled (const String&) const;
+    [[deprecated ("Use addMidiInputDeviceCallback instead.")]]
+    void addMidiInputCallback (const String&, MidiInputCallback*);
+    [[deprecated ("Use removeMidiInputDeviceCallback instead.")]]
+    void removeMidiInputCallback (const String&, MidiInputCallback*);
+    [[deprecated ("Use setDefaultMidiOutputDevice instead.")]]
+    void setDefaultMidiOutput (const String&);
+    [[deprecated ("Use getDefaultMidiOutputIdentifier instead.")]]
+    const String& getDefaultMidiOutputName() const noexcept  { return defaultMidiOutputDeviceInfo.name; }
+   #endif
+
+private:
+    //==============================================================================
+    OwnedArray<AudioIODeviceType> availableDeviceTypes;
+    OwnedArray<AudioDeviceSetup> lastDeviceTypeConfigs;
+
+    AudioDeviceSetup currentSetup;
+    std::unique_ptr<AudioIODevice> currentAudioDevice;
+    Array<AudioIODeviceCallback*> callbacks;
+    int numInputChansNeeded = 0, numOutputChansNeeded = 2;
+    String preferredDeviceName, currentDeviceType;
+    std::unique_ptr<XmlElement> lastExplicitSettings;
+    mutable bool listNeedsScanning = true;
+    AudioBuffer<float> tempBuffer;
+    MidiDeviceListConnection midiDeviceListConnection = MidiDeviceListConnection::make ([this]
+    {
+        midiDeviceListChanged();
+    });
+
+    struct MidiCallbackInfo
+    {
+        String deviceIdentifier;
+        MidiInputCallback* callback;
+    };
+
+    Array<MidiDeviceInfo> midiDeviceInfosFromXml;
+    std::vector<std::unique_ptr<MidiInput>> enabledMidiInputs;
+    Array<MidiCallbackInfo> midiCallbacks;
+
+    MidiDeviceInfo defaultMidiOutputDeviceInfo;
+    std::unique_ptr<MidiOutput> defaultMidiOutput;
+    CriticalSection audioCallbackLock, midiCallbackLock;
+
+    std::unique_ptr<AudioBuffer<float>> testSound;
+    int testSoundPosition = 0;
+
+    AudioProcessLoadMeasurer loadMeasurer;
+
+    LevelMeter::Ptr inputLevelGetter   { new LevelMeter() },
+                    outputLevelGetter  { new LevelMeter() };
+
+    //==============================================================================
+    class CallbackHandler;
+    std::unique_ptr<CallbackHandler> callbackHandler;
+
+    void audioDeviceIOCallbackInt (const float* const* inputChannelData,
+                                   int totalNumInputChannels,
+                                   float* const* outputChannelData,
+                                   int totalNumOutputChannels,
+                                   int numSamples,
+                                   const AudioIODeviceCallbackContext& context);
+    void audioDeviceAboutToStartInt (AudioIODevice*);
+    void audioDeviceStoppedInt();
+    void audioDeviceErrorInt (const String&);
+    void handleIncomingMidiMessageInt (MidiInput*, const MidiMessage&);
+    void audioDeviceListChanged();
+    void midiDeviceListChanged();
+
+    String restartDevice (int blockSizeToUse, double sampleRateToUse,
+                          const BigInteger& ins, const BigInteger& outs);
+    void stopDevice();
+
+    void updateXml();
+
+    void updateCurrentSetup();
+    void createDeviceTypesIfNeeded();
+    void scanDevicesIfNeeded();
+    void deleteCurrentDevice();
+    double chooseBestSampleRate (double preferred) const;
+    int chooseBestBufferSize (int preferred) const;
+    void insertDefaultDeviceNames (AudioDeviceSetup&) const;
+    String initialiseDefault (const String& preferredDefaultDeviceName, const AudioDeviceSetup*);
+    String initialiseFromXML (const XmlElement&, bool selectDefaultDeviceOnFailure,
+                              const String& preferredDefaultDeviceName, const AudioDeviceSetup*);
+    void openLastRequestedMidiDevices (const Array<MidiDeviceInfo>&, const MidiDeviceInfo&);
+
+    AudioIODeviceType* findType (const String& inputName, const String& outputName);
+    AudioIODeviceType* findType (const String& typeName);
+    void pickCurrentDeviceTypeWithDevices();
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioDeviceManager)
+};
+
+} // namespace juce

package/ios/juce_modules/juce_audio_devices/audio_io/juce_AudioIODevice.cpp

@@ -0,0 +1,65 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE framework.
+   Copyright (c) Raw Material Software Limited
+
+   JUCE is an open source framework subject to commercial or open source
+   licensing.
+
+   By downloading, installing, or using the JUCE framework, or combining the
+   JUCE framework with any other source code, object code, content or any other
+   copyrightable work, you agree to the terms of the JUCE End User Licence
+   Agreement, and all incorporated terms including the JUCE Privacy Policy and
+   the JUCE Website Terms of Service, as applicable, which will bind you. If you
+   do not agree to the terms of these agreements, we will not license the JUCE
+   framework to you, and you must discontinue the installation or download
+   process and cease use of the JUCE framework.
+
+   JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
+   JUCE Privacy Policy: https://juce.com/juce-privacy-policy
+   JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
+
+   Or:
+
+   You may also use this code under the terms of the AGPLv3:
+   https://www.gnu.org/licenses/agpl-3.0.en.html
+
+   THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
+   WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+void AudioIODeviceCallback::audioDeviceIOCallbackWithContext ([[maybe_unused]] const float* const* inputChannelData,
+                                                              [[maybe_unused]] int numInputChannels,
+                                                              [[maybe_unused]] float* const* outputChannelData,
+                                                              [[maybe_unused]] int numOutputChannels,
+                                                              [[maybe_unused]] int numSamples,
+                                                              [[maybe_unused]] const AudioIODeviceCallbackContext& context) {}
+
+//==============================================================================
+AudioIODevice::AudioIODevice (const String& deviceName, const String& deviceTypeName)
+    : name (deviceName), typeName (deviceTypeName)
+{
+}
+
+AudioIODevice::~AudioIODevice() {}
+
+void AudioIODeviceCallback::audioDeviceError (const String&)    {}
+bool AudioIODevice::setAudioPreprocessingEnabled (bool)         { return false; }
+bool AudioIODevice::hasControlPanel() const                     { return false; }
+int  AudioIODevice::getXRunCount() const noexcept               { return -1; }
+
+bool AudioIODevice::showControlPanel()
+{
+    jassertfalse;    // this should only be called for devices which return true from
+                     // their hasControlPanel() method.
+    return false;
+}
+
+} // namespace juce