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,
   // 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.

[scherkus (not reviewing), 2011/01/14 00:54:49]

nit: no need to align comment here

 
   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() {

[scherkus (not reviewing), 2011/01/14 00:54:49]

might be helpful to add DCHECKs to methods that must be run on certain threads:

DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI))
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO))

we have some similarly named functions (InitializeAlsaMixer, InitThread,
InitPrefs) but they must be run on certain threads

[davejcool, 2011/01/14 02:23:47]

The ALSA calls do not need to be called on the UI thread, but any prefs access
must be on the UI thread.  Since there were alraedy DCHECKs in prefs for this, I
didn't put them here.  But I guess it doesn't hurt to have some extra checks
around.

+  DCHECK(g_browser_process);
+  PrefService* prefs = g_browser_process->local_state();
+  DCHECK(prefs);
+
+  if (!prefs->FindPreference(prefs::kAudioVolume)) {
+    prefs->RegisterRealPref(prefs::kAudioVolume, kPrefVolumeNotSet);

[scherkus (not reviewing), 2011/01/14 00:54:49]

sanity check: do you know whether there are other chrome os prefs that get
registered outside of chromeos::Preferences class?

just want to make sure we don't start scattering prefs around, even though I'm
preeeeeeetty sure it's OK thing to do

[davejcool, 2011/01/14 02:23:47]

It looked like the preferences in chromeos::Preferences were for items in the
Settings screen.  Several chromeos classes register their own prefs as well, but
all seem to be passed in the PrefService* in from browser::RegisterLocalState()
and RegisterUserPrefs().  I didn't really want to touch so many files with this,
but I could mimic the others by having a RegisterPrefs() function that is called
by RegisterLocalState().

+    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) {

[scherkus (not reviewing), 2011/01/14 00:54:49]

hmm I only see one callee.. perhaps inline into RestoreVolumeMuteOnUIThread()
and reverse the condition to return early?

do you have future plans for this function?

[davejcool, 2011/01/14 02:23:47]

Originally I had it calling DoSetVolumeMute on the worker thread, so maybe I
should have it do that, since the more that is done away from the UI thread the
better?

+  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() >= kSilenceDb)
+    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