chromeos: Check ALSA return values in mixer code.

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 <cmath>
+
 #include <alsa/asoundlib.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/threading/thread_restrictions.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"
@@ skipping 101 matching lines @@
     *vol_min = min_volume_;
   if (vol_max)
     *vol_max = max_volume_;
   return true;
 }
 
 void AudioMixerAlsa::SetVolumeDb(double vol_db) {
   base::AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return;
-  if (vol_db < kSilenceDb)
+
+  if (vol_db < kSilenceDb || isnan(vol_db)) {
+    if (isnan(vol_db))
+      LOG(WARNING) << "Got request to set volume to NaN";
     vol_db = kSilenceDb;
+  }
+
   DoSetVolumeDb_Locked(vol_db);
   prefs_->SetDouble(prefs::kAudioVolume, vol_db);
 }
 
 bool AudioMixerAlsa::IsMute() const {
   base::AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return false;
   return GetElementMuted_Locked(elem_master_);
 }
@@ skipping 123 matching lines @@
     snd_mixer_close(handle);
     return false;
   }
 
   VLOG(1) << "Opened ALSA mixer " << card << " OK";
 
   elem_master_ = FindElementWithName_Locked(handle, kMasterVolume);
   if (elem_master_) {
     alsa_long_t long_lo = static_cast<alsa_long_t>(kDefaultMinVolume * 100);
     alsa_long_t long_hi = static_cast<alsa_long_t>(kDefaultMaxVolume * 100);
-    snd_mixer_selem_get_playback_dB_range(elem_master_, &long_lo, &long_hi);
+    err = snd_mixer_selem_get_playback_dB_range(
+        elem_master_, &long_lo, &long_hi);
+    if (err != 0) {
+      LOG(WARNING) << "snd_mixer_selem_get_playback_dB_range() failed "
+                   << "for master: " << snd_strerror(err);
+      snd_mixer_close(handle);
+      return false;
+    }
     min_volume_ = static_cast<double>(long_lo) / 100.0;
     max_volume_ = static_cast<double>(long_hi) / 100.0;
   } else {
     LOG(ERROR) << "Cannot find 'Master' ALSA mixer element on " << card;
     snd_mixer_close(handle);
     return false;
   }
 
   elem_pcm_ = FindElementWithName_Locked(handle, kPCMVolume);
   if (elem_pcm_) {
     alsa_long_t long_lo = static_cast<alsa_long_t>(kDefaultMinVolume * 100);
     alsa_long_t long_hi = static_cast<alsa_long_t>(kDefaultMaxVolume * 100);
-    snd_mixer_selem_get_playback_dB_range(elem_pcm_, &long_lo, &long_hi);
+    err = snd_mixer_selem_get_playback_dB_range(elem_pcm_, &long_lo, &long_hi);
+    if (err != 0) {
+      LOG(WARNING) << "snd_mixer_selem_get_playback_dB_range() failed for PCM: "
+                   << snd_strerror(err);
+      snd_mixer_close(handle);
+      return false;
+    }
     min_volume_ += static_cast<double>(long_lo) / 100.0;
     max_volume_ += static_cast<double>(long_hi) / 100.0;
   }
 
   VLOG(1) << "ALSA volume range is " << min_volume_ << " dB to "
           << max_volume_ << " dB";
 
   alsa_mixer_ = handle;
   mixer_state_ = READY;
   return true;
 }
 
 void AudioMixerAlsa::FreeAlsaMixer() {
   if (alsa_mixer_) {
     snd_mixer_close(alsa_mixer_);
     alsa_mixer_ = NULL;
   }
   done_event_.Signal();
 }
 
 void AudioMixerAlsa::DoSetVolumeMute(double pref_volume, int pref_mute) {
   base::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;
+  bool mute = false;
   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_);
@@ skipping 15 matching lines @@
     base::AutoLock lock(mixer_state_lock_);
     if (mixer_state_ == SHUTTING_DOWN)
       return;
     thread_->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &AudioMixerAlsa::DoSetVolumeMute, vol, mute));
   }
 }
 
 double AudioMixerAlsa::DoGetVolumeDb_Locked() const {
   double vol_total = 0.0;
-  GetElementVolume_Locked(elem_master_, &vol_total);
+  if (!GetElementVolume_Locked(elem_master_, &vol_total))
+    return 0.0;
 
   double vol_pcm = 0.0;
-  if (elem_pcm_ && (GetElementVolume_Locked(elem_pcm_, &vol_pcm)))
+  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
@@ skipping 24 matching lines @@
                << snd_mixer_selem_id_get_name(sid);
   }
 
   snd_mixer_selem_id_free(sid);
   return elem;
 }
 
 bool AudioMixerAlsa::GetElementVolume_Locked(snd_mixer_elem_t* elem,
                                              double* current_vol) const {
   alsa_long_t long_vol = 0;
-  snd_mixer_selem_get_playback_dB(elem,
-                                  static_cast<snd_mixer_selem_channel_id_t>(0),
-                                  &long_vol);
+  int alsa_result = snd_mixer_selem_get_playback_dB(
+      elem, static_cast<snd_mixer_selem_channel_id_t>(0), &long_vol);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_get_playback_dB() failed: "
+                 << snd_strerror(alsa_result);
+    return false;
+  }
+
   *current_vol = static_cast<double>(long_vol) / 100.0;
-
   return true;
 }
 
 bool AudioMixerAlsa::SetElementVolume_Locked(snd_mixer_elem_t* elem,
                                              double new_vol,
                                              double* actual_vol,
                                              double rounding_bias) {
   alsa_long_t vol_lo = 0;
   alsa_long_t vol_hi = 0;
-  snd_mixer_selem_get_playback_volume_range(elem, &vol_lo, &vol_hi);
+  int alsa_result =
+      snd_mixer_selem_get_playback_volume_range(elem, &vol_lo, &vol_hi);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_get_playback_volume_range() failed: "
+                 << snd_strerror(alsa_result);
+    return false;
+  }
   alsa_long_t vol_range = vol_hi - vol_lo;
   if (vol_range <= 0)
     return false;
 
   alsa_long_t db_lo_int = 0;
   alsa_long_t db_hi_int = 0;
-  snd_mixer_selem_get_playback_dB_range(elem, &db_lo_int, &db_hi_int);
+  alsa_result =
+      snd_mixer_selem_get_playback_dB_range(elem, &db_lo_int, &db_hi_int);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_get_playback_dB_range() failed: "
+                 << snd_strerror(alsa_result);
+    return false;
+  }
+
   double db_lo = static_cast<double>(db_lo_int) / 100.0;
   double db_hi = static_cast<double>(db_hi_int) / 100.0;
   double db_step = static_cast<double>(db_hi - db_lo) / vol_range;
   if (db_step <= 0.0)
     return false;
 
   if (new_vol < db_lo)
     new_vol = db_lo;
 
   alsa_long_t value = static_cast<alsa_long_t>(rounding_bias +
       (new_vol - db_lo) / db_step) + vol_lo;
-  snd_mixer_selem_set_playback_volume_all(elem, value);
+  alsa_result = snd_mixer_selem_set_playback_volume_all(elem, value);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_set_playback_volume_all() failed: "
+                 << snd_strerror(alsa_result);
+    return false;
+  }
 
   VLOG(1) << "Set volume " << snd_mixer_selem_get_name(elem)
           << " to " << new_vol << " ==> " << (value - vol_lo) * db_step + db_lo
           << " dB";
 
   if (actual_vol) {
     alsa_long_t volume = vol_lo;
-    snd_mixer_selem_get_playback_volume(
-        elem,
-        static_cast<snd_mixer_selem_channel_id_t>(0),
-        &volume);
+    alsa_result = snd_mixer_selem_get_playback_volume(
+        elem, static_cast<snd_mixer_selem_channel_id_t>(0), &volume);
+    if (alsa_result != 0) {
+      LOG(WARNING) << "snd_mixer_selem_get_playback_volume() failed: "
+                   << snd_strerror(alsa_result);
+      return false;
+    }
     *actual_vol = db_lo + (volume - vol_lo) * db_step;
 
     VLOG(1) << "Actual volume " << snd_mixer_selem_get_name(elem)
             << " now " << *actual_vol << " dB";
   }
   return true;
 }
 
 bool AudioMixerAlsa::GetElementMuted_Locked(snd_mixer_elem_t* elem) const {
   int enabled = 0;
-  snd_mixer_selem_get_playback_switch(
-      elem,
-      static_cast<snd_mixer_selem_channel_id_t>(0),
-      &enabled);
+  int alsa_result = snd_mixer_selem_get_playback_switch(
+      elem, static_cast<snd_mixer_selem_channel_id_t>(0), &enabled);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_get_playback_switch() failed: "
+                 << snd_strerror(alsa_result);
+    return false;
+  }
   return (enabled) ? false : true;
 }
 
 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;
+  int alsa_result = snd_mixer_selem_set_playback_switch_all(elem, enabled);
+  if (alsa_result != 0) {
+    LOG(WARNING) << "snd_mixer_selem_set_playback_switch_all() failed: "
+                 << snd_strerror(alsa_result);
+  } else {
+    VLOG(1) << "Set playback switch " << snd_mixer_selem_get_name(elem)
+            << " to " << enabled;
+  }
 }
 
 }  // namespace chromeos