chromeos: Look for "Master" or "Digital" mixer elements.

chrome/browser/chromeos/audio_mixer_alsa.cc

 // Copyright (c) 2011 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 <unistd.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include <alsa/asoundlib.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 
 typedef long alsa_long_t;  // 'long' is required for ALSA API calls.
 
 using std::max;
 using std::min;
 using std::string;
-using std::vector;
 
 namespace chromeos {
 
 namespace {
 
 // Name of the ALSA card to which we connect.
 const char kCardName[] = "default";
 
-// Mixer element names.  We try to connect to the preferred master element
-// first; if it doesn't exist, we'll control any of the alternates that exist.
-const char kPreferredMasterElementName[] = "Master";
-const char* const kAlternateMasterElementNames[] = {
-  "Headphone",
-  "Speaker",
+// Mixer element names.  We'll use the first master element from the list that
+// exists.
+const char* const kMasterElementNames[] = {
+  "Master",   // x86
+  "Digital",  // ARM
 };
 const char kPCMElementName[] = "PCM";
 
 // Default minimum and maximum volume (before we've loaded the actual range from
 // ALSA), in decibels.
 const double kDefaultMinVolumeDb = -90.0;
 const double kDefaultMaxVolumeDb = 0.0;
 
 // Default value assigned to the pref when it's first created, in decibels.
 const double kDefaultVolumeDb = -10.0;
@@ skipping 179 matching lines @@
                    << snd_strerror(err);
     snd_mixer_close(handle);
     return false;
   }
 
   VLOG(1) << "Opened mixer " << kCardName << " successfully";
 
   double min_volume_db = kDefaultMinVolumeDb;
   double max_volume_db = kDefaultMaxVolumeDb;
 
-  vector<snd_mixer_elem_t*> master_elements;
-  snd_mixer_elem_t* element =
-      FindElementWithName(handle, kPreferredMasterElementName);
-  if (element) {
-    master_elements.push_back(element);
-  } else {
-    for (size_t i = 0; i < arraysize(kAlternateMasterElementNames); ++i) {
-      element = FindElementWithName(handle, kAlternateMasterElementNames[i]);
-      if (element)
-        master_elements.push_back(element);
-    }
+  snd_mixer_elem_t* master_element = NULL;
+  for (size_t i = 0; i < arraysize(kMasterElementNames); ++i) {
+    master_element = FindElementWithName(handle, kMasterElementNames[i]);
+    if (master_element)
+      break;
   }
 
-  if (master_elements.empty()) {
+  if (!master_element) {
     if (num_connection_attempts_ == kConnectionAttemptToLogFailure)
-      LOG(WARNING) << "Unable to find any mixer elements on " << kCardName;
+      LOG(WARNING) << "Unable to find a master element on " << kCardName;
     snd_mixer_close(handle);
     return false;
   }
 
   alsa_long_t long_low = static_cast<alsa_long_t>(kDefaultMinVolumeDb * 100);
   alsa_long_t long_high = static_cast<alsa_long_t>(kDefaultMaxVolumeDb * 100);
   err = snd_mixer_selem_get_playback_dB_range(
-      master_elements.at(0), &long_low, &long_high);
+      master_element, &long_low, &long_high);
   if (err != 0) {
     if (num_connection_attempts_ == kConnectionAttemptToLogFailure)
       LOG(WARNING) << "snd_mixer_selem_get_playback_dB_range() failed:"
                    << snd_strerror(err);
     snd_mixer_close(handle);
     return false;
   }
   min_volume_db = static_cast<double>(long_low) / 100.0;
   max_volume_db = static_cast<double>(long_high) / 100.0;
 
@@ skipping 12 matching lines @@
     }
     min_volume_db += static_cast<double>(long_low) / 100.0;
     max_volume_db += static_cast<double>(long_high) / 100.0;
   }
 
   VLOG(1) << "Volume range is " << min_volume_db << " dB to "
           << max_volume_db << " dB";
   {
     base::AutoLock lock(lock_);
     alsa_mixer_ = handle;
-    master_elements_.swap(master_elements);
+    master_element_ = master_element;
     pcm_element_ = pcm_element;
     min_volume_db_ = min_volume_db;
     max_volume_db_ = max_volume_db;
     volume_db_ = min(max(volume_db_, min_volume_db_), max_volume_db_);
   }
 
   ApplyState();
   return true;
 }
 
@@ skipping 17 matching lines @@
     base::AutoLock lock(lock_);
     should_mute = is_muted_;
     new_volume_db = should_mute ? min_volume_db_ : volume_db_;
     apply_is_pending_ = false;
   }
 
   if (pcm_element_) {
     // 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.
-    for (vector<snd_mixer_elem_t*>::iterator it = master_elements_.begin();
-         it != master_elements_.end(); ++it)
-      SetElementVolume(*it, new_volume_db, 0.9999f);
+    SetElementVolume(master_element_, new_volume_db, 0.9999f);
 
     double pcm_volume_db = 0.0;
     double master_volume_db = 0.0;
-    if (GetElementVolume(master_elements_.at(0), &master_volume_db))
+    if (GetElementVolume(master_element_, &master_volume_db))
       pcm_volume_db = new_volume_db - master_volume_db;
     SetElementVolume(pcm_element_, pcm_volume_db, 0.5f);
   } else {
-    for (vector<snd_mixer_elem_t*>::iterator it = master_elements_.begin();
-         it != master_elements_.end(); ++it)
-      SetElementVolume(*it, new_volume_db, 0.5f);
+    SetElementVolume(master_element_, new_volume_db, 0.5f);
   }
 
-  for (vector<snd_mixer_elem_t*>::iterator it = master_elements_.begin();
-       it != master_elements_.end(); ++it)
-    SetElementMuted(*it, should_mute);
+  SetElementMuted(master_element_, should_mute);
 }
 
 snd_mixer_elem_t* AudioMixerAlsa::FindElementWithName(
     snd_mixer_t* handle, const string& element_name) const {
   DCHECK(MessageLoop::current() == thread_->message_loop());
   snd_mixer_selem_id_t* sid = NULL;
 
   // 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'.
   if (snd_mixer_selem_id_malloc(&sid))
@@ skipping 82 matching lines @@
   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(element)
             << " to " << mute;
   }
 }
 
 }  // namespace chromeos