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 = -999.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,
   // 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;
   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_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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(g_browser_process);
+  PrefService* prefs = g_browser_process->local_state();
+  DCHECK(prefs);
+
+  if (!prefs->FindPreference(prefs::kAudioVolume)) {
+    prefs->RegisterRealPref(prefs::kAudioVolume, kPrefVolumeNotSet);
+    prefs->RegisterBooleanPref(prefs::kAudioMute, false);
+  }
+  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() {
+  if (volume_pref_.GetValue() != kPrefVolumeNotSet)

[Daniel Erat, 2011/01/13 21:37:21]

Could you do something like GetValue() <= kDefaultMinVolume or track whether the
pref is set or not in a bool or something?  Floating-point equality comparisons
scare me.

[davejcool, 2011/01/14 00:14:12]

I recall problems in the distant past with comparing doubles as well.  I do see
pref tests that verify doubles are equal when set and then read back.  But I
updated the comparison here anyway so there should be no question.

+    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,
@@ skipping 85 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