mirror/JUCE
1
0
Fork 0
mirror of https://github.com/juce-framework/JUCE.git synced 2026-01-10 23:44:24 +00:00
Code Activity

Updated the MidiInput/Output methods to return unique_ptrs

Browse source
This commit is contained in:
ed 2019-05-22 15:45:06 +01:00
parent e8caa05756
commit f0ea1c00a6
8 changed files with 109 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

4
examples/Audio/MidiDemo.h
View file

@ -187,7 +187,7 @@ public:
if (isInput)
{
jassert (midiInputs[index]->inDevice.get() == nullptr);
midiInputs[index]->inDevice.reset (MidiInput::openDevice (midiInputs[index]->deviceInfo.identifier, this));
midiInputs[index]->inDevice = MidiInput::openDevice (midiInputs[index]->deviceInfo.identifier, this);
if (midiInputs[index]->inDevice.get() == nullptr)
{
@ -200,7 +200,7 @@ public:
else
{
jassert (midiOutputs[index]->outDevice.get() == nullptr);
midiOutputs[index]->outDevice.reset (MidiOutput::openDevice (midiOutputs[index]->deviceInfo.identifier));
midiOutputs[index]->outDevice = MidiOutput::openDevice (midiOutputs[index]->deviceInfo.identifier);
if (midiOutputs[index]->outDevice.get() == nullptr)
{

28
modules/juce_audio_devices/midi_io/juce_MidiDevices.h
View file

@ -93,10 +93,10 @@ public:
/** Tries to open one of the midi input devices.
This will return a MidiInput object if it manages to open it. You can then
call start() and stop() on this device, and delete it when no longer needed.
This will return a MidiInput object if it manages to open it, you can then
call start() and stop() on this device.
If the device can't be opened, this will return nullptr.
If the device can't be opened, this will return an empty object.
@param deviceIdentifier the ID of the device to open - use the getAvailableDevices() method to
find the available devices that can be opened
@ -104,7 +104,7 @@ public:
@see MidiInputCallback, getDevices
*/
static MidiInput* openDevice (const String& deviceIdentifier, MidiInputCallback* callback);
static std::unique_ptr<MidiInput> openDevice (const String& deviceIdentifier, MidiInputCallback* callback);
#if JUCE_LINUX || JUCE_MAC || JUCE_IOS || DOXYGEN
/** This will try to create a new midi input device (only available on Linux, macOS and iOS).
@ -115,12 +115,12 @@ public:
NB - if you are calling this method on iOS you must have enabled the "Audio Background Capability"
setting in the iOS exporter otherwise this method will fail.
Returns nullptr if a device can't be created.
Returns an empty object if a device can't be created.
@param deviceName the name of the device to create
@param callback the object that will receive the midi messages from this device
*/
static MidiInput* createNewDevice (const String& deviceName, MidiInputCallback* callback);
static std::unique_ptr<MidiInput> createNewDevice (const String& deviceName, MidiInputCallback* callback);
#endif
//==============================================================================
@ -160,7 +160,7 @@ public:
/** Deprecated. */
static int getDefaultDeviceIndex();
/** Deprecated. */
static MidiInput* openDevice (int, MidiInputCallback*);
static std::unique_ptr<MidiInput> openDevice (int, MidiInputCallback*);
private:
//==============================================================================
@ -251,16 +251,16 @@ public:
/** Tries to open one of the midi output devices.
This will return a MidiOutput object if it manages to open it. You can then
send messages to this device, and delete it when no longer needed.
This will return a MidiOutput object if it manages to open it, you can then
send messages to this device.
If the device can't be opened, this will return nullptr.
If the device can't be opened, this will return an empty object.
@param deviceIdentifier the ID of the device to open - use the getAvailableDevices() method to
find the available devices that can be opened
@see getDevices
*/
static MidiOutput* openDevice (const String& deviceIdentifier);
static std::unique_ptr<MidiOutput> openDevice (const String& deviceIdentifier);
#if JUCE_LINUX || JUCE_MAC || JUCE_IOS || DOXYGEN
/** This will try to create a new midi output device (only available on Linux, macOS and iOS).
@ -271,11 +271,11 @@ public:
NB - if you are calling this method on iOS you must have enabled the "Audio Background Capability"
setting in the iOS exporter otherwise this method will fail.
Returns nullptr if a device can't be created.
Returns an empty object if a device can't be created.
@param deviceName the name of the device to create
*/
static MidiOutput* createNewDevice (const String& deviceName);
static std::unique_ptr<MidiOutput> createNewDevice (const String& deviceName);
#endif
//==============================================================================
@ -341,7 +341,7 @@ public:
/** Deprecated. */
static int getDefaultDeviceIndex();
/** Deprecated. */
static MidiOutput* openDevice (int);
static std::unique_ptr<MidiOutput> openDevice (int);
private:
//==============================================================================

20
modules/juce_audio_devices/native/juce_android_Midi.cpp
View file

@ -554,10 +554,10 @@ MidiDeviceInfo MidiInput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
{
if (getAndroidSDKVersion() < 23 || deviceIdentifier.isEmpty())
return nullptr;
return {};
AndroidMidiDeviceManager manager;
@ -568,10 +568,10 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
midiInput->internal = port;
midiInput->setName (port->getName());
return midiInput.release();
return midiInput;
}
return nullptr;
return {};
}
StringArray MidiInput::getDevices()
@ -592,7 +592,7 @@ int MidiInput::getDefaultDeviceIndex()
return (getAndroidSDKVersion() < 23 ? -1 : 0);
}
MidiInput* MidiInput::openDevice (int index, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
{
return openDevice (getAvailableDevices()[index].identifier, callback);
}
@ -637,10 +637,10 @@ MidiDeviceInfo MidiOutput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String& deviceIdentifier)
{
if (getAndroidSDKVersion() < 23 || deviceIdentifier.isEmpty())
return nullptr;
return {};
AndroidMidiDeviceManager manager;
@ -650,10 +650,10 @@ MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
midiOutput->internal = port;
midiOutput->setName (port->getName());
return midiOutput.release();
return midiOutput;
}
return nullptr;
return {};
}
StringArray MidiOutput::getDevices()
@ -674,7 +674,7 @@ int MidiOutput::getDefaultDeviceIndex()
return (getAndroidSDKVersion() < 23 ? -1 : 0);
}
MidiOutput* MidiOutput::openDevice (int index)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int index)
{
return openDevice (getAvailableDevices()[index].identifier);
}

30
modules/juce_audio_devices/native/juce_linux_Bela.cpp
View file

@ -528,22 +528,22 @@ MidiDeviceInfo MidiInput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
{
if (deviceIdentifier.isEmpty())
return nullptr;
return {};
std::unique_ptr<MidiInput> midiInput (new MidiInput (deviceIdentifier, deviceIdentifier));
midiInput->internal = new BelaMidiInput (deviceIdentifier, result, callback);
return midiInput.release();
return midiInput;
}
MidiInput* MidiInput::createNewDevice (const String&, MidiInputCallback*)
std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String&, MidiInputCallback*)
{
// N/A on Bela
jassertfalse;
return nullptr;
return {};
}
StringArray MidiInput::getDevices()
@ -561,21 +561,21 @@ int MidiInput::getDefaultDeviceIndex()
return 0;
}
MidiInput* MidiInput::openDevice (int index, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
{
return openDevice (getAvailableDevices()[index].identifier, callback);
}
//==============================================================================
// TODO: Add Bela MidiOutput support
MidiOutput::~MidiOutput() {}
void MidiOutput::sendMessageNow (const MidiMessage&) {}
Array<MidiDeviceInfo> MidiOutput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiOutput::getDefaultDevice() { return {}; }
MidiOutput* MidiOutput::openDevice (const String&) { return nullptr; }
MidiOutput* MidiOutput::createNewDevice (const String&) { return nullptr; }
StringArray MidiOutput::getDevices() { return {}; }
int MidiOutput::getDefaultDeviceIndex() { return 0;}
MidiOutput* MidiOutput::openDevice (int) { return nullptr; }
MidiOutput::~MidiOutput() {}
void MidiOutput::sendMessageNow (const MidiMessage&) {}
Array<MidiDeviceInfo> MidiOutput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiOutput::getDefaultDevice() { return {}; }
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String&) { return {}; }
std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String&) { return {}; }
StringArray MidiOutput::getDevices() { return {}; }
int MidiOutput::getDefaultDeviceIndex() { return 0;}
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int) { return {}; }
} // namespace juce

78
modules/juce_audio_devices/native/juce_linux_Midi.cpp
View file

@ -469,16 +469,16 @@ MidiDeviceInfo MidiInput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
{
if (deviceIdentifier.isEmpty())
return nullptr;
return {};
Array<MidiDeviceInfo> devices;
auto* port = iterateMidiDevices (true, devices, deviceIdentifier);
if (port == nullptr)
return nullptr;
if (port == nullptr || ! port->isValid())
return {};
jassert (port->isValid());
@ -487,22 +487,23 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
port->setupInput (midiInput.get(), callback);
midiInput->internal = port;
return midiInput.release();
return midiInput;
}
MidiInput* MidiInput::createNewDevice (const String& deviceName, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String& deviceName, MidiInputCallback* callback)
{
auto client = AlsaClient::getInstance();
auto* port = client->createPort (deviceName, true, true);
jassert (port->isValid());
if (port == nullptr || ! port->isValid())
return {};
std::unique_ptr<MidiInput> midiInput (new MidiInput (deviceName, getFormattedPortIdentifier (client->getId(), port->portId)));
port->setupInput (midiInput.get(), callback);
midiInput->internal = port;
return midiInput.release();
return midiInput;
}
StringArray MidiInput::getDevices()
@ -522,7 +523,7 @@ int MidiInput::getDefaultDeviceIndex()
return 0;
}
MidiInput* MidiInput::openDevice (int index, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
{
return openDevice (getAvailableDevices()[index].identifier, callback);
}
@ -562,40 +563,39 @@ MidiDeviceInfo MidiOutput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String& deviceIdentifier)
{
if (deviceIdentifier.isEmpty())
return nullptr;
return {};
Array<MidiDeviceInfo> devices;
auto* port = iterateMidiDevices (false, devices, deviceIdentifier);
if (port == nullptr)
return nullptr;
jassert (port->isValid());
if (port == nullptr || ! port->isValid())
return {};
std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (port->portName, deviceIdentifier));
port->setupOutput();
midiOutput->internal = port;
return midiOutput.release();
return midiOutput;
}
MidiOutput* MidiOutput::createNewDevice (const String& deviceName)
std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String& deviceName)
{
auto client = AlsaClient::getInstance();
auto* port = client->createPort (deviceName, false, true);
jassert (port != nullptr && port->isValid());
if (port == nullptr || ! port->isValid())
return {};
std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (deviceName, getFormattedPortIdentifier (client->getId(), port->portId)));
port->setupOutput();
midiOutput->internal = port;
return midiOutput.release();
return midiOutput;
}
StringArray MidiOutput::getDevices()
@ -615,7 +615,7 @@ int MidiOutput::getDefaultDeviceIndex()
return 0;
}
MidiOutput* MidiOutput::openDevice (int index)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int index)
{
return openDevice (getAvailableDevices()[index].identifier);
}
@ -640,26 +640,26 @@ MidiInput::MidiInput (const String& deviceName, const String& deviceID)
{
}
MidiInput::~MidiInput() {}
void MidiInput::start() {}
void MidiInput::stop() {}
Array<MidiDeviceInfo> MidiInput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiInput::getDefaultDevice() { return {}; }
MidiInput* MidiInput::openDevice (const String&, MidiInputCallback*) { return nullptr; }
MidiInput* MidiInput::createNewDevice (const String&, MidiInputCallback*) { return nullptr; }
StringArray MidiInput::getDevices() { return {}; }
int MidiInput::getDefaultDeviceIndex() { return 0;}
MidiInput* MidiInput::openDevice (int, MidiInputCallback*) { return nullptr; }
MidiInput::~MidiInput() {}
void MidiInput::start() {}
void MidiInput::stop() {}
Array<MidiDeviceInfo> MidiInput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiInput::getDefaultDevice() { return {}; }
std::unique_ptr<MidiInput> MidiInput::openDevice (const String&, MidiInputCallback*) { return {}; }
std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String&, MidiInputCallback*) { return {}; }
StringArray MidiInput::getDevices() { return {}; }
int MidiInput::getDefaultDeviceIndex() { return 0;}
std::unique_ptr<MidiInput> MidiInput::openDevice (int, MidiInputCallback*) { return {}; }
MidiOutput::~MidiOutput() {}
void MidiOutput::sendMessageNow (const MidiMessage&) {}
Array<MidiDeviceInfo> MidiOutput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiOutput::getDefaultDevice() { return {}; }
MidiOutput* MidiOutput::openDevice (const String&) { return nullptr; }
MidiOutput* MidiOutput::createNewDevice (const String&) { return nullptr; }
StringArray MidiOutput::getDevices() { return {}; }
int MidiOutput::getDefaultDeviceIndex() { return 0;}
MidiOutput* MidiOutput::openDevice (int) { return nullptr; }
MidiOutput::~MidiOutput() {}
void MidiOutput::sendMessageNow (const MidiMessage&) {}
Array<MidiDeviceInfo> MidiOutput::getAvailableDevices() { return {}; }
MidiDeviceInfo MidiOutput::getDefaultDevice() { return {}; }
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String&) { return {}; }
std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String&) { return {}; }
StringArray MidiOutput::getDevices() { return {}; }
int MidiOutput::getDefaultDeviceIndex() { return 0;}
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int) { return {}; }
#endif

34
modules/juce_audio_devices/native/juce_mac_CoreMidi.cpp
View file

@ -395,7 +395,7 @@ MidiDeviceInfo MidiInput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
{
if (deviceIdentifier.isEmpty())
return nullptr;
@ -415,13 +415,13 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
if (CHECK_ERROR (MIDIObjectGetStringProperty (endpoint, kMIDIPropertyName, &cfName.cfString)))
{
MIDIPortRef port;
std::unique_ptr<MidiPortAndCallback> mpc (new MidiPortAndCallback (*callback));
auto mpc = std::make_unique<MidiPortAndCallback> (*callback);
if (CHECK_ERROR (MIDIInputPortCreate (client, cfName.cfString, midiInputProc, mpc.get(), &port)))
{
if (CHECK_ERROR (MIDIPortConnectSource (port, endpoint, nullptr)))
{
mpc->portAndEndpoint.reset (new MidiPortAndEndpoint (port, endpoint));
mpc->portAndEndpoint = std::make_unique<MidiPortAndEndpoint> (port, endpoint);
std::unique_ptr<MidiInput> midiInput (new MidiInput (endpointInfo.name, endpointInfo.identifier));
@ -431,7 +431,7 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
const ScopedLock sl (callbackLock);
activeCallbacks.add (mpc.release());
return midiInput.release();
return midiInput;
}
else
{
@ -443,10 +443,10 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
}
}
return nullptr;
return {};
}
MidiInput* MidiInput::createNewDevice (const String& deviceName, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::createNewDevice (const String& deviceName, MidiInputCallback* callback)
{
using namespace CoreMidiHelpers;
jassert (callback != nullptr);
@ -477,7 +477,7 @@ MidiInput* MidiInput::createNewDevice (const String& deviceName, MidiInputCallba
if (CHECK_ERROR (MIDIObjectSetIntegerProperty (endpoint, kMIDIPropertyUniqueID, (SInt32) deviceIdentifier)))
{
mpc->portAndEndpoint.reset (new MidiPortAndEndpoint (0, endpoint));
mpc->portAndEndpoint = std::make_unique<MidiPortAndEndpoint> (0, endpoint);
std::unique_ptr<MidiInput> midiInput (new MidiInput (deviceName, String (deviceIdentifier)));
@ -487,12 +487,12 @@ MidiInput* MidiInput::createNewDevice (const String& deviceName, MidiInputCallba
const ScopedLock sl (callbackLock);
activeCallbacks.add (mpc.release());
return midiInput.release();
return midiInput;
}
}
}
return nullptr;
return {};
}
StringArray MidiInput::getDevices()
@ -510,7 +510,7 @@ int MidiInput::getDefaultDeviceIndex()
return 0;
}
MidiInput* MidiInput::openDevice (int index, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
{
return openDevice (getAvailableDevices()[index].identifier, callback);
}
@ -548,7 +548,7 @@ MidiDeviceInfo MidiOutput::getDefaultDevice()
return getAvailableDevices().getFirst();
}
MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String& deviceIdentifier)
{
if (deviceIdentifier.isEmpty())
return nullptr;
@ -574,17 +574,17 @@ MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (endpointInfo.name, endpointInfo.identifier));
midiOutput->internal = new MidiPortAndEndpoint (port, endpoint);
return midiOutput.release();
return midiOutput;
}
}
}
}
}
return nullptr;
return {};
}
MidiOutput* MidiOutput::createNewDevice (const String& deviceName)
std::unique_ptr<MidiOutput> MidiOutput::createNewDevice (const String& deviceName)
{
using namespace CoreMidiHelpers;
@ -615,12 +615,12 @@ MidiOutput* MidiOutput::createNewDevice (const String& deviceName)
std::unique_ptr<MidiOutput> midiOutput (new MidiOutput (deviceName, String (deviceIdentifier)));
midiOutput->internal = new MidiPortAndEndpoint (0, endpoint);
return midiOutput.release();
return midiOutput;
}
}
}
return nullptr;
return {};
}
StringArray MidiOutput::getDevices()
@ -638,7 +638,7 @@ int MidiOutput::getDefaultDeviceIndex()
return 0;
}
MidiOutput* MidiOutput::openDevice (int index)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int index)
{
return openDevice (getAvailableDevices()[index].identifier);
}

20
modules/juce_audio_devices/native/juce_win32_Midi.cpp
View file

@ -1820,10 +1820,10 @@ MidiDeviceInfo MidiInput::getDefaultDevice()
return MidiService::getService().getDefaultDevice (true);
}
MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallback* callback)
{
if (deviceIdentifier.isEmpty() || callback == nullptr)
return nullptr;
return {};
std::unique_ptr<MidiInput> in (new MidiInput ({}, deviceIdentifier));
std::unique_ptr<MidiServiceType::InputWrapper> wrapper;
@ -1834,13 +1834,13 @@ MidiInput* MidiInput::openDevice (const String& deviceIdentifier, MidiInputCallb
}
catch (std::runtime_error&)
{
return nullptr;
return {};
}
in->setName (wrapper->getDeviceName());
in->internal = wrapper.release();
return in.release();
return in;
}
StringArray MidiInput::getDevices()
@ -1858,7 +1858,7 @@ int MidiInput::getDefaultDeviceIndex()
return findDefaultDeviceIndex (getAvailableDevices(), getDefaultDevice());
}
MidiInput* MidiInput::openDevice (int index, MidiInputCallback* callback)
std::unique_ptr<MidiInput> MidiInput::openDevice (int index, MidiInputCallback* callback)
{
return openDevice (getAvailableDevices()[index].identifier, callback);
}
@ -1887,10 +1887,10 @@ MidiDeviceInfo MidiOutput::getDefaultDevice()
return MidiService::getService().getDefaultDevice (false);
}
MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (const String& deviceIdentifier)
{
if (deviceIdentifier.isEmpty())
return nullptr;
return {};
std::unique_ptr<MidiServiceType::OutputWrapper> wrapper;
@ -1900,7 +1900,7 @@ MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
}
catch (std::runtime_error&)
{
return nullptr;
return {};
}
std::unique_ptr<MidiOutput> out;
@ -1908,7 +1908,7 @@ MidiOutput* MidiOutput::openDevice (const String& deviceIdentifier)
out->internal = wrapper.release();
return out.release();
return out;
}
StringArray MidiOutput::getDevices()
@ -1926,7 +1926,7 @@ int MidiOutput::getDefaultDeviceIndex()
return findDefaultDeviceIndex (getAvailableDevices(), getDefaultDevice());
}
MidiOutput* MidiOutput::openDevice (int index)
std::unique_ptr<MidiOutput> MidiOutput::openDevice (int index)
{
return openDevice (getAvailableDevices()[index].identifier);
}

4
modules/juce_blocks_basics/topology/internal/juce_MIDIDeviceDetector.cpp
View file

@ -51,8 +51,8 @@ struct MIDIDeviceDetector : public PhysicalTopologySource::DeviceDetector
lockedFromOutside = false;
dev->setLockAgainstOtherProcesses (lock);
dev->midiInput.reset (MidiInput::openDevice (pair.input.identifier, dev.get()));
dev->midiOutput.reset (MidiOutput::openDevice (pair.output.identifier));
dev->midiInput = MidiInput::openDevice (pair.input.identifier, dev.get());
dev->midiOutput = MidiOutput::openDevice (pair.output.identifier);
if (dev->midiInput != nullptr)
{