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 kPrefVolumeInvalid = -999.0;
+const int kPrefMuteOff = 0;
+const int kPrefMuteOn = 1;
+const int kPrefMuteInvalid = 2;
 
 }  // 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_);
 }
 
+// To indicate the volume is not valid yet, a very low volume value is stored.
+// We compare against a slightly higher value in case of rounding errors.
+static bool PrefVolumeValid(double volume) {
+  return (volume > kPrefVolumeInvalid + 0.1);
+}
+
 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.  Currently mute
+  // is done by setting the volume to min_volume_.
 
   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 ? kPrefMuteOn : kPrefMuteOff);
 }
 
 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))
+    local_state->RegisterRealPref(prefs::kAudioVolume, kPrefVolumeInvalid);
+  if (!local_state->FindPreference(prefs::kAudioMute))
+    local_state->RegisterIntegerPref(prefs::kAudioMute, kPrefMuteInvalid);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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 pref_volume, int pref_mute) {
+  AutoLock lock(mixer_state_lock_);
+  if (mixer_state_ != READY)
+    return;
+
+  // If volume or mute are invalid, set them now to the current actual values.
+  if (!PrefVolumeValid(pref_volume))
+    pref_volume = DoGetVolumeDb_Locked();
+  bool mute;
+  if (pref_mute == kPrefMuteInvalid)
+    mute = GetElementMuted_Locked(elem_master_);
+  else
+    mute = (pref_mute == kPrefMuteOn) ? true : false;
+
+  VLOG(1) << "Setting volume to " << pref_volume << " and mute to " << mute;
+
+  if (mute) {
+    save_volume_ = pref_volume;
+    DoSetVolumeDb_Locked(min_volume_);
+  } else if (pref_mute == kPrefMuteOff) {
+      DoSetVolumeDb_Locked(pref_volume);
+  }
+
+  SetElementMuted_Locked(elem_master_, mute);
+  if (elem_pcm_)
+    SetElementMuted_Locked(elem_pcm_, mute);
+}
+
+void AudioMixerAlsa::RestoreVolumeMuteOnUIThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // 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