/*
 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "webrtc/modules/audio_device/mac/audio_mixer_manager_mac.h"
#include "webrtc/system_wrappers/include/trace.h"

#include <unistd.h>             // getpid()

namespace webrtc {
	
#define WEBRTC_CA_RETURN_ON_ERR(expr)                                     \
    do {                                                                \
        err = expr;                                                     \
        if (err != noErr) {                                             \
            logCAMsg(kTraceError, kTraceAudioDevice, _id,    \
                "Error in " #expr, (const char *)&err);                 \
            return -1;                                                  \
        }                                                               \
    } while(0)

#define WEBRTC_CA_LOG_ERR(expr)                                           \
    do {                                                                \
        err = expr;                                                     \
        if (err != noErr) {                                             \
            logCAMsg(kTraceError, kTraceAudioDevice, _id,    \
                "Error in " #expr, (const char *)&err);                 \
        }                                                               \
    } while(0)

#define WEBRTC_CA_LOG_WARN(expr)                                           \
    do {                                                                 \
        err = expr;                                                      \
        if (err != noErr) {                                              \
            logCAMsg(kTraceWarning, kTraceAudioDevice, _id,  \
                "Error in " #expr, (const char *)&err);                  \
        }                                                                \
    } while(0)

AudioMixerManagerMac::AudioMixerManagerMac(const int32_t id) :
    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
    _id(id),
    _inputDeviceID(kAudioObjectUnknown),
    _outputDeviceID(kAudioObjectUnknown),
    _noInputChannels(0),
    _noOutputChannels(0)
{
    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                 "%s constructed", __FUNCTION__);
}

AudioMixerManagerMac::~AudioMixerManagerMac()
{
    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                 "%s destructed", __FUNCTION__);

    Close();

    delete &_critSect;
}

// ============================================================================
//	                                PUBLIC METHODS
// ============================================================================

int32_t AudioMixerManagerMac::Close()
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                 __FUNCTION__);

    CriticalSectionScoped lock(&_critSect);

    CloseSpeaker();
    CloseMicrophone();

    return 0;

}

int32_t AudioMixerManagerMac::CloseSpeaker()
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                 __FUNCTION__);

    CriticalSectionScoped lock(&_critSect);

    _outputDeviceID = kAudioObjectUnknown;
    _noOutputChannels = 0;

    return 0;
}

int32_t AudioMixerManagerMac::CloseMicrophone()
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                 __FUNCTION__);

    CriticalSectionScoped lock(&_critSect);

    _inputDeviceID = kAudioObjectUnknown;
    _noInputChannels = 0;

    return 0;
}

int32_t AudioMixerManagerMac::OpenSpeaker(AudioDeviceID deviceID)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::OpenSpeaker(id=%d)", deviceID);

    CriticalSectionScoped lock(&_critSect);

    OSStatus err = noErr;
    UInt32 size = 0;
    pid_t hogPid = -1;

    _outputDeviceID = deviceID;

    // Check which process, if any, has hogged the device. 
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyHogMode,
            kAudioDevicePropertyScopeOutput, 0 };

    size = sizeof(hogPid);
    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
            &propertyAddress, 0, NULL, &size, &hogPid));

    if (hogPid == -1)
    {
        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                     " No process has hogged the input device");
    }
    // getpid() is apparently "always successful"
    else if (hogPid == getpid())
    {
        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                     " Our process has hogged the input device");
    } else
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Another process (pid = %d) has hogged the input device",
                     static_cast<int> (hogPid));

        return -1;
    }

    // get number of channels from stream format
    propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;

    // Get the stream format, to be able to read the number of channels.
    AudioStreamBasicDescription streamFormat;
    size = sizeof(AudioStreamBasicDescription);
    memset(&streamFormat, 0, size);
    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
            &propertyAddress, 0, NULL, &size, &streamFormat));

    _noOutputChannels = streamFormat.mChannelsPerFrame;

    return 0;
}

int32_t AudioMixerManagerMac::OpenMicrophone(AudioDeviceID deviceID)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::OpenMicrophone(id=%d)", deviceID);

    CriticalSectionScoped lock(&_critSect);

    OSStatus err = noErr;
    UInt32 size = 0;
    pid_t hogPid = -1;

    _inputDeviceID = deviceID;

    // Check which process, if any, has hogged the device. 
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyHogMode,
            kAudioDevicePropertyScopeInput, 0 };
    size = sizeof(hogPid);
    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
            &propertyAddress, 0, NULL, &size, &hogPid));
    if (hogPid == -1)
    {
        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                     " No process has hogged the input device");
    }
    // getpid() is apparently "always successful"
    else if (hogPid == getpid())
    {
        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                     " Our process has hogged the input device");
    } else
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Another process (pid = %d) has hogged the input device",
                     static_cast<int> (hogPid));

        return -1;
    }

    // get number of channels from stream format
    propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;

    // Get the stream format, to be able to read the number of channels.
    AudioStreamBasicDescription streamFormat;
    size = sizeof(AudioStreamBasicDescription);
    memset(&streamFormat, 0, size);
    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
            &propertyAddress, 0, NULL, &size, &streamFormat));

    _noInputChannels = streamFormat.mChannelsPerFrame;

    return 0;
}

bool AudioMixerManagerMac::SpeakerIsInitialized() const
{
    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s",
                 __FUNCTION__);

    return (_outputDeviceID != kAudioObjectUnknown);
}

bool AudioMixerManagerMac::MicrophoneIsInitialized() const
{
    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s",
                 __FUNCTION__);

    return (_inputDeviceID != kAudioObjectUnknown);
}

int32_t AudioMixerManagerMac::SetSpeakerVolume(uint32_t volume)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::SetSpeakerVolume(volume=%u)", volume);

    CriticalSectionScoped lock(&_critSect);

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    bool success = false;

    // volume range is 0.0 - 1.0, convert from 0 -255
    const Float32 vol = (Float32)(volume / 255.0);

    assert(vol <= 1.0 && vol >= 0.0);

    // Does the capture device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = {
            kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeOutput,
            0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        size = sizeof(vol);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_outputDeviceID,
                &propertyAddress, 0, NULL, size, &vol));

        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noOutputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err == noErr && isSettable)
        {
            size = sizeof(vol);
            WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_outputDeviceID,
                    &propertyAddress, 0, NULL, size, &vol));
        }
        success = true;
    }

    if (!success)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Unable to set a volume on any output channel");
        return -1;
    }

    return 0;
}

int32_t AudioMixerManagerMac::SpeakerVolume(uint32_t& volume) const
{

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    unsigned int channels = 0;
    Float32 channelVol = 0;
    Float32 vol = 0;

    // Does the device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = {
            kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeOutput,
            0 };
    Boolean hasProperty = AudioObjectHasProperty(_outputDeviceID,
                                                 &propertyAddress);
    if (hasProperty)
    {
        size = sizeof(vol);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
                &propertyAddress, 0, NULL, &size, &vol));

        // vol 0.0 to 1.0 -> convert to 0 - 255
        volume = static_cast<uint32_t> (vol * 255 + 0.5);
    } else
    {
        // Otherwise get the average volume across channels.
        vol = 0;
        for (UInt32 i = 1; i <= _noOutputChannels; i++)
        {
            channelVol = 0;
            propertyAddress.mElement = i;
            hasProperty = AudioObjectHasProperty(_outputDeviceID,
                                                 &propertyAddress);
            if (hasProperty)
            {
                size = sizeof(channelVol);
                WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
                        &propertyAddress, 0, NULL, &size, &channelVol));

                vol += channelVol;
                channels++;
            }
        }

        if (channels == 0)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Unable to get a volume on any channel");
            return -1;
        }

        assert(channels > 0);
        // vol 0.0 to 1.0 -> convert to 0 - 255
        volume = static_cast<uint32_t> (255 * vol / channels + 0.5);
    }

    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "     AudioMixerManagerMac::SpeakerVolume() => vol=%i", vol);

    return 0;
}

int32_t
AudioMixerManagerMac::MaxSpeakerVolume(uint32_t& maxVolume) const
{

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 255
    maxVolume = 255;

    return 0;
}

int32_t
AudioMixerManagerMac::MinSpeakerVolume(uint32_t& minVolume) const
{

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 255
    minVolume = 0;

    return 0;
}

int32_t
AudioMixerManagerMac::SpeakerVolumeStepSize(uint16_t& stepSize) const
{

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 255
    stepSize = 1;

    return 0;
}

int32_t AudioMixerManagerMac::SpeakerVolumeIsAvailable(bool& available)
{
    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;

    // Does the capture device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = {
            kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeOutput,
            0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        available = true;
        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noOutputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err != noErr || !isSettable)
        {
            available = false;
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Volume cannot be set for output channel %d, err=%d",
                         i, err);
            return -1;
        }
    }

    available = true;
    return 0;
}

int32_t AudioMixerManagerMac::SpeakerMuteIsAvailable(bool& available)
{
    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;

    // Does the capture device have a master mute control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeOutput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        available = true;
        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noOutputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err != noErr || !isSettable)
        {
            available = false;
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Mute cannot be set for output channel %d, err=%d",
                         i, err);
            return -1;
        }
    }

    available = true;
    return 0;
}

int32_t AudioMixerManagerMac::SetSpeakerMute(bool enable)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::SetSpeakerMute(enable=%u)", enable);

    CriticalSectionScoped lock(&_critSect);

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    UInt32 mute = enable ? 1 : 0;
    bool success = false;

    // Does the render device have a master mute control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeOutput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        size = sizeof(mute);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_outputDeviceID,
                &propertyAddress, 0, NULL, size, &mute));

        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noOutputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err == noErr && isSettable)
        {
            size = sizeof(mute);
            WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_outputDeviceID,
                    &propertyAddress, 0, NULL, size, &mute));
        }
        success = true;
    }

    if (!success)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Unable to set mute on any input channel");
        return -1;
    }

    return 0;
}

int32_t AudioMixerManagerMac::SpeakerMute(bool& enabled) const
{

    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    unsigned int channels = 0;
    UInt32 channelMuted = 0;
    UInt32 muted = 0;

    // Does the device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeOutput, 0 };
    Boolean hasProperty = AudioObjectHasProperty(_outputDeviceID,
                                                 &propertyAddress);
    if (hasProperty)
    {
        size = sizeof(muted);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
                &propertyAddress, 0, NULL, &size, &muted));

        // 1 means muted
        enabled = static_cast<bool> (muted);
    } else
    {
        // Otherwise check if all channels are muted.
        for (UInt32 i = 1; i <= _noOutputChannels; i++)
        {
            muted = 0;
            propertyAddress.mElement = i;
            hasProperty = AudioObjectHasProperty(_outputDeviceID,
                                                 &propertyAddress);
            if (hasProperty)
            {
                size = sizeof(channelMuted);
                WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
                        &propertyAddress, 0, NULL, &size, &channelMuted));

                muted = (muted && channelMuted);
                channels++;
            }
        }

        if (channels == 0)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Unable to get mute for any channel");
            return -1;
        }

        assert(channels > 0);
        // 1 means muted
        enabled = static_cast<bool> (muted);
    }

    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "     AudioMixerManagerMac::SpeakerMute() => enabled=%d, enabled");

    return 0;
}

int32_t AudioMixerManagerMac::StereoPlayoutIsAvailable(bool& available)
{
    if (_outputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    available = (_noOutputChannels == 2);
    return 0;
}

int32_t AudioMixerManagerMac::StereoRecordingIsAvailable(bool& available)
{
    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    available = (_noInputChannels == 2);
    return 0;
}

int32_t AudioMixerManagerMac::MicrophoneMuteIsAvailable(bool& available)
{
    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;

    // Does the capture device have a master mute control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeInput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        available = true;
        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noInputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err != noErr || !isSettable)
        {
            available = false;
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Mute cannot be set for output channel %d, err=%d",
                         i, err);
            return -1;
        }
    }

    available = true;
    return 0;
}

int32_t AudioMixerManagerMac::SetMicrophoneMute(bool enable)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::SetMicrophoneMute(enable=%u)", enable);

    CriticalSectionScoped lock(&_critSect);

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    UInt32 mute = enable ? 1 : 0;
    bool success = false;

    // Does the capture device have a master mute control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeInput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        size = sizeof(mute);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_inputDeviceID,
                &propertyAddress, 0, NULL, size, &mute));

        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noInputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err == noErr && isSettable)
        {
            size = sizeof(mute);
            WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_inputDeviceID,
                    &propertyAddress, 0, NULL, size, &mute));
        }
        success = true;
    }

    if (!success)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Unable to set mute on any input channel");
        return -1;
    }

    return 0;
}

int32_t AudioMixerManagerMac::MicrophoneMute(bool& enabled) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    unsigned int channels = 0;
    UInt32 channelMuted = 0;
    UInt32 muted = 0;

    // Does the device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress propertyAddress = { kAudioDevicePropertyMute,
            kAudioDevicePropertyScopeInput, 0 };
    Boolean hasProperty = AudioObjectHasProperty(_inputDeviceID,
                                                 &propertyAddress);
    if (hasProperty)
    {
        size = sizeof(muted);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
                &propertyAddress, 0, NULL, &size, &muted));

        // 1 means muted
        enabled = static_cast<bool> (muted);
    } else
    {
        // Otherwise check if all channels are muted.
        for (UInt32 i = 1; i <= _noInputChannels; i++)
        {
            muted = 0;
            propertyAddress.mElement = i;
            hasProperty = AudioObjectHasProperty(_inputDeviceID,
                                                 &propertyAddress);
            if (hasProperty)
            {
                size = sizeof(channelMuted);
                WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
                        &propertyAddress, 0, NULL, &size, &channelMuted));

                muted = (muted && channelMuted);
                channels++;
            }
        }

        if (channels == 0)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Unable to get mute for any channel");
            return -1;
        }

        assert(channels > 0);
        // 1 means muted
        enabled = static_cast<bool> (muted);
    }

    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "     AudioMixerManagerMac::MicrophoneMute() => enabled=%d",
                 enabled);

    return 0;
}

int32_t AudioMixerManagerMac::MicrophoneBoostIsAvailable(bool& available)
{
    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    available = false; // No AudioObjectPropertySelector value for Mic Boost

    return 0;
}

int32_t AudioMixerManagerMac::SetMicrophoneBoost(bool enable)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::SetMicrophoneBoost(enable=%u)", enable);

    CriticalSectionScoped lock(&_critSect);

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // Ensure that the selected microphone has a valid boost control.
    bool available(false);
    MicrophoneBoostIsAvailable(available);
    if (!available)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  it is not possible to enable microphone boost");
        return -1;
    }

    // It is assumed that the call above fails!
    return 0;
}

int32_t AudioMixerManagerMac::MicrophoneBoost(bool& enabled) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // Microphone boost cannot be enabled on this platform!
    enabled = false;

    return 0;
}

int32_t AudioMixerManagerMac::MicrophoneVolumeIsAvailable(bool& available)
{
    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;

    // Does the capture device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress
        propertyAddress = { kAudioDevicePropertyVolumeScalar,
                kAudioDevicePropertyScopeInput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        available = true;
        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noInputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err != noErr || !isSettable)
        {
            available = false;
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Volume cannot be set for input channel %d, err=%d",
                         i, err);
            return -1;
        }
    }

    available = true;
    return 0;
}

int32_t AudioMixerManagerMac::SetMicrophoneVolume(uint32_t volume)
{
    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "AudioMixerManagerMac::SetMicrophoneVolume(volume=%u)", volume);

    CriticalSectionScoped lock(&_critSect);

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    bool success = false;

    // volume range is 0.0 - 1.0, convert from 0 - 255
    const Float32 vol = (Float32)(volume / 255.0);

    assert(vol <= 1.0 && vol >= 0.0);

    // Does the capture device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress
        propertyAddress = { kAudioDevicePropertyVolumeScalar,
                kAudioDevicePropertyScopeInput, 0 };
    Boolean isSettable = false;
    err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                        &isSettable);
    if (err == noErr && isSettable)
    {
        size = sizeof(vol);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_inputDeviceID,
                &propertyAddress, 0, NULL, size, &vol));

        return 0;
    }

    // Otherwise try to set each channel.
    for (UInt32 i = 1; i <= _noInputChannels; i++)
    {
        propertyAddress.mElement = i;
        isSettable = false;
        err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                            &isSettable);
        if (err == noErr && isSettable)
        {
            size = sizeof(vol);
            WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_inputDeviceID,
                    &propertyAddress, 0, NULL, size, &vol));
        }
        success = true;
    }

    if (!success)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     " Unable to set a level on any input channel");
        return -1;
    }

    return 0;
}

int32_t
AudioMixerManagerMac::MicrophoneVolume(uint32_t& volume) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    OSStatus err = noErr;
    UInt32 size = 0;
    unsigned int channels = 0;
    Float32 channelVol = 0;
    Float32 volFloat32 = 0;

    // Does the device have a master volume control?
    // If so, use it exclusively.
    AudioObjectPropertyAddress
        propertyAddress = { kAudioDevicePropertyVolumeScalar,
                kAudioDevicePropertyScopeInput, 0 };
    Boolean hasProperty = AudioObjectHasProperty(_inputDeviceID,
                                                 &propertyAddress);
    if (hasProperty)
    {
        size = sizeof(volFloat32);
        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
                &propertyAddress, 0, NULL, &size, &volFloat32));

        // vol 0.0 to 1.0 -> convert to 0 - 255
        volume = static_cast<uint32_t> (volFloat32 * 255 + 0.5);
    } else
    {
        // Otherwise get the average volume across channels.
        volFloat32 = 0;
        for (UInt32 i = 1; i <= _noInputChannels; i++)
        {
            channelVol = 0;
            propertyAddress.mElement = i;
            hasProperty = AudioObjectHasProperty(_inputDeviceID,
                                                 &propertyAddress);
            if (hasProperty)
            {
                size = sizeof(channelVol);
                WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
                        &propertyAddress, 0, NULL, &size, &channelVol));

                volFloat32 += channelVol;
                channels++;
            }
        }

        if (channels == 0)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                         " Unable to get a level on any channel");
            return -1;
        }

        assert(channels > 0);
        // vol 0.0 to 1.0 -> convert to 0 - 255
        volume = static_cast<uint32_t> 
            (255 * volFloat32 / channels + 0.5);
    }

    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "     AudioMixerManagerMac::MicrophoneVolume() => vol=%u",
                 volume);

    return 0;
}

int32_t
AudioMixerManagerMac::MaxMicrophoneVolume(uint32_t& maxVolume) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 255
    maxVolume = 255;

    return 0;
}

int32_t
AudioMixerManagerMac::MinMicrophoneVolume(uint32_t& minVolume) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 10
    minVolume = 0;

    return 0;
}

int32_t
AudioMixerManagerMac::MicrophoneVolumeStepSize(uint16_t& stepSize) const
{

    if (_inputDeviceID == kAudioObjectUnknown)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                     "  device ID has not been set");
        return -1;
    }

    // volume range is 0.0 to 1.0
    // we convert that to 0 - 10
    stepSize = 1;

    return 0;
}

// ============================================================================
//                                 Private Methods
// ============================================================================

// CoreAudio errors are best interpreted as four character strings.
void AudioMixerManagerMac::logCAMsg(const TraceLevel level,
                                    const TraceModule module,
                                    const int32_t id, const char *msg,
                                    const char *err)
{
    assert(msg != NULL);
    assert(err != NULL);

#ifdef WEBRTC_ARCH_BIG_ENDIAN
    WEBRTC_TRACE(level, module, id, "%s: %.4s", msg, err);
#else
    // We need to flip the characters in this case.
    WEBRTC_TRACE(level, module, id, "%s: %.1s%.1s%.1s%.1s", msg, err + 3, err
        + 2, err + 1, err);
#endif
}

}  // namespace webrtc
// EOF