media/audio/linux/alsa_input.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/audio/linux/alsa_input.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/time/time.h"
  12 #include "media/audio/audio_manager.h"
  13 #include "media/audio/linux/alsa_output.h"
  14 #include "media/audio/linux/alsa_util.h"
  15 #include "media/audio/linux/alsa_wrapper.h"
  16 #include "media/audio/linux/audio_manager_linux.h"
  17
  18 namespace media {
  19
  20 static const int kNumPacketsInRingBuffer = 3;
  21
  22 static const char kDefaultDevice1[] = "default";
  23 static const char kDefaultDevice2[] = "plug:default";
  24
  25 const char AlsaPcmInputStream::kAutoSelectDevice[] = "";
  26
  27 AlsaPcmInputStream::AlsaPcmInputStream(AudioManagerLinux* audio_manager,
  28                                        const std::string& device_name,
  29                                        const AudioParameters& params,
  30                                        AlsaWrapper* wrapper)
  31     : audio_manager_(audio_manager),
  32       device_name_(device_name),
  33       params_(params),
  34       bytes_per_buffer_(params.frames_per_buffer() *
  35                         (params.channels() * params.bits_per_sample()) / 8),
  36       wrapper_(wrapper),
  37       buffer_duration_(base::TimeDelta::FromMicroseconds(
  38           params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
  39           static_cast<float>(params.sample_rate()))),
  40       callback_(NULL),
  41       device_handle_(NULL),
  42       mixer_handle_(NULL),
  43       mixer_element_handle_(NULL),
  44       weak_factory_(this),
  45       read_callback_behind_schedule_(false) {
  46 }
  47
  48 AlsaPcmInputStream::~AlsaPcmInputStream() {}
  49
  50 bool AlsaPcmInputStream::Open() {
  51   if (device_handle_)
  52     return false;  // Already open.
  53
  54   snd_pcm_format_t pcm_format = alsa_util::BitsToFormat(
  55       params_.bits_per_sample());
  56   if (pcm_format == SND_PCM_FORMAT_UNKNOWN) {
  57     LOG(WARNING) << "Unsupported bits per sample: "
  58                  << params_.bits_per_sample();
  59     return false;
  60   }
  61
  62   uint32 latency_us =
  63       buffer_duration_.InMicroseconds() * kNumPacketsInRingBuffer;
  64
  65   // Use the same minimum required latency as output.
  66   latency_us = std::max(latency_us, AlsaPcmOutputStream::kMinLatencyMicros);
  67
  68   if (device_name_ == kAutoSelectDevice) {
  69     const char* device_names[] = { kDefaultDevice1, kDefaultDevice2 };
  70     for (size_t i = 0; i < arraysize(device_names); ++i) {
  71       device_handle_ = alsa_util::OpenCaptureDevice(
  72           wrapper_, device_names[i], params_.channels(),
  73           params_.sample_rate(), pcm_format, latency_us);
  74
  75       if (device_handle_) {
  76         device_name_ = device_names[i];
  77         break;
  78       }
  79     }
  80   } else {
  81     device_handle_ = alsa_util::OpenCaptureDevice(wrapper_,
  82                                                   device_name_.c_str(),
  83                                                   params_.channels(),
  84                                                   params_.sample_rate(),
  85                                                   pcm_format, latency_us);
  86   }
  87
  88   if (device_handle_) {
  89     audio_buffer_.reset(new uint8[bytes_per_buffer_]);
  90
  91     // Open the microphone mixer.
  92     mixer_handle_ = alsa_util::OpenMixer(wrapper_, device_name_);
  93     if (mixer_handle_) {
  94       mixer_element_handle_ = alsa_util::LoadCaptureMixerElement(
  95           wrapper_, mixer_handle_);
  96     }
  97   }
  98
  99   return device_handle_ != NULL;
 100 }
 101
 102 void AlsaPcmInputStream::Start(AudioInputCallback* callback) {
 103   DCHECK(!callback_ && callback);
 104   callback_ = callback;
 105   StartAgc();
 106   int error = wrapper_->PcmPrepare(device_handle_);
 107   if (error < 0) {
 108     HandleError("PcmPrepare", error);
 109   } else {
 110     error = wrapper_->PcmStart(device_handle_);
 111     if (error < 0)
 112       HandleError("PcmStart", error);
 113   }
 114
 115   if (error < 0) {
 116     callback_ = NULL;
 117   } else {
 118     // We start reading data half |buffer_duration_| later than when the
 119     // buffer might have got filled, to accommodate some delays in the audio
 120     // driver. This could also give us a smooth read sequence going forward.
 121     base::TimeDelta delay = buffer_duration_ + buffer_duration_ / 2;
 122     next_read_time_ = base::TimeTicks::Now() + delay;
 123     base::MessageLoop::current()->PostDelayedTask(
 124         FROM_HERE,
 125         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
 126         delay);
 127   }
 128 }
 129
 130 bool AlsaPcmInputStream::Recover(int original_error) {
 131   int error = wrapper_->PcmRecover(device_handle_, original_error, 1);
 132   if (error < 0) {
 133     // Docs say snd_pcm_recover returns the original error if it is not one
 134     // of the recoverable ones, so this log message will probably contain the
 135     // same error twice.
 136     LOG(WARNING) << "Unable to recover from \""
 137                  << wrapper_->StrError(original_error) << "\": "
 138                  << wrapper_->StrError(error);
 139     return false;
 140   }
 141
 142   if (original_error == -EPIPE) {  // Buffer underrun/overrun.
 143     // For capture streams we have to repeat the explicit start() to get
 144     // data flowing again.
 145     error = wrapper_->PcmStart(device_handle_);
 146     if (error < 0) {
 147       HandleError("PcmStart", error);
 148       return false;
 149     }
 150   }
 151
 152   return true;
 153 }
 154
 155 snd_pcm_sframes_t AlsaPcmInputStream::GetCurrentDelay() {
 156   snd_pcm_sframes_t delay = -1;
 157
 158   int error = wrapper_->PcmDelay(device_handle_, &delay);
 159   if (error < 0)
 160     Recover(error);
 161
 162   // snd_pcm_delay() may not work in the beginning of the stream. In this case
 163   // return delay of data we know currently is in the ALSA's buffer.
 164   if (delay < 0)
 165     delay = wrapper_->PcmAvailUpdate(device_handle_);
 166
 167   return delay;
 168 }
 169
 170 void AlsaPcmInputStream::ReadAudio() {
 171   DCHECK(callback_);
 172
 173   snd_pcm_sframes_t frames = wrapper_->PcmAvailUpdate(device_handle_);
 174   if (frames < 0) {  // Potentially recoverable error?
 175     LOG(WARNING) << "PcmAvailUpdate(): " << wrapper_->StrError(frames);
 176     Recover(frames);
 177   }
 178
 179   if (frames < params_.frames_per_buffer()) {
 180     // Not enough data yet or error happened. In both cases wait for a very
 181     // small duration before checking again.
 182     // Even Though read callback was behind schedule, there is no data, so
 183     // reset the next_read_time_.
 184     if (read_callback_behind_schedule_) {
 185       next_read_time_ = base::TimeTicks::Now();
 186       read_callback_behind_schedule_ = false;
 187     }
 188
 189     base::TimeDelta next_check_time = buffer_duration_ / 2;
 190     base::MessageLoop::current()->PostDelayedTask(
 191         FROM_HERE,
 192         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
 193         next_check_time);
 194     return;
 195   }
 196
 197   int num_buffers = frames / params_.frames_per_buffer();
 198   uint32 hardware_delay_bytes =
 199       static_cast<uint32>(GetCurrentDelay() * params_.GetBytesPerFrame());
 200   double normalized_volume = 0.0;
 201
 202   // Update the AGC volume level once every second. Note that, |volume| is
 203   // also updated each time SetVolume() is called through IPC by the
 204   // render-side AGC.
 205   GetAgcVolume(&normalized_volume);
 206
 207   while (num_buffers--) {
 208     int frames_read = wrapper_->PcmReadi(device_handle_, audio_buffer_.get(),
 209                                          params_.frames_per_buffer());
 210     if (frames_read == params_.frames_per_buffer()) {
 211       callback_->OnData(this, audio_buffer_.get(), bytes_per_buffer_,
 212                         hardware_delay_bytes, normalized_volume);
 213     } else {
 214       LOG(WARNING) << "PcmReadi returning less than expected frames: "
 215                    << frames_read << " vs. " << params_.frames_per_buffer()
 216                    << ". Dropping this buffer.";
 217     }
 218   }
 219
 220   next_read_time_ += buffer_duration_;
 221   base::TimeDelta delay = next_read_time_ - base::TimeTicks::Now();
 222   if (delay < base::TimeDelta()) {
 223     DVLOG(1) << "Audio read callback behind schedule by "
 224              << (buffer_duration_ - delay).InMicroseconds()
 225              << " (us).";
 226     // Read callback is behind schedule. Assuming there is data pending in
 227     // the soundcard, invoke the read callback immediate in order to catch up.
 228     read_callback_behind_schedule_ = true;
 229     delay = base::TimeDelta();
 230   }
 231
 232   base::MessageLoop::current()->PostDelayedTask(
 233       FROM_HERE,
 234       base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
 235       delay);
 236 }
 237
 238 void AlsaPcmInputStream::Stop() {
 239   if (!device_handle_ || !callback_)
 240     return;
 241
 242   StopAgc();
 243
 244   weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
 245   int error = wrapper_->PcmDrop(device_handle_);
 246   if (error < 0)
 247     HandleError("PcmDrop", error);
 248 }
 249
 250 void AlsaPcmInputStream::Close() {
 251   if (device_handle_) {
 252     weak_factory_.InvalidateWeakPtrs();  // Cancel the next scheduled read.
 253     int error = alsa_util::CloseDevice(wrapper_, device_handle_);
 254     if (error < 0)
 255       HandleError("PcmClose", error);
 256
 257     if (mixer_handle_)
 258       alsa_util::CloseMixer(wrapper_, mixer_handle_, device_name_);
 259
 260     audio_buffer_.reset();
 261     device_handle_ = NULL;
 262     mixer_handle_ = NULL;
 263     mixer_element_handle_ = NULL;
 264
 265     if (callback_)
 266       callback_->OnClose(this);
 267   }
 268
 269   audio_manager_->ReleaseInputStream(this);
 270 }
 271
 272 double AlsaPcmInputStream::GetMaxVolume() {
 273   if (!mixer_handle_ || !mixer_element_handle_) {
 274     DLOG(WARNING) << "GetMaxVolume is not supported for " << device_name_;
 275     return 0.0;
 276   }
 277
 278   if (!wrapper_->MixerSelemHasCaptureVolume(mixer_element_handle_)) {
 279     DLOG(WARNING) << "Unsupported microphone volume for " << device_name_;
 280     return 0.0;
 281   }
 282
 283   long min = 0;
 284   long max = 0;
 285   if (wrapper_->MixerSelemGetCaptureVolumeRange(mixer_element_handle_,
 286                                                 &min,
 287                                                 &max)) {
 288     DLOG(WARNING) << "Unsupported max microphone volume for " << device_name_;
 289     return 0.0;
 290   }
 291   DCHECK(min == 0);
 292   DCHECK(max > 0);
 293
 294   return static_cast<double>(max);
 295 }
 296
 297 void AlsaPcmInputStream::SetVolume(double volume) {
 298   if (!mixer_handle_ || !mixer_element_handle_) {
 299     DLOG(WARNING) << "SetVolume is not supported for " << device_name_;
 300     return;
 301   }
 302
 303   int error = wrapper_->MixerSelemSetCaptureVolumeAll(
 304       mixer_element_handle_, static_cast<long>(volume));
 305   if (error < 0) {
 306     DLOG(WARNING) << "Unable to set volume for " << device_name_;
 307   }
 308
 309   // Update the AGC volume level based on the last setting above. Note that,
 310   // the volume-level resolution is not infinite and it is therefore not
 311   // possible to assume that the volume provided as input parameter can be
 312   // used directly. Instead, a new query to the audio hardware is required.
 313   // This method does nothing if AGC is disabled.
 314   UpdateAgcVolume();
 315 }
 316
 317 double AlsaPcmInputStream::GetVolume() {
 318   if (!mixer_handle_ || !mixer_element_handle_) {
 319     DLOG(WARNING) << "GetVolume is not supported for " << device_name_;
 320     return 0.0;
 321   }
 322
 323   long current_volume = 0;
 324   int error = wrapper_->MixerSelemGetCaptureVolume(
 325       mixer_element_handle_, static_cast<snd_mixer_selem_channel_id_t>(0),
 326       &current_volume);
 327   if (error < 0) {
 328     DLOG(WARNING) << "Unable to get volume for " << device_name_;
 329     return 0.0;
 330   }
 331
 332   return static_cast<double>(current_volume);
 333 }
 334
 335 void AlsaPcmInputStream::HandleError(const char* method, int error) {
 336   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
 337   callback_->OnError(this);
 338 }
 339
 340 }  // namespace media