Implement audio recording for Linux via ALSA.

media/audio/linux/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // The AlsaPcmOutputStream object's internal state is accessed by two threads:
 //
 //   client thread - creates the object and calls the public APIs.
 //   message loop thread - executes all the internal tasks including querying
@@ skipping 64 matching lines @@
 
 #include "media/audio/linux/alsa_output.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "media/audio/audio_util.h"
+#include "media/audio/linux/alsa_util.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 
 // Amount of time to wait if we've exhausted the data source.  This is to avoid
 // busy looping.
 static const uint32 kNoDataSleepMilliseconds = 10;
 
 // According to the linux nanosleep manpage, nanosleep on linux can miss the
@@ skipping 17 matching lines @@
 // kSleepErrorMilliseconds, double that for our minimum required latency.
 const uint32 AlsaPcmOutputStream::kMinLatencyMicros =
     kSleepErrorMilliseconds * 2 * 1000;
 
 namespace {
 
 // ALSA is currently limited to 48Khz.
 // TODO(fbarchard): Resample audio from higher frequency to 48000.
 const int kAlsaMaxSampleRate = 48000;
 
-snd_pcm_format_t BitsToFormat(char bits_per_sample) {
-  switch (bits_per_sample) {
-    case 8:
-      return SND_PCM_FORMAT_U8;
-
-    case 16:
-      return SND_PCM_FORMAT_S16;
-
-    case 24:
-      return SND_PCM_FORMAT_S24;
-
-    case 32:
-      return SND_PCM_FORMAT_S32;
-
-    default:
-      return SND_PCM_FORMAT_UNKNOWN;
-  }
-}
-
 // While the "default" device may support multi-channel audio, in Alsa, only
 // the device names surround40, surround41, surround50, etc, have a defined
 // channel mapping according to Lennart:
 //
 // http://0pointer.de/blog/projects/guide-to-sound-apis.html
 //
 // This function makes a best guess at the specific > 2 channel device name
 // based on the number of channels requested.  NULL is returned if no device
 // can be found to match the channel numbers.  In this case, using
 // kDefaultDevice is probably the best bet.
@@ skipping 85 matching lines @@
   return os;
 }
 
 AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
                                          AudioParameters params,
                                          AlsaWrapper* wrapper,
                                          AudioManagerLinux* manager,
                                          MessageLoop* message_loop)
     : shared_data_(MessageLoop::current()),
       requested_device_name_(device_name),
-      pcm_format_(BitsToFormat(params.bits_per_sample)),
+      pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample)),
       channels_(params.channels),
       sample_rate_(params.sample_rate),
       bytes_per_sample_(params.bits_per_sample / 8),
       bytes_per_frame_(channels_ * params.bits_per_sample / 8),
       should_downmix_(false),
       latency_micros_(0),
       micros_per_packet_(0),
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
@@ skipping 127 matching lines @@
       FramesToMicros(packet_size / bytes_per_frame_, sample_rate_);
   latency_micros_ = std::max(AlsaPcmOutputStream::kMinLatencyMicros,
                              micros_per_packet_ * 2);
   if (requested_device_name_ == kAutoSelectDevice) {
     playback_handle_ = AutoSelectDevice(latency_micros_);
     if (playback_handle_) {
       LOG(INFO) << "Auto-selected device: " << device_name_;
     }
   } else {
     device_name_ = requested_device_name_;
-    playback_handle_ = OpenDevice(device_name_, channels_, latency_micros_);
+    playback_handle_ = alsa_util::OpenPlaybackDevice(wrapper_,
+                                                     device_name_.c_str(),
+                                                     channels_, sample_rate_,
+                                                     pcm_format_,
+                                                     latency_micros_);
   }
 
   // Finish initializing the stream if the device was opened successfully.
   if (playback_handle_ == NULL) {
     stop_stream_ = true;
   } else {
     bytes_per_output_frame_ = should_downmix_ ? 2 * bytes_per_sample_ :
         bytes_per_frame_;
     uint32 output_packet_size = frames_per_packet_ * bytes_per_output_frame_;
     buffer_.reset(new media::SeekableBuffer(0, output_packet_size));
@@ skipping 42 matching lines @@
 
   ScheduleNextWrite(false);
 }
 
 void AlsaPcmOutputStream::CloseTask() {
   // NOTE: Keep this function idempotent to handle errors that might cause
   // multiple CloseTasks to be posted.
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Shutdown the audio device.
-  if (playback_handle_ && !CloseDevice(playback_handle_)) {
+  if (playback_handle_ &&
+      alsa_util::CloseDevice(wrapper_, playback_handle_) < 0) {
     LOG(WARNING) << "Unable to close audio device. Leaking handle.";
   }
   playback_handle_ = NULL;
 
   // Release the buffer.
   buffer_.reset();
 
   // Signal anything that might already be scheduled to stop.
   stop_stream_ = true;
 }
@@ skipping 252 matching lines @@
     wrapper_->DeviceNameFreeHint(hints);
     hints = NULL;
   } else {
     LOG(ERROR) << "Unable to get hints for devices: "
                << wrapper_->StrError(error);
   }
 
   return guessed_device;
 }
 
-snd_pcm_t* AlsaPcmOutputStream::OpenDevice(const std::string& device_name,
-                                           uint32 channels,
-                                           unsigned int latency) {
-  snd_pcm_t* handle = NULL;
-  int error = wrapper_->PcmOpen(&handle, device_name.c_str(),
-                                SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
-  if (error < 0) {
-    LOG(ERROR) << "Cannot open audio device (" << device_name << "): "
-               << wrapper_->StrError(error);
-    return NULL;
-  }
-
-  // Configure the device for software resampling.
-  if ((error = wrapper_->PcmSetParams(handle,
-                                      pcm_format_,
-                                      SND_PCM_ACCESS_RW_INTERLEAVED,
-                                      channels,
-                                      sample_rate_,
-                                      1,  // soft_resample -- let ALSA resample
-                                      latency)) < 0) {
-    LOG(ERROR) << "Unable to set PCM parameters for (" << device_name
-               << "): " << wrapper_->StrError(error)
-               << " -- Format: " << pcm_format_
-               << " Channels: " << channels
-               << " Latency (us): " << latency;
-    if (!CloseDevice(handle)) {
-      // TODO(ajwong): Retry on certain errors?
-      LOG(WARNING) << "Unable to close audio device. Leaking handle.";
-    }
-    return NULL;
-  }
-
-  return handle;
-}
-
-bool AlsaPcmOutputStream::CloseDevice(snd_pcm_t* handle) {
-  std::string name = wrapper_->PcmName(handle);
-  int error = wrapper_->PcmClose(handle);
-  if (error < 0) {
-    LOG(ERROR) << "Error closing audio device (" << name << "): "
-               << wrapper_->StrError(error);
-    return false;
-  }
-
-  return true;
-}
-
 snd_pcm_sframes_t AlsaPcmOutputStream::GetAvailableFrames() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return 0;
   }
 
   // Find the number of frames queued in the sound device.
   snd_pcm_sframes_t available_frames =
       wrapper_->PcmAvailUpdate(playback_handle_);
@@ skipping 18 matching lines @@
   //   2) If that fails, attempt the "plug:" version of it incase ALSA can
   //      remap do some software conversion to make it work.
   //   3) Fallback to kDefaultDevice.
   //   4) If that fails too, try the "plug:" version of kDefaultDevice.
   //   5) Give up.
   snd_pcm_t* handle = NULL;
   device_name_ = FindDeviceForChannels(channels_);
 
   // Step 1.
   if (!device_name_.empty()) {
-    if ((handle = OpenDevice(device_name_, channels_, latency)) != NULL) {
+    if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
+                                                channels_, sample_rate_,
+                                                pcm_format_,
+                                                latency)) != NULL) {
       return handle;
     }
 
     // Step 2.
     device_name_ = kPlugPrefix + device_name_;
-    if ((handle = OpenDevice(device_name_, channels_, latency)) != NULL) {
+    if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
+                                                channels_, sample_rate_,
+                                                pcm_format_,
+                                                latency)) != NULL) {
       return handle;
     }
   }
 
   // For the kDefaultDevice device, we can only reliably depend on 2-channel
   // output to have the correct ordering according to Lennart.  For the channel
   // formats that we know how to downmix from (5 channel to 6 channel), setup
   // downmixing.
   //
   // TODO(ajwong): We need a SupportsFolding() function.
   uint32 default_channels = channels_;
   if (default_channels >= 5 && default_channels <= 6) {
     should_downmix_ = true;
     default_channels = 2;
   }
 
   // Step 3.
   device_name_ = kDefaultDevice;
-  if ((handle = OpenDevice(device_name_, default_channels, latency)) != NULL) {
+  if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
+                                              default_channels, sample_rate_,
+                                              pcm_format_, latency)) != NULL) {
     return handle;
   }
 
   // Step 4.
   device_name_ = kPlugPrefix + device_name_;
-  if ((handle = OpenDevice(device_name_, default_channels, latency)) != NULL) {
+  if ((handle = alsa_util::OpenPlaybackDevice(wrapper_, device_name_.c_str(),
+                                              default_channels, sample_rate_,
+                                              pcm_format_, latency)) != NULL) {
     return handle;
   }
 
   // Unable to open any device.
   device_name_.clear();
   return NULL;
 }
 
 AudioManagerLinux* AlsaPcmOutputStream::manager() {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
@@ skipping 99 matching lines @@
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::SharedData::set_source_callback(
     AudioSourceCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), state_transition_loop_);
   AutoLock l(lock_);
   source_callback_ = callback;
 }