Adding microphone volume support to chrome.

media/audio/linux/alsa_input.cc

 // Copyright (c) 2012 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 "media/audio/linux/alsa_input.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 19 matching lines @@
       device_name_(device_name),
       params_(params),
       bytes_per_packet_(params.samples_per_packet *
                         (params.channels * params.bits_per_sample) / 8),
       wrapper_(wrapper),
       packet_duration_ms_(
           (params.samples_per_packet * base::Time::kMillisecondsPerSecond) /
           params.sample_rate),
       callback_(NULL),
       device_handle_(NULL),
+      mixer_handle_(NULL),
+      mixer_element_handle_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       read_callback_behind_schedule_(false) {
 }
 
 AlsaPcmInputStream::~AlsaPcmInputStream() {}
 
 bool AlsaPcmInputStream::Open() {
   if (device_handle_)
     return false;  // Already open.
 
   snd_pcm_format_t pcm_format = alsa_util::BitsToFormat(
       params_.bits_per_sample);
   if (pcm_format == SND_PCM_FORMAT_UNKNOWN) {
     LOG(WARNING) << "Unsupported bits per sample: "
                  << params_.bits_per_sample;
     return false;
   }
 
   uint32 latency_us = packet_duration_ms_ * kNumPacketsInRingBuffer *
       base::Time::kMicrosecondsPerMillisecond;
 
   // Use the same minimum required latency as output.
   latency_us = std::max(latency_us, AlsaPcmOutputStream::kMinLatencyMicros);
 
   if (device_name_ == kAutoSelectDevice) {
+    device_name_ = kDefaultDevice1;
     device_handle_ = alsa_util::OpenCaptureDevice(wrapper_, kDefaultDevice1,
                                                   params_.channels,
                                                   params_.sample_rate,
                                                   pcm_format, latency_us);

[tommi (sloooow) - chröme, 2012/02/21 14:03:25]

instead of assigning to device_name and copy paste the code, use a data driven
approach:

const char* device_names[] = { kDefaultDevice1, kDefaultDevice2 };
for (size_t i = 0; i < arraysize(device_names); ++i) {
  device_handle_ = alsa_util::OpenCaptureDevice(
      wrapper_, device_names[i], ...);
  if (device_handle_) {
    device_name_ = device_names[i];
    break;
  }
}

[no longer working on chromium, 2012/02/21 18:01:38]

Done.

     if (!device_handle_) {
+      device_name_ = kDefaultDevice2;
       device_handle_ = alsa_util::OpenCaptureDevice(wrapper_, kDefaultDevice2,
                                                     params_.channels,
                                                     params_.sample_rate,
                                                     pcm_format, latency_us);
     }
   } else {
     device_handle_ = alsa_util::OpenCaptureDevice(wrapper_,
                                                   device_name_.c_str(),
                                                   params_.channels,
                                                   params_.sample_rate,
                                                   pcm_format, latency_us);
   }
 
-  if (device_handle_)
+  if (device_handle_) {
     audio_packet_.reset(new uint8[bytes_per_packet_]);
 
+    // Open the microphone mixer.
+    mixer_handle_ = alsa_util::OpenMixer(wrapper_, device_name_);
+    if (mixer_handle_) {
+      mixer_element_handle_ = alsa_util::LoadCaptureMixerElement(
+          wrapper_, mixer_handle_);
+    }
+  }
+
   return device_handle_ != NULL;
 }
 
 void AlsaPcmInputStream::Start(AudioInputCallback* callback) {
   DCHECK(!callback_ && callback);
   callback_ = callback;
   int error = wrapper_->PcmPrepare(device_handle_);
   if (error < 0) {
     HandleError("PcmPrepare", error);
   } else {
@@ skipping 136 matching lines @@
   weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
   int error = wrapper_->PcmDrop(device_handle_);
   if (error < 0)
     HandleError("PcmDrop", error);
 }
 
 void AlsaPcmInputStream::Close() {
   scoped_ptr<AlsaPcmInputStream> self_deleter(this);
 
   // Check in case we were already closed or not initialized yet.
-  if (!device_handle_ || !callback_)
+  if (!device_handle_)
     return;
 
   weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
   int error = alsa_util::CloseDevice(wrapper_, device_handle_);
   if (error < 0)
     HandleError("PcmClose", error);
 
+  alsa_util::CloseMixer(wrapper_, mixer_handle_, device_name_);
   audio_packet_.reset();
   device_handle_ = NULL;
-  callback_->OnClose(this);
+
+  if (callback_)
+    callback_->OnClose(this);
+}
+
+void AlsaPcmInputStream::SetMicVolume(double volume) {
+  if (!mixer_handle_ || !mixer_element_handle_) {
+    DLOG(WARNING) << "SetMicVolume is not supported for " << device_name_;
+    return;
+  }
+
+  int error = wrapper_->MixerSelemSetCaptureVolumeAll(
+      mixer_element_handle_, static_cast<long>(volume));
+  if (error < 0) {
+    DLOG(WARNING) << "Unable to set volume for " << device_name_;

[tommi (sloooow) - chröme, 2012/02/21 14:03:25]

do we never intend to support error notifications for these apis?

[no longer working on chromium, 2012/02/21 18:01:38]

My concern is that we may need to use IPC message to Get/Set() volume, so we may
not want returned value for those API. And failure in the volume APIs may not be
considered as critical, so in the future if we want to handle the error, we can
add something like HandleWarning().

+  }
+}
+
+void AlsaPcmInputStream::GetMicVolume(double* volume) {
+  if (!mixer_handle_ || !mixer_element_handle_) {
+    DLOG(WARNING) << "GetMicVolume is not supported for " << device_name_;
+    return;
+  }
+
+  long current_volume = 0;
+  int error = wrapper_->MixerSelemGetCaptureVolume(
+      mixer_element_handle_, static_cast<snd_mixer_selem_channel_id_t>(0),
+      &current_volume);
+  if (error < 0) {
+    DLOG(WARNING) << "Unable to get volume for " << device_name_;
+  }
+  *volume = static_cast<double>(current_volume);

[tommi (sloooow) - chröme, 2012/02/21 14:03:25]

this should be inside an else {}.

[no longer working on chromium, 2012/02/21 18:01:38]

Done.

+}
+
+void AlsaPcmInputStream::GetMaxMicVolume(double* max_volume) {
+  if (!mixer_handle_ || !mixer_element_handle_) {
+    DLOG(WARNING) << "GetMaxVolume is not supported for " << device_name_;
+    return;
+  }
+
+  if (!wrapper_->MixerSelemHasCaptureVolume(mixer_element_handle_)) {
+    DLOG(WARNING) << "Unsupported microphone volume for " << device_name_;
+    return;
+  }
+
+  long min = 0;
+  long max = 0;
+  if (wrapper_->MixerSelemGetCaptureVolumeRange(
+      mixer_element_handle_, &min, &max)) {

[tommi (sloooow) - chröme, 2012/02/21 14:03:25]

indentation feels off to me.  Looks like this:

Foo(
x, y, z)

and not
Foo(
    x, y, z)

Does the first parameter (at least) not fit on the line above?

[no longer working on chromium, 2012/02/21 18:01:38]

Done.

+    DLOG(WARNING) << "Unsupported max microphone volume for " << device_name_;
+    return;
+  }
+  DCHECK(min == 0);
+  DCHECK(max > 0);
+
+  *max_volume = static_cast<double>(max);
 }
 
 void AlsaPcmInputStream::HandleError(const char* method, int error) {
   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
   callback_->OnError(this, error);
 }