qcoreaudioutils.cpp

++ // Copyright (C) 2016 The Qt Company Ltd and/or its subsidiary(-ies).

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

++

++ #include "qcoreaudioutils_p.h"

++

++ #include <QtCore/qdebug.h>

++ #include <QtMultimedia/private/qmultimedia_ranges_p.h>

++ #include <QtMultimedia/private/qapple_utils_p.h>

++

++ #ifdef Q_OS_MACOS

++ #  include <CoreAudio/AudioHardware.h>

++ #  include <QtMultimedia/private/qmacosaudiodatautils_p.h>

++ #  include <QtMultimedia/private/qaudioformat_p.h>

++ #endif

++

++ QT_BEGIN_NAMESPACE

++

++ namespace QCoreAudioUtils {

++

++ namespace ranges = QtMultimediaPrivate::ranges;

++

++ QAudioFormat toPreferredQAudioFormat(AudioStreamBasicDescription const &sf)

++ {

++     // coreaudio will do the format conversions for us, we only need to give the best match

++     const QAudioFormat::SampleFormat format = [&] {

++         const bool isFloat = sf.mFormatFlags & kAudioFormatFlagIsFloat;

++         switch (sf.mBitsPerChannel) {

++         case 8:

++             return QAudioFormat::UInt8;

++         case 16:

++             return QAudioFormat::Int16;

++         case 32:

++             return isFloat ? QAudioFormat::Float : QAudioFormat::Int32;

++         default:

++             return QAudioFormat::Float;

++         }

++     }();

++

++     QAudioFormat audioFormat;

++     audioFormat.setSampleFormat(format);

++     audioFormat.setSampleRate(sf.mSampleRate);

++     audioFormat.setChannelCount(sf.mChannelsPerFrame);

++

++     return audioFormat;

++ }

++

++ AudioStreamBasicDescription toAudioStreamBasicDescription(QAudioFormat const& audioFormat)

++ {

++     AudioStreamBasicDescription sf;

++

++     sf.mFormatFlags         = kAudioFormatFlagIsPacked;

++     sf.mSampleRate          = audioFormat.sampleRate();

++     sf.mFramesPerPacket     = 1;

++     sf.mChannelsPerFrame    = audioFormat.channelCount();

++     sf.mBitsPerChannel      = audioFormat.bytesPerSample() * 8;

++     sf.mBytesPerFrame       = audioFormat.bytesPerFrame();

++     sf.mBytesPerPacket      = sf.mFramesPerPacket * sf.mBytesPerFrame;

++     sf.mFormatID            = kAudioFormatLinearPCM;

++

++     switch (audioFormat.sampleFormat()) {

++     case QAudioFormat::Int16:

++     case QAudioFormat::Int32:

++         sf.mFormatFlags |= kAudioFormatFlagIsSignedInteger;

++         break;

++     case QAudioFormat::Float:

++         sf.mFormatFlags |= kAudioFormatFlagIsFloat;

++         break;

++     case QAudioFormat::UInt8:

++         /* default */

++     case QAudioFormat::Unknown:

++     case QAudioFormat::NSampleFormats:

++         break;

++     }

++

++     return sf;

++ }

++

++

++ static constexpr struct {

++     QAudioFormat::AudioChannelPosition pos;

++     AudioChannelLabel label;

++ } channelMap[] =  {

++         { QAudioFormat::FrontLeft, kAudioChannelLabel_Left },

++         { QAudioFormat::FrontRight, kAudioChannelLabel_Right },

++         { QAudioFormat::FrontCenter, kAudioChannelLabel_Center },

++         { QAudioFormat::LFE, kAudioChannelLabel_LFEScreen },

++         { QAudioFormat::BackLeft, kAudioChannelLabel_LeftSurround },

++         { QAudioFormat::BackRight, kAudioChannelLabel_RightSurround },

++         { QAudioFormat::FrontLeftOfCenter, kAudioChannelLabel_LeftCenter },

++         { QAudioFormat::FrontRightOfCenter, kAudioChannelLabel_RightCenter },

++         { QAudioFormat::BackCenter, kAudioChannelLabel_CenterSurround },

++         { QAudioFormat::LFE2, kAudioChannelLabel_LFE2 },

++         { QAudioFormat::SideLeft, kAudioChannelLabel_LeftSurroundDirect }, // ???

++         { QAudioFormat::SideRight, kAudioChannelLabel_RightSurroundDirect }, // ???

++         { QAudioFormat::TopFrontLeft, kAudioChannelLabel_VerticalHeightLeft },

++         { QAudioFormat::TopFrontRight, kAudioChannelLabel_VerticalHeightRight },

++         { QAudioFormat::TopFrontCenter, kAudioChannelLabel_VerticalHeightCenter },

++         { QAudioFormat::TopCenter, kAudioChannelLabel_CenterTopMiddle },

++         { QAudioFormat::TopBackLeft, kAudioChannelLabel_TopBackLeft },

++         { QAudioFormat::TopBackRight, kAudioChannelLabel_TopBackRight },

++         { QAudioFormat::TopSideLeft, kAudioChannelLabel_LeftTopMiddle },

++         { QAudioFormat::TopSideRight, kAudioChannelLabel_RightTopMiddle },

++         { QAudioFormat::TopBackCenter, kAudioChannelLabel_TopBackCenter },

++ };

++

++ std::unique_ptr<AudioChannelLayout, QFreeDeleter>

++ toAudioChannelLayout(const QAudioFormat &format, UInt32 *size)

++ {

++     auto channelConfig = format.channelConfig();

++     if (channelConfig == QAudioFormat::ChannelConfigUnknown)

++         channelConfig = QAudioFormat::defaultChannelConfigForChannelCount(format.channelCount());

++

++     *size = sizeof(AudioChannelLayout) + int(QAudioFormat::NChannelPositions)*sizeof(AudioChannelDescription);

++     auto *layout = static_cast<AudioChannelLayout *>(malloc(*size));

++     memset(layout, 0, *size);

++     layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;

++

++     for (const auto &m : channelMap) {

++         if (channelConfig & QAudioFormat::channelConfig(m.pos))

++             layout->mChannelDescriptions[layout->mNumberChannelDescriptions++].mChannelLabel = m.label;

++     }

++

++     if (channelConfig & QAudioFormat::channelConfig(QAudioFormat::BottomFrontCenter)) {

++         auto &desc = layout->mChannelDescriptions[layout->mNumberChannelDescriptions++];

++         desc.mChannelLabel = kAudioChannelLabel_UseCoordinates;

++         desc.mChannelFlags = kAudioChannelFlags_SphericalCoordinates;

++         desc.mCoordinates[kAudioChannelCoordinates_Azimuth] = 0.f;

++         desc.mCoordinates[kAudioChannelCoordinates_Elevation] = -20.;

++         desc.mCoordinates[kAudioChannelCoordinates_Distance] = 1.f;

++     }

++     if (channelConfig & QAudioFormat::channelConfig(QAudioFormat::BottomFrontLeft)) {

++         auto &desc = layout->mChannelDescriptions[layout->mNumberChannelDescriptions++];

++         desc.mChannelLabel = kAudioChannelLabel_UseCoordinates;

++         desc.mChannelFlags = kAudioChannelFlags_SphericalCoordinates;

++         desc.mCoordinates[kAudioChannelCoordinates_Azimuth] = -45.f;

++         desc.mCoordinates[kAudioChannelCoordinates_Elevation] = -20.;

++         desc.mCoordinates[kAudioChannelCoordinates_Distance] = 1.f;

++     }

++     if (channelConfig & QAudioFormat::channelConfig(QAudioFormat::BottomFrontRight)) {

++         auto &desc = layout->mChannelDescriptions[layout->mNumberChannelDescriptions++];

++         desc.mChannelLabel = kAudioChannelLabel_UseCoordinates;

++         desc.mChannelFlags = kAudioChannelFlags_SphericalCoordinates;

++         desc.mCoordinates[kAudioChannelCoordinates_Azimuth] = 45.f;

++         desc.mCoordinates[kAudioChannelCoordinates_Elevation] = -20.;

++         desc.mCoordinates[kAudioChannelCoordinates_Distance] = 1.f;

++     }

++

++     return std::unique_ptr<AudioChannelLayout, QFreeDeleter>(layout);

++ }

++

++ static constexpr struct {

++     AudioChannelLayoutTag tag;

++     QAudioFormat::ChannelConfig channelConfig;

++ } layoutTagMap[] = {

++     { kAudioChannelLayoutTag_Mono, QAudioFormat::ChannelConfigMono },

++     { kAudioChannelLayoutTag_Stereo, QAudioFormat::ChannelConfigStereo },

++     { kAudioChannelLayoutTag_StereoHeadphones, QAudioFormat::ChannelConfigStereo },

++     { kAudioChannelLayoutTag_MPEG_1_0, QAudioFormat::ChannelConfigMono },

++     { kAudioChannelLayoutTag_MPEG_2_0, QAudioFormat::ChannelConfigStereo },

++     { kAudioChannelLayoutTag_MPEG_3_0_A, QAudioFormat::channelConfig(QAudioFormat::FrontLeft,

++                                                                      QAudioFormat::FrontRight,

++                                                                      QAudioFormat::FrontCenter) },

++     { kAudioChannelLayoutTag_MPEG_4_0_A, QAudioFormat::channelConfig(QAudioFormat::FrontLeft,

++                                                                      QAudioFormat::FrontRight,

++                                                                      QAudioFormat::FrontCenter,

++                                                                      QAudioFormat::BackCenter) },

++     { kAudioChannelLayoutTag_MPEG_5_0_A, QAudioFormat::ChannelConfigSurround5Dot0 },

++     { kAudioChannelLayoutTag_MPEG_5_1_A, QAudioFormat::ChannelConfigSurround5Dot1 },

++     { kAudioChannelLayoutTag_MPEG_6_1_A, QAudioFormat::channelConfig(QAudioFormat::FrontLeft,

++                                                                      QAudioFormat::FrontRight,

++                                                                      QAudioFormat::FrontCenter,

++                                                                      QAudioFormat::LFE,

++                                                                      QAudioFormat::BackLeft,

++                                                                      QAudioFormat::BackRight,

++                                                                      QAudioFormat::BackCenter) },

++     { kAudioChannelLayoutTag_MPEG_7_1_A, QAudioFormat::ChannelConfigSurround7Dot1 },

++     { kAudioChannelLayoutTag_SMPTE_DTV, QAudioFormat::channelConfig(QAudioFormat::FrontLeft,

++                                                                     QAudioFormat::FrontRight,

++                                                                     QAudioFormat::FrontCenter,

++                                                                     QAudioFormat::LFE,

++                                                                     QAudioFormat::BackLeft,

++                                                                     QAudioFormat::BackRight,

++                                                                     QAudioFormat::TopFrontLeft,

++                                                                     QAudioFormat::TopFrontRight) },

++

++     { kAudioChannelLayoutTag_ITU_2_1, QAudioFormat::ChannelConfig2Dot1 },

++     { kAudioChannelLayoutTag_ITU_2_2, QAudioFormat::channelConfig(QAudioFormat::FrontLeft,

++                                                                   QAudioFormat::FrontRight,

++                                                                   QAudioFormat::BackLeft,

++                                                                   QAudioFormat::BackRight) }

++ };

++

++

++ QAudioFormat::ChannelConfig fromAudioChannelLayout(const AudioChannelLayout *layout)

++ {

++     for (const auto &m : layoutTagMap) {

++         if (m.tag == layout->mChannelLayoutTag)

++             return m.channelConfig;

++     }

++

++     quint32 channels = 0;

++     if (layout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {

++         // special case 1 and 2 channel configs, as they are often reported without proper descriptions

++         if (layout->mNumberChannelDescriptions == 1

++             && (layout->mChannelDescriptions[0].mChannelLabel == kAudioChannelLabel_Unknown

++                 || layout->mChannelDescriptions[0].mChannelLabel == kAudioChannelLabel_Mono))

++             return QAudioFormat::ChannelConfigMono;

++         if (layout->mNumberChannelDescriptions == 2 &&

++             layout->mChannelDescriptions[0].mChannelLabel == kAudioChannelLabel_Unknown &&

++             layout->mChannelDescriptions[1].mChannelLabel == kAudioChannelLabel_Unknown)

++             return QAudioFormat::ChannelConfigStereo;

++

++         for (uint i = 0; i < layout->mNumberChannelDescriptions; ++i) {

++             const auto channelLabel = layout->mChannelDescriptions[i].mChannelLabel;

++             if (channelLabel == kAudioChannelLabel_Unknown) {

++                 // Any number of unknown channel labels occurs for loopback audio devices.

++                 // E.g. the case is reproduced with installed software Soundflower.

++                 continue;

++             }

++

++             const auto found = ranges::find_if(channelMap, [&](const auto &labelWithPos) {

++                 return labelWithPos.label == channelLabel;

++             });

++

++             if (found == std::end(channelMap))

++                 qWarning() << "audio device has unrecognized channel, index:" << i

++                            << "label:" << channelLabel;

++             else

++                 channels |= QAudioFormat::channelConfig(found->pos);

++         }

++     } else {

++         qWarning() << "Channel layout uses unimplemented format, channelLayoutTag:"

++                    << layout->mChannelLayoutTag;

++     }

++     return QAudioFormat::ChannelConfig(channels);

++ }

++

++ std::optional<AudioUnitHandle> makeAudioUnitForIO()

++ {

++     AudioComponentDescription componentDescription;

++     componentDescription.componentType = kAudioUnitType_Output;

++ #if defined(Q_OS_MACOS)

++     componentDescription.componentSubType = kAudioUnitSubType_HALOutput;

++ #else

++     componentDescription.componentSubType = kAudioUnitSubType_RemoteIO;

++ #endif

++     componentDescription.componentManufacturer = kAudioUnitManufacturer_Apple;

++     componentDescription.componentFlags = 0;

++     componentDescription.componentFlagsMask = 0;

++

++     AudioComponent component = AudioComponentFindNext(nullptr, &componentDescription);

++     if (component == nullptr) {

++         qWarning() << "makeAudioUnitForIO: Failed to find Output component";

++         return std::nullopt;

++     }

++

++     AudioUnitHandle audioUnit;

++     if (AudioComponentInstanceNew(component, &audioUnit) != noErr) {

++         qWarning() << "makeAudioUnitForIO: Unable to Open Output Component";

++         return std::nullopt;

++     }

++

++     return audioUnit;

++ }

++

++ bool audioUnitSetInputEnabled(AudioUnitHandle &audioUnit, bool enabled)

++ {

++     UInt32 enable = enabled ? 1 : 0;

++     if (AudioUnitSetProperty(audioUnit.get(), kAudioOutputUnitProperty_EnableIO,

++                              kAudioUnitScope_Input, 1, &enable, sizeof(enable))

++         != noErr) {

++         qWarning() << "AudioUnit: Unable to enable input";

++         return false;

++     }

++     return true;

++ }

++

++ bool audioUnitSetOutputEnabled(AudioUnitHandle &audioUnit, bool enabled)

++ {

++     UInt32 enable = enabled ? 1 : 0;

++     if (AudioUnitSetProperty(audioUnit.get(), kAudioOutputUnitProperty_EnableIO,

++                              kAudioUnitScope_Output, 0, &enable, sizeof(enable))

++         != noErr) {

++         qWarning() << "AudioUnit: Unable to enable output";

++         return false;

++     }

++     return true;

++ }

++

++ #ifdef Q_OS_MACOS

++ bool audioUnitSetCurrentDevice(AudioUnitHandle &audioUnit, AudioObjectID deviceID)

++ {

++     if (AudioUnitSetProperty(audioUnit.get(), kAudioOutputUnitProperty_CurrentDevice,

++                              kAudioUnitScope_Global, 0, &deviceID, sizeof(deviceID))

++         != noErr) {

++         qWarning() << "AudioUnit: Unable to use set device ID";

++         return false;

++     }

++

++     return true;

++ }

++ #endif

++

++ bool audioUnitSetInputStreamFormat(AudioUnitHandle &audioUnit, AudioUnitElement element,

++                                    const AudioStreamBasicDescription &format)

++ {

++     OSStatus status = AudioUnitSetProperty(audioUnit.get(), kAudioUnitProperty_StreamFormat,

++                                            kAudioUnitScope_Input, element, &format, sizeof(format));

++     if (status != noErr) {

++         qWarning() << "AudioUnit: Unable to set stream format" << QtMultimediaPrivate::QOSStatus(status);

++         return false;

++     }

++     return true;

++ }

++

++ bool audioUnitSetOutputStreamFormat(AudioUnitHandle &audioUnit, AudioUnitElement element,

++                                     const AudioStreamBasicDescription &format)

++ {

++     if (AudioUnitSetProperty(audioUnit.get(), kAudioUnitProperty_StreamFormat,

++                              kAudioUnitScope_Output, element, &format, sizeof(format))

++         != noErr) {

++         qWarning() << "AudioUnit: Unable to set stream format";

++         return false;

++     }

++     return true;

++ }

++

++ #ifdef Q_OS_MACOS

++ std::optional<int> audioUnitGetFramesPerBuffer(AudioUnitHandle &audioUnit)

++ {

++     int numberOfFrames;

++     UInt32 size = sizeof(UInt32);

++     if (AudioUnitGetProperty(audioUnit.get(), kAudioDevicePropertyBufferFrameSize,

++                              kAudioUnitScope_Global, 0, &numberOfFrames, &size)

++         == noErr) {

++         return numberOfFrames;

++     }

++

++     qWarning() << "audioUnitGetFramesPerBuffer: Failed to get audio period size";

++

++     AudioValueRange bufferRange;

++     size = sizeof(AudioValueRange);

++     if (AudioUnitGetProperty(audioUnit.get(), kAudioDevicePropertyBufferFrameSizeRange,

++                              kAudioUnitScope_Global, 0, &bufferRange, &size)

++         == noErr) {

++         return int(bufferRange.mMaximum);

++     }

++

++     return std::nullopt;

++ }

++

++ bool audioObjectSetSamplingRate(AudioObjectID id, int samplingRate)

++ {

++     constexpr AudioObjectPropertyAddress sampleRateAddress = {

++         kAudioDevicePropertyNominalSampleRate,

++         kAudioObjectPropertyScopeGlobal,

++         kAudioObjectPropertyElementMain,

++     };

++

++     Float64 sampleRateArg(samplingRate);

++

++     OSStatus status = AudioObjectSetPropertyData(id, &sampleRateAddress, 0, nullptr,

++                                                  sizeof(Float64), &sampleRateArg);

++

++     if (status != noErr) {

++         qDebug() << "AudioObjectSetPropertyData failed" << QtMultimediaPrivate::QOSStatus(status);

++         return false;

++     }

++

++     return true;

++ }

++

++ std::optional<int> audioObjectGetSamplingRate(AudioObjectID id)

++ {

++     constexpr AudioObjectPropertyAddress sampleRateAddress = {

++         kAudioDevicePropertyNominalSampleRate,

++         kAudioObjectPropertyScopeGlobal,

++         kAudioObjectPropertyElementMain,

++     };

++

++     Float64 rate;

++     uint32_t size = sizeof(Float64);

++     OSStatus status = AudioObjectGetPropertyData(id, &sampleRateAddress, 0, nullptr, &size, &rate);

++

++     if (status != noErr) {

++         qDebug() << "AudioObjectGetPropertyData failed" << status;

++         return {};

++     }

++

++     return int(rate);

++ }

++

++ std::optional<int> audioObjectFindBestNominalSampleRate(AudioObjectID id, QAudioDevice::Mode mode,

++                                                         int rate)

++ {

++     auto optionalAvailableRates = getAudioPropertyList<Float64>(

++             id, makePropertyAddress(kAudioDevicePropertyAvailableNominalSampleRates, mode));

++     if (!optionalAvailableRates)

++         return std::nullopt;

++

++     using namespace QtMultimediaPrivate;

++     return findClosestSamplingRate(rate,

++                                    QSpan<const double>{

++                                            *optionalAvailableRates,

++                                    });

++ }

++

++ bool audioObjectSetFramesPerBuffer(AudioObjectID id, int32_t bufferFrames)

++ {

++     constexpr AudioObjectPropertyAddress bufferFrameSizeAddress = {

++         kAudioDevicePropertyBufferFrameSize,

++         kAudioObjectPropertyScopeGlobal,

++         kAudioObjectPropertyElementMain,

++     };

++

++     OSStatus status = AudioObjectSetPropertyData(id, &bufferFrameSizeAddress, 0, nullptr,

++                                                  sizeof(int32_t), &bufferFrames);

++

++     if (status != noErr) {

++         qDebug() << "AudioObjectSetPropertyData failed" << QtMultimediaPrivate::QOSStatus(status);

++         return false;

++     }

++

++     return true;

++ }

++

++ #endif

++

++ bool audioUnitIsRunning(AudioUnitHandle &audioUnit)

++ {

++     UInt32 isRunning = 0;

++     UInt32 size = sizeof(isRunning);

++

++     OSStatus status = AudioUnitGetProperty(audioUnit.get(), kAudioOutputUnitProperty_IsRunning,

++                                            kAudioUnitScope_Global, 0, &isRunning, &size);

++

++     if (status != noErr) {

++         qDebug() << "AudioUnitGetProperty failed" << QtMultimediaPrivate::QOSStatus(status);

++         return false;

++     }

++

++     return bool(isRunning);

++ }

++

++ bool audioUnitSetRenderCallback(AudioUnitHandle &audioUnit, AURenderCallbackStruct &callback)

++ {

++     OSStatus status = AudioUnitSetProperty(audioUnit.get(), kAudioUnitProperty_SetRenderCallback,

++                                            kAudioUnitScope_Global, 0, &callback, sizeof(callback));

++

++     if (status != noErr) {

++         qWarning() << "AudioUnitSetProperty: Failed to set AudioUnit "

++                       "kAudioUnitProperty_SetRenderCallback"

++                     << QtMultimediaPrivate::QOSStatus(status);

++         return false;

++     }

++     return true;

++ }

++

++ std::optional<int> audioUnitGetFramesPerSlice(AudioUnitHandle &audioUnit)

++ {

++     int numberOfFrames;

++     UInt32 size = sizeof(UInt32);

++     if (AudioUnitGetProperty(audioUnit.get(), kAudioUnitProperty_MaximumFramesPerSlice,

++                              kAudioUnitScope_Global, 0, &numberOfFrames, &size)

++         == noErr) {

++         return numberOfFrames;

++     }

++

++     return std::nullopt;

++ }

++

++ std::optional<AudioStreamBasicDescription> audioUnitGetInputStreamFormat(AudioUnitHandle &audioUnit,

++                                                                          AudioUnitElement element)

++ {

++     AudioStreamBasicDescription ret;

++     UInt32 size = sizeof(AudioStreamBasicDescription);

++

++     if (AudioUnitGetProperty(audioUnit.get(), kAudioUnitProperty_StreamFormat,

++                              kAudioUnitScope_Input, element, &ret, &size)

++         != noErr) {

++         qWarning() << "QAudioSource: Unable to retrieve device format";

++         return std::nullopt;

++     }

++

++     return ret;

++ }

++

++ AudioUnitHandle::~AudioUnitHandle()

++ {

++     deinitialize();

++ }

++

++ bool AudioUnitHandle::initialize()

++ {

++     Q_ASSERT(!m_initialized);

++     if (AudioUnitInitialize(get())) {

++         qWarning() << "AudioUnitHandle: Failed to initialize AudioUnit";

++         return false;

++     }

++     m_initialized = true;

++     return true;

++ }

++

++ void AudioUnitHandle::deinitialize()

++ {

++     if (m_initialized)

++         AudioUnitUninitialize(get());

++

++     m_initialized = false;

++ }

++

++ } // namespace QCoreAudioUtils

++

++ QT_END_NAMESPACE

Revision control