Fixes issue in ADM on Mac OSX when audio is renegotiated

webrtc/modules/audio_device/mac/audio_device_mac.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 953 matching lines @@
 
   // Cancel effect of initialization
   if (StopRecording() == -1) {
     available = false;
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitPlayout() {
+  LOG(LS_INFO) << "InitPlayout";
   rtc::CritScope lock(&_critSect);
 
   if (_playing) {
     return -1;
   }
 
   if (!_outputDeviceIsSpecified) {
     return -1;
   }
 
@@ skipping 115 matching lines @@
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceCreateIOProcID(
         _outputDeviceID, deviceIOProc, this, &_deviceIOProcID));
   }
 
   _playIsInitialized = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitRecording() {
+  LOG(LS_INFO) << "InitRecording";
   rtc::CritScope lock(&_critSect);
 
   if (_recording) {
     return -1;
   }
 
   if (!_inputDeviceIsSpecified) {
     return -1;
   }
 
@@ skipping 175 matching lines @@
         _inputDeviceID, deviceIOProc, this, &_deviceIOProcID));
   }
 
   // Mark recording side as initialized
   _recIsInitialized = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StartRecording() {
+  LOG(LS_INFO) << "StartRecording";
   rtc::CritScope lock(&_critSect);
 
   if (!_recIsInitialized) {
     return -1;
   }
 
   if (_recording) {
     return 0;
   }
 
@@ skipping 16 matching lines @@
   } else if (!_playing) {
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _deviceIOProcID));
   }
 
   _recording = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StopRecording() {
+  LOG(LS_INFO) << "StopRecording";
   rtc::CritScope lock(&_critSect);
 
   if (!_recIsInitialized) {
     return 0;
   }
 
   OSStatus err = noErr;
-
-  // Stop device
   int32_t captureDeviceIsAlive = AtomicGet32(&_captureDeviceIsAlive);
-  if (_twoDevices) {
-    if (_recording && captureDeviceIsAlive == 1) {
+  if (_twoDevices && captureDeviceIsAlive == 1) {
+    // Recording side uses its own dedicated device and IOProc.
+    if (_recording) {
       _recording = false;
       _doStopRec = true;  // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEventRec.Wait(2000)) {
         rtc::CritScope critScoped(&_critSect);
         LOG(LS_WARNING)
             << "Timed out stopping the capture IOProc."
             << "We may have failed to detect a device removal.";
-
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_inputDeviceID, _inDeviceIOProcID));
         WEBRTC_CA_LOG_WARN(
-            AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
+          AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
       }
       _critSect.Enter();
       _doStopRec = false;
-      LOG(LS_VERBOSE) << "Recording stopped";
+      LOG(LS_INFO) << "Recording stopped (input device)";
+    } else if (_recIsInitialized) {
+      WEBRTC_CA_LOG_WARN(
+          AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
+      LOG(LS_INFO) << "Recording uninitialized (input device)";
     }
   } else {
     // We signal a stop for a shared device even when rendering has
     // not yet ended. This is to ensure the IOProc will return early as
     // intended (by checking |_recording|) before accessing
     // resources we free below (e.g. the capture converter).
     //
     // In the case of a shared devcie, the IOProc will verify
     // rendering has ended before stopping itself.
     if (_recording && captureDeviceIsAlive == 1) {
       _recording = false;
       _doStop = true;     // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEvent.Wait(2000)) {
         rtc::CritScope critScoped(&_critSect);
         LOG(LS_WARNING)
             << "Timed out stopping the shared IOProc."
             << "We may have failed to detect a device removal.";
-
         // We assume rendering on a shared device has stopped as well if
         // the IOProc times out.
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
       }
       _critSect.Enter();
       _doStop = false;
-      LOG(LS_VERBOSE) << "Recording stopped (shared)";
+      LOG(LS_INFO) << "Recording stopped (shared device)";
+    } else if (_recIsInitialized && !_playing && !_playIsInitialized) {
+      WEBRTC_CA_LOG_WARN(
+            AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
+      LOG(LS_INFO) << "Recording uninitialized (shared device)";
     }
   }
 
   // Setting this signal will allow the worker thread to be stopped.
   AtomicSet32(&_captureDeviceIsAlive, 0);
 
   if (capture_worker_thread_.get()) {
     _critSect.Leave();
     capture_worker_thread_->Stop();
     capture_worker_thread_.reset();
@@ skipping 24 matching lines @@
 
 bool AudioDeviceMac::Recording() const {
   return (_recording);
 }
 
 bool AudioDeviceMac::PlayoutIsInitialized() const {
   return (_playIsInitialized);
 }
 
 int32_t AudioDeviceMac::StartPlayout() {
+  LOG(LS_INFO) << "StartPlayout";
   rtc::CritScope lock(&_critSect);
 
   if (!_playIsInitialized) {
     return -1;
   }
 
   if (_playing) {
     return 0;
   }
 
   RTC_DCHECK(!render_worker_thread_.get());
   render_worker_thread_.reset(
       new rtc::PlatformThread(RunRender, this, "RenderWorkerThread"));
   render_worker_thread_->Start();
   render_worker_thread_->SetPriority(rtc::kRealtimePriority);
 
   if (_twoDevices || !_recording) {
     OSStatus err = noErr;
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_outputDeviceID, _deviceIOProcID));
   }
   _playing = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StopPlayout() {
+  LOG(LS_INFO) << "StopPlayout";
   rtc::CritScope lock(&_critSect);
 
   if (!_playIsInitialized) {
     return 0;
   }
 
   OSStatus err = noErr;
-
   int32_t renderDeviceIsAlive = AtomicGet32(&_renderDeviceIsAlive);
   if (_playing && renderDeviceIsAlive == 1) {
     // We signal a stop for a shared device even when capturing has not
     // yet ended. This is to ensure the IOProc will return early as
     // intended (by checking |_playing|) before accessing resources we
     // free below (e.g. the render converter).
     //
     // In the case of a shared device, the IOProc will verify capturing
     // has ended before stopping itself.
     _playing = false;
     _doStop = true;     // Signal to io proc to stop audio device
     _critSect.Leave();  // Cannot be under lock, risk of deadlock
     if (kEventTimeout == _stopEvent.Wait(2000)) {
       rtc::CritScope critScoped(&_critSect);
       LOG(LS_WARNING)
           << "Timed out stopping the render IOProc."
           << "We may have failed to detect a device removal.";
 
       // We assume capturing on a shared device has stopped as well if the
       // IOProc times out.
       WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
       WEBRTC_CA_LOG_WARN(
           AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
     }
     _critSect.Enter();
     _doStop = false;
-    LOG(LS_VERBOSE) << "Playout stopped";
+    LOG(LS_INFO) << "Playout stopped";
+  } else if (_twoDevices && _playIsInitialized) {
+    WEBRTC_CA_LOG_WARN(
+          AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
+    LOG(LS_INFO) << "Playout uninitialized (output device)";
+  } else if (!_twoDevices && _playIsInitialized && !_recIsInitialized) {
+    WEBRTC_CA_LOG_WARN(
+          AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
+    LOG(LS_INFO) << "Playout uninitialized (shared device)";
   }
 
   // Setting this signal will allow the worker thread to be stopped.
   AtomicSet32(&_renderDeviceIsAlive, 0);
   if (render_worker_thread_.get()) {
     _critSect.Leave();
     render_worker_thread_->Stop();
     render_worker_thread_.reset();
     _critSect.Enter();
   }
@@ skipping 322 matching lines @@
   size = sizeof(devName);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
                                                      0, NULL, &size, devName));
 
   propertyAddress.mSelector = kAudioDevicePropertyDeviceManufacturer;
   size = sizeof(devManf);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
                                                      0, NULL, &size, devManf));
 
   if (isInput) {
-    LOG(LS_VERBOSE) << "Input device: " << devManf << " " << devName;
+    LOG(LS_INFO) << "Input device: " << devManf << " " << devName;
   } else {
-    LOG(LS_VERBOSE) << "Output device: " << devManf << " " << devName;
+    LOG(LS_INFO) << "Output device: " << devManf << " " << devName;
   }
 
   return 0;
 }
 
 OSStatus AudioDeviceMac::SetDesiredPlayoutFormat() {
   // Our preferred format to work with.
   _outDesiredFormat.mSampleRate = N_PLAY_SAMPLES_PER_SEC;
   _outDesiredFormat.mChannelsPerFrame = _playChannels;
 
@@ skipping 746 matching lines @@
     bool keyState =
         CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, key_index);
     // A false -> true change in keymap means a key is pressed.
     key_down |= (keyState && !prev_key_state_[key_index]);
     // Save current state.
     prev_key_state_[key_index] = keyState;
   }
   return key_down;
 }
 }  // namespace webrtc