Source/WebCore/platform/audio/mac/AudioSessionMac.cpp

   1 /*
   2  * Copyright (C) 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "AudioSession.h"
  28
  29 #if USE(AUDIO_SESSION) && PLATFORM(MAC)
  30
  31 #include "FloatConversion.h"
  32 #include "Logging.h"
  33 #include "NotImplemented.h"
  34 #include <CoreAudio/AudioHardware.h>
  35 #include <wtf/MainThread.h>
  36
  37 namespace WebCore {
  38
  39 static AudioDeviceID defaultDevice()
  40 {
  41     AudioDeviceID deviceID = kAudioDeviceUnknown;
  42     UInt32 infoSize = sizeof(deviceID);
  43
  44     AudioObjectPropertyAddress defaultOutputDeviceAddress = {
  45         kAudioHardwarePropertyDefaultOutputDevice,
  46         kAudioObjectPropertyScopeGlobal,
  47         kAudioObjectPropertyElementMaster };
  48     OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject, &defaultOutputDeviceAddress, 0, 0, &infoSize, (void*)&deviceID);
  49     if (result)
  50         return 0; // error
  51     return deviceID;
  52 }
  53
  54 class AudioSessionPrivate {
  55 public:
  56     AudioSessionPrivate(bool mutedState)
  57         : lastMutedState(mutedState) { }
  58     bool lastMutedState;
  59 };
  60
  61 AudioSession::AudioSession()
  62     : m_private(std::make_unique<AudioSessionPrivate>(isMuted()))
  63 {
  64 }
  65
  66 AudioSession::~AudioSession()
  67 {
  68 }
  69
  70 AudioSession::CategoryType AudioSession::category() const
  71 {
  72     notImplemented();
  73     return None;
  74 }
  75
  76 void AudioSession::setCategory(CategoryType)
  77 {
  78     notImplemented();
  79 }
  80
  81 AudioSession::CategoryType AudioSession::categoryOverride() const
  82 {
  83     notImplemented();
  84     return None;
  85 }
  86
  87 void AudioSession::setCategoryOverride(CategoryType)
  88 {
  89     notImplemented();
  90 }
  91
  92 float AudioSession::sampleRate() const
  93 {
  94     Float64 nominalSampleRate;
  95     UInt32 nominalSampleRateSize = sizeof(Float64);
  96
  97     AudioObjectPropertyAddress nominalSampleRateAddress = {
  98         kAudioDevicePropertyNominalSampleRate,
  99         kAudioObjectPropertyScopeGlobal,
 100         kAudioObjectPropertyElementMaster };
 101     OSStatus result = AudioObjectGetPropertyData(defaultDevice(), &nominalSampleRateAddress, 0, 0, &nominalSampleRateSize, (void*)&nominalSampleRate);
 102     if (result)
 103         return 0;
 104
 105     return narrowPrecisionToFloat(nominalSampleRate);
 106 }
 107
 108 size_t AudioSession::bufferSize() const
 109 {
 110     UInt32 bufferSize;
 111     UInt32 bufferSizeSize = sizeof(bufferSize);
 112
 113     AudioObjectPropertyAddress bufferSizeAddress = {
 114         kAudioDevicePropertyBufferFrameSize,
 115         kAudioObjectPropertyScopeGlobal,
 116         kAudioObjectPropertyElementMaster };
 117     OSStatus result = AudioObjectGetPropertyData(defaultDevice(), &bufferSizeAddress, 0, 0, &bufferSizeSize, &bufferSize);
 118
 119     if (result)
 120         return 0;
 121     return bufferSize;
 122 }
 123
 124 size_t AudioSession::numberOfOutputChannels() const
 125 {
 126     notImplemented();
 127     return 0;
 128 }
 129
 130 bool AudioSession::tryToSetActive(bool)
 131 {
 132     notImplemented();
 133     return true;
 134 }
 135
 136 size_t AudioSession::preferredBufferSize() const
 137 {
 138     UInt32 bufferSize;
 139     UInt32 bufferSizeSize = sizeof(bufferSize);
 140
 141     AudioObjectPropertyAddress preferredBufferSizeAddress = {
 142         kAudioDevicePropertyBufferFrameSizeRange,
 143         kAudioObjectPropertyScopeGlobal,
 144         kAudioObjectPropertyElementMaster };
 145     OSStatus result = AudioObjectGetPropertyData(defaultDevice(), &preferredBufferSizeAddress, 0, 0, &bufferSizeSize, &bufferSize);
 146
 147     if (result)
 148         return 0;
 149     return bufferSize;
 150 }
 151
 152 void AudioSession::setPreferredBufferSize(size_t bufferSize)
 153 {
 154     AudioValueRange bufferSizeRange = {0, 0};
 155     UInt32 bufferSizeRangeSize = sizeof(AudioValueRange);
 156     AudioObjectPropertyAddress bufferSizeRangeAddress = {
 157         kAudioDevicePropertyBufferFrameSizeRange,
 158         kAudioObjectPropertyScopeGlobal,
 159         kAudioObjectPropertyElementMaster
 160     };
 161     OSStatus result = AudioObjectGetPropertyData(defaultDevice(), &bufferSizeRangeAddress, 0, 0, &bufferSizeRangeSize, &bufferSizeRange);
 162     if (result)
 163         return;
 164
 165     size_t minBufferSize = static_cast<size_t>(bufferSizeRange.mMinimum);
 166     size_t maxBufferSize = static_cast<size_t>(bufferSizeRange.mMaximum);
 167     UInt32 bufferSizeOut = std::min(maxBufferSize, std::max(minBufferSize, bufferSize));
 168
 169     AudioObjectPropertyAddress preferredBufferSizeAddress = {
 170         kAudioDevicePropertyBufferFrameSize,
 171         kAudioObjectPropertyScopeGlobal,
 172         kAudioObjectPropertyElementMaster };
 173
 174     result = AudioObjectSetPropertyData(defaultDevice(), &preferredBufferSizeAddress, 0, 0, sizeof(bufferSizeOut), (void*)&bufferSizeOut);
 175
 176 #if LOG_DISABLED
 177     UNUSED_PARAM(result);
 178 #else
 179     if (result)
 180         LOG(Media, "AudioSession::setPreferredBufferSize(%zu) - failed with error %d", bufferSize, static_cast<int>(result));
 181     else
 182         LOG(Media, "AudioSession::setPreferredBufferSize(%zu)", bufferSize);
 183 #endif
 184 }
 185
 186 bool AudioSession::isMuted() const
 187 {
 188     UInt32 mute = 0;
 189     UInt32 muteSize = sizeof(mute);
 190     AudioObjectPropertyAddress muteAddress = { kAudioDevicePropertyMute, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
 191     AudioObjectGetPropertyData(defaultDevice(), &muteAddress, 0, nullptr, &muteSize, &mute);
 192
 193     switch (mute) {
 194     case 0:
 195         return false;
 196     case 1:
 197         return true;
 198     default:
 199         ASSERT_NOT_REACHED();
 200         return false;
 201     }
 202 }
 203
 204 static OSStatus handleMutePropertyChange(AudioObjectID, UInt32, const AudioObjectPropertyAddress*, void* inClientData)
 205 {
 206     callOnMainThread([inClientData] {
 207         reinterpret_cast<AudioSession*>(inClientData)->handleMutedStateChange();
 208     });
 209     return noErr;
 210 }
 211
 212 void AudioSession::handleMutedStateChange()
 213 {
 214     if (!m_private)
 215         return;
 216
 217     bool isCurrentlyMuted = isMuted();
 218     if (m_private->lastMutedState == isCurrentlyMuted)
 219         return;
 220
 221     for (auto* observer : m_observers)
 222         observer->hardwareMutedStateDidChange(this);
 223
 224     m_private->lastMutedState = isCurrentlyMuted;
 225 }
 226
 227 void AudioSession::addMutedStateObserver(MutedStateObserver* observer)
 228 {
 229     m_observers.add(observer);
 230
 231     if (m_observers.size() > 1)
 232         return;
 233
 234     AudioObjectPropertyAddress muteAddress = { kAudioDevicePropertyMute, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
 235     AudioObjectAddPropertyListener(defaultDevice(), &muteAddress, handleMutePropertyChange, this);
 236 }
 237
 238 void AudioSession::removeMutedStateObserver(MutedStateObserver* observer)
 239 {
 240     if (m_observers.size() == 1) {
 241         AudioObjectPropertyAddress muteAddress = { kAudioDevicePropertyMute, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
 242         AudioObjectRemovePropertyListener(defaultDevice(), &muteAddress, handleMutePropertyChange, this);
 243     }
 244
 245     m_observers.remove(observer);
 246 }
 247
 248 }
 249
 250 #endif // USE(AUDIO_SESSION) && PLATFORM(MAC)