自学教程：C++ AudioObjectSetPropertyData函数代码示例

bool CCoreAudioDevice::SetHogStatus(bool hog){  // According to Jeff Moore (Core Audio, Apple), Setting kAudioDevicePropertyHogMode  // is a toggle and the only way to tell if you do get hog mode is to compare  // the returned pid against getpid, if the match, you have hog mode, if not you don't.  if (!m_DeviceId)    return false;  AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyHogMode;  if (hog)  {    // Not already set    if (m_HogPid == -1)    {      CLog::Log(LOGDEBUG, "CCoreAudioDevice::SetHogStatus: "        "Setting 'hog' status on device 0x%04x", (unsigned int)m_DeviceId);      OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, sizeof(m_HogPid), &m_HogPid);      // even if setting hogmode was successfull our PID might not get written      // into m_HogPid (so it stays -1). Readback hogstatus for judging if we      // had success on getting hog status      m_HogPid = GetHogStatus();      if (ret || m_HogPid != getpid())      {        CLog::Log(LOGERROR, "CCoreAudioDevice::SetHogStatus: "          "Unable to set 'hog' status. Error = %s", GetError(ret).c_str());        return false;      }      CLog::Log(LOGDEBUG, "CCoreAudioDevice::SetHogStatus: "                "Successfully set 'hog' status on device 0x%04x", (unsigned int)m_DeviceId);    }  }  else  {    // Currently Set    if (m_HogPid > -1)    {      CLog::Log(LOGDEBUG, "CCoreAudioDevice::SetHogStatus: "                "Releasing 'hog' status on device 0x%04x", (unsigned int)m_DeviceId);      pid_t hogPid = -1;      OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, sizeof(hogPid), &hogPid);      if (ret || hogPid == getpid())      {        CLog::Log(LOGERROR, "CCoreAudioDevice::SetHogStatus: "          "Unable to release 'hog' status. Error = %s", GetError(ret).c_str());        return false;      }      // Reset internal state      m_HogPid = hogPid;    }  }  return true;}

bool CCoreAudioDevice::SetHogStatus(bool hog){  // According to Jeff Moore (Core Audio, Apple), Setting kAudioDevicePropertyHogMode  // is a toggle and the only way to tell if you do get hog mode is to compare  // the returned pid against getpid, if the match, you have hog mode, if not you don't.  if (!m_DeviceId)    return false;  AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyHogMode;  if (hog)  {    // Not already set    if (m_HogPid == -1)    {      OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, sizeof(m_HogPid), &m_HogPid);      // even if setting hogmode was successfull our PID might not get written      // into m_HogPid (so it stays -1). Readback hogstatus for judging if we      // had success on getting hog status      // We do this only when AudioObjectSetPropertyData didn't set m_HogPid because      // it seems that in the other cases the GetHogStatus could return -1      // which would overwrite our valid m_HogPid again      // Man we should never touch this shit again ;)      if (m_HogPid == -1)        m_HogPid = GetHogStatus();      if (ret || m_HogPid != getpid())      {        CLog::Log(LOGERROR, "CCoreAudioDevice::SetHogStatus: "          "Unable to set 'hog' status. Error = %s", GetError(ret).c_str());        return false;      }    }  }  else  {    // Currently Set    if (m_HogPid > -1)    {      pid_t hogPid = -1;      OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, sizeof(hogPid), &hogPid);      if (ret || hogPid == getpid())      {        CLog::Log(LOGERROR, "CCoreAudioDevice::SetHogStatus: "          "Unable to release 'hog' status. Error = %s", GetError(ret).c_str());        return false;      }      // Reset internal state      m_HogPid = hogPid;    }  }  return true;}

void AudioSession::setPreferredBufferSize(size_t bufferSize){    AudioValueRange bufferSizeRange = {0, 0};    UInt32 bufferSizeRangeSize = sizeof(AudioValueRange);    AudioObjectPropertyAddress bufferSizeRangeAddress = {        kAudioDevicePropertyBufferFrameSizeRange,        kAudioObjectPropertyScopeGlobal,        kAudioObjectPropertyElementMaster    };    OSStatus result = AudioObjectGetPropertyData(defaultDevice(), &bufferSizeRangeAddress, 0, 0, &bufferSizeRangeSize, &bufferSizeRange);    if (result)        return;    size_t minBufferSize = static_cast<size_t>(bufferSizeRange.mMinimum);    size_t maxBufferSize = static_cast<size_t>(bufferSizeRange.mMaximum);    UInt32 bufferSizeOut = std::min(maxBufferSize, std::max(minBufferSize, bufferSize));    AudioObjectPropertyAddress preferredBufferSizeAddress = {        kAudioDevicePropertyBufferFrameSize,        kAudioObjectPropertyScopeGlobal,        kAudioObjectPropertyElementMaster };    result = AudioObjectSetPropertyData(defaultDevice(), &preferredBufferSizeAddress, 0, 0, sizeof(bufferSizeOut), (void*)&bufferSizeOut);#if LOG_DISABLED    UNUSED_PARAM(result);#else    if (result)        LOG(Media, "AudioSession::setPreferredBufferSize(%zu) - failed with error %d", bufferSize, static_cast<int>(result));    else        LOG(Media, "AudioSession::setPreferredBufferSize(%zu)", bufferSize);#endif}

bool CCoreAudioDevice::SetBufferSize(UInt32 size){  if (!m_DeviceId)    return false;  AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyBufferFrameSize;  UInt32 propertySize = sizeof(size);  OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, propertySize, &size);  if (ret != noErr)  {    CLog::Log(LOGERROR, "CCoreAudioDevice::SetBufferSize: "      "Unable to set buffer size. Error = %s", GetError(ret).c_str());  }  if (GetBufferSize() != size)    CLog::Log(LOGERROR, "CCoreAudioDevice::SetBufferSize: Buffer size change not applied.");  else    CLog::Log(LOGDEBUG, "CCoreAudioDevice::SetBufferSize: Set buffer size to %d", (int)size);  return (ret == noErr);}

bool CCoreAudioDevice::SetNominalSampleRate(Float64 sampleRate){  if (!m_DeviceId || sampleRate == 0.0f)    return false;  Float64 currentRate = GetNominalSampleRate();  if (currentRate == sampleRate)    return true; //No need to change  AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyNominalSampleRate;  OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, sizeof(Float64), &sampleRate);  if (ret != noErr)  {    CLog::Log(LOGERROR, "CCoreAudioDevice::SetNominalSampleRate: "      "Unable to set current device sample rate to %0.0f. Error = %s",      (float)sampleRate, GetError(ret).c_str());    return false;  }  if (m_SampleRateRestore == 0.0f)    m_SampleRateRestore = currentRate;  return true;}

void add_audio_status_listener(audio_status_callback_t function, ptr_t data){    OSStatus result;    CFRunLoopRef theRunLoop;    closure_t closure;    AudioObjectPropertyAddress runLoop = {        .mSelector = kAudioHardwarePropertyRunLoop,        .mScope    = kAudioObjectPropertyScopeGlobal,        .mElement  = kAudioObjectPropertyElementMaster    };    AudioObjectPropertyAddress devices = {        .mSelector = kAudioHardwarePropertyDevices,        .mScope    = kAudioObjectPropertyScopeGlobal,        .mElement  = kAudioObjectPropertyElementMaster    };    theRunLoop = NULL; // necessary?    result = AudioObjectSetPropertyData(kAudioObjectSystemObject, &runLoop, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);    assert(result == noErr);    closure = new_closure(function, data);    result = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &devices, audio_listener, closure);    assert(result == noErr);}

void mozilla_set_coreaudio_notification_runloop_if_needed(){  mozilla::StaticMutexAutoLock lock(gMutex);  if (gRunLoopSet) {    return;  }  /* This is needed so that AudioUnit listeners get called on this thread, and   * not the main thread. If we don't do that, they are not called, or a crash   * occur, depending on the OSX version. */  AudioObjectPropertyAddress runloop_address = {    kAudioHardwarePropertyRunLoop,    kAudioObjectPropertyScopeGlobal,    kAudioObjectPropertyElementMaster  };  CFRunLoopRef run_loop = nullptr;  OSStatus r;  r = AudioObjectSetPropertyData(kAudioObjectSystemObject,                                 &runloop_address,                                 0, NULL, sizeof(CFRunLoopRef), &run_loop);  if (r != noErr) {    NS_WARNING("Could not make global CoreAudio notifications use their own thread.");  }  gRunLoopSet = true;}

OSStatus AudioDevice::SetBufferSize(UInt32 buffersize) {  OSStatus err = noErr;  UInt32 size = sizeof(UInt32);  AudioObjectPropertyAddress addr = { kAudioDevicePropertyBufferFrameSize, (mIsInput ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput), 0 };  err = AudioObjectSetPropertyData(mID, &addr, 0, NULL, size, &buffersize);  AudioObjectGetPropertyData(mID, &addr, 0, NULL, &size, &mBufferSizeFrames);  if(mBufferSizeFrames != buffersize) printf("buffer size mismatch!");  return err;}

OSStatus AudioOutputSetVolume(AudioDeviceID device, Float32 left, Float32 right) {  OSStatus err = AudioObjectSetPropertyData(device, &kAudioOutputVolumeProperty, 0, NULL, (UInt32)sizeof(left), &left);  if (kAudioHardwareUnknownPropertyError == err) {    UInt32 channels[2];    err = AudioOutputGetStereoChannels(device, &channels[0], &channels[1]);    if (noErr == err) err = AudioDeviceSetProperty(device, NULL, channels[0], FALSE, kAudioDevicePropertyVolumeScalar, (UInt32)sizeof(Float32), &left);    if (noErr == err) err = AudioDeviceSetProperty(device, NULL, channels[1], FALSE, kAudioDevicePropertyVolumeScalar, (UInt32)sizeof(Float32), &right);  }  return err;}

static OSStatus SetAudioProperty(AudioObjectID id,                                 AudioObjectPropertySelector selector,                                 UInt32 inDataSize, void *inData){    AudioObjectPropertyAddress property_address;    property_address.mSelector = selector;    property_address.mScope    = kAudioObjectPropertyScopeGlobal;    property_address.mElement  = kAudioObjectPropertyElementMaster;    return AudioObjectSetPropertyData(id, &property_address, 0, NULL, inDataSize, inData);}

static BOOL MIX_LineSetMute(DWORD lineID, BOOL mute){    MixerLine *line = &mixer.lines[lineID];    UInt32 val = mute;    UInt32 size = sizeof(UInt32);    AudioObjectPropertyAddress address;    OSStatus err = noErr;    address.mSelector = kAudioDevicePropertyMute;    address.mScope = IsInput(line->direction) ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;    address.mElement = 0;    err = AudioObjectSetPropertyData(line->deviceID, &address, 0, 0, size, &val);    return (err == noErr);}

void CCoreAudioHardware::SetAutoHogMode(bool enable){  AudioObjectPropertyAddress propertyAddress;   propertyAddress.mScope    = kAudioObjectPropertyScopeGlobal;   propertyAddress.mElement  = kAudioObjectPropertyElementMaster;  propertyAddress.mSelector = kAudioHardwarePropertyHogModeIsAllowed;   UInt32 val = enable ? 1 : 0;  UInt32 size = sizeof(val);  OSStatus ret = AudioObjectSetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, size, &val);   if (ret != noErr)    CLog::Log(LOGERROR, "CCoreAudioHardware::SetAutoHogMode: "      "Unable to set auto 'hog' mode. Error = %s", GetError(ret).c_str());}

/* * Setters */static BOOL MIX_LineSetVolume(DWORD lineID, DWORD channels, Float32 left, Float32 right){    MixerLine *line = &mixer.lines[lineID];    UInt32 size = sizeof(Float32);    AudioObjectPropertyAddress address;    OSStatus err = noErr;    TRACE("lineID %d channels %d left %f right %f/n", lineID, channels, left, right);    address.mSelector = kAudioDevicePropertyVolumeScalar;    address.mScope = IsInput(line->direction) ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;    if (channels == 2)    {        address.mElement = 1;        err = AudioObjectSetPropertyData(line->deviceID, &address, 0, NULL, size, &left);        if (err != noErr)            return FALSE;        address.mElement = 2;        err = AudioObjectSetPropertyData(line->deviceID, &address, 0, NULL, size, &right);    }    else    {        /*            FIXME Using master channel failed ?? return kAudioHardwareUnknownPropertyError            address.mElement = 0;            err = AudioObjectSetPropertyData(line->deviceID, &address, 0, NULL, size, &left);        */        right = left;        address.mElement = 1;        err = AudioObjectSetPropertyData(line->deviceID, &address, 0, NULL, size, &left);        if (err != noErr)            return FALSE;        address.mElement = 2;        err = AudioObjectSetPropertyData(line->deviceID, &address, 0, NULL, size, &right);    }    return (err == noErr);}

void	AudioDevice::SetBufferSize(UInt32 size){        UInt32 propsize = sizeof(UInt32);            AudioObjectPropertyScope theScope = mIsInput ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;        AudioObjectPropertyAddress theAddress = { kAudioDevicePropertyBufferFrameSize,                                              theScope,                                              0 }; // channel                                                  verify_noerr(AudioObjectSetPropertyData(mID, &theAddress, 0, NULL, propsize, &size));        verify_noerr(AudioObjectGetPropertyData(mID, &theAddress, 0, NULL, &propsize, &mBufferSizeFrames));}

static inline gboolean_audio_device_set_mixing (AudioDeviceID device_id, gboolean enable_mix){  OSStatus status = noErr;  UInt32 propertySize = 0, can_mix = enable_mix;  Boolean writable = FALSE;  gboolean res = FALSE;  AudioObjectPropertyAddress audioDeviceSupportsMixingAddress = {    kAudioDevicePropertySupportsMixing,    kAudioObjectPropertyScopeGlobal,    kAudioObjectPropertyElementMaster  };  if (AudioObjectHasProperty (device_id, &audioDeviceSupportsMixingAddress)) {    /* Set mixable to false if we are allowed to */    status = AudioObjectIsPropertySettable (device_id,        &audioDeviceSupportsMixingAddress, &writable);    if (status) {      GST_DEBUG ("AudioObjectIsPropertySettable: %d", (int) status);    }    status = AudioObjectGetPropertyDataSize (device_id,        &audioDeviceSupportsMixingAddress, 0, NULL, &propertySize);    if (status) {      GST_DEBUG ("AudioObjectGetPropertyDataSize: %d", (int) status);    }    status = AudioObjectGetPropertyData (device_id,        &audioDeviceSupportsMixingAddress, 0, NULL, &propertySize, &can_mix);    if (status) {      GST_DEBUG ("AudioObjectGetPropertyData: %d", (int) status);    }    if (status == noErr && writable) {      can_mix = enable_mix;      status = AudioObjectSetPropertyData (device_id,          &audioDeviceSupportsMixingAddress, 0, NULL, propertySize, &can_mix);      res = TRUE;    }    if (status != noErr) {      GST_ERROR ("failed to set mixmode: %d", (int) status);    }  } else {    GST_DEBUG ("property not found, mixing coudln't be changed");  }  return res;}

static OSStatus coreaudio_set_framesize(AudioDeviceID id, UInt32 *framesize){    UInt32 size = sizeof(*framesize);    AudioObjectPropertyAddress addr = {        kAudioDevicePropertyBufferFrameSize,        kAudioDevicePropertyScopeOutput,        kAudioObjectPropertyElementMaster    };    return AudioObjectSetPropertyData(id,                                      &addr,                                      0,                                      NULL,                                      size,                                      framesize);}

static intcoreaudio_plugin_start (void) {		// This is a largely undocumented but absolutely necessary	// requirement starting with OS-X 10.6.  If not called, queries and	// updates to various audio device properties are not handled	// correctly.	// Many thanks to the rtaudio project for documenting this.	CFRunLoopRef theRunLoop = NULL;	AudioObjectPropertyAddress property = { kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };	OSStatus err = AudioObjectSetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);	if (err) { trace ("AudioObjectSetPropertyData-plugin_start= %s/n", GetMacOSStatusErrorString(err) ); return -1; }	au_state = 0;		return 0;}

static OSStatus coreaudio_set_streamformat(AudioDeviceID id,                                           AudioStreamBasicDescription *d){    UInt32 size = sizeof(*d);    AudioObjectPropertyAddress addr = {        kAudioDevicePropertyStreamFormat,        kAudioDevicePropertyScopeOutput,        kAudioObjectPropertyElementMaster    };    return AudioObjectSetPropertyData(id,                                      &addr,                                      0,                                      NULL,                                      size,                                      d);}

bool CCoreAudioDevice::SetDataSource(UInt32 &dataSourceId){  bool ret = false;    if (!m_DeviceId)    return false;    AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyDataSource;    UInt32 size = sizeof(dataSourceId);  OSStatus status = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, size, &dataSourceId);  if(status == noErr)    ret = true;    return ret;}

    void setCurrentSourceIndex (int index, bool input)    {        if (deviceID != 0)        {            HeapBlock <OSType> types;            const int num = getAllDataSourcesForDevice (deviceID, types);            if (isPositiveAndBelow (index, num))            {                AudioObjectPropertyAddress pa;                pa.mSelector = kAudioDevicePropertyDataSource;                pa.mScope = input ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;                pa.mElement = kAudioObjectPropertyElementMaster;                OSType typeId = types[index];                OK (AudioObjectSetPropertyData (deviceID, &pa, 0, 0, sizeof (typeId), &typeId));            }        }    }

static void coreaudio_set_channel_position(AudioDeviceID dev_id,					    int channels,					    const channel_position_t *map){	AudioObjectPropertyAddress aopa = {		kAudioDevicePropertyPreferredChannelLayout,		kAudioObjectPropertyScopeOutput,		kAudioObjectPropertyElementMaster	};	AudioChannelLayout *layout = NULL;	size_t layout_size = (size_t) &layout->mChannelDescriptions[channels];	layout = (AudioChannelLayout*)malloc(layout_size);	layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions ;	layout->mChannelBitmap = 0;	layout->mNumberChannelDescriptions = channels;	AudioChannelDescription *descriptions = layout->mChannelDescriptions;	for (int i = 0; i < channels; i++) {		const channel_position_t pos = map[i];		AudioChannelLabel label = kAudioChannelLabel_Mono;		for (int j = 0; j < N_ELEMENTS(coreaudio_channel_mapping); j++) {			if (pos == coreaudio_channel_mapping[j].pos) {				label = coreaudio_channel_mapping[j].label;				break;			}		}		descriptions[channels - 1 - i].mChannelLabel = label;		descriptions[i].mChannelFlags = kAudioChannelFlags_AllOff;		descriptions[i].mCoordinates[0] = 0;		descriptions[i].mCoordinates[1] = 0;		descriptions[i].mCoordinates[2] = 0;	}	OSStatus err =		AudioObjectSetPropertyData(dev_id,				&aopa,			 0, NULL, layout_size, layout);	if (err != noErr)		d_print("Cannot set the channel layout successfully./n");	free(layout);}

static inline gboolean_audio_stream_set_current_format (AudioStreamID stream_id,    AudioStreamBasicDescription format){  OSStatus status = noErr;  UInt32 propertySize = sizeof (AudioStreamBasicDescription);  AudioObjectPropertyAddress formatAddress = {    kAudioStreamPropertyPhysicalFormat,    kAudioObjectPropertyScopeGlobal,    kAudioObjectPropertyElementMaster  };  status = AudioObjectSetPropertyData (stream_id,      &formatAddress, 0, NULL, propertySize, &format);  if (status != noErr) {    GST_ERROR ("failed to set current format: %d", (int) status);    return FALSE;  }  return TRUE;}

CCoreAudioAEHALOSX::CCoreAudioAEHALOSX() :  m_audioGraph        (NULL   ),  m_Initialized       (false  ),  m_Passthrough       (false  ),  m_allowMixing       (false  ),  m_encoded           (false  ),  m_initVolume        (1.0f   ),  m_NumLatencyFrames  (0      ),  m_OutputBufferIndex (0      ),  m_ae                (NULL   ){  m_AudioDevice   = new CCoreAudioDevice();  m_OutputStream  = new CCoreAudioStream();  SInt32 major, minor;  Gestalt(gestaltSystemVersionMajor, &major);  Gestalt(gestaltSystemVersionMinor, &minor);  // By default, kAudioHardwarePropertyRunLoop points at the process's main thread on SnowLeopard,  // If your process lacks such a run loop, you can set kAudioHardwarePropertyRunLoop to NULL which  // tells the HAL to run it's own thread for notifications (which was the default prior to SnowLeopard).  // So tell the HAL to use its own thread for similar behavior under all supported versions of OSX.  if (major == 10 && minor >= 6)  {    CFRunLoopRef theRunLoop = NULL;    AudioObjectPropertyAddress theAddress = {      kAudioHardwarePropertyRunLoop,      kAudioObjectPropertyScopeGlobal,      kAudioObjectPropertyElementMaster    };    OSStatus theError = AudioObjectSetPropertyData(kAudioObjectSystemObject,      &theAddress, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);    if (theError != noErr)    {      CLog::Log(LOGERROR, "CCoreAudioAE::constructor: kAudioHardwarePropertyRunLoop error.");    }  }}

static inline gboolean_audio_system_set_runloop (CFRunLoopRef runLoop){  OSStatus status = noErr;  gboolean res = FALSE;  AudioObjectPropertyAddress runloopAddress = {    kAudioHardwarePropertyRunLoop,    kAudioObjectPropertyScopeGlobal,    kAudioObjectPropertyElementMaster  };  status = AudioObjectSetPropertyData (kAudioObjectSystemObject,      &runloopAddress, 0, NULL, sizeof (CFRunLoopRef), &runLoop);  if (status == noErr) {    res = TRUE;  } else {    GST_ERROR ("failed to set runloop to %p: %d", runLoop, (int) status);  }  return res;}

audio::orchestra::api::Core::Core() :  m_private(new audio::orchestra::api::CorePrivate()) {#if defined(AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER)	// This is a largely undocumented but absolutely necessary	// requirement starting with OS-X 10.6.	If not called, queries and	// updates to various audio device properties are not handled	// correctly.	CFRunLoopRef theRunLoop = nullptr;	AudioObjectPropertyAddress property = {		kAudioHardwarePropertyRunLoop,		kAudioObjectPropertyScopeGlobal,		kAudioObjectPropertyElementMaster	};	OSStatus result = AudioObjectSetPropertyData(kAudioObjectSystemObject,	                                             &property,	                                             0,	                                             nullptr,	                                             sizeof(CFRunLoopRef),	                                             &theRunLoop);	if (result != noErr) {		ATA_ERROR("error setting run loop property!");	}#endif}

static inline gboolean_audio_device_set_hog (AudioDeviceID device_id, pid_t hog_pid){  OSStatus status = noErr;  UInt32 propertySize = sizeof (hog_pid);  gboolean res = FALSE;  AudioObjectPropertyAddress audioDeviceHogModeAddress = {    kAudioDevicePropertyHogMode,    kAudioDevicePropertyScopeOutput,    kAudioObjectPropertyElementMaster  };  status = AudioObjectSetPropertyData (device_id,      &audioDeviceHogModeAddress, 0, NULL, propertySize, &hog_pid);  if (status == noErr) {    res = TRUE;  } else {    GST_ERROR ("failed to set hog: %d", (int) status);  }  return res;}