Save/Restore ALSA volume/mute

chrome/browser/chromeos/audio_mixer_alsa.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/audio_mixer_alsa.h"
 
 #include <alsa/asoundlib.h>
 
 #include "base/logging.h"
 #include "base/task.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/browser_thread.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/common/pref_names.h"
 
 namespace chromeos {
 
 // Connect to the ALSA mixer using their simple element API.  Init is performed
 // asynchronously on the worker thread.
 //
 // To get a wider range and finer control over volume levels, first the Master
 // level is set, then if the PCM element exists, the total level is refined by
 // adjusting that as well.  If the PCM element has more volume steps, it allows
 // for finer granularity in the total volume.
 
-// TODO(davej): Serialize volume/mute to preserve settings when restarting.
-
 typedef long alsa_long_t;  // 'long' is required for ALSA API calls.
 
 namespace {
 
 const char* kMasterVolume = "Master";
 const char* kPCMVolume = "PCM";
 const double kDefaultMinVolume = -90.0;
 const double kDefaultMaxVolume = 0.0;
+const double kPrefVolumeNotSet = AudioMixer::kSilenceDb - 100.0;
 
 }  // namespace
 
 AudioMixerAlsa::AudioMixerAlsa()
     : min_volume_(kDefaultMinVolume),
       max_volume_(kDefaultMaxVolume),
       save_volume_(0),
       mixer_state_(UNINITIALIZED),
       alsa_mixer_(NULL),
       elem_master_(NULL),
       elem_pcm_(NULL) {
 }
 
 AudioMixerAlsa::~AudioMixerAlsa() {
   FreeAlsaMixer();
   if (thread_ != NULL) {
     thread_->Stop();
     thread_.reset();
   }
 }
 
 void AudioMixerAlsa::Init(InitDoneCallback* callback) {
   DCHECK(callback);
   if (!InitThread()) {
     callback->Run(false);
     delete callback;
     return;
   }
+  InitPrefs();
 
-  // Post the task of starting up, which can block for 200-500ms,
+  // Post the task of starting up, which may block on the order of ms,
   // so best not to do it on the caller's thread.
   thread_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioMixerAlsa::DoInit, callback));
 }
 
 bool AudioMixerAlsa::InitSync() {
   if (!InitThread())
     return false;
+  InitPrefs();
   return InitializeAlsaMixer();
 }
 
 double AudioMixerAlsa::GetVolumeDb() const {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return kSilenceDb;
 
   return DoGetVolumeDb_Locked();
 }
 
 bool AudioMixerAlsa::GetVolumeLimits(double* vol_min, double* vol_max) {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return false;
   if (vol_min)
     *vol_min = min_volume_;
   if (vol_max)
     *vol_max = max_volume_;
   return true;
 }
 
 void AudioMixerAlsa::SetVolumeDb(double vol_db) {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return;
+  if (vol_db < kSilenceDb)
+    vol_db = kSilenceDb;
   DoSetVolumeDb_Locked(vol_db);
+  volume_pref_.SetValue(vol_db);
 }
 
 bool AudioMixerAlsa::IsMute() const {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return false;
   return GetElementMuted_Locked(elem_master_);
 }
 
 void AudioMixerAlsa::SetMute(bool mute) {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return;
 
   // Set volume to minimum on mute, since switching the element off does not
   // always mute as it should.
 
-  // TODO(davej): Setting volume to minimum can be removed once switching the
-  //              element off can be guaranteed to work.
+  // TODO(davej): Remove save_volume_ and setting volume to minimum if
+  // switching the element off can be guaranteed to mute it.
 
   bool old_value = GetElementMuted_Locked(elem_master_);
 
   if (old_value != mute) {
     if (mute) {
       save_volume_ = DoGetVolumeDb_Locked();
       DoSetVolumeDb_Locked(min_volume_);
     } else {
       DoSetVolumeDb_Locked(save_volume_);
     }
   }
 
   SetElementMuted_Locked(elem_master_, mute);
   if (elem_pcm_)
     SetElementMuted_Locked(elem_pcm_, mute);
+  mute_pref_.SetValue(mute);
 }
 
 AudioMixer::State AudioMixerAlsa::GetState() const {
   AutoLock lock(mixer_state_lock_);
   // If we think it's ready, verify it is actually so.
   if ((mixer_state_ == READY) && (alsa_mixer_ == NULL))
     mixer_state_ = IN_ERROR;
   return mixer_state_;
 }
 
+// static
+void AudioMixerAlsa::RegisterPrefs(PrefService* local_state) {
+  if (!local_state->FindPreference(prefs::kAudioVolume)) {

[scherkus (not reviewing), 2011/01/14 23:38:50]

nit: what about checking for kAudioMute?

[davejcool, 2011/01/15 03:49:07]

Hmmmm... This unraveled an issue with the case of the user only does a mute,
restarts, and now we don't restore the mute because volume is still invalid.  So
to fix this, both volume and mute prefs are each handled individually.  This
means the stored pref for mute can be On, Off, or Unset, which is why I'm
changing this to storing an int instead of a bool.

+    local_state->RegisterRealPref(prefs::kAudioVolume, kPrefVolumeNotSet);
+    local_state->RegisterBooleanPref(prefs::kAudioMute, false);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Private functions follow
 
 void AudioMixerAlsa::DoInit(InitDoneCallback* callback) {
   bool success = InitializeAlsaMixer();
 
+  if (success) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &AudioMixerAlsa::RestoreVolumeMuteOnUIThread));
+  }
+
   if (callback) {
     callback->Run(success);
     delete callback;
   }
 }
 
 bool AudioMixerAlsa::InitThread() {
   AutoLock lock(mixer_state_lock_);
 
   if (mixer_state_ != UNINITIALIZED)
     return false;
 
   if (thread_ == NULL) {
     thread_.reset(new base::Thread("AudioMixerAlsa"));
     if (!thread_->Start()) {
       thread_.reset();
       return false;
     }
   }
 
   mixer_state_ = INITIALIZING;
   return true;
 }
 
+void AudioMixerAlsa::InitPrefs() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  PrefService* prefs = g_browser_process->local_state();
+  volume_pref_.Init(prefs::kAudioVolume, prefs, NULL);
+  mute_pref_.Init(prefs::kAudioMute, prefs, NULL);
+}
+
 bool AudioMixerAlsa::InitializeAlsaMixer() {
   AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != INITIALIZING)
     return false;
 
   int err;
   snd_mixer_t* handle = NULL;
   const char* card = "default";
 
   if ((err = snd_mixer_open(&handle, 0)) < 0) {
@@ skipping 53 matching lines @@
 
 void AudioMixerAlsa::FreeAlsaMixer() {
   AutoLock lock(mixer_state_lock_);
   mixer_state_ = SHUTTING_DOWN;
   if (alsa_mixer_) {
     snd_mixer_close(alsa_mixer_);
     alsa_mixer_ = NULL;
   }
 }
 
+void AudioMixerAlsa::DoSetVolumeMute(double volume, bool mute) {
+  AutoLock lock(mixer_state_lock_);
+  if (mixer_state_ != READY)
+    return;
+
+  VLOG(1) << "Setting volume to " << volume << "and mute to " << mute;
+  if (mute) {
+    save_volume_ = volume;
+    DoSetVolumeDb_Locked(min_volume_);
+  } else {
+    DoSetVolumeDb_Locked(volume);
+  }
+
+  SetElementMuted_Locked(elem_master_, mute);
+  if (elem_pcm_)
+    SetElementMuted_Locked(elem_pcm_, mute);
+}
+
+void AudioMixerAlsa::RestoreVolumeMuteOnUIThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (volume_pref_.GetValue() < kSilenceDb)
+    return;
+
+  // This happens during init, so set the volume off the UI thread.
+  thread_->message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioMixerAlsa::DoSetVolumeMute,
+                        volume_pref_.GetValue(), mute_pref_.GetValue()));
+}
+
 double AudioMixerAlsa::DoGetVolumeDb_Locked() const {
   double vol_total = 0.0;
   GetElementVolume_Locked(elem_master_, &vol_total);
 
   double vol_pcm = 0.0;
   if (elem_pcm_ && (GetElementVolume_Locked(elem_pcm_, &vol_pcm)))
     vol_total += vol_pcm;
 
   return vol_total;
 }
 
 void AudioMixerAlsa::DoSetVolumeDb_Locked(double vol_db) {
   double actual_vol = 0.0;
 
   // If a PCM volume slider exists, then first set the Master volume to the
   // nearest volume >= requested volume, then adjust PCM volume down to get
   // closer to the requested volume.
-
   if (elem_pcm_) {
     SetElementVolume_Locked(elem_master_, vol_db, &actual_vol, 0.9999f);
     SetElementVolume_Locked(elem_pcm_, vol_db - actual_vol, NULL, 0.5f);
   } else {
     SetElementVolume_Locked(elem_master_, vol_db, NULL, 0.5f);
   }
 }
 
 snd_mixer_elem_t* AudioMixerAlsa::FindElementWithName_Locked(
     snd_mixer_t* handle,
     const char* element_name) const {
   snd_mixer_selem_id_t* sid;
 
   // Using id_malloc/id_free API instead of id_alloca since the latter gives the
-  // warning: the address of 'sid' will always evaluate as 'true'
+  // warning: the address of 'sid' will always evaluate as 'true'.
   if (snd_mixer_selem_id_malloc(&sid))
     return NULL;
 
   snd_mixer_selem_id_set_index(sid, 0);
   snd_mixer_selem_id_set_name(sid, element_name);
   snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
   if (!elem) {
     LOG(ERROR) << "ALSA unable to find simple control "
                << snd_mixer_selem_id_get_name(sid);
   }
@@ skipping 70 matching lines @@
 void AudioMixerAlsa::SetElementMuted_Locked(snd_mixer_elem_t* elem, bool mute) {
   int enabled = mute ? 0 : 1;
   snd_mixer_selem_set_playback_switch_all(elem, enabled);
 
   VLOG(1) << "Set playback switch " << snd_mixer_selem_get_name(elem)
           << " to " << enabled;
 }
 
 }  // namespace chromeos