Home | History | Annotate | Download | only in mac 
      1 /*
      2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #include "webrtc/modules/audio_device/audio_device_config.h"
     12 #include "webrtc/modules/audio_device/audio_device_utility.h"
     13 #include "webrtc/modules/audio_device/mac/audio_device_mac.h"
     14 
     15 #include "webrtc/modules/audio_device/mac/portaudio/pa_ringbuffer.h"
     16 #include "webrtc/system_wrappers/interface/event_wrapper.h"
     17 #include "webrtc/system_wrappers/interface/thread_wrapper.h"
     18 #include "webrtc/system_wrappers/interface/trace.h"
     19 
     20 #include <ApplicationServices/ApplicationServices.h>
     21 #include <assert.h>
     22 #include <libkern/OSAtomic.h>   // OSAtomicCompareAndSwap()
     23 #include <mach/mach.h>          // mach_task_self()
     24 #include <sys/sysctl.h>         // sysctlbyname()
     25 
     26 
     27 
     28 namespace webrtc
     29 {
     30 
     31 #define WEBRTC_CA_RETURN_ON_ERR(expr)                                   \
     32     do {                                                                \
     33         err = expr;                                                     \
     34         if (err != noErr) {                                             \
     35             logCAMsg(kTraceError, kTraceAudioDevice, _id,               \
     36                 "Error in " #expr, (const char *)&err);                 \
     37             return -1;                                                  \
     38         }                                                               \
     39     } while(0)
     40 
     41 #define WEBRTC_CA_LOG_ERR(expr)                                         \
     42     do {                                                                \
     43         err = expr;                                                     \
     44         if (err != noErr) {                                             \
     45             logCAMsg(kTraceError, kTraceAudioDevice, _id,               \
     46                 "Error in " #expr, (const char *)&err);                 \
     47         }                                                               \
     48     } while(0)
     49 
     50 #define WEBRTC_CA_LOG_WARN(expr)                                        \
     51     do {                                                                \
     52         err = expr;                                                     \
     53         if (err != noErr) {                                             \
     54             logCAMsg(kTraceWarning, kTraceAudioDevice, _id,             \
     55                 "Error in " #expr, (const char *)&err);                 \
     56         }                                                               \
     57     } while(0)
     58 
     59 #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
     60 
     61 enum
     62 {
     63     MaxNumberDevices = 64
     64 };
     65 
     66 void AudioDeviceMac::AtomicSet32(int32_t* theValue, int32_t newValue)
     67 {
     68     while (1)
     69     {
     70         int32_t oldValue = *theValue;
     71         if (OSAtomicCompareAndSwap32Barrier(oldValue, newValue, theValue)
     72             == true)
     73         {
     74             return;
     75         }
     76     }
     77 }
     78 
     79 int32_t AudioDeviceMac::AtomicGet32(int32_t* theValue)
     80 {
     81     while (1)
     82     {
     83         int32_t value = *theValue;
     84         if (OSAtomicCompareAndSwap32Barrier(value, value, theValue) == true)
     85         {
     86             return value;
     87         }
     88     }
     89 }
     90 
     91 // CoreAudio errors are best interpreted as four character strings.
     92 void AudioDeviceMac::logCAMsg(const TraceLevel level,
     93                               const TraceModule module,
     94                               const int32_t id, const char *msg,
     95                               const char *err)
     96 {
     97     assert(msg != NULL);
     98     assert(err != NULL);
     99 
    100 #ifdef WEBRTC_ARCH_BIG_ENDIAN
    101     WEBRTC_TRACE(level, module, id, "%s: %.4s", msg, err);
    102 #else
    103     // We need to flip the characters in this case.
    104     WEBRTC_TRACE(level, module, id, "%s: %.1s%.1s%.1s%.1s", msg, err + 3, err
    105         + 2, err + 1, err);
    106 #endif
    107 }
    108 
    109 AudioDeviceMac::AudioDeviceMac(const int32_t id) :
    110     _ptrAudioBuffer(NULL),
    111     _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
    112     _stopEventRec(*EventWrapper::Create()),
    113     _stopEvent(*EventWrapper::Create()),
    114     _captureWorkerThread(NULL),
    115     _renderWorkerThread(NULL),
    116     _captureWorkerThreadId(0),
    117     _renderWorkerThreadId(0),
    118     _id(id),
    119     _mixerManager(id),
    120     _inputDeviceIndex(0),
    121     _outputDeviceIndex(0),
    122     _inputDeviceID(kAudioObjectUnknown),
    123     _outputDeviceID(kAudioObjectUnknown),
    124     _inputDeviceIsSpecified(false),
    125     _outputDeviceIsSpecified(false),
    126     _recChannels(N_REC_CHANNELS),
    127     _playChannels(N_PLAY_CHANNELS),
    128     _captureBufData(NULL),
    129     _renderBufData(NULL),
    130     _playBufType(AudioDeviceModule::kFixedBufferSize),
    131     _initialized(false),
    132     _isShutDown(false),
    133     _recording(false),
    134     _playing(false),
    135     _recIsInitialized(false),
    136     _playIsInitialized(false),
    137     _AGC(false),
    138     _renderDeviceIsAlive(1),
    139     _captureDeviceIsAlive(1),
    140     _twoDevices(true),
    141     _doStop(false),
    142     _doStopRec(false),
    143     _macBookPro(false),
    144     _macBookProPanRight(false),
    145     _captureLatencyUs(0),
    146     _renderLatencyUs(0),
    147     _captureDelayUs(0),
    148     _renderDelayUs(0),
    149     _renderDelayOffsetSamples(0),
    150     _playBufDelayFixed(20),
    151     _playWarning(0),
    152     _playError(0),
    153     _recWarning(0),
    154     _recError(0),
    155     _paCaptureBuffer(NULL),
    156     _paRenderBuffer(NULL),
    157     _captureBufSizeSamples(0),
    158     _renderBufSizeSamples(0),
    159     prev_key_state_()
    160 {
    161     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id,
    162                  "%s created", __FUNCTION__);
    163 
    164     assert(&_stopEvent != NULL);
    165     assert(&_stopEventRec != NULL);
    166 
    167     memset(_renderConvertData, 0, sizeof(_renderConvertData));
    168     memset(&_outStreamFormat, 0, sizeof(AudioStreamBasicDescription));
    169     memset(&_outDesiredFormat, 0, sizeof(AudioStreamBasicDescription));
    170     memset(&_inStreamFormat, 0, sizeof(AudioStreamBasicDescription));
    171     memset(&_inDesiredFormat, 0, sizeof(AudioStreamBasicDescription));
    172 }
    173 
    174 
    175 AudioDeviceMac::~AudioDeviceMac()
    176 {
    177     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
    178                  "%s destroyed", __FUNCTION__);
    179 
    180     if (!_isShutDown)
    181     {
    182         Terminate();
    183     }
    184 
    185     if (_captureWorkerThread)
    186     {
    187         delete _captureWorkerThread;
    188         _captureWorkerThread = NULL;
    189     }
    190 
    191     if (_renderWorkerThread)
    192     {
    193         delete _renderWorkerThread;
    194         _renderWorkerThread = NULL;
    195     }
    196 
    197     if (_paRenderBuffer)
    198     {
    199         delete _paRenderBuffer;
    200         _paRenderBuffer = NULL;
    201     }
    202 
    203     if (_paCaptureBuffer)
    204     {
    205         delete _paCaptureBuffer;
    206         _paCaptureBuffer = NULL;
    207     }
    208 
    209     if (_renderBufData)
    210     {
    211         delete[] _renderBufData;
    212         _renderBufData = NULL;
    213     }
    214 
    215     if (_captureBufData)
    216     {
    217         delete[] _captureBufData;
    218         _captureBufData = NULL;
    219     }
    220 
    221     kern_return_t kernErr = KERN_SUCCESS;
    222     kernErr = semaphore_destroy(mach_task_self(), _renderSemaphore);
    223     if (kernErr != KERN_SUCCESS)
    224     {
    225         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
    226                      " semaphore_destroy() error: %d", kernErr);
    227     }
    228 
    229     kernErr = semaphore_destroy(mach_task_self(), _captureSemaphore);
    230     if (kernErr != KERN_SUCCESS)
    231     {
    232         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
    233                      " semaphore_destroy() error: %d", kernErr);
    234     }
    235 
    236     delete &_stopEvent;
    237     delete &_stopEventRec;
    238     delete &_critSect;
    239 }
    240 
    241 // ============================================================================
    242 //                                     API
    243 // ============================================================================
    244 
    245 void AudioDeviceMac::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
    246 {
    247 
    248     CriticalSectionScoped lock(&_critSect);
    249 
    250     _ptrAudioBuffer = audioBuffer;
    251 
    252     // inform the AudioBuffer about default settings for this implementation
    253     _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
    254     _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC);
    255     _ptrAudioBuffer->SetRecordingChannels(N_REC_CHANNELS);
    256     _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS);
    257 }
    258 
    259 int32_t AudioDeviceMac::ActiveAudioLayer(
    260     AudioDeviceModule::AudioLayer& audioLayer) const
    261 {
    262     audioLayer = AudioDeviceModule::kPlatformDefaultAudio;
    263     return 0;
    264 }
    265 
    266 int32_t AudioDeviceMac::Init()
    267 {
    268 
    269     CriticalSectionScoped lock(&_critSect);
    270 
    271     if (_initialized)
    272     {
    273         return 0;
    274     }
    275 
    276     OSStatus err = noErr;
    277 
    278     _isShutDown = false;
    279 
    280     // PortAudio ring buffers require an elementCount which is a power of two.
    281     if (_renderBufData == NULL)
    282     {
    283         UInt32 powerOfTwo = 1;
    284         while (powerOfTwo < PLAY_BUF_SIZE_IN_SAMPLES)
    285         {
    286             powerOfTwo <<= 1;
    287         }
    288         _renderBufSizeSamples = powerOfTwo;
    289         _renderBufData = new SInt16[_renderBufSizeSamples];
    290     }
    291 
    292     if (_paRenderBuffer == NULL)
    293     {
    294         _paRenderBuffer = new PaUtilRingBuffer;
    295         ring_buffer_size_t bufSize = -1;
    296         bufSize = PaUtil_InitializeRingBuffer(_paRenderBuffer, sizeof(SInt16),
    297                                               _renderBufSizeSamples,
    298                                               _renderBufData);
    299         if (bufSize == -1)
    300         {
    301             WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
    302                          _id, " PaUtil_InitializeRingBuffer() error");
    303             return -1;
    304         }
    305     }
    306 
    307     if (_captureBufData == NULL)
    308     {
    309         UInt32 powerOfTwo = 1;
    310         while (powerOfTwo < REC_BUF_SIZE_IN_SAMPLES)
    311         {
    312             powerOfTwo <<= 1;
    313         }
    314         _captureBufSizeSamples = powerOfTwo;
    315         _captureBufData = new Float32[_captureBufSizeSamples];
    316     }
    317 
    318     if (_paCaptureBuffer == NULL)
    319     {
    320         _paCaptureBuffer = new PaUtilRingBuffer;
    321         ring_buffer_size_t bufSize = -1;
    322         bufSize = PaUtil_InitializeRingBuffer(_paCaptureBuffer,
    323                                               sizeof(Float32),
    324                                               _captureBufSizeSamples,
    325                                               _captureBufData);
    326         if (bufSize == -1)
    327         {
    328             WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
    329                          _id, " PaUtil_InitializeRingBuffer() error");
    330             return -1;
    331         }
    332     }
    333 
    334     if (_renderWorkerThread == NULL)
    335     {
    336         _renderWorkerThread
    337             = ThreadWrapper::CreateThread(RunRender, this, kRealtimePriority,
    338                                           "RenderWorkerThread");
    339         if (_renderWorkerThread == NULL)
    340         {
    341             WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
    342                          _id, " Render CreateThread() error");
    343             return -1;
    344         }
    345     }
    346 
    347     if (_captureWorkerThread == NULL)
    348     {
    349         _captureWorkerThread
    350             = ThreadWrapper::CreateThread(RunCapture, this, kRealtimePriority,
    351                                           "CaptureWorkerThread");
    352         if (_captureWorkerThread == NULL)
    353         {
    354             WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice,
    355                          _id, " Capture CreateThread() error");
    356             return -1;
    357         }
    358     }
    359 
    360     kern_return_t kernErr = KERN_SUCCESS;
    361     kernErr = semaphore_create(mach_task_self(), &_renderSemaphore,
    362                                SYNC_POLICY_FIFO, 0);
    363     if (kernErr != KERN_SUCCESS)
    364     {
    365         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
    366                      " semaphore_create() error: %d", kernErr);
    367         return -1;
    368     }
    369 
    370     kernErr = semaphore_create(mach_task_self(), &_captureSemaphore,
    371                                SYNC_POLICY_FIFO, 0);
    372     if (kernErr != KERN_SUCCESS)
    373     {
    374         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
    375                      " semaphore_create() error: %d", kernErr);
    376         return -1;
    377     }
    378 
    379     // Setting RunLoop to NULL here instructs HAL to manage its own thread for
    380     // notifications. This was the default behaviour on OS X 10.5 and earlier,
    381     // but now must be explicitly specified. HAL would otherwise try to use the
    382     // main thread to issue notifications.
    383     AudioObjectPropertyAddress propertyAddress = {
    384             kAudioHardwarePropertyRunLoop,
    385             kAudioObjectPropertyScopeGlobal,
    386             kAudioObjectPropertyElementMaster };
    387     CFRunLoopRef runLoop = NULL;
    388     UInt32 size = sizeof(CFRunLoopRef);
    389     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(kAudioObjectSystemObject,
    390             &propertyAddress, 0, NULL, size, &runLoop));
    391 
    392     // Listen for any device changes.
    393     propertyAddress.mSelector = kAudioHardwarePropertyDevices;
    394     WEBRTC_CA_LOG_ERR(AudioObjectAddPropertyListener(kAudioObjectSystemObject,
    395             &propertyAddress, &objectListenerProc, this));
    396 
    397     // Determine if this is a MacBook Pro
    398     _macBookPro = false;
    399     _macBookProPanRight = false;
    400     char buf[128];
    401     size_t length = sizeof(buf);
    402     memset(buf, 0, length);
    403 
    404     int intErr = sysctlbyname("hw.model", buf, &length, NULL, 0);
    405     if (intErr != 0)
    406     {
    407         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
    408                      " Error in sysctlbyname(): %d", err);
    409     } else
    410     {
    411         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
    412                      " Hardware model: %s", buf);
    413         if (strncmp(buf, "MacBookPro", 10) == 0)
    414         {
    415             _macBookPro = true;
    416         }
    417     }
    418 
    419     _playWarning = 0;
    420     _playError = 0;
    421     _recWarning = 0;
    422     _recError = 0;
    423 
    424     _initialized = true;
    425 
    426     return 0;
    427 }
    428 
    429 int32_t AudioDeviceMac::Terminate()
    430 {
    431 
    432     if (!_initialized)
    433     {
    434         return 0;
    435     }
    436 
    437     if (_recording)
    438     {
    439         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
    440                      " Recording must be stopped");
    441         return -1;
    442     }
    443 
    444     if (_playing)
    445     {
    446         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
    447                      " Playback must be stopped");
    448         return -1;
    449     }
    450 
    451     _critSect.Enter();
    452 
    453     _mixerManager.Close();
    454 
    455     OSStatus err = noErr;
    456     int retVal = 0;
    457 
    458     AudioObjectPropertyAddress propertyAddress = {
    459             kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
    460             kAudioObjectPropertyElementMaster };
    461     WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
    462             &propertyAddress, &objectListenerProc, this));
    463 
    464     err = AudioHardwareUnload();
    465     if (err != noErr)
    466     {
    467         logCAMsg(kTraceError, kTraceAudioDevice, _id,
    468                  "Error in AudioHardwareUnload()", (const char*) &err);
    469         retVal = -1;
    470     }
    471 
    472     _critSect.Leave();
    473 
    474     _isShutDown = true;
    475     _initialized = false;
    476     _outputDeviceIsSpecified = false;
    477     _inputDeviceIsSpecified = false;
    478 
    479     return retVal;
    480 }
    481 
    482 bool AudioDeviceMac::Initialized() const
    483 {
    484     return (_initialized);
    485 }
    486 
    487 int32_t AudioDeviceMac::SpeakerIsAvailable(bool& available)
    488 {
    489 
    490     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
    491 
    492     // Make an attempt to open up the
    493     // output mixer corresponding to the currently selected output device.
    494     //
    495     if (!wasInitialized && InitSpeaker() == -1)
    496     {
    497         available = false;
    498         return 0;
    499     }
    500 
    501     // Given that InitSpeaker was successful, we know that a valid speaker
    502     // exists.
    503     available = true;
    504 
    505     // Close the initialized output mixer
    506     //
    507     if (!wasInitialized)
    508     {
    509         _mixerManager.CloseSpeaker();
    510     }
    511 
    512     return 0;
    513 }
    514 
    515 int32_t AudioDeviceMac::InitSpeaker()
    516 {
    517 
    518     CriticalSectionScoped lock(&_critSect);
    519 
    520     if (_playing)
    521     {
    522         return -1;
    523     }
    524 
    525     if (InitDevice(_outputDeviceIndex, _outputDeviceID, false) == -1)
    526     {
    527         return -1;
    528     }
    529 
    530     if (_inputDeviceID == _outputDeviceID)
    531     {
    532         _twoDevices = false;
    533     } else
    534     {
    535         _twoDevices = true;
    536     }
    537 
    538     if (_mixerManager.OpenSpeaker(_outputDeviceID) == -1)
    539     {
    540         return -1;
    541     }
    542 
    543     return 0;
    544 }
    545 
    546 int32_t AudioDeviceMac::MicrophoneIsAvailable(bool& available)
    547 {
    548 
    549     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
    550 
    551     // Make an attempt to open up the
    552     // input mixer corresponding to the currently selected output device.
    553     //
    554     if (!wasInitialized && InitMicrophone() == -1)
    555     {
    556         available = false;
    557         return 0;
    558     }
    559 
    560     // Given that InitMicrophone was successful, we know that a valid microphone
    561     // exists.
    562     available = true;
    563 
    564     // Close the initialized input mixer
    565     //
    566     if (!wasInitialized)
    567     {
    568         _mixerManager.CloseMicrophone();
    569     }
    570 
    571     return 0;
    572 }
    573 
    574 int32_t AudioDeviceMac::InitMicrophone()
    575 {
    576 
    577     CriticalSectionScoped lock(&_critSect);
    578 
    579     if (_recording)
    580     {
    581         return -1;
    582     }
    583 
    584     if (InitDevice(_inputDeviceIndex, _inputDeviceID, true) == -1)
    585     {
    586         return -1;
    587     }
    588 
    589     if (_inputDeviceID == _outputDeviceID)
    590     {
    591         _twoDevices = false;
    592     } else
    593     {
    594         _twoDevices = true;
    595     }
    596 
    597     if (_mixerManager.OpenMicrophone(_inputDeviceID) == -1)
    598     {
    599         return -1;
    600     }
    601 
    602     return 0;
    603 }
    604 
    605 bool AudioDeviceMac::SpeakerIsInitialized() const
    606 {
    607     return (_mixerManager.SpeakerIsInitialized());
    608 }
    609 
    610 bool AudioDeviceMac::MicrophoneIsInitialized() const
    611 {
    612     return (_mixerManager.MicrophoneIsInitialized());
    613 }
    614 
    615 int32_t AudioDeviceMac::SpeakerVolumeIsAvailable(bool& available)
    616 {
    617 
    618     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
    619 
    620     // Make an attempt to open up the
    621     // output mixer corresponding to the currently selected output device.
    622     //
    623     if (!wasInitialized && InitSpeaker() == -1)
    624     {
    625         // If we end up here it means that the selected speaker has no volume
    626         // control.
    627         available = false;
    628         return 0;
    629     }
    630 
    631     // Given that InitSpeaker was successful, we know that a volume control exists
    632     //
    633     available = true;
    634 
    635     // Close the initialized output mixer
    636     //
    637     if (!wasInitialized)
    638     {
    639         _mixerManager.CloseSpeaker();
    640     }
    641 
    642     return 0;
    643 }
    644 
    645 int32_t AudioDeviceMac::SetSpeakerVolume(uint32_t volume)
    646 {
    647 
    648     return (_mixerManager.SetSpeakerVolume(volume));
    649 }
    650 
    651 int32_t AudioDeviceMac::SpeakerVolume(uint32_t& volume) const
    652 {
    653 
    654     uint32_t level(0);
    655 
    656     if (_mixerManager.SpeakerVolume(level) == -1)
    657     {
    658         return -1;
    659     }
    660 
    661     volume = level;
    662     return 0;
    663 }
    664 
    665 int32_t AudioDeviceMac::SetWaveOutVolume(uint16_t volumeLeft,
    666                                          uint16_t volumeRight)
    667 {
    668 
    669     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
    670                  "  API call not supported on this platform");
    671     return -1;
    672 }
    673 
    674 int32_t
    675 AudioDeviceMac::WaveOutVolume(uint16_t& /*volumeLeft*/,
    676                               uint16_t& /*volumeRight*/) const
    677 {
    678 
    679     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
    680                  "  API call not supported on this platform");
    681     return -1;
    682 }
    683 
    684 int32_t AudioDeviceMac::MaxSpeakerVolume(uint32_t& maxVolume) const
    685 {
    686 
    687     uint32_t maxVol(0);
    688 
    689     if (_mixerManager.MaxSpeakerVolume(maxVol) == -1)
    690     {
    691         return -1;
    692     }
    693 
    694     maxVolume = maxVol;
    695     return 0;
    696 }
    697 
    698 int32_t AudioDeviceMac::MinSpeakerVolume(uint32_t& minVolume) const
    699 {
    700 
    701     uint32_t minVol(0);
    702 
    703     if (_mixerManager.MinSpeakerVolume(minVol) == -1)
    704     {
    705         return -1;
    706     }
    707 
    708     minVolume = minVol;
    709     return 0;
    710 }
    711 
    712 int32_t
    713 AudioDeviceMac::SpeakerVolumeStepSize(uint16_t& stepSize) const
    714 {
    715 
    716     uint16_t delta(0);
    717 
    718     if (_mixerManager.SpeakerVolumeStepSize(delta) == -1)
    719     {
    720         return -1;
    721     }
    722 
    723     stepSize = delta;
    724     return 0;
    725 }
    726 
    727 int32_t AudioDeviceMac::SpeakerMuteIsAvailable(bool& available)
    728 {
    729 
    730     bool isAvailable(false);
    731     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
    732 
    733     // Make an attempt to open up the
    734     // output mixer corresponding to the currently selected output device.
    735     //
    736     if (!wasInitialized && InitSpeaker() == -1)
    737     {
    738         // If we end up here it means that the selected speaker has no volume
    739         // control, hence it is safe to state that there is no mute control
    740         // already at this stage.
    741         available = false;
    742         return 0;
    743     }
    744 
    745     // Check if the selected speaker has a mute control
    746     //
    747     _mixerManager.SpeakerMuteIsAvailable(isAvailable);
    748 
    749     available = isAvailable;
    750 
    751     // Close the initialized output mixer
    752     //
    753     if (!wasInitialized)
    754     {
    755         _mixerManager.CloseSpeaker();
    756     }
    757 
    758     return 0;
    759 }
    760 
    761 int32_t AudioDeviceMac::SetSpeakerMute(bool enable)
    762 {
    763     return (_mixerManager.SetSpeakerMute(enable));
    764 }
    765 
    766 int32_t AudioDeviceMac::SpeakerMute(bool& enabled) const
    767 {
    768 
    769     bool muted(0);
    770 
    771     if (_mixerManager.SpeakerMute(muted) == -1)
    772     {
    773         return -1;
    774     }
    775 
    776     enabled = muted;
    777     return 0;
    778 }
    779 
    780 int32_t AudioDeviceMac::MicrophoneMuteIsAvailable(bool& available)
    781 {
    782 
    783     bool isAvailable(false);
    784     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
    785 
    786     // Make an attempt to open up the
    787     // input mixer corresponding to the currently selected input device.
    788     //
    789     if (!wasInitialized && InitMicrophone() == -1)
    790     {
    791         // If we end up here it means that the selected microphone has no volume
    792         // control, hence it is safe to state that there is no boost control
    793         // already at this stage.
    794         available = false;
    795         return 0;
    796     }
    797 
    798     // Check if the selected microphone has a mute control
    799     //
    800     _mixerManager.MicrophoneMuteIsAvailable(isAvailable);
    801     available = isAvailable;
    802 
    803     // Close the initialized input mixer
    804     //
    805     if (!wasInitialized)
    806     {
    807         _mixerManager.CloseMicrophone();
    808     }
    809 
    810     return 0;
    811 }
    812 
    813 int32_t AudioDeviceMac::SetMicrophoneMute(bool enable)
    814 {
    815     return (_mixerManager.SetMicrophoneMute(enable));
    816 }
    817 
    818 int32_t AudioDeviceMac::MicrophoneMute(bool& enabled) const
    819 {
    820 
    821     bool muted(0);
    822 
    823     if (_mixerManager.MicrophoneMute(muted) == -1)
    824     {
    825         return -1;
    826     }
    827 
    828     enabled = muted;
    829     return 0;
    830 }
    831 
    832 int32_t AudioDeviceMac::MicrophoneBoostIsAvailable(bool& available)
    833 {
    834 
    835     bool isAvailable(false);
    836     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
    837 
    838     // Enumerate all avaliable microphone and make an attempt to open up the
    839     // input mixer corresponding to the currently selected input device.
    840     //
    841     if (!wasInitialized && InitMicrophone() == -1)
    842     {
    843         // If we end up here it means that the selected microphone has no volume
    844         // control, hence it is safe to state that there is no boost control
    845         // already at this stage.
    846         available = false;
    847         return 0;
    848     }
    849 
    850     // Check if the selected microphone has a boost control
    851     //
    852     _mixerManager.MicrophoneBoostIsAvailable(isAvailable);
    853     available = isAvailable;
    854 
    855     // Close the initialized input mixer
    856     //
    857     if (!wasInitialized)
    858     {
    859         _mixerManager.CloseMicrophone();
    860     }
    861 
    862     return 0;
    863 }
    864 
    865 int32_t AudioDeviceMac::SetMicrophoneBoost(bool enable)
    866 {
    867 
    868     return (_mixerManager.SetMicrophoneBoost(enable));
    869 }
    870 
    871 int32_t AudioDeviceMac::MicrophoneBoost(bool& enabled) const
    872 {
    873 
    874     bool onOff(0);
    875 
    876     if (_mixerManager.MicrophoneBoost(onOff) == -1)
    877     {
    878         return -1;
    879     }
    880 
    881     enabled = onOff;
    882     return 0;
    883 }
    884 
    885 int32_t AudioDeviceMac::StereoRecordingIsAvailable(bool& available)
    886 {
    887 
    888     bool isAvailable(false);
    889     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
    890 
    891     if (!wasInitialized && InitMicrophone() == -1)
    892     {
    893         // Cannot open the specified device
    894         available = false;
    895         return 0;
    896     }
    897 
    898     // Check if the selected microphone can record stereo
    899     //
    900     _mixerManager.StereoRecordingIsAvailable(isAvailable);
    901     available = isAvailable;
    902 
    903     // Close the initialized input mixer
    904     //
    905     if (!wasInitialized)
    906     {
    907         _mixerManager.CloseMicrophone();
    908     }
    909 
    910     return 0;
    911 }
    912 
    913 int32_t AudioDeviceMac::SetStereoRecording(bool enable)
    914 {
    915 
    916     if (enable)
    917         _recChannels = 2;
    918     else
    919         _recChannels = 1;
    920 
    921     return 0;
    922 }
    923 
    924 int32_t AudioDeviceMac::StereoRecording(bool& enabled) const
    925 {
    926 
    927     if (_recChannels == 2)
    928         enabled = true;
    929     else
    930         enabled = false;
    931 
    932     return 0;
    933 }
    934 
    935 int32_t AudioDeviceMac::StereoPlayoutIsAvailable(bool& available)
    936 {
    937 
    938     bool isAvailable(false);
    939     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
    940 
    941     if (!wasInitialized && InitSpeaker() == -1)
    942     {
    943         // Cannot open the specified device
    944         available = false;
    945         return 0;
    946     }
    947 
    948     // Check if the selected microphone can record stereo
    949     //
    950     _mixerManager.StereoPlayoutIsAvailable(isAvailable);
    951     available = isAvailable;
    952 
    953     // Close the initialized input mixer
    954     //
    955     if (!wasInitialized)
    956     {
    957         _mixerManager.CloseSpeaker();
    958     }
    959 
    960     return 0;
    961 }
    962 
    963 int32_t AudioDeviceMac::SetStereoPlayout(bool enable)
    964 {
    965 
    966     if (enable)
    967         _playChannels = 2;
    968     else
    969         _playChannels = 1;
    970 
    971     return 0;
    972 }
    973 
    974 int32_t AudioDeviceMac::StereoPlayout(bool& enabled) const
    975 {
    976 
    977     if (_playChannels == 2)
    978         enabled = true;
    979     else
    980         enabled = false;
    981 
    982     return 0;
    983 }
    984 
    985 int32_t AudioDeviceMac::SetAGC(bool enable)
    986 {
    987 
    988     _AGC = enable;
    989 
    990     return 0;
    991 }
    992 
    993 bool AudioDeviceMac::AGC() const
    994 {
    995 
    996     return _AGC;
    997 }
    998 
    999 int32_t AudioDeviceMac::MicrophoneVolumeIsAvailable(bool& available)
   1000 {
   1001 
   1002     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
   1003 
   1004     // Make an attempt to open up the
   1005     // input mixer corresponding to the currently selected output device.
   1006     //
   1007     if (!wasInitialized && InitMicrophone() == -1)
   1008     {
   1009         // If we end up here it means that the selected microphone has no volume
   1010         // control.
   1011         available = false;
   1012         return 0;
   1013     }
   1014 
   1015     // Given that InitMicrophone was successful, we know that a volume control
   1016     // exists
   1017     //
   1018     available = true;
   1019 
   1020     // Close the initialized input mixer
   1021     //
   1022     if (!wasInitialized)
   1023     {
   1024         _mixerManager.CloseMicrophone();
   1025     }
   1026 
   1027     return 0;
   1028 }
   1029 
   1030 int32_t AudioDeviceMac::SetMicrophoneVolume(uint32_t volume)
   1031 {
   1032 
   1033     return (_mixerManager.SetMicrophoneVolume(volume));
   1034 }
   1035 
   1036 int32_t AudioDeviceMac::MicrophoneVolume(uint32_t& volume) const
   1037 {
   1038 
   1039     uint32_t level(0);
   1040 
   1041     if (_mixerManager.MicrophoneVolume(level) == -1)
   1042     {
   1043         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1044                      "  failed to retrive current microphone level");
   1045         return -1;
   1046     }
   1047 
   1048     volume = level;
   1049     return 0;
   1050 }
   1051 
   1052 int32_t
   1053 AudioDeviceMac::MaxMicrophoneVolume(uint32_t& maxVolume) const
   1054 {
   1055 
   1056     uint32_t maxVol(0);
   1057 
   1058     if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1)
   1059     {
   1060         return -1;
   1061     }
   1062 
   1063     maxVolume = maxVol;
   1064     return 0;
   1065 }
   1066 
   1067 int32_t
   1068 AudioDeviceMac::MinMicrophoneVolume(uint32_t& minVolume) const
   1069 {
   1070 
   1071     uint32_t minVol(0);
   1072 
   1073     if (_mixerManager.MinMicrophoneVolume(minVol) == -1)
   1074     {
   1075         return -1;
   1076     }
   1077 
   1078     minVolume = minVol;
   1079     return 0;
   1080 }
   1081 
   1082 int32_t
   1083 AudioDeviceMac::MicrophoneVolumeStepSize(uint16_t& stepSize) const
   1084 {
   1085 
   1086     uint16_t delta(0);
   1087 
   1088     if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1)
   1089     {
   1090         return -1;
   1091     }
   1092 
   1093     stepSize = delta;
   1094     return 0;
   1095 }
   1096 
   1097 int16_t AudioDeviceMac::PlayoutDevices()
   1098 {
   1099 
   1100     AudioDeviceID playDevices[MaxNumberDevices];
   1101     return GetNumberDevices(kAudioDevicePropertyScopeOutput, playDevices,
   1102                             MaxNumberDevices);
   1103 }
   1104 
   1105 int32_t AudioDeviceMac::SetPlayoutDevice(uint16_t index)
   1106 {
   1107 
   1108     if (_playIsInitialized)
   1109     {
   1110         return -1;
   1111     }
   1112 
   1113     AudioDeviceID playDevices[MaxNumberDevices];
   1114     uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeOutput,
   1115                                          playDevices, MaxNumberDevices);
   1116     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1117                  "  number of availiable waveform-audio output devices is %u",
   1118                  nDevices);
   1119 
   1120     if (index > (nDevices - 1))
   1121     {
   1122         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1123                      "  device index is out of range [0,%u]", (nDevices - 1));
   1124         return -1;
   1125     }
   1126 
   1127     _outputDeviceIndex = index;
   1128     _outputDeviceIsSpecified = true;
   1129 
   1130     return 0;
   1131 }
   1132 
   1133 int32_t AudioDeviceMac::SetPlayoutDevice(
   1134     AudioDeviceModule::WindowsDeviceType /*device*/)
   1135 {
   1136     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1137                  "WindowsDeviceType not supported");
   1138     return -1;
   1139 }
   1140 
   1141 int32_t AudioDeviceMac::PlayoutDeviceName(
   1142     uint16_t index,
   1143     char name[kAdmMaxDeviceNameSize],
   1144     char guid[kAdmMaxGuidSize])
   1145 {
   1146 
   1147     const uint16_t nDevices(PlayoutDevices());
   1148 
   1149     if ((index > (nDevices - 1)) || (name == NULL))
   1150     {
   1151         return -1;
   1152     }
   1153 
   1154     memset(name, 0, kAdmMaxDeviceNameSize);
   1155 
   1156     if (guid != NULL)
   1157     {
   1158         memset(guid, 0, kAdmMaxGuidSize);
   1159     }
   1160 
   1161     return GetDeviceName(kAudioDevicePropertyScopeOutput, index, name);
   1162 }
   1163 
   1164 int32_t AudioDeviceMac::RecordingDeviceName(
   1165     uint16_t index,
   1166     char name[kAdmMaxDeviceNameSize],
   1167     char guid[kAdmMaxGuidSize])
   1168 {
   1169 
   1170     const uint16_t nDevices(RecordingDevices());
   1171 
   1172     if ((index > (nDevices - 1)) || (name == NULL))
   1173     {
   1174         return -1;
   1175     }
   1176 
   1177     memset(name, 0, kAdmMaxDeviceNameSize);
   1178 
   1179     if (guid != NULL)
   1180     {
   1181         memset(guid, 0, kAdmMaxGuidSize);
   1182     }
   1183 
   1184     return GetDeviceName(kAudioDevicePropertyScopeInput, index, name);
   1185 }
   1186 
   1187 int16_t AudioDeviceMac::RecordingDevices()
   1188 {
   1189 
   1190     AudioDeviceID recDevices[MaxNumberDevices];
   1191     return GetNumberDevices(kAudioDevicePropertyScopeInput, recDevices,
   1192                             MaxNumberDevices);
   1193 }
   1194 
   1195 int32_t AudioDeviceMac::SetRecordingDevice(uint16_t index)
   1196 {
   1197 
   1198     if (_recIsInitialized)
   1199     {
   1200         return -1;
   1201     }
   1202 
   1203     AudioDeviceID recDevices[MaxNumberDevices];
   1204     uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeInput,
   1205                                          recDevices, MaxNumberDevices);
   1206     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1207                  "  number of availiable waveform-audio input devices is %u",
   1208                  nDevices);
   1209 
   1210     if (index > (nDevices - 1))
   1211     {
   1212         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1213                      "  device index is out of range [0,%u]", (nDevices - 1));
   1214         return -1;
   1215     }
   1216 
   1217     _inputDeviceIndex = index;
   1218     _inputDeviceIsSpecified = true;
   1219 
   1220     return 0;
   1221 }
   1222 
   1223 
   1224 int32_t
   1225 AudioDeviceMac::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType /*device*/)
   1226 {
   1227     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1228                  "WindowsDeviceType not supported");
   1229     return -1;
   1230 }
   1231 
   1232 int32_t AudioDeviceMac::PlayoutIsAvailable(bool& available)
   1233 {
   1234 
   1235     available = true;
   1236 
   1237     // Try to initialize the playout side
   1238     if (InitPlayout() == -1)
   1239     {
   1240         available = false;
   1241     }
   1242 
   1243     // We destroy the IOProc created by InitPlayout() in implDeviceIOProc().
   1244     // We must actually start playout here in order to have the IOProc
   1245     // deleted by calling StopPlayout().
   1246     if (StartPlayout() == -1)
   1247     {
   1248         available = false;
   1249     }
   1250 
   1251     // Cancel effect of initialization
   1252     if (StopPlayout() == -1)
   1253     {
   1254         available = false;
   1255     }
   1256 
   1257     return 0;
   1258 }
   1259 
   1260 int32_t AudioDeviceMac::RecordingIsAvailable(bool& available)
   1261 {
   1262 
   1263     available = true;
   1264 
   1265     // Try to initialize the recording side
   1266     if (InitRecording() == -1)
   1267     {
   1268         available = false;
   1269     }
   1270 
   1271     // We destroy the IOProc created by InitRecording() in implInDeviceIOProc().
   1272     // We must actually start recording here in order to have the IOProc
   1273     // deleted by calling StopRecording().
   1274     if (StartRecording() == -1)
   1275     {
   1276         available = false;
   1277     }
   1278 
   1279     // Cancel effect of initialization
   1280     if (StopRecording() == -1)
   1281     {
   1282         available = false;
   1283     }
   1284 
   1285     return 0;
   1286 }
   1287 
   1288 int32_t AudioDeviceMac::InitPlayout()
   1289 {
   1290 
   1291     CriticalSectionScoped lock(&_critSect);
   1292 
   1293     if (_playing)
   1294     {
   1295         return -1;
   1296     }
   1297 
   1298     if (!_outputDeviceIsSpecified)
   1299     {
   1300         return -1;
   1301     }
   1302 
   1303     if (_playIsInitialized)
   1304     {
   1305         return 0;
   1306     }
   1307 
   1308     // Initialize the speaker (devices might have been added or removed)
   1309     if (InitSpeaker() == -1)
   1310     {
   1311         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1312                      "  InitSpeaker() failed");
   1313     }
   1314 
   1315     if (!MicrophoneIsInitialized())
   1316     {
   1317         // Make this call to check if we are using
   1318         // one or two devices (_twoDevices)
   1319         bool available = false;
   1320         if (MicrophoneIsAvailable(available) == -1)
   1321         {
   1322             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1323                          "  MicrophoneIsAvailable() failed");
   1324         }
   1325     }
   1326 
   1327     PaUtil_FlushRingBuffer(_paRenderBuffer);
   1328 
   1329     OSStatus err = noErr;
   1330     UInt32 size = 0;
   1331     _renderDelayOffsetSamples = 0;
   1332     _renderDelayUs = 0;
   1333     _renderLatencyUs = 0;
   1334     _renderDeviceIsAlive = 1;
   1335     _doStop = false;
   1336 
   1337     // The internal microphone of a MacBook Pro is located under the left speaker
   1338     // grille. When the internal speakers are in use, we want to fully stereo
   1339     // pan to the right.
   1340     AudioObjectPropertyAddress
   1341         propertyAddress = { kAudioDevicePropertyDataSource,
   1342                 kAudioDevicePropertyScopeOutput, 0 };
   1343     if (_macBookPro)
   1344     {
   1345         _macBookProPanRight = false;
   1346         Boolean hasProperty = AudioObjectHasProperty(_outputDeviceID,
   1347                                                      &propertyAddress);
   1348         if (hasProperty)
   1349         {
   1350             UInt32 dataSource = 0;
   1351             size = sizeof(dataSource);
   1352             WEBRTC_CA_LOG_WARN(AudioObjectGetPropertyData(_outputDeviceID,
   1353                     &propertyAddress, 0, NULL, &size, &dataSource));
   1354 
   1355             if (dataSource == 'ispk')
   1356             {
   1357                 _macBookProPanRight = true;
   1358                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice,
   1359                              _id,
   1360                              "MacBook Pro using internal speakers; stereo"
   1361                              " panning right");
   1362             } else
   1363             {
   1364                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice,
   1365                              _id, "MacBook Pro not using internal speakers");
   1366             }
   1367 
   1368             // Add a listener to determine if the status changes.
   1369             WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(_outputDeviceID,
   1370                     &propertyAddress, &objectListenerProc, this));
   1371         }
   1372     }
   1373 
   1374     // Get current stream description
   1375     propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   1376     memset(&_outStreamFormat, 0, sizeof(_outStreamFormat));
   1377     size = sizeof(_outStreamFormat);
   1378     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
   1379             &propertyAddress, 0, NULL, &size, &_outStreamFormat));
   1380 
   1381     if (_outStreamFormat.mFormatID != kAudioFormatLinearPCM)
   1382     {
   1383         logCAMsg(kTraceError, kTraceAudioDevice, _id,
   1384                  "Unacceptable output stream format -> mFormatID",
   1385                  (const char *) &_outStreamFormat.mFormatID);
   1386         return -1;
   1387     }
   1388 
   1389     if (_outStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS)
   1390     {
   1391         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1392             "Too many channels on output device (mChannelsPerFrame = %d)",
   1393             _outStreamFormat.mChannelsPerFrame);
   1394         return -1;
   1395     }
   1396 
   1397     if (_outStreamFormat.mFormatFlags & kAudioFormatFlagIsNonInterleaved)
   1398     {
   1399         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1400                      "Non-interleaved audio data is not supported.",
   1401                      "AudioHardware streams should not have this format.");
   1402         return -1;
   1403     }
   1404 
   1405     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1406                  "Ouput stream format:");
   1407     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1408                  "mSampleRate = %f, mChannelsPerFrame = %u",
   1409                  _outStreamFormat.mSampleRate,
   1410                  _outStreamFormat.mChannelsPerFrame);
   1411     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1412                  "mBytesPerPacket = %u, mFramesPerPacket = %u",
   1413                  _outStreamFormat.mBytesPerPacket,
   1414                  _outStreamFormat.mFramesPerPacket);
   1415     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1416                  "mBytesPerFrame = %u, mBitsPerChannel = %u",
   1417                  _outStreamFormat.mBytesPerFrame,
   1418                  _outStreamFormat.mBitsPerChannel);
   1419     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1420                  "mFormatFlags = %u",
   1421                  _outStreamFormat.mFormatFlags);
   1422     logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
   1423              (const char *) &_outStreamFormat.mFormatID);
   1424 
   1425     // Our preferred format to work with
   1426     _outDesiredFormat.mSampleRate = N_PLAY_SAMPLES_PER_SEC;
   1427     if (_outStreamFormat.mChannelsPerFrame >= 2 && (_playChannels == 2))
   1428     {
   1429         _outDesiredFormat.mChannelsPerFrame = 2;
   1430     } else
   1431     {
   1432         // Disable stereo playout when we only have one channel on the device.
   1433         _outDesiredFormat.mChannelsPerFrame = 1;
   1434         _playChannels = 1;
   1435         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1436                      "Stereo playout unavailable on this device");
   1437     }
   1438 
   1439     if (_ptrAudioBuffer)
   1440     {
   1441         // Update audio buffer with the selected parameters
   1442         _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC);
   1443         _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels);
   1444     }
   1445 
   1446     _renderDelayOffsetSamples = _renderBufSizeSamples - N_BUFFERS_OUT
   1447         * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES * _outDesiredFormat.mChannelsPerFrame;
   1448 
   1449     _outDesiredFormat.mBytesPerPacket = _outDesiredFormat.mChannelsPerFrame
   1450         * sizeof(SInt16);
   1451     _outDesiredFormat.mFramesPerPacket = 1; // In uncompressed audio,
   1452     // a packet is one frame.
   1453     _outDesiredFormat.mBytesPerFrame = _outDesiredFormat.mChannelsPerFrame
   1454         * sizeof(SInt16);
   1455     _outDesiredFormat.mBitsPerChannel = sizeof(SInt16) * 8;
   1456 
   1457     _outDesiredFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
   1458         | kLinearPCMFormatFlagIsPacked;
   1459 #ifdef WEBRTC_ARCH_BIG_ENDIAN
   1460     _outDesiredFormat.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
   1461 #endif
   1462     _outDesiredFormat.mFormatID = kAudioFormatLinearPCM;
   1463 
   1464     WEBRTC_CA_RETURN_ON_ERR(AudioConverterNew(&_outDesiredFormat, &_outStreamFormat,
   1465             &_renderConverter));
   1466 
   1467     // First try to set buffer size to desired value (_playBufDelayFixed)
   1468     UInt32 bufByteCount = (UInt32)((_outStreamFormat.mSampleRate / 1000.0)
   1469         * _playBufDelayFixed * _outStreamFormat.mChannelsPerFrame
   1470         * sizeof(Float32));
   1471     if (_outStreamFormat.mFramesPerPacket != 0)
   1472     {
   1473         if (bufByteCount % _outStreamFormat.mFramesPerPacket != 0)
   1474         {
   1475             bufByteCount = ((UInt32)(bufByteCount
   1476                 / _outStreamFormat.mFramesPerPacket) + 1)
   1477                 * _outStreamFormat.mFramesPerPacket;
   1478         }
   1479     }
   1480 
   1481     // Ensure the buffer size is within the acceptable range provided by the device.
   1482     propertyAddress.mSelector = kAudioDevicePropertyBufferSizeRange;
   1483     AudioValueRange range;
   1484     size = sizeof(range);
   1485     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
   1486             &propertyAddress, 0, NULL, &size, &range));
   1487     if (range.mMinimum > bufByteCount)
   1488     {
   1489         bufByteCount = range.mMinimum;
   1490     } else if (range.mMaximum < bufByteCount)
   1491     {
   1492         bufByteCount = range.mMaximum;
   1493     }
   1494 
   1495     propertyAddress.mSelector = kAudioDevicePropertyBufferSize;
   1496     size = sizeof(bufByteCount);
   1497     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_outputDeviceID,
   1498             &propertyAddress, 0, NULL, size, &bufByteCount));
   1499 
   1500     // Get render device latency
   1501     propertyAddress.mSelector = kAudioDevicePropertyLatency;
   1502     UInt32 latency = 0;
   1503     size = sizeof(UInt32);
   1504     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
   1505             &propertyAddress, 0, NULL, &size, &latency));
   1506     _renderLatencyUs = (uint32_t) ((1.0e6 * latency)
   1507         / _outStreamFormat.mSampleRate);
   1508 
   1509     // Get render stream latency
   1510     propertyAddress.mSelector = kAudioDevicePropertyStreams;
   1511     AudioStreamID stream = 0;
   1512     size = sizeof(AudioStreamID);
   1513     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
   1514             &propertyAddress, 0, NULL, &size, &stream));
   1515     propertyAddress.mSelector = kAudioStreamPropertyLatency;
   1516     size = sizeof(UInt32);
   1517     latency = 0;
   1518     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID,
   1519             &propertyAddress, 0, NULL, &size, &latency));
   1520     _renderLatencyUs += (uint32_t) ((1.0e6 * latency)
   1521         / _outStreamFormat.mSampleRate);
   1522 
   1523     // Listen for format changes
   1524     propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   1525     WEBRTC_CA_RETURN_ON_ERR(AudioObjectAddPropertyListener(_outputDeviceID,
   1526             &propertyAddress, &objectListenerProc, this));
   1527 
   1528     // Listen for processor overloads
   1529     propertyAddress.mSelector = kAudioDeviceProcessorOverload;
   1530     WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(_outputDeviceID,
   1531             &propertyAddress, &objectListenerProc, this));
   1532 
   1533     if (_twoDevices || !_recIsInitialized)
   1534     {
   1535         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceCreateIOProcID(_outputDeviceID,
   1536                 deviceIOProc, this, &_deviceIOProcID));
   1537     }
   1538 
   1539     // Mark playout side as initialized
   1540     _playIsInitialized = true;
   1541 
   1542     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1543                  "  initial playout status: _renderDelayOffsetSamples=%d,"
   1544                  " _renderDelayUs=%d, _renderLatencyUs=%d",
   1545                  _renderDelayOffsetSamples, _renderDelayUs, _renderLatencyUs);
   1546 
   1547     return 0;
   1548 }
   1549 
   1550 int32_t AudioDeviceMac::InitRecording()
   1551 {
   1552 
   1553     CriticalSectionScoped lock(&_critSect);
   1554 
   1555     if (_recording)
   1556     {
   1557         return -1;
   1558     }
   1559 
   1560     if (!_inputDeviceIsSpecified)
   1561     {
   1562         return -1;
   1563     }
   1564 
   1565     if (_recIsInitialized)
   1566     {
   1567         return 0;
   1568     }
   1569 
   1570     // Initialize the microphone (devices might have been added or removed)
   1571     if (InitMicrophone() == -1)
   1572     {
   1573         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1574                      "  InitMicrophone() failed");
   1575     }
   1576 
   1577     if (!SpeakerIsInitialized())
   1578     {
   1579         // Make this call to check if we are using
   1580         // one or two devices (_twoDevices)
   1581         bool available = false;
   1582         if (SpeakerIsAvailable(available) == -1)
   1583         {
   1584             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1585                          "  SpeakerIsAvailable() failed");
   1586         }
   1587     }
   1588 
   1589     OSStatus err = noErr;
   1590     UInt32 size = 0;
   1591 
   1592     PaUtil_FlushRingBuffer(_paCaptureBuffer);
   1593 
   1594     _captureDelayUs = 0;
   1595     _captureLatencyUs = 0;
   1596     _captureDeviceIsAlive = 1;
   1597     _doStopRec = false;
   1598 
   1599     // Get current stream description
   1600     AudioObjectPropertyAddress
   1601         propertyAddress = { kAudioDevicePropertyStreamFormat,
   1602                 kAudioDevicePropertyScopeInput, 0 };
   1603     memset(&_inStreamFormat, 0, sizeof(_inStreamFormat));
   1604     size = sizeof(_inStreamFormat);
   1605     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
   1606             &propertyAddress, 0, NULL, &size, &_inStreamFormat));
   1607 
   1608     if (_inStreamFormat.mFormatID != kAudioFormatLinearPCM)
   1609     {
   1610         logCAMsg(kTraceError, kTraceAudioDevice, _id,
   1611                  "Unacceptable input stream format -> mFormatID",
   1612                  (const char *) &_inStreamFormat.mFormatID);
   1613         return -1;
   1614     }
   1615 
   1616     if (_inStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS)
   1617     {
   1618         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1619             "Too many channels on input device (mChannelsPerFrame = %d)",
   1620             _inStreamFormat.mChannelsPerFrame);
   1621         return -1;
   1622     }
   1623 
   1624     const int io_block_size_samples = _inStreamFormat.mChannelsPerFrame *
   1625         _inStreamFormat.mSampleRate / 100 * N_BLOCKS_IO;
   1626     if (io_block_size_samples > _captureBufSizeSamples)
   1627     {
   1628         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1629             "Input IO block size (%d) is larger than ring buffer (%u)",
   1630             io_block_size_samples, _captureBufSizeSamples);
   1631         return -1;
   1632     }
   1633 
   1634     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1635                  " Input stream format:");
   1636     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1637                  " mSampleRate = %f, mChannelsPerFrame = %u",
   1638                  _inStreamFormat.mSampleRate, _inStreamFormat.mChannelsPerFrame);
   1639     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1640                  " mBytesPerPacket = %u, mFramesPerPacket = %u",
   1641                  _inStreamFormat.mBytesPerPacket,
   1642                  _inStreamFormat.mFramesPerPacket);
   1643     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1644                  " mBytesPerFrame = %u, mBitsPerChannel = %u",
   1645                  _inStreamFormat.mBytesPerFrame,
   1646                  _inStreamFormat.mBitsPerChannel);
   1647     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1648                  " mFormatFlags = %u",
   1649                  _inStreamFormat.mFormatFlags);
   1650     logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
   1651              (const char *) &_inStreamFormat.mFormatID);
   1652 
   1653     // Our preferred format to work with
   1654     if (_inStreamFormat.mChannelsPerFrame >= 2 && (_recChannels == 2))
   1655     {
   1656         _inDesiredFormat.mChannelsPerFrame = 2;
   1657     } else
   1658     {
   1659         // Disable stereo recording when we only have one channel on the device.
   1660         _inDesiredFormat.mChannelsPerFrame = 1;
   1661         _recChannels = 1;
   1662         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   1663                      "Stereo recording unavailable on this device");
   1664     }
   1665 
   1666     if (_ptrAudioBuffer)
   1667     {
   1668         // Update audio buffer with the selected parameters
   1669         _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
   1670         _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels);
   1671     }
   1672 
   1673     _inDesiredFormat.mSampleRate = N_REC_SAMPLES_PER_SEC;
   1674     _inDesiredFormat.mBytesPerPacket = _inDesiredFormat.mChannelsPerFrame
   1675         * sizeof(SInt16);
   1676     _inDesiredFormat.mFramesPerPacket = 1;
   1677     _inDesiredFormat.mBytesPerFrame = _inDesiredFormat.mChannelsPerFrame
   1678         * sizeof(SInt16);
   1679     _inDesiredFormat.mBitsPerChannel = sizeof(SInt16) * 8;
   1680 
   1681     _inDesiredFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
   1682         | kLinearPCMFormatFlagIsPacked;
   1683 #ifdef WEBRTC_ARCH_BIG_ENDIAN
   1684     _inDesiredFormat.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
   1685 #endif
   1686     _inDesiredFormat.mFormatID = kAudioFormatLinearPCM;
   1687 
   1688     WEBRTC_CA_RETURN_ON_ERR(AudioConverterNew(&_inStreamFormat, &_inDesiredFormat,
   1689             &_captureConverter));
   1690 
   1691     // First try to set buffer size to desired value (10 ms * N_BLOCKS_IO)
   1692     // TODO(xians): investigate this block.
   1693     UInt32 bufByteCount = (UInt32)((_inStreamFormat.mSampleRate / 1000.0)
   1694         * 10.0 * N_BLOCKS_IO * _inStreamFormat.mChannelsPerFrame
   1695         * sizeof(Float32));
   1696     if (_inStreamFormat.mFramesPerPacket != 0)
   1697     {
   1698         if (bufByteCount % _inStreamFormat.mFramesPerPacket != 0)
   1699         {
   1700             bufByteCount = ((UInt32)(bufByteCount
   1701                 / _inStreamFormat.mFramesPerPacket) + 1)
   1702                 * _inStreamFormat.mFramesPerPacket;
   1703         }
   1704     }
   1705 
   1706     // Ensure the buffer size is within the acceptable range provided by the device.
   1707     propertyAddress.mSelector = kAudioDevicePropertyBufferSizeRange;
   1708     AudioValueRange range;
   1709     size = sizeof(range);
   1710     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
   1711             &propertyAddress, 0, NULL, &size, &range));
   1712     if (range.mMinimum > bufByteCount)
   1713     {
   1714         bufByteCount = range.mMinimum;
   1715     } else if (range.mMaximum < bufByteCount)
   1716     {
   1717         bufByteCount = range.mMaximum;
   1718     }
   1719 
   1720     propertyAddress.mSelector = kAudioDevicePropertyBufferSize;
   1721     size = sizeof(bufByteCount);
   1722     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(_inputDeviceID,
   1723             &propertyAddress, 0, NULL, size, &bufByteCount));
   1724 
   1725     // Get capture device latency
   1726     propertyAddress.mSelector = kAudioDevicePropertyLatency;
   1727     UInt32 latency = 0;
   1728     size = sizeof(UInt32);
   1729     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
   1730             &propertyAddress, 0, NULL, &size, &latency));
   1731     _captureLatencyUs = (UInt32)((1.0e6 * latency)
   1732         / _inStreamFormat.mSampleRate);
   1733 
   1734     // Get capture stream latency
   1735     propertyAddress.mSelector = kAudioDevicePropertyStreams;
   1736     AudioStreamID stream = 0;
   1737     size = sizeof(AudioStreamID);
   1738     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
   1739             &propertyAddress, 0, NULL, &size, &stream));
   1740     propertyAddress.mSelector = kAudioStreamPropertyLatency;
   1741     size = sizeof(UInt32);
   1742     latency = 0;
   1743     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_inputDeviceID,
   1744             &propertyAddress, 0, NULL, &size, &latency));
   1745     _captureLatencyUs += (UInt32)((1.0e6 * latency)
   1746         / _inStreamFormat.mSampleRate);
   1747 
   1748     // Listen for format changes
   1749     // TODO(xians): should we be using kAudioDevicePropertyDeviceHasChanged?
   1750     propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   1751     WEBRTC_CA_RETURN_ON_ERR(AudioObjectAddPropertyListener(_inputDeviceID,
   1752             &propertyAddress, &objectListenerProc, this));
   1753 
   1754     // Listen for processor overloads
   1755     propertyAddress.mSelector = kAudioDeviceProcessorOverload;
   1756     WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(_inputDeviceID,
   1757             &propertyAddress, &objectListenerProc, this));
   1758 
   1759     if (_twoDevices)
   1760     {
   1761         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceCreateIOProcID(_inputDeviceID,
   1762                 inDeviceIOProc, this, &_inDeviceIOProcID));
   1763     } else if (!_playIsInitialized)
   1764     {
   1765         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceCreateIOProcID(_inputDeviceID,
   1766                 deviceIOProc, this, &_deviceIOProcID));
   1767     }
   1768 
   1769     // Mark recording side as initialized
   1770     _recIsInitialized = true;
   1771 
   1772     return 0;
   1773 }
   1774 
   1775 int32_t AudioDeviceMac::StartRecording()
   1776 {
   1777 
   1778     CriticalSectionScoped lock(&_critSect);
   1779 
   1780     if (!_recIsInitialized)
   1781     {
   1782         return -1;
   1783     }
   1784 
   1785     if (_recording)
   1786     {
   1787         return 0;
   1788     }
   1789 
   1790     if (!_initialized)
   1791     {
   1792         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1793                      " Recording worker thread has not been started");
   1794         return -1;
   1795     }
   1796 
   1797     OSStatus err = noErr;
   1798 
   1799     unsigned int threadID(0);
   1800     if (_captureWorkerThread != NULL)
   1801     {
   1802         _captureWorkerThread->Start(threadID);
   1803     }
   1804     _captureWorkerThreadId = threadID;
   1805 
   1806     if (_twoDevices)
   1807     {
   1808         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _inDeviceIOProcID));
   1809     } else if (!_playing)
   1810     {
   1811         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _deviceIOProcID));
   1812     }
   1813 
   1814     _recording = true;
   1815 
   1816     return 0;
   1817 }
   1818 
   1819 int32_t AudioDeviceMac::StopRecording()
   1820 {
   1821 
   1822     CriticalSectionScoped lock(&_critSect);
   1823 
   1824     if (!_recIsInitialized)
   1825     {
   1826         return 0;
   1827     }
   1828 
   1829     OSStatus err = noErr;
   1830 
   1831     // Stop device
   1832     int32_t captureDeviceIsAlive = AtomicGet32(&_captureDeviceIsAlive);
   1833     if (_twoDevices)
   1834     {
   1835         if (_recording && captureDeviceIsAlive == 1)
   1836         {
   1837             _recording = false;
   1838             _doStopRec = true; // Signal to io proc to stop audio device
   1839             _critSect.Leave(); // Cannot be under lock, risk of deadlock
   1840             if (kEventTimeout == _stopEventRec.Wait(2000))
   1841             {
   1842                 CriticalSectionScoped critScoped(&_critSect);
   1843                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1844                              " Timed out stopping the capture IOProc. "
   1845                              "We may have failed to detect a device removal.");
   1846 
   1847                 WEBRTC_CA_LOG_WARN(AudioDeviceStop(_inputDeviceID,
   1848                                                    _inDeviceIOProcID));
   1849                 WEBRTC_CA_LOG_WARN(
   1850                     AudioDeviceDestroyIOProcID(_inputDeviceID,
   1851                                                _inDeviceIOProcID));
   1852             }
   1853             _critSect.Enter();
   1854             _doStopRec = false;
   1855             WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   1856                          " Recording stopped");
   1857         }
   1858     }
   1859     else
   1860     {
   1861         // We signal a stop for a shared device even when rendering has
   1862         // not yet ended. This is to ensure the IOProc will return early as
   1863         // intended (by checking |_recording|) before accessing
   1864         // resources we free below (e.g. the capture converter).
   1865         //
   1866         // In the case of a shared devcie, the IOProc will verify
   1867         // rendering has ended before stopping itself.
   1868         if (_recording && captureDeviceIsAlive == 1)
   1869         {
   1870             _recording = false;
   1871             _doStop = true; // Signal to io proc to stop audio device
   1872             _critSect.Leave(); // Cannot be under lock, risk of deadlock
   1873             if (kEventTimeout == _stopEvent.Wait(2000))
   1874             {
   1875                 CriticalSectionScoped critScoped(&_critSect);
   1876                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   1877                              " Timed out stopping the shared IOProc. "
   1878                              "We may have failed to detect a device removal.");
   1879 
   1880                 // We assume rendering on a shared device has stopped as well if
   1881                 // the IOProc times out.
   1882                 WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID,
   1883                                                    _deviceIOProcID));
   1884                 WEBRTC_CA_LOG_WARN(AudioDeviceDestroyIOProcID(_outputDeviceID,
   1885                                                               _deviceIOProcID));
   1886             }
   1887             _critSect.Enter();
   1888             _doStop = false;
   1889             WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   1890                          " Recording stopped (shared)");
   1891         }
   1892     }
   1893 
   1894     // Setting this signal will allow the worker thread to be stopped.
   1895     AtomicSet32(&_captureDeviceIsAlive, 0);
   1896     _critSect.Leave();
   1897     if (_captureWorkerThread != NULL)
   1898     {
   1899         if (!_captureWorkerThread->Stop())
   1900         {
   1901             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   1902                          " Timed out waiting for the render worker thread to "
   1903                              "stop.");
   1904         }
   1905     }
   1906     _critSect.Enter();
   1907 
   1908     WEBRTC_CA_LOG_WARN(AudioConverterDispose(_captureConverter));
   1909 
   1910     // Remove listeners.
   1911     AudioObjectPropertyAddress
   1912         propertyAddress = { kAudioDevicePropertyStreamFormat,
   1913                 kAudioDevicePropertyScopeInput, 0 };
   1914     WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(_inputDeviceID,
   1915             &propertyAddress, &objectListenerProc, this));
   1916 
   1917     propertyAddress.mSelector = kAudioDeviceProcessorOverload;
   1918     WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(_inputDeviceID,
   1919             &propertyAddress, &objectListenerProc, this));
   1920 
   1921     _recIsInitialized = false;
   1922     _recording = false;
   1923 
   1924     return 0;
   1925 }
   1926 
   1927 bool AudioDeviceMac::RecordingIsInitialized() const
   1928 {
   1929     return (_recIsInitialized);
   1930 }
   1931 
   1932 bool AudioDeviceMac::Recording() const
   1933 {
   1934     return (_recording);
   1935 }
   1936 
   1937 bool AudioDeviceMac::PlayoutIsInitialized() const
   1938 {
   1939     return (_playIsInitialized);
   1940 }
   1941 
   1942 int32_t AudioDeviceMac::StartPlayout()
   1943 {
   1944 
   1945     CriticalSectionScoped lock(&_critSect);
   1946 
   1947     if (!_playIsInitialized)
   1948     {
   1949         return -1;
   1950     }
   1951 
   1952     if (_playing)
   1953     {
   1954         return 0;
   1955     }
   1956 
   1957     OSStatus err = noErr;
   1958 
   1959     unsigned int threadID(0);
   1960     if (_renderWorkerThread != NULL)
   1961     {
   1962         _renderWorkerThread->Start(threadID);
   1963     }
   1964     _renderWorkerThreadId = threadID;
   1965 
   1966     if (_twoDevices || !_recording)
   1967     {
   1968         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_outputDeviceID, _deviceIOProcID));
   1969     }
   1970     _playing = true;
   1971 
   1972     return 0;
   1973 }
   1974 
   1975 int32_t AudioDeviceMac::StopPlayout()
   1976 {
   1977 
   1978     CriticalSectionScoped lock(&_critSect);
   1979 
   1980     if (!_playIsInitialized)
   1981     {
   1982         return 0;
   1983     }
   1984 
   1985     OSStatus err = noErr;
   1986 
   1987     int32_t renderDeviceIsAlive = AtomicGet32(&_renderDeviceIsAlive);
   1988     if (_playing && renderDeviceIsAlive == 1)
   1989     {
   1990         // We signal a stop for a shared device even when capturing has not
   1991         // yet ended. This is to ensure the IOProc will return early as
   1992         // intended (by checking |_playing|) before accessing resources we
   1993         // free below (e.g. the render converter).
   1994         //
   1995         // In the case of a shared device, the IOProc will verify capturing
   1996         // has ended before stopping itself.
   1997         _playing = false;
   1998         _doStop = true; // Signal to io proc to stop audio device
   1999         _critSect.Leave(); // Cannot be under lock, risk of deadlock
   2000         if (kEventTimeout == _stopEvent.Wait(2000))
   2001         {
   2002             CriticalSectionScoped critScoped(&_critSect);
   2003             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2004                          " Timed out stopping the render IOProc. "
   2005                          "We may have failed to detect a device removal.");
   2006 
   2007             // We assume capturing on a shared device has stopped as well if the
   2008             // IOProc times out.
   2009             WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID,
   2010                                                _deviceIOProcID));
   2011             WEBRTC_CA_LOG_WARN(AudioDeviceDestroyIOProcID(_outputDeviceID,
   2012                                                           _deviceIOProcID));
   2013         }
   2014         _critSect.Enter();
   2015         _doStop = false;
   2016         WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   2017                      "Playout stopped");
   2018     }
   2019 
   2020     // Setting this signal will allow the worker thread to be stopped.
   2021     AtomicSet32(&_renderDeviceIsAlive, 0);
   2022     _critSect.Leave();
   2023     if (_renderWorkerThread != NULL)
   2024     {
   2025         if (!_renderWorkerThread->Stop())
   2026         {
   2027             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2028                          " Timed out waiting for the render worker thread to "
   2029                          "stop.");
   2030         }
   2031     }
   2032     _critSect.Enter();
   2033 
   2034     WEBRTC_CA_LOG_WARN(AudioConverterDispose(_renderConverter));
   2035 
   2036     // Remove listeners.
   2037     AudioObjectPropertyAddress propertyAddress = {
   2038             kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeOutput,
   2039             0 };
   2040     WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(_outputDeviceID,
   2041             &propertyAddress, &objectListenerProc, this));
   2042 
   2043     propertyAddress.mSelector = kAudioDeviceProcessorOverload;
   2044     WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(_outputDeviceID,
   2045             &propertyAddress, &objectListenerProc, this));
   2046 
   2047     if (_macBookPro)
   2048     {
   2049         Boolean hasProperty = AudioObjectHasProperty(_outputDeviceID,
   2050                                                      &propertyAddress);
   2051         if (hasProperty)
   2052         {
   2053             propertyAddress.mSelector = kAudioDevicePropertyDataSource;
   2054             WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(_outputDeviceID,
   2055                     &propertyAddress, &objectListenerProc, this));
   2056         }
   2057     }
   2058 
   2059     _playIsInitialized = false;
   2060     _playing = false;
   2061 
   2062     return 0;
   2063 }
   2064 
   2065 int32_t AudioDeviceMac::PlayoutDelay(uint16_t& delayMS) const
   2066 {
   2067     int32_t renderDelayUs = AtomicGet32(&_renderDelayUs);
   2068     delayMS = static_cast<uint16_t> (1e-3 * (renderDelayUs + _renderLatencyUs) +
   2069                                      0.5);
   2070     return 0;
   2071 }
   2072 
   2073 int32_t AudioDeviceMac::RecordingDelay(uint16_t& delayMS) const
   2074 {
   2075     int32_t captureDelayUs = AtomicGet32(&_captureDelayUs);
   2076     delayMS = static_cast<uint16_t> (1e-3 * (captureDelayUs +
   2077                                              _captureLatencyUs) + 0.5);
   2078     return 0;
   2079 }
   2080 
   2081 bool AudioDeviceMac::Playing() const
   2082 {
   2083     return (_playing);
   2084 }
   2085 
   2086 int32_t AudioDeviceMac::SetPlayoutBuffer(
   2087     const AudioDeviceModule::BufferType type,
   2088     uint16_t sizeMS)
   2089 {
   2090 
   2091     if (type != AudioDeviceModule::kFixedBufferSize)
   2092     {
   2093         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2094                      " Adaptive buffer size not supported on this platform");
   2095         return -1;
   2096     }
   2097 
   2098     _playBufType = type;
   2099     _playBufDelayFixed = sizeMS;
   2100     return 0;
   2101 }
   2102 
   2103 int32_t AudioDeviceMac::PlayoutBuffer(
   2104     AudioDeviceModule::BufferType& type,
   2105     uint16_t& sizeMS) const
   2106 {
   2107 
   2108     type = _playBufType;
   2109     sizeMS = _playBufDelayFixed;
   2110 
   2111     return 0;
   2112 }
   2113 
   2114 // Not implemented for Mac.
   2115 int32_t AudioDeviceMac::CPULoad(uint16_t& /*load*/) const
   2116 {
   2117 
   2118     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2119                  "  API call not supported on this platform");
   2120 
   2121     return -1;
   2122 }
   2123 
   2124 bool AudioDeviceMac::PlayoutWarning() const
   2125 {
   2126     return (_playWarning > 0);
   2127 }
   2128 
   2129 bool AudioDeviceMac::PlayoutError() const
   2130 {
   2131     return (_playError > 0);
   2132 }
   2133 
   2134 bool AudioDeviceMac::RecordingWarning() const
   2135 {
   2136     return (_recWarning > 0);
   2137 }
   2138 
   2139 bool AudioDeviceMac::RecordingError() const
   2140 {
   2141     return (_recError > 0);
   2142 }
   2143 
   2144 void AudioDeviceMac::ClearPlayoutWarning()
   2145 {
   2146     _playWarning = 0;
   2147 }
   2148 
   2149 void AudioDeviceMac::ClearPlayoutError()
   2150 {
   2151     _playError = 0;
   2152 }
   2153 
   2154 void AudioDeviceMac::ClearRecordingWarning()
   2155 {
   2156     _recWarning = 0;
   2157 }
   2158 
   2159 void AudioDeviceMac::ClearRecordingError()
   2160 {
   2161     _recError = 0;
   2162 }
   2163 
   2164 // ============================================================================
   2165 //                                 Private Methods
   2166 // ============================================================================
   2167 
   2168 int32_t
   2169 AudioDeviceMac::GetNumberDevices(const AudioObjectPropertyScope scope,
   2170                                  AudioDeviceID scopedDeviceIds[],
   2171                                  const uint32_t deviceListLength)
   2172 {
   2173     OSStatus err = noErr;
   2174 
   2175     AudioObjectPropertyAddress propertyAddress = {
   2176             kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
   2177             kAudioObjectPropertyElementMaster };
   2178     UInt32 size = 0;
   2179     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
   2180             &propertyAddress, 0, NULL, &size));
   2181     if (size == 0)
   2182     {
   2183         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2184                      "No devices");
   2185         return 0;
   2186     }
   2187 
   2188     AudioDeviceID* deviceIds = (AudioDeviceID*) malloc(size);
   2189     UInt32 numberDevices = size / sizeof(AudioDeviceID);
   2190     AudioBufferList* bufferList = NULL;
   2191     UInt32 numberScopedDevices = 0;
   2192 
   2193     // First check if there is a default device and list it
   2194     UInt32 hardwareProperty = 0;
   2195     if (scope == kAudioDevicePropertyScopeOutput)
   2196     {
   2197         hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
   2198     } else
   2199     {
   2200         hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
   2201     }
   2202 
   2203     AudioObjectPropertyAddress
   2204         propertyAddressDefault = { hardwareProperty,
   2205                 kAudioObjectPropertyScopeGlobal,
   2206                 kAudioObjectPropertyElementMaster };
   2207 
   2208     AudioDeviceID usedID;
   2209     UInt32 uintSize = sizeof(UInt32);
   2210     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
   2211             &propertyAddressDefault, 0, NULL, &uintSize, &usedID));
   2212     if (usedID != kAudioDeviceUnknown)
   2213     {
   2214         scopedDeviceIds[numberScopedDevices] = usedID;
   2215         numberScopedDevices++;
   2216     } else
   2217     {
   2218         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2219                      "GetNumberDevices(): Default device unknown");
   2220     }
   2221 
   2222     // Then list the rest of the devices
   2223     bool listOK = true;
   2224 
   2225     WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
   2226             &propertyAddress, 0, NULL, &size, deviceIds));
   2227     if (err != noErr)
   2228     {
   2229         listOK = false;
   2230     } else
   2231     {
   2232         propertyAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
   2233         propertyAddress.mScope = scope;
   2234         propertyAddress.mElement = 0;
   2235         for (UInt32 i = 0; i < numberDevices; i++)
   2236         {
   2237             // Check for input channels
   2238             WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyDataSize(deviceIds[i],
   2239                     &propertyAddress, 0, NULL, &size));
   2240             if (err == kAudioHardwareBadDeviceError)
   2241             {
   2242                 // This device doesn't actually exist; continue iterating.
   2243                 continue;
   2244             } else if (err != noErr)
   2245             {
   2246                 listOK = false;
   2247                 break;
   2248             }
   2249 
   2250             bufferList = (AudioBufferList*) malloc(size);
   2251             WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(deviceIds[i],
   2252                     &propertyAddress, 0, NULL, &size, bufferList));
   2253             if (err != noErr)
   2254             {
   2255                 listOK = false;
   2256                 break;
   2257             }
   2258 
   2259             if (bufferList->mNumberBuffers > 0)
   2260             {
   2261                 if (numberScopedDevices >= deviceListLength)
   2262                 {
   2263                     WEBRTC_TRACE(kTraceError,
   2264                                  kTraceAudioDevice, _id,
   2265                                  "Device list is not long enough");
   2266                     listOK = false;
   2267                     break;
   2268                 }
   2269 
   2270                 scopedDeviceIds[numberScopedDevices] = deviceIds[i];
   2271                 numberScopedDevices++;
   2272             }
   2273 
   2274             free(bufferList);
   2275             bufferList = NULL;
   2276         }  // for
   2277     }
   2278 
   2279     if (!listOK)
   2280     {
   2281         if (deviceIds)
   2282         {
   2283             free(deviceIds);
   2284             deviceIds = NULL;
   2285         }
   2286 
   2287         if (bufferList)
   2288         {
   2289             free(bufferList);
   2290             bufferList = NULL;
   2291         }
   2292 
   2293         return -1;
   2294     }
   2295 
   2296     // Happy ending
   2297     if (deviceIds)
   2298     {
   2299         free(deviceIds);
   2300         deviceIds = NULL;
   2301     }
   2302 
   2303     return numberScopedDevices;
   2304 }
   2305 
   2306 int32_t
   2307 AudioDeviceMac::GetDeviceName(const AudioObjectPropertyScope scope,
   2308                               const uint16_t index,
   2309                               char* name)
   2310 {
   2311     OSStatus err = noErr;
   2312     UInt32 len = kAdmMaxDeviceNameSize;
   2313     AudioDeviceID deviceIds[MaxNumberDevices];
   2314 
   2315     int numberDevices = GetNumberDevices(scope, deviceIds, MaxNumberDevices);
   2316     if (numberDevices < 0)
   2317     {
   2318         return -1;
   2319     } else if (numberDevices == 0)
   2320     {
   2321         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2322                      "No devices");
   2323         return -1;
   2324     }
   2325 
   2326     // If the number is below the number of devices, assume it's "WEBRTC ID"
   2327     // otherwise assume it's a CoreAudio ID
   2328     AudioDeviceID usedID;
   2329 
   2330     // Check if there is a default device
   2331     bool isDefaultDevice = false;
   2332     if (index == 0)
   2333     {
   2334         UInt32 hardwareProperty = 0;
   2335         if (scope == kAudioDevicePropertyScopeOutput)
   2336         {
   2337             hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
   2338         } else
   2339         {
   2340             hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
   2341         }
   2342         AudioObjectPropertyAddress propertyAddress = { hardwareProperty,
   2343                 kAudioObjectPropertyScopeGlobal,
   2344                 kAudioObjectPropertyElementMaster };
   2345         UInt32 size = sizeof(UInt32);
   2346         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
   2347                 &propertyAddress, 0, NULL, &size, &usedID));
   2348         if (usedID == kAudioDeviceUnknown)
   2349         {
   2350             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2351                          "GetDeviceName(): Default device unknown");
   2352         } else
   2353         {
   2354             isDefaultDevice = true;
   2355         }
   2356     }
   2357 
   2358     AudioObjectPropertyAddress propertyAddress = {
   2359             kAudioDevicePropertyDeviceName, scope, 0 };
   2360 
   2361     if (isDefaultDevice)
   2362     {
   2363         char devName[len];
   2364 
   2365         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(usedID,
   2366                 &propertyAddress, 0, NULL, &len, devName));
   2367 
   2368         sprintf(name, "default (%s)", devName);
   2369     } else
   2370     {
   2371         if (index < numberDevices)
   2372         {
   2373             usedID = deviceIds[index];
   2374         } else
   2375         {
   2376             usedID = index;
   2377         }
   2378 
   2379         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(usedID,
   2380                 &propertyAddress, 0, NULL, &len, name));
   2381     }
   2382 
   2383     return 0;
   2384 }
   2385 
   2386 int32_t AudioDeviceMac::InitDevice(const uint16_t userDeviceIndex,
   2387                                    AudioDeviceID& deviceId,
   2388                                    const bool isInput)
   2389 {
   2390     OSStatus err = noErr;
   2391     UInt32 size = 0;
   2392     AudioObjectPropertyScope deviceScope;
   2393     AudioObjectPropertySelector defaultDeviceSelector;
   2394     AudioDeviceID deviceIds[MaxNumberDevices];
   2395 
   2396     if (isInput)
   2397     {
   2398         deviceScope = kAudioDevicePropertyScopeInput;
   2399         defaultDeviceSelector = kAudioHardwarePropertyDefaultInputDevice;
   2400     } else
   2401     {
   2402         deviceScope = kAudioDevicePropertyScopeOutput;
   2403         defaultDeviceSelector = kAudioHardwarePropertyDefaultOutputDevice;
   2404     }
   2405 
   2406     AudioObjectPropertyAddress
   2407         propertyAddress = { defaultDeviceSelector,
   2408                 kAudioObjectPropertyScopeGlobal,
   2409                 kAudioObjectPropertyElementMaster };
   2410 
   2411     // Get the actual device IDs
   2412     int numberDevices = GetNumberDevices(deviceScope, deviceIds,
   2413                                          MaxNumberDevices);
   2414     if (numberDevices < 0)
   2415     {
   2416         return -1;
   2417     } else if (numberDevices == 0)
   2418     {
   2419         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2420                      "InitDevice(): No devices");
   2421         return -1;
   2422     }
   2423 
   2424     bool isDefaultDevice = false;
   2425     deviceId = kAudioDeviceUnknown;
   2426     if (userDeviceIndex == 0)
   2427     {
   2428         // Try to use default system device
   2429         size = sizeof(AudioDeviceID);
   2430         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
   2431                 &propertyAddress, 0, NULL, &size, &deviceId));
   2432         if (deviceId == kAudioDeviceUnknown)
   2433         {
   2434             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2435                          " No default device exists");
   2436         } else
   2437         {
   2438             isDefaultDevice = true;
   2439         }
   2440     }
   2441 
   2442     if (!isDefaultDevice)
   2443     {
   2444         deviceId = deviceIds[userDeviceIndex];
   2445     }
   2446 
   2447     // Obtain device name and manufacturer for logging.
   2448     // Also use this as a test to ensure a user-set device ID is valid.
   2449     char devName[128];
   2450     char devManf[128];
   2451     memset(devName, 0, sizeof(devName));
   2452     memset(devManf, 0, sizeof(devManf));
   2453 
   2454     propertyAddress.mSelector = kAudioDevicePropertyDeviceName;
   2455     propertyAddress.mScope = deviceScope;
   2456     propertyAddress.mElement = 0;
   2457     size = sizeof(devName);
   2458     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId,
   2459             &propertyAddress, 0, NULL, &size, devName));
   2460 
   2461     propertyAddress.mSelector = kAudioDevicePropertyDeviceManufacturer;
   2462     size = sizeof(devManf);
   2463     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId,
   2464             &propertyAddress, 0, NULL, &size, devManf));
   2465 
   2466     if (isInput)
   2467     {
   2468         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2469                      " Input device: %s %s", devManf, devName);
   2470     } else
   2471     {
   2472         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2473                      " Output device: %s %s", devManf, devName);
   2474     }
   2475 
   2476     return 0;
   2477 }
   2478 
   2479 OSStatus AudioDeviceMac::objectListenerProc(
   2480     AudioObjectID objectId,
   2481     UInt32 numberAddresses,
   2482     const AudioObjectPropertyAddress addresses[],
   2483     void* clientData)
   2484 {
   2485     AudioDeviceMac *ptrThis = (AudioDeviceMac *) clientData;
   2486     assert(ptrThis != NULL);
   2487 
   2488     ptrThis->implObjectListenerProc(objectId, numberAddresses, addresses);
   2489 
   2490     // AudioObjectPropertyListenerProc functions are supposed to return 0
   2491     return 0;
   2492 }
   2493 
   2494 OSStatus AudioDeviceMac::implObjectListenerProc(
   2495     const AudioObjectID objectId,
   2496     const UInt32 numberAddresses,
   2497     const AudioObjectPropertyAddress addresses[])
   2498 {
   2499     WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   2500                  "AudioDeviceMac::implObjectListenerProc()");
   2501 
   2502     for (UInt32 i = 0; i < numberAddresses; i++)
   2503     {
   2504         if (addresses[i].mSelector == kAudioHardwarePropertyDevices)
   2505         {
   2506             HandleDeviceChange();
   2507         } else if (addresses[i].mSelector == kAudioDevicePropertyStreamFormat)
   2508         {
   2509             HandleStreamFormatChange(objectId, addresses[i]);
   2510         } else if (addresses[i].mSelector == kAudioDevicePropertyDataSource)
   2511         {
   2512             HandleDataSourceChange(objectId, addresses[i]);
   2513         } else if (addresses[i].mSelector == kAudioDeviceProcessorOverload)
   2514         {
   2515             HandleProcessorOverload(addresses[i]);
   2516         }
   2517     }
   2518 
   2519     return 0;
   2520 }
   2521 
   2522 int32_t AudioDeviceMac::HandleDeviceChange()
   2523 {
   2524     OSStatus err = noErr;
   2525 
   2526     WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   2527                  "kAudioHardwarePropertyDevices");
   2528 
   2529     // A device has changed. Check if our registered devices have been removed.
   2530     // Ensure the devices have been initialized, meaning the IDs are valid.
   2531     if (MicrophoneIsInitialized())
   2532     {
   2533         AudioObjectPropertyAddress propertyAddress = {
   2534                 kAudioDevicePropertyDeviceIsAlive,
   2535                 kAudioDevicePropertyScopeInput, 0 };
   2536         UInt32 deviceIsAlive = 1;
   2537         UInt32 size = sizeof(UInt32);
   2538         err = AudioObjectGetPropertyData(_inputDeviceID, &propertyAddress, 0,
   2539                                          NULL, &size, &deviceIsAlive);
   2540 
   2541         if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0)
   2542         {
   2543             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2544                          "Capture device is not alive (probably removed)");
   2545             AtomicSet32(&_captureDeviceIsAlive, 0);
   2546             _mixerManager.CloseMicrophone();
   2547             if (_recError == 1)
   2548             {
   2549                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice,
   2550                              _id, "  pending recording error exists");
   2551             }
   2552             _recError = 1; // triggers callback from module process thread
   2553         } else if (err != noErr)
   2554         {
   2555             logCAMsg(kTraceError, kTraceAudioDevice, _id,
   2556                      "Error in AudioDeviceGetProperty()", (const char*) &err);
   2557             return -1;
   2558         }
   2559     }
   2560 
   2561     if (SpeakerIsInitialized())
   2562     {
   2563         AudioObjectPropertyAddress propertyAddress = {
   2564                 kAudioDevicePropertyDeviceIsAlive,
   2565                 kAudioDevicePropertyScopeOutput, 0 };
   2566         UInt32 deviceIsAlive = 1;
   2567         UInt32 size = sizeof(UInt32);
   2568         err = AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0,
   2569                                          NULL, &size, &deviceIsAlive);
   2570 
   2571         if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0)
   2572         {
   2573             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2574                          "Render device is not alive (probably removed)");
   2575             AtomicSet32(&_renderDeviceIsAlive, 0);
   2576             _mixerManager.CloseSpeaker();
   2577             if (_playError == 1)
   2578             {
   2579                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice,
   2580                              _id, "  pending playout error exists");
   2581             }
   2582             _playError = 1; // triggers callback from module process thread
   2583         } else if (err != noErr)
   2584         {
   2585             logCAMsg(kTraceError, kTraceAudioDevice, _id,
   2586                      "Error in AudioDeviceGetProperty()", (const char*) &err);
   2587             return -1;
   2588         }
   2589     }
   2590 
   2591     return 0;
   2592 }
   2593 
   2594 int32_t AudioDeviceMac::HandleStreamFormatChange(
   2595     const AudioObjectID objectId,
   2596     const AudioObjectPropertyAddress propertyAddress)
   2597 {
   2598     OSStatus err = noErr;
   2599 
   2600     WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   2601                  "Stream format changed");
   2602 
   2603     if (objectId != _inputDeviceID && objectId != _outputDeviceID)
   2604     {
   2605         return 0;
   2606     }
   2607 
   2608     // Get the new device format
   2609     AudioStreamBasicDescription streamFormat;
   2610     UInt32 size = sizeof(streamFormat);
   2611     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(objectId,
   2612             &propertyAddress, 0, NULL, &size, &streamFormat));
   2613 
   2614     if (streamFormat.mFormatID != kAudioFormatLinearPCM)
   2615     {
   2616         logCAMsg(kTraceError, kTraceAudioDevice, _id,
   2617                  "Unacceptable input stream format -> mFormatID",
   2618                  (const char *) &streamFormat.mFormatID);
   2619         return -1;
   2620     }
   2621 
   2622     if (streamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS)
   2623     {
   2624         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2625                      "Too many channels on device (mChannelsPerFrame = %d)",
   2626                      streamFormat.mChannelsPerFrame);
   2627         return -1;
   2628     }
   2629 
   2630     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2631                  "Stream format:");
   2632     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2633                  "mSampleRate = %f, mChannelsPerFrame = %u",
   2634                  streamFormat.mSampleRate, streamFormat.mChannelsPerFrame);
   2635     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2636                  "mBytesPerPacket = %u, mFramesPerPacket = %u",
   2637                  streamFormat.mBytesPerPacket, streamFormat.mFramesPerPacket);
   2638     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2639                  "mBytesPerFrame = %u, mBitsPerChannel = %u",
   2640                  streamFormat.mBytesPerFrame, streamFormat.mBitsPerChannel);
   2641     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2642                  "mFormatFlags = %u",
   2643                  streamFormat.mFormatFlags);
   2644     logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
   2645              (const char *) &streamFormat.mFormatID);
   2646 
   2647     if (propertyAddress.mScope == kAudioDevicePropertyScopeInput)
   2648     {
   2649         const int io_block_size_samples = streamFormat.mChannelsPerFrame *
   2650             streamFormat.mSampleRate / 100 * N_BLOCKS_IO;
   2651         if (io_block_size_samples > _captureBufSizeSamples)
   2652         {
   2653             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2654                 "Input IO block size (%d) is larger than ring buffer (%u)",
   2655                 io_block_size_samples, _captureBufSizeSamples);
   2656             return -1;
   2657 
   2658         }
   2659 
   2660         memcpy(&_inStreamFormat, &streamFormat, sizeof(streamFormat));
   2661 
   2662         if (_inStreamFormat.mChannelsPerFrame >= 2 && (_recChannels == 2))
   2663         {
   2664             _inDesiredFormat.mChannelsPerFrame = 2;
   2665         } else
   2666         {
   2667             // Disable stereo recording when we only have one channel on the device.
   2668             _inDesiredFormat.mChannelsPerFrame = 1;
   2669             _recChannels = 1;
   2670             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2671                          "Stereo recording unavailable on this device");
   2672         }
   2673 
   2674         if (_ptrAudioBuffer)
   2675         {
   2676             // Update audio buffer with the selected parameters
   2677             _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
   2678             _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels);
   2679         }
   2680 
   2681         // Recreate the converter with the new format
   2682         // TODO(xians): make this thread safe
   2683         WEBRTC_CA_RETURN_ON_ERR(AudioConverterDispose(_captureConverter));
   2684 
   2685         WEBRTC_CA_RETURN_ON_ERR(AudioConverterNew(&streamFormat, &_inDesiredFormat,
   2686                 &_captureConverter));
   2687     } else
   2688     {
   2689         memcpy(&_outStreamFormat, &streamFormat, sizeof(streamFormat));
   2690 
   2691         if (_outStreamFormat.mChannelsPerFrame >= 2 && (_playChannels == 2))
   2692         {
   2693             _outDesiredFormat.mChannelsPerFrame = 2;
   2694         } else
   2695         {
   2696             // Disable stereo playout when we only have one channel on the device.
   2697             _outDesiredFormat.mChannelsPerFrame = 1;
   2698             _playChannels = 1;
   2699             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2700                          "Stereo playout unavailable on this device");
   2701         }
   2702 
   2703         if (_ptrAudioBuffer)
   2704         {
   2705             // Update audio buffer with the selected parameters
   2706             _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC);
   2707             _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels);
   2708         }
   2709 
   2710         _renderDelayOffsetSamples = _renderBufSizeSamples - N_BUFFERS_OUT
   2711             * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES
   2712             * _outDesiredFormat.mChannelsPerFrame;
   2713 
   2714         // Recreate the converter with the new format
   2715         // TODO(xians): make this thread safe
   2716         WEBRTC_CA_RETURN_ON_ERR(AudioConverterDispose(_renderConverter));
   2717 
   2718         WEBRTC_CA_RETURN_ON_ERR(AudioConverterNew(&_outDesiredFormat, &streamFormat,
   2719                 &_renderConverter));
   2720     }
   2721 
   2722     return 0;
   2723 }
   2724 
   2725 int32_t AudioDeviceMac::HandleDataSourceChange(
   2726     const AudioObjectID objectId,
   2727     const AudioObjectPropertyAddress propertyAddress)
   2728 {
   2729     OSStatus err = noErr;
   2730 
   2731     if (_macBookPro && propertyAddress.mScope
   2732         == kAudioDevicePropertyScopeOutput)
   2733     {
   2734         WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
   2735                      "Data source changed");
   2736 
   2737         _macBookProPanRight = false;
   2738         UInt32 dataSource = 0;
   2739         UInt32 size = sizeof(UInt32);
   2740         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(objectId,
   2741                 &propertyAddress, 0, NULL, &size, &dataSource));
   2742         if (dataSource == 'ispk')
   2743         {
   2744             _macBookProPanRight = true;
   2745             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2746                          "MacBook Pro using internal speakers; stereo panning right");
   2747         } else
   2748         {
   2749             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
   2750                          "MacBook Pro not using internal speakers");
   2751         }
   2752     }
   2753 
   2754     return 0;
   2755 }
   2756 int32_t AudioDeviceMac::HandleProcessorOverload(
   2757     const AudioObjectPropertyAddress propertyAddress)
   2758 {
   2759     // TODO(xians): we probably want to notify the user in some way of the
   2760     // overload. However, the Windows interpretations of these errors seem to
   2761     // be more severe than what ProcessorOverload is thrown for.
   2762     //
   2763     // We don't log the notification, as it's sent from the HAL's IO thread. We
   2764     // don't want to slow it down even further.
   2765     if (propertyAddress.mScope == kAudioDevicePropertyScopeInput)
   2766     {
   2767         //WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Capture processor
   2768         // overload");
   2769         //_callback->ProblemIsReported(
   2770         // SndCardStreamObserver::ERecordingProblem);
   2771     } else
   2772     {
   2773         //WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   2774         // "Render processor overload");
   2775         //_callback->ProblemIsReported(
   2776         // SndCardStreamObserver::EPlaybackProblem);
   2777     }
   2778 
   2779     return 0;
   2780 }
   2781 
   2782 // ============================================================================
   2783 //                                  Thread Methods
   2784 // ============================================================================
   2785 
   2786 OSStatus AudioDeviceMac::deviceIOProc(AudioDeviceID, const AudioTimeStamp*,
   2787                                       const AudioBufferList* inputData,
   2788                                       const AudioTimeStamp* inputTime,
   2789                                       AudioBufferList* outputData,
   2790                                       const AudioTimeStamp* outputTime,
   2791                                       void *clientData)
   2792 {
   2793     AudioDeviceMac *ptrThis = (AudioDeviceMac *) clientData;
   2794     assert(ptrThis != NULL);
   2795 
   2796     ptrThis->implDeviceIOProc(inputData, inputTime, outputData, outputTime);
   2797 
   2798     // AudioDeviceIOProc functions are supposed to return 0
   2799     return 0;
   2800 }
   2801 
   2802 OSStatus AudioDeviceMac::outConverterProc(AudioConverterRef,
   2803                                           UInt32 *numberDataPackets,
   2804                                           AudioBufferList *data,
   2805                                           AudioStreamPacketDescription **,
   2806                                           void *userData)
   2807 {
   2808     AudioDeviceMac *ptrThis = (AudioDeviceMac *) userData;
   2809     assert(ptrThis != NULL);
   2810 
   2811     return ptrThis->implOutConverterProc(numberDataPackets, data);
   2812 }
   2813 
   2814 OSStatus AudioDeviceMac::inDeviceIOProc(AudioDeviceID, const AudioTimeStamp*,
   2815                                         const AudioBufferList* inputData,
   2816                                         const AudioTimeStamp* inputTime,
   2817                                         AudioBufferList*,
   2818                                         const AudioTimeStamp*, void* clientData)
   2819 {
   2820     AudioDeviceMac *ptrThis = (AudioDeviceMac *) clientData;
   2821     assert(ptrThis != NULL);
   2822 
   2823     ptrThis->implInDeviceIOProc(inputData, inputTime);
   2824 
   2825     // AudioDeviceIOProc functions are supposed to return 0
   2826     return 0;
   2827 }
   2828 
   2829 OSStatus AudioDeviceMac::inConverterProc(
   2830     AudioConverterRef,
   2831     UInt32 *numberDataPackets,
   2832     AudioBufferList *data,
   2833     AudioStreamPacketDescription ** /*dataPacketDescription*/,
   2834     void *userData)
   2835 {
   2836     AudioDeviceMac *ptrThis = static_cast<AudioDeviceMac*> (userData);
   2837     assert(ptrThis != NULL);
   2838 
   2839     return ptrThis->implInConverterProc(numberDataPackets, data);
   2840 }
   2841 
   2842 OSStatus AudioDeviceMac::implDeviceIOProc(const AudioBufferList *inputData,
   2843                                           const AudioTimeStamp *inputTime,
   2844                                           AudioBufferList *outputData,
   2845                                           const AudioTimeStamp *outputTime)
   2846 {
   2847     OSStatus err = noErr;
   2848     UInt64 outputTimeNs = AudioConvertHostTimeToNanos(outputTime->mHostTime);
   2849     UInt64 nowNs = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   2850 
   2851     if (!_twoDevices && _recording)
   2852     {
   2853         implInDeviceIOProc(inputData, inputTime);
   2854     }
   2855 
   2856     // Check if we should close down audio device
   2857     // Double-checked locking optimization to remove locking overhead
   2858     if (_doStop)
   2859     {
   2860         _critSect.Enter();
   2861         if (_doStop)
   2862         {
   2863             if (_twoDevices || (!_recording && !_playing))
   2864             {
   2865                // In the case of a shared device, the single driving ioProc
   2866                // is stopped here
   2867                WEBRTC_CA_LOG_ERR(AudioDeviceStop(_outputDeviceID,
   2868                                                  _deviceIOProcID));
   2869                WEBRTC_CA_LOG_WARN(AudioDeviceDestroyIOProcID(_outputDeviceID,
   2870                                                              _deviceIOProcID));
   2871                if (err == noErr)
   2872                {
   2873                   WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice,
   2874                                _id, " Playout or shared device stopped");
   2875                }
   2876             }
   2877 
   2878             _doStop = false;
   2879             _stopEvent.Set();
   2880             _critSect.Leave();
   2881             return 0;
   2882         }
   2883         _critSect.Leave();
   2884     }
   2885 
   2886     if (!_playing)
   2887     {
   2888         // This can be the case when a shared device is capturing but not
   2889         // rendering. We allow the checks above before returning to avoid a
   2890         // timeout when capturing is stopped.
   2891         return 0;
   2892     }
   2893 
   2894     assert(_outStreamFormat.mBytesPerFrame != 0);
   2895     UInt32 size = outputData->mBuffers->mDataByteSize
   2896         / _outStreamFormat.mBytesPerFrame;
   2897 
   2898     // TODO(xians): signal an error somehow?
   2899     err = AudioConverterFillComplexBuffer(_renderConverter, outConverterProc,
   2900                                           this, &size, outputData, NULL);
   2901     if (err != noErr)
   2902     {
   2903         if (err == 1)
   2904         {
   2905             // This is our own error.
   2906             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2907                          " Error in AudioConverterFillComplexBuffer()");
   2908             return 1;
   2909         } else
   2910         {
   2911             logCAMsg(kTraceError, kTraceAudioDevice, _id,
   2912                      "Error in AudioConverterFillComplexBuffer()",
   2913                      (const char *) &err);
   2914             return 1;
   2915         }
   2916     }
   2917 
   2918     ring_buffer_size_t bufSizeSamples =
   2919         PaUtil_GetRingBufferReadAvailable(_paRenderBuffer);
   2920 
   2921     int32_t renderDelayUs = static_cast<int32_t> (1e-3 * (outputTimeNs - nowNs)
   2922         + 0.5);
   2923     renderDelayUs += static_cast<int32_t> ((1.0e6 * bufSizeSamples)
   2924         / _outDesiredFormat.mChannelsPerFrame / _outDesiredFormat.mSampleRate
   2925         + 0.5);
   2926 
   2927     AtomicSet32(&_renderDelayUs, renderDelayUs);
   2928 
   2929     return 0;
   2930 }
   2931 
   2932 OSStatus AudioDeviceMac::implOutConverterProc(UInt32 *numberDataPackets,
   2933                                               AudioBufferList *data)
   2934 {
   2935     assert(data->mNumberBuffers == 1);
   2936     ring_buffer_size_t numSamples = *numberDataPackets
   2937         * _outDesiredFormat.mChannelsPerFrame;
   2938 
   2939     data->mBuffers->mNumberChannels = _outDesiredFormat.mChannelsPerFrame;
   2940     // Always give the converter as much as it wants, zero padding as required.
   2941     data->mBuffers->mDataByteSize = *numberDataPackets
   2942         * _outDesiredFormat.mBytesPerPacket;
   2943     data->mBuffers->mData = _renderConvertData;
   2944     memset(_renderConvertData, 0, sizeof(_renderConvertData));
   2945 
   2946     PaUtil_ReadRingBuffer(_paRenderBuffer, _renderConvertData, numSamples);
   2947 
   2948     kern_return_t kernErr = semaphore_signal_all(_renderSemaphore);
   2949     if (kernErr != KERN_SUCCESS)
   2950     {
   2951         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   2952                      " semaphore_signal_all() error: %d", kernErr);
   2953         return 1;
   2954     }
   2955 
   2956     return 0;
   2957 }
   2958 
   2959 OSStatus AudioDeviceMac::implInDeviceIOProc(const AudioBufferList *inputData,
   2960                                             const AudioTimeStamp *inputTime)
   2961 {
   2962     OSStatus err = noErr;
   2963     UInt64 inputTimeNs = AudioConvertHostTimeToNanos(inputTime->mHostTime);
   2964     UInt64 nowNs = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   2965 
   2966     // Check if we should close down audio device
   2967     // Double-checked locking optimization to remove locking overhead
   2968     if (_doStopRec)
   2969     {
   2970         _critSect.Enter();
   2971         if (_doStopRec)
   2972         {
   2973             // This will be signalled only when a shared device is not in use.
   2974             WEBRTC_CA_LOG_ERR(AudioDeviceStop(_inputDeviceID, _inDeviceIOProcID));
   2975             WEBRTC_CA_LOG_WARN(AudioDeviceDestroyIOProcID(_inputDeviceID,
   2976                                                           _inDeviceIOProcID));
   2977             if (err == noErr)
   2978             {
   2979                 WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice,
   2980                              _id, " Recording device stopped");
   2981             }
   2982 
   2983             _doStopRec = false;
   2984             _stopEventRec.Set();
   2985             _critSect.Leave();
   2986             return 0;
   2987         }
   2988         _critSect.Leave();
   2989     }
   2990 
   2991     if (!_recording)
   2992     {
   2993         // Allow above checks to avoid a timeout on stopping capture.
   2994         return 0;
   2995     }
   2996 
   2997     ring_buffer_size_t bufSizeSamples =
   2998         PaUtil_GetRingBufferReadAvailable(_paCaptureBuffer);
   2999 
   3000     int32_t captureDelayUs = static_cast<int32_t> (1e-3 * (nowNs - inputTimeNs)
   3001         + 0.5);
   3002     captureDelayUs
   3003         += static_cast<int32_t> ((1.0e6 * bufSizeSamples)
   3004             / _inStreamFormat.mChannelsPerFrame / _inStreamFormat.mSampleRate
   3005             + 0.5);
   3006 
   3007     AtomicSet32(&_captureDelayUs, captureDelayUs);
   3008 
   3009     assert(inputData->mNumberBuffers == 1);
   3010     ring_buffer_size_t numSamples = inputData->mBuffers->mDataByteSize
   3011         * _inStreamFormat.mChannelsPerFrame / _inStreamFormat.mBytesPerPacket;
   3012     PaUtil_WriteRingBuffer(_paCaptureBuffer, inputData->mBuffers->mData,
   3013                            numSamples);
   3014 
   3015     kern_return_t kernErr = semaphore_signal_all(_captureSemaphore);
   3016     if (kernErr != KERN_SUCCESS)
   3017     {
   3018         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3019                      " semaphore_signal_all() error: %d", kernErr);
   3020     }
   3021 
   3022     return err;
   3023 }
   3024 
   3025 OSStatus AudioDeviceMac::implInConverterProc(UInt32 *numberDataPackets,
   3026                                              AudioBufferList *data)
   3027 {
   3028     assert(data->mNumberBuffers == 1);
   3029     ring_buffer_size_t numSamples = *numberDataPackets
   3030         * _inStreamFormat.mChannelsPerFrame;
   3031 
   3032     while (PaUtil_GetRingBufferReadAvailable(_paCaptureBuffer) < numSamples)
   3033     {
   3034         mach_timespec_t timeout;
   3035         timeout.tv_sec = 0;
   3036         timeout.tv_nsec = TIMER_PERIOD_MS;
   3037 
   3038         kern_return_t kernErr = semaphore_timedwait(_captureSemaphore, timeout);
   3039         if (kernErr == KERN_OPERATION_TIMED_OUT)
   3040         {
   3041             int32_t signal = AtomicGet32(&_captureDeviceIsAlive);
   3042             if (signal == 0)
   3043             {
   3044                 // The capture device is no longer alive; stop the worker thread.
   3045                 *numberDataPackets = 0;
   3046                 return 1;
   3047             }
   3048         } else if (kernErr != KERN_SUCCESS)
   3049         {
   3050             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3051                          " semaphore_wait() error: %d", kernErr);
   3052         }
   3053     }
   3054 
   3055     // Pass the read pointer directly to the converter to avoid a memcpy.
   3056     void* dummyPtr;
   3057     ring_buffer_size_t dummySize;
   3058     PaUtil_GetRingBufferReadRegions(_paCaptureBuffer, numSamples,
   3059                                     &data->mBuffers->mData, &numSamples,
   3060                                     &dummyPtr, &dummySize);
   3061     PaUtil_AdvanceRingBufferReadIndex(_paCaptureBuffer, numSamples);
   3062 
   3063     data->mBuffers->mNumberChannels = _inStreamFormat.mChannelsPerFrame;
   3064     *numberDataPackets = numSamples / _inStreamFormat.mChannelsPerFrame;
   3065     data->mBuffers->mDataByteSize = *numberDataPackets
   3066         * _inStreamFormat.mBytesPerPacket;
   3067 
   3068     return 0;
   3069 }
   3070 
   3071 bool AudioDeviceMac::RunRender(void* ptrThis)
   3072 {
   3073     return static_cast<AudioDeviceMac*> (ptrThis)->RenderWorkerThread();
   3074 }
   3075 
   3076 bool AudioDeviceMac::RenderWorkerThread()
   3077 {
   3078     ring_buffer_size_t numSamples = ENGINE_PLAY_BUF_SIZE_IN_SAMPLES
   3079         * _outDesiredFormat.mChannelsPerFrame;
   3080     while (PaUtil_GetRingBufferWriteAvailable(_paRenderBuffer)
   3081         - _renderDelayOffsetSamples < numSamples)
   3082     {
   3083         mach_timespec_t timeout;
   3084         timeout.tv_sec = 0;
   3085         timeout.tv_nsec = TIMER_PERIOD_MS;
   3086 
   3087         kern_return_t kernErr = semaphore_timedwait(_renderSemaphore, timeout);
   3088         if (kernErr == KERN_OPERATION_TIMED_OUT)
   3089         {
   3090             int32_t signal = AtomicGet32(&_renderDeviceIsAlive);
   3091             if (signal == 0)
   3092             {
   3093                 // The render device is no longer alive; stop the worker thread.
   3094                 return false;
   3095             }
   3096         } else if (kernErr != KERN_SUCCESS)
   3097         {
   3098             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3099                          " semaphore_timedwait() error: %d", kernErr);
   3100         }
   3101     }
   3102 
   3103     int8_t playBuffer[4 * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES];
   3104 
   3105     if (!_ptrAudioBuffer)
   3106     {
   3107         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3108                      "  capture AudioBuffer is invalid");
   3109         return false;
   3110     }
   3111 
   3112     // Ask for new PCM data to be played out using the AudioDeviceBuffer.
   3113     uint32_t nSamples =
   3114         _ptrAudioBuffer->RequestPlayoutData(ENGINE_PLAY_BUF_SIZE_IN_SAMPLES);
   3115 
   3116     nSamples = _ptrAudioBuffer->GetPlayoutData(playBuffer);
   3117     if (nSamples != ENGINE_PLAY_BUF_SIZE_IN_SAMPLES)
   3118     {
   3119         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3120                      "  invalid number of output samples(%d)", nSamples);
   3121     }
   3122 
   3123     uint32_t nOutSamples = nSamples * _outDesiredFormat.mChannelsPerFrame;
   3124 
   3125     SInt16 *pPlayBuffer = (SInt16 *) &playBuffer;
   3126     if (_macBookProPanRight && (_playChannels == 2))
   3127     {
   3128         // Mix entirely into the right channel and zero the left channel.
   3129         SInt32 sampleInt32 = 0;
   3130         for (uint32_t sampleIdx = 0; sampleIdx < nOutSamples; sampleIdx
   3131             += 2)
   3132         {
   3133             sampleInt32 = pPlayBuffer[sampleIdx];
   3134             sampleInt32 += pPlayBuffer[sampleIdx + 1];
   3135             sampleInt32 /= 2;
   3136 
   3137             if (sampleInt32 > 32767)
   3138             {
   3139                 sampleInt32 = 32767;
   3140             } else if (sampleInt32 < -32768)
   3141             {
   3142                 sampleInt32 = -32768;
   3143             }
   3144 
   3145             pPlayBuffer[sampleIdx] = 0;
   3146             pPlayBuffer[sampleIdx + 1] = static_cast<SInt16> (sampleInt32);
   3147         }
   3148     }
   3149 
   3150     PaUtil_WriteRingBuffer(_paRenderBuffer, pPlayBuffer, nOutSamples);
   3151 
   3152     return true;
   3153 }
   3154 
   3155 bool AudioDeviceMac::RunCapture(void* ptrThis)
   3156 {
   3157     return static_cast<AudioDeviceMac*> (ptrThis)->CaptureWorkerThread();
   3158 }
   3159 
   3160 bool AudioDeviceMac::CaptureWorkerThread()
   3161 {
   3162     OSStatus err = noErr;
   3163     UInt32 noRecSamples = ENGINE_REC_BUF_SIZE_IN_SAMPLES
   3164         * _inDesiredFormat.mChannelsPerFrame;
   3165     SInt16 recordBuffer[noRecSamples];
   3166     UInt32 size = ENGINE_REC_BUF_SIZE_IN_SAMPLES;
   3167 
   3168     AudioBufferList engineBuffer;
   3169     engineBuffer.mNumberBuffers = 1; // Interleaved channels.
   3170     engineBuffer.mBuffers->mNumberChannels = _inDesiredFormat.mChannelsPerFrame;
   3171     engineBuffer.mBuffers->mDataByteSize = _inDesiredFormat.mBytesPerPacket
   3172         * noRecSamples;
   3173     engineBuffer.mBuffers->mData = recordBuffer;
   3174 
   3175     err = AudioConverterFillComplexBuffer(_captureConverter, inConverterProc,
   3176                                           this, &size, &engineBuffer, NULL);
   3177     if (err != noErr)
   3178     {
   3179         if (err == 1)
   3180         {
   3181             // This is our own error.
   3182             return false;
   3183         } else
   3184         {
   3185             logCAMsg(kTraceError, kTraceAudioDevice, _id,
   3186                      "Error in AudioConverterFillComplexBuffer()",
   3187                      (const char *) &err);
   3188             return false;
   3189         }
   3190     }
   3191 
   3192     // TODO(xians): what if the returned size is incorrect?
   3193     if (size == ENGINE_REC_BUF_SIZE_IN_SAMPLES)
   3194     {
   3195         uint32_t currentMicLevel(0);
   3196         uint32_t newMicLevel(0);
   3197         int32_t msecOnPlaySide;
   3198         int32_t msecOnRecordSide;
   3199 
   3200         int32_t captureDelayUs = AtomicGet32(&_captureDelayUs);
   3201         int32_t renderDelayUs = AtomicGet32(&_renderDelayUs);
   3202 
   3203         msecOnPlaySide = static_cast<int32_t> (1e-3 * (renderDelayUs +
   3204                                                        _renderLatencyUs) + 0.5);
   3205         msecOnRecordSide = static_cast<int32_t> (1e-3 * (captureDelayUs +
   3206                                                          _captureLatencyUs) +
   3207                                                  0.5);
   3208 
   3209         if (!_ptrAudioBuffer)
   3210         {
   3211             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
   3212                          "  capture AudioBuffer is invalid");
   3213             return false;
   3214         }
   3215 
   3216         // store the recorded buffer (no action will be taken if the
   3217         // #recorded samples is not a full buffer)
   3218         _ptrAudioBuffer->SetRecordedBuffer((int8_t*) &recordBuffer,
   3219                                            (uint32_t) size);
   3220 
   3221         if (AGC())
   3222         {
   3223             // store current mic level in the audio buffer if AGC is enabled
   3224             if (MicrophoneVolume(currentMicLevel) == 0)
   3225             {
   3226                 // this call does not affect the actual microphone volume
   3227                 _ptrAudioBuffer->SetCurrentMicLevel(currentMicLevel);
   3228             }
   3229         }
   3230 
   3231         _ptrAudioBuffer->SetVQEData(msecOnPlaySide, msecOnRecordSide, 0);
   3232 
   3233         _ptrAudioBuffer->SetTypingStatus(KeyPressed());
   3234 
   3235         // deliver recorded samples at specified sample rate, mic level etc.
   3236         // to the observer using callback
   3237         _ptrAudioBuffer->DeliverRecordedData();
   3238 
   3239         if (AGC())
   3240         {
   3241             newMicLevel = _ptrAudioBuffer->NewMicLevel();
   3242             if (newMicLevel != 0)
   3243             {
   3244                 // The VQE will only deliver non-zero microphone levels when
   3245                 // a change is needed.
   3246                 // Set this new mic level (received from the observer as return
   3247                 // value in the callback).
   3248                 WEBRTC_TRACE(kTraceStream, kTraceAudioDevice,
   3249                              _id, "  AGC change of volume: old=%u => new=%u",
   3250                              currentMicLevel, newMicLevel);
   3251                 if (SetMicrophoneVolume(newMicLevel) == -1)
   3252                 {
   3253                     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
   3254                                  "  the required modification of the microphone "
   3255                                  "volume failed");
   3256                 }
   3257             }
   3258         }
   3259     }
   3260 
   3261     return true;
   3262 }
   3263 
   3264 bool AudioDeviceMac::KeyPressed() {
   3265   bool key_down = false;
   3266   // Loop through all Mac virtual key constant values.
   3267   for (unsigned int key_index = 0;
   3268                     key_index < ARRAY_SIZE(prev_key_state_);
   3269                     ++key_index) {
   3270     bool keyState = CGEventSourceKeyState(
   3271                              kCGEventSourceStateHIDSystemState,
   3272                              key_index);
   3273     // A false -> true change in keymap means a key is pressed.
   3274     key_down |= (keyState && !prev_key_state_[key_index]);
   3275     // Save current state.
   3276     prev_key_state_[key_index] = keyState;
   3277   }
   3278   return key_down;
   3279 }
   3280 }  // namespace webrtc
   3281