Work around for HDMI audio output rediscovering transistion loss.

chromeos/audio/cras_audio_handler.cc

 // Copyright (c) 2013 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 "chromeos/audio/cras_audio_handler.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 
 namespace {
 
 // Default value for unmuting, as a percent in the range [0, 100].
 // Used when sound is unmuted, but volume was less than kMuteThresholdPercent.
 const int kDefaultUnmuteVolumePercent = 4;
 
 // Volume value which should be considered as muted in range [0, 100].
 const int kMuteThresholdPercent = 1;
 
+// The duration of HDMI output re-discover grace period in milliseconds.
+const int kHDMIRediscoverGracePeriodDurationInMs = 2000;
+
 static CrasAudioHandler* g_cras_audio_handler = NULL;
 
 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) {
   return a.id == b.id && a.is_input == b.is_input && a.type == b.type
       && a.device_name == b.device_name;
 }
 
 bool IsInNodeList(uint64_t node_id,
                   const CrasAudioHandler::NodeIdList& id_list) {
   return std::find(id_list.begin(), id_list.end(), node_id) != id_list.end();
@@ skipping 384 matching lines @@
   const AudioDevice* device = GetDeviceFromId(device_id);
   // Input device's mute state is not recorded in the pref. crbug.com/365050.
   if (device && !device->is_input)
     audio_pref_handler_->SetMuteValue(*device, mute_on);
 }
 
 void CrasAudioHandler::LogErrors() {
   log_errors_ = true;
 }
 
+// If the HDMI device is the active output device, when the device enters/exits
+// docking mode, or HDMI display changes resolution, or chromeos device
+// suspends/resumes, cras will lose the HDMI output node for a short period of
+// time, then rediscover it. This hotplug behavior will cause the audio output
+// be leaked to the alternatvie active audio output during HDMI re-discovering
+// period. See crbug.com/503667.
+void CrasAudioHandler::SetActiveHDMIOutoutRediscoveringIfNecessary(
+    bool force_rediscovering) {
+  if (!GetDeviceFromId(active_output_node_id_))
+    return;
+
+  // Marks the start of the HDMI re-discovering grace period, during which we
+  // will mute the audio output to prevent it to be be leaked to the
+  // alternative output device.
+  if ((hdmi_rediscovering_ && force_rediscovering) ||
+      (!hdmi_rediscovering_ && IsHDMIPrimaryOutputDevice())) {
+    StartHDMIRediscoverGracePeriod();
+  }
+}
+
 CrasAudioHandler::CrasAudioHandler(
     scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler)
     : audio_pref_handler_(audio_pref_handler),
       output_mute_on_(false),
       input_mute_on_(false),
       output_volume_(0),
       input_gain_(0),
       active_output_node_id_(0),
       active_input_node_id_(0),
       has_alternative_input_(false),
       has_alternative_output_(false),
       output_mute_locked_(false),
       log_errors_(false),
+      hdmi_rediscover_grace_period_duration_in_ms_(
+          kHDMIRediscoverGracePeriodDurationInMs),
+      hdmi_rediscovering_(false),
       weak_ptr_factory_(this) {
   if (!audio_pref_handler.get())
     return;
   // If the DBusThreadManager or the CrasAudioClient aren't available, there
   // isn't much we can do. This should only happen when running tests.
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->AddObserver(this);
   audio_pref_handler_->AddAudioPrefObserver(this);
   if (chromeos::DBusThreadManager::Get()->GetSessionManagerClient()) {
     chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
         AddObserver(this);
   }
   InitializeAudioState();
 }
 
 CrasAudioHandler::~CrasAudioHandler() {
+  hdmi_rediscover_timer_.Stop();
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       RemoveObserver(this);
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
       RemoveObserver(this);
   if (audio_pref_handler_.get())
     audio_pref_handler_->RemoveAudioPrefObserver(this);
@@ skipping 86 matching lines @@
 
 void CrasAudioHandler::SetupAudioOutputState() {
   const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
   if (!device) {
     LOG_IF(ERROR, log_errors_)
         << "Can't set up audio state for unknown output device id ="
         << "0x" << std::hex << active_output_node_id_;
     return;
   }
   DCHECK(!device->is_input);
-  output_mute_on_ = audio_pref_handler_->GetMuteValue(*device);
+  // Mute the output during HDMI re-discovering grace period.
+  if (hdmi_rediscovering_ && !IsHDMIPrimaryOutputDevice()) {
+    VLOG(1) << "Mute the output during HDMI re-discovering grace period";
+    output_mute_on_ = true;
+  } else {
+    output_mute_on_ = audio_pref_handler_->GetMuteValue(*device);
+  }
   output_volume_ = audio_pref_handler_->GetOutputVolumeValue(device);
 
   SetOutputMuteInternal(output_mute_on_);
   SetOutputNodeVolume(active_output_node_id_, output_volume_);
 }
 
 // This sets up the state of an additional active node.
 void CrasAudioHandler::SetupAdditionalActiveAudioNodeState(uint64_t node_id) {
   const AudioDevice* device = GetDeviceFromId(node_id);
   if (!device) {
@@ skipping 385 matching lines @@
     if (node_id == active_output_node_id_)
       active_output_node_id_ = 0;
     chromeos::DBusThreadManager::Get()
         ->GetCrasAudioClient()
         ->RemoveActiveOutputNode(node_id);
     if (notify)
       NotifyActiveNodeChanged(false);
   }
 }
 
+void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() {
+  VLOG(1) << "HDMI output re-discover grace period ends.";
+  hdmi_rediscovering_ = false;
+  if (!IsOutputMutedForDevice(active_output_node_id_)) {
+    // Unmute the audio output after the HDMI transition period.
+    VLOG(1) << "Unmute output after HDMI rediscovring grace period.";
+    SetOutputMuteInternal(false);
+  }
+}
+
+bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const {
+  const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
+  return (device && device->type == chromeos::AUDIO_TYPE_HDMI);
+}
+
+void CrasAudioHandler::StartHDMIRediscoverGracePeriod() {
+  VLOG(1) << "Start HDMI rediscovering grace period.";
+  hdmi_rediscovering_ = true;
+  hdmi_rediscover_timer_.Stop();
+  hdmi_rediscover_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(
+                     hdmi_rediscover_grace_period_duration_in_ms_),
+      this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
+}
+
+void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
+    int duration_in_ms) {
+  hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
+}
+
 }  // namespace chromeos