Add a virtual beamforming audio device on ChromeOS.

media/audio/cras/audio_manager_cras.cc

 // Copyright 2013 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/cras/audio_manager_cras.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/nix/xdg_util.h"
 #include "base/stl_util.h"
 #include "chromeos/audio/audio_device.h"
 #include "chromeos/audio/cras_audio_handler.h"
 #include "media/audio/cras/cras_input.h"
 #include "media/audio/cras/cras_unified.h"
 #include "media/base/channel_layout.h"
 
 // cras_util.h headers pull in min/max macros...
 // TODO(dgreid): Fix headers such that these aren't imported.
 #undef min
 #undef max
 
 namespace media {
+namespace {
 
-static void AddDefaultDevice(AudioDeviceNames* device_names) {
-  DCHECK(device_names->empty());

[Henrik Grunell, 2015/08/27 08:38:18]

Why remove the dcheck?

-
+void AddDefaultDevice(AudioDeviceNames* device_names) {
   // Cras will route audio from a proper physical device automatically.
   device_names->push_back(
       AudioDeviceName(AudioManagerBase::kDefaultDeviceName,
                       AudioManagerBase::kDefaultDeviceId));
 }
 
+std::string GetMicPositions() {

[Henrik Grunell, 2015/08/27 08:38:18]

Add comment.

Can the function be called on any thread?

+  // Get the list of devices from CRAS. An internal mic with a non-empty
+  // positions field indicates the machine has a beamforming capable mic array.
+  chromeos::AudioDeviceList devices;
+  chromeos::CrasAudioHandler::Get()->GetAudioDevices(&devices);
+  for (const auto& device : devices) {
+    if (device.type == chromeos::AUDIO_TYPE_INTERNAL_MIC) {
+      // There should be only one internal mic device.
+      return device.mic_positions;
+    }
+  }
+  return "";
+}
+
 // Maximum number of output streams that can be open simultaneously.
-static const int kMaxOutputStreams = 50;
+const int kMaxOutputStreams = 50;
 
 // Default sample rate for input and output streams.
-static const int kDefaultSampleRate = 48000;
+const int kDefaultSampleRate = 48000;
 
 // Define bounds for the output buffer size.
-static const int kMinimumOutputBufferSize = 512;
-static const int kMaximumOutputBufferSize = 8192;
+const int kMinimumOutputBufferSize = 512;
+const int kMaximumOutputBufferSize = 8192;
 
 // Default input buffer size.
-static const int kDefaultInputBufferSize = 1024;
+const int kDefaultInputBufferSize = 1024;
+
+const char kBeamformingDeviceNameSuffix[] = " with beamforming";
+const char kBeamformingDeviceIdSuffix[] = "-beamforming";

[aluebs-chromium, 2015/08/28 19:14:30]

Since they are user-facing strings, is this the right thing for these strings?
Isn't there a standard way of handling them? I am thinking specially about
internationalization, etc.

[ajm, 2015/08/28 20:17:18]

Great question, I wonder the same thing! The existing "Default" doesn't appear
to have any i8ln. Dylan do you know anything about this case? If not, we need to
find someone that does.

[dgreid, 2015/08/28 20:24:55]

I don't think we ever bothered to translate "Default" because without another
option it didn't matter.  That might have to be revisited now. 

+
+}  // namespace
 
 bool AudioManagerCras::HasAudioOutputDevices() {
   return true;
 }
 
 bool AudioManagerCras::HasAudioInputDevices() {
   chromeos::AudioDeviceList devices;
   chromeos::CrasAudioHandler::Get()->GetAudioDevices(&devices);
   for (size_t i = 0; i < devices.size(); ++i) {
     if (devices[i].is_input && devices[i].is_for_simple_usage())
       return true;
   }
   return false;
 }
 
 AudioManagerCras::AudioManagerCras(AudioLogFactory* audio_log_factory)
     : AudioManagerBase(audio_log_factory),
-      has_keyboard_mic_(false) {
+      has_keyboard_mic_(false),
+      beamforming_device_name_(
+          std::string(AudioManagerBase::kDefaultDeviceName) +
+              kBeamformingDeviceNameSuffix,
+          std::string(AudioManagerBase::kDefaultDeviceId) +
+              kBeamformingDeviceIdSuffix),
+      mic_positions_(GetMicPositions()) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 }
 
 AudioManagerCras::~AudioManagerCras() {
   Shutdown();
 }
 
 void AudioManagerCras::ShowAudioInputSettings() {
   NOTIMPLEMENTED();
 }
 
 void AudioManagerCras::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
+  // A non-empty mic_positions indicates we have a beamforming capable mic
+  // array. Add the virtual beamforming device to the list. When this device is
+  // queried through GetInputStreamParameters, provide the cached mic positions.
+  if (!mic_positions_.empty()) {

[aluebs-chromium, 2015/08/28 19:14:30]

Shouldn't we be more restrictive here? For instance check that tha
mic_positions_ represents a valid geometry and has more than one mic, for
example? Else we will be surfacing this device and then don't know how to handle
it later.

[ajm, 2015/08/28 23:38:31]

That's a good point. I have those checks in MSAP for uniformity with the media
constraint, but you're right that we shouldn't expose a beamforming device if
it's not possible.

My thinking was that the CRAS configs would be responsible for this. Don't
provide non-empty mic positions if we don't have a beamforming capable device.

If we do the string parsing here, it's a stronger argument for doing checks here
as well. Will consider.

[aluebs-chromium, 2015/08/29 00:00:26]

Yes, I know it was in MSAP, but if we do it here we are protected against
potential string bugs in CRAS config.

[ajm, 2015/09/02 20:38:41]

Forgot to switch the check to > 1 mic. Done in PS#11.

+    device_names->push_back(beamforming_device_name_);
+  }
+
   AddDefaultDevice(device_names);
 }
 
 void AudioManagerCras::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
   AddDefaultDevice(device_names);
 }
 
 AudioParameters AudioManagerCras::GetInputStreamParameters(
     const std::string& device_id) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   int user_buffer_size = GetUserBufferSize();
   int buffer_size = user_buffer_size ?
       user_buffer_size : kDefaultInputBufferSize;
   AudioParameters::PlatformEffectsMask effects =
       has_keyboard_mic_ ? AudioParameters::KEYBOARD_MIC
                         : AudioParameters::NO_EFFECTS;
+  // Return the cached mic positions in the case of the beamforming device.
+  const std::string& mic_positions =
+      device_id == beamforming_device_name_.unique_id ? mic_positions_ : "";
 
   // TODO(hshi): Fine-tune audio parameters based on |device_id|. The optimal
   // parameters for the loopback stream may differ from the default.
-  return AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
-      kDefaultSampleRate, 16, buffer_size, effects);
+  return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         CHANNEL_LAYOUT_STEREO, kDefaultSampleRate, 16,

[aluebs-chromium, 2015/08/28 19:14:30]

What does CHANNEL_LAYOUT_STEREO represent? Is this the number of channels before
or after AudioProcessing? Because when beamforming this is going to be
different. Also , does this mean that it doesn't support higher number of
channels than 2? What about mono?

[ajm, 2015/08/28 23:38:31]

This represents the channel layout for the audio coming from the device.

We'll eventually have to refactor this to support > 2 mics. We may use the
CHANNEL_LAYOUT_DISCRETE format for that, which lets us specify an arbitrary
number of channels. I don't want to do that in this CL though.

[aluebs-chromium, 2015/08/29 00:00:26]

Agreed that this CL is big enough. But it needs to be added at some point.

+                         buffer_size, mic_positions, effects);
 }
 
 void AudioManagerCras::SetHasKeyboardMic() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   has_keyboard_mic_ = true;
 }
 
 AudioOutputStream* AudioManagerCras::MakeLinearOutputStream(
     const AudioParameters& params) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
@@ skipping 36 matching lines @@
     channel_layout = input_params.channel_layout();
     buffer_size =
         std::min(kMaximumOutputBufferSize,
                  std::max(buffer_size, input_params.frames_per_buffer()));
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
-  return AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
-      sample_rate, bits_per_sample, buffer_size, AudioParameters::NO_EFFECTS);
+  return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
+                         sample_rate, bits_per_sample, buffer_size);
 }
 
 AudioOutputStream* AudioManagerCras::MakeOutputStream(
     const AudioParameters& params) {
   return new CrasUnifiedStream(params, this);
 }
 
 AudioInputStream* AudioManagerCras::MakeInputStream(
     const AudioParameters& params, const std::string& device_id) {
   return new CrasInputStream(params, this, device_id);
 }
 
 snd_pcm_format_t AudioManagerCras::BitsToFormat(int 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;
   }
 }
 
 }  // namespace media