qmacosaudiodatautils.cpp

++ // Copyright (C) 2025 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++

++ #include "qmacosaudiodatautils_p.h"

++

++ QT_BEGIN_NAMESPACE

++

++ namespace QCoreAudioUtils

++ {

++

++ #define ENUM_CASE(NAME) \

++ case NAME: return QStringView(QT_UNICODE_LITERAL(QT_STRINGIFY(NAME)))

++

++ #define DUPLICATE_ENUM_CASE(NAME) static_assert(true, "force semicolon")

++

++ QStringView audioPropertySelectorToString(AudioObjectPropertySelector selector)

++ {

++     switch (selector) {

++         // AudioObject properties

++         ENUM_CASE(kAudioObjectPropertyBaseClass          );

++         ENUM_CASE(kAudioObjectPropertyClass              );

++         ENUM_CASE(kAudioObjectPropertyOwner              );

++         ENUM_CASE(kAudioObjectPropertyName               );

++         ENUM_CASE(kAudioObjectPropertyModelName          );

++         ENUM_CASE(kAudioObjectPropertyManufacturer       );

++         ENUM_CASE(kAudioObjectPropertyElementName        );

++         ENUM_CASE(kAudioObjectPropertyElementCategoryName);

++         ENUM_CASE(kAudioObjectPropertyElementNumberName  );

++         ENUM_CASE(kAudioObjectPropertyOwnedObjects       );

++         ENUM_CASE(kAudioObjectPropertyIdentify           );

++         ENUM_CASE(kAudioObjectPropertySerialNumber       );

++         ENUM_CASE(kAudioObjectPropertyFirmwareVersion    );

++         ENUM_CASE(kAudioObjectPropertySelectorWildcard   );

++

++                // AudioDevice properties

++         ENUM_CASE(kAudioDevicePropertyConfigurationApplication      );

++         ENUM_CASE(kAudioDevicePropertyDeviceUID                     );

++         ENUM_CASE(kAudioDevicePropertyModelUID                      );

++         ENUM_CASE(kAudioDevicePropertyTransportType                 );

++         ENUM_CASE(kAudioDevicePropertyRelatedDevices                );

++         ENUM_CASE(kAudioDevicePropertyClockDomain                   );

++         ENUM_CASE(kAudioDevicePropertyDeviceIsAlive                 );

++         ENUM_CASE(kAudioDevicePropertyDeviceIsRunning               );

++         ENUM_CASE(kAudioDevicePropertyDeviceCanBeDefaultDevice      );

++         ENUM_CASE(kAudioDevicePropertyDeviceCanBeDefaultSystemDevice);

++         ENUM_CASE(kAudioDevicePropertyLatency                       );

++         ENUM_CASE(kAudioDevicePropertyStreams                       );

++         ENUM_CASE(kAudioObjectPropertyControlList                   );

++         ENUM_CASE(kAudioDevicePropertySafetyOffset                  );

++         ENUM_CASE(kAudioDevicePropertyNominalSampleRate             );

++         ENUM_CASE(kAudioDevicePropertyAvailableNominalSampleRates   );

++         ENUM_CASE(kAudioDevicePropertyIcon                          );

++         ENUM_CASE(kAudioDevicePropertyIsHidden                      );

++         ENUM_CASE(kAudioDevicePropertyPreferredChannelsForStereo    );

++         ENUM_CASE(kAudioDevicePropertyPreferredChannelLayout        );

++

++                // AudioClockDevice properties

++         ENUM_CASE(kAudioClockDevicePropertyDeviceUID                            );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyTransportType              );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyClockDomain                );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyDeviceIsAlive              );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyDeviceIsRunning            );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyLatency                    );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyControlList                );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyNominalSampleRate          );

++         DUPLICATE_ENUM_CASE(kAudioClockDevicePropertyAvailableNominalSampleRates);

++

++                // AudioEndPointDevice properties

++         ENUM_CASE(kAudioEndPointDevicePropertyComposition );

++         ENUM_CASE(kAudioEndPointDevicePropertyEndPointList);

++         ENUM_CASE(kAudioEndPointDevicePropertyIsPrivate   );

++

++                // AudioStream properties

++         ENUM_CASE(kAudioStreamPropertyIsActive                );

++         ENUM_CASE(kAudioStreamPropertyDirection               );

++         ENUM_CASE(kAudioStreamPropertyTerminalType            );

++         ENUM_CASE(kAudioStreamPropertyStartingChannel         );

++         ENUM_CASE(kAudioStreamPropertyVirtualFormat           );

++         ENUM_CASE(kAudioStreamPropertyAvailableVirtualFormats );

++         ENUM_CASE(kAudioStreamPropertyPhysicalFormat          );

++         ENUM_CASE(kAudioStreamPropertyAvailablePhysicalFormats);

++

++     default:

++         Q_UNREACHABLE_RETURN(u"");

++     }

++ }

++

++ QStringView audioPropertyScopeToString(AudioObjectPropertyScope scope)

++ {

++     switch (scope) {

++         ENUM_CASE(kAudioObjectPropertyScopeGlobal     );

++         ENUM_CASE(kAudioObjectPropertyScopeInput      );

++         ENUM_CASE(kAudioObjectPropertyScopeOutput     );

++         ENUM_CASE(kAudioObjectPropertyScopePlayThrough);

++         ENUM_CASE(kAudioObjectPropertyScopeWildcard   );

++     default:

++         Q_UNREACHABLE_RETURN(u"");

++     }

++ }

++

++ QStringView audioPropertyElementToString(AudioObjectPropertyElement element)

++ {

++     switch (element) {

++         ENUM_CASE(kAudioObjectPropertyElementMain    );

++         ENUM_CASE(kAudioObjectPropertyElementWildcard);

++     default:

++         Q_UNREACHABLE_RETURN(u"");

++     }

++ }

++

++ #undef ENUM_CASE

++ #undef DUPLICATE_ENUM_CASE

++

++ }

++

++ AudioObjectPropertyAddress

++ QCoreAudioUtils::makePropertyAddress(

++     AudioObjectPropertySelector selector,

++     QAudioDevice::Mode mode,

++     AudioObjectPropertyElement element)

++ {

++     return { selector,

++              mode == QAudioDevice::Input ? kAudioDevicePropertyScopeInput

++                                          : kAudioDevicePropertyScopeOutput,

++              element };

++ }

++

++ bool QCoreAudioUtils::getAudioPropertyRaw(AudioObjectID objectID, const AudioObjectPropertyAddress &address,

++                          QSpan<std::byte> destination, bool warnIfMissing)

++ {

++     UInt32 readBytes = destination.size();

++     const auto res =

++             AudioObjectGetPropertyData(objectID, &address, 0, nullptr, &readBytes, destination.data());

++

++     if (res != noErr) {

++         if (warnIfMissing)

++             printUnableToReadWarning(objectID, address, "Err:", res);

++     } else if (readBytes != destination.size()) {

++         if (warnIfMissing)

++             printUnableToReadWarning(objectID, address, "Data size", readBytes, "VS", destination.size(),

++                                      "expected");

++     } else {

++         return true;

++     }

++

++     return false;

++ }

++

++ QByteArray QCoreAudioUtils::readPersistentDeviceId(

++     AudioDeviceID device,

++     QAudioDevice::Mode mode)

++ {

++     const AudioObjectPropertyAddress propertyAddress = makePropertyAddress(

++         kAudioDevicePropertyDeviceUID,

++         mode);

++

++     const std::optional<QCFString> name = getAudioProperty<QCFString>(device, propertyAddress);

++     if (name)

++         return QString{*name}.toUtf8();

++

++     return QByteArray();

++ }

++

++ std::optional<AudioDeviceID> QCoreAudioUtils::findAudioDeviceId(

++     const QByteArray &id,

++     QAudioDevice::Mode mode)

++ {

++     if (id.isEmpty() || mode == QAudioDevice::Mode::Null)

++         return std::nullopt;

++     // Iterate over all the devices connected and find the one matching our ID and return the AudioDeviceID.

++     const AudioObjectPropertyAddress audioDevicesPropertyAddress = {

++         kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,

++         kAudioObjectPropertyElementMain

++     };

++     const std::optional<std::vector<AudioDeviceID>> audioDevicesOpt = getAudioPropertyList<AudioDeviceID>(

++         kAudioObjectSystemObject,

++         audioDevicesPropertyAddress);

++     if (audioDevicesOpt.has_value()) {

++         const std::vector<AudioDeviceID> &audioDevices = audioDevicesOpt.value();

++         const AudioObjectPropertyAddress audioDeviceStreamFormatPropertyAddress = makePropertyAddress(

++             kAudioDevicePropertyStreamFormat,

++             mode);

++         for (const AudioDeviceID &device : audioDevices) {

++             // Ignore devices that don't have any audio formats we can use.

++             const std::optional<AudioStreamBasicDescription> audioStreamOpt =

++                 getAudioProperty<AudioStreamBasicDescription>(

++                     device,

++                     audioDeviceStreamFormatPropertyAddress);

++             // Check that these devices have the same unique-id. In which case, we found the

++             // correct CoreAudioID.

++             if (audioStreamOpt.has_value() && readPersistentDeviceId(device, mode) == id)

++                 return device;

++         }

++     }

++     return std::nullopt;

++ }

++

++ std::optional<AudioDeviceID> QCoreAudioUtils::findAudioDeviceId(

++     const QAudioDevice &device)

++ {

++     return findAudioDeviceId(device.id(), device.mode());

++ }

++

++ QT_END_NAMESPACE

Revision control