[Chromoting] Audio playback won't work after switching default playback device

remoting/host/audio_capturer_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/audio_capturer_win.h"
 
 #include <avrt.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 #include <stdint.h>
@@ skipping 22 matching lines @@
 // Lower bound for timer intervals, in milliseconds.
 const int kMinTimerInterval = 30;
 
 // Upper bound for the timer precision error, in milliseconds.
 // Timers are supposed to be accurate to 20ms, so we use 30ms to be safe.
 const int kMaxExpectedTimerLag = 30;
 }  // namespace
 
 namespace remoting {
 
+class AudioCapturerWin::MMNotificationClient : public IMMNotificationClient {
+ public:
+  MMNotificationClient(AudioCapturerWin* owner);
+
+  HRESULT __stdcall OnDefaultDeviceChanged(EDataFlow flow,
+                                           ERole role,
+                                           LPCWSTR pwstrDefaultDevice) override;
+
+  HRESULT __stdcall QueryInterface(REFIID iid, void** object) override;
+
+  // No Ops overrides.
+  HRESULT __stdcall OnDeviceAdded(LPCWSTR pwstrDeviceId) override {
+    return S_OK;
+  }
+  HRESULT __stdcall OnDeviceRemoved(LPCWSTR pwstrDeviceId) override {
+    return S_OK;
+  }
+  HRESULT __stdcall OnDeviceStateChanged(LPCWSTR pwstrDeviceId,
+                                         DWORD dwNewState) override {
+    return S_OK;
+  }
+  HRESULT __stdcall OnPropertyValueChanged(LPCWSTR pwstrDeviceId,
+                                           const PROPERTYKEY key) override {
+    return S_OK;
+  }
+  ULONG __stdcall AddRef() override { return 1; }
+  ULONG __stdcall Release() override { return 1; }
+
+ private:
+  AudioCapturerWin* owner_;
+};
+
+AudioCapturerWin::MMNotificationClient::MMNotificationClient(
+    AudioCapturerWin* owner)
+    : owner_(owner) {

[Sergey Ulanov, 2016/07/20 17:28:34]

nit: Please either inline all methods in MMNotificationClient, or none. It looks
like all methods are short, so I'd prefer inlining them all.

[Hzj_jie, 2016/07/20 20:43:14]

Oh, I thought only functions with only return statement can be inlined. No
matter, I will inline them all.

[Sergey Ulanov, 2016/07/21 18:54:02]

That's for when you define class in a header, which doesn't apply here.

+  DCHECK(owner_);
+}
+
+HRESULT AudioCapturerWin::MMNotificationClient::OnDefaultDeviceChanged(
+    EDataFlow flow,
+    ERole role,
+    LPCWSTR pwstrDefaultDevice) {
+  owner_->default_audio_device_changed_ = true;
+  return S_OK;
+}
+
+HRESULT AudioCapturerWin::MMNotificationClient::QueryInterface(REFIID iid,
+                                                               void** object) {
+  if (iid == IID_IUnknown || iid == __uuidof(IMMNotificationClient)) {
+    *object = static_cast<IMMNotificationClient*>(this);
+    return S_OK;
+  }
+  *object = nullptr;
+  return E_NOINTERFACE;
+}
+
 AudioCapturerWin::AudioCapturerWin()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID),
       silence_detector_(kSilenceThreshold),
+      mm_notification_client_(new MMNotificationClient(this)),
       last_capture_error_(S_OK) {
-    thread_checker_.DetachFromThread();
+  thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
   if (audio_client_) {
     audio_client_->Stop();
   }
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
   DCHECK(!audio_client_.get());
   DCHECK(!mm_device_.get());
   DCHECK(!audio_volume_.get());
   DCHECK(static_cast<PWAVEFORMATEX>(wave_format_ex_) == nullptr);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   callback_ = callback;
 
-  // Initialize the capture timer.
+  if (!ResetAndInitialize()) {
+    return false;
+  }
+
+  // Initialize the capture timer and start capturing.
   capture_timer_.reset(new base::RepeatingTimer());
+  capture_timer_->Start(FROM_HERE, audio_device_period_, this,
+                        &AudioCapturerWin::DoCapture);
+  return true;
+}
+
+bool AudioCapturerWin::ResetAndInitialize() {
+  default_audio_device_changed_ = false;
+  wave_format_ex_.Reset(nullptr);
+  mm_device_enumerator_.Release();
+  audio_capture_client_.Release();
+  audio_client_.Release();
+  mm_device_.Release();
+  audio_volume_.Release();
 
   HRESULT hr = S_OK;
-
-  base::win::ScopedComPtr<IMMDeviceEnumerator> mm_device_enumerator;
-  hr = mm_device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator));
+  hr = mm_device_enumerator_.CreateInstance(__uuidof(MMDeviceEnumerator));
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to create IMMDeviceEnumerator. Error " << hr;
     return false;
   }
 
+  hr = mm_device_enumerator_->RegisterEndpointNotificationCallback(
+      mm_notification_client_.get());
+  if (FAILED(hr)) {
+    // We cannot predict which kind of error the API may return, but this is
+    // not a fatal error.
+    LOG(ERROR) << "Failed to register IMMNotificationClient. Error " << hr;
+  }
+
   // Get the audio endpoint.
-  hr = mm_device_enumerator->GetDefaultAudioEndpoint(eRender,
-                                                     eConsole,
-                                                     mm_device_.Receive());
+  hr = mm_device_enumerator_->GetDefaultAudioEndpoint(eRender, eConsole,
+                                                      mm_device_.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get IMMDevice. Error " << hr;
     return false;
   }
 
   // Get an audio client.
   hr = mm_device_->Activate(__uuidof(IAudioClient),
                             CLSCTX_ALL,
                             nullptr,
                             audio_client_.ReceiveVoid());
@@ skipping 109 matching lines @@
   // TODO(zijiehe): Do we need to control per process volume?
   hr = mm_device_->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, nullptr,
                             audio_volume_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get an IAudioEndpointVolume. Error " << hr;
     return false;
   }
 
   silence_detector_.Reset(sampling_rate_, kChannels);
 
-  // Start capturing.
-  capture_timer_->Start(FROM_HERE,
-                        audio_device_period_,
-                        this,
-                        &AudioCapturerWin::DoCapture);
   return true;
 }
 
 float AudioCapturerWin::GetAudioLevel() {
   BOOL mute;
   HRESULT hr = audio_volume_->GetMute(&mute);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get mute status from IAudioEndpointVolume, error "
                << hr;
     return 1;
@@ skipping 50 matching lines @@
   packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
   packet->set_channels(AudioPacket::CHANNELS_STEREO);
 
   callback_.Run(std::move(packet));
 }
 
 void AudioCapturerWin::DoCapture() {
   DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (default_audio_device_changed_ && !ResetAndInitialize()) {
+    // Initialization failed, we should wait for next DoCapture call.
+    return;
+  }
+
   // Fetch all packets from the audio capture endpoint buffer.
   HRESULT hr = S_OK;
   while (true) {
     UINT32 next_packet_size;
     HRESULT hr = audio_capture_client_->GetNextPacketSize(&next_packet_size);
     if (FAILED(hr))
       break;
 
     if (next_packet_size <= 0) {
       return;
@@ skipping 29 matching lines @@
 
 bool AudioCapturer::IsSupported() {
   return true;
 }
 
 std::unique_ptr<AudioCapturer> AudioCapturer::Create() {
   return base::WrapUnique(new AudioCapturerWin());
 }
 
 }  // namespace remoting