Add a virtual beamforming audio device on ChromeOS.

media/audio/audio_parameters.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_PARAMETERS_H_
 #define MEDIA_AUDIO_AUDIO_PARAMETERS_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 39 matching lines @@
   // effects should be enabled.
   enum PlatformEffectsMask {
     NO_EFFECTS = 0x0,
     ECHO_CANCELLER = 0x1,
     DUCKING = 0x2,  // Enables ducking if the OS supports it.
     KEYBOARD_MIC = 0x4,
     HOTWORD = 0x8,
   };
 
   AudioParameters();
-  AudioParameters(Format format, ChannelLayout channel_layout,
-                  int sample_rate, int bits_per_sample,
-                  int frames_per_buffer);
-  AudioParameters(Format format, ChannelLayout channel_layout,
-                  int sample_rate, int bits_per_sample,
-                  int frames_per_buffer, int effects);
-  AudioParameters(Format format, ChannelLayout channel_layout,
-                  int channels, int sample_rate, int bits_per_sample,
-                  int frames_per_buffer, int effects);
+  AudioParameters(Format format,
+                  ChannelLayout channel_layout,
+                  int sample_rate,
+                  int bits_per_sample,
+                  int frames_per_buffer,
+                  const std::string& mic_positions = "",
+                  int effects = NO_EFFECTS);
+  AudioParameters(Format format,
+                  int channels,
+                  ChannelLayout channel_layout,
+                  int sample_rate,
+                  int bits_per_sample,
+                  int frames_per_buffer,
+                  const std::string& mic_positions = "",
+                  int effects = NO_EFFECTS);
 
   void Reset(Format format, ChannelLayout channel_layout,
              int channels, int sample_rate, int bits_per_sample,
              int frames_per_buffer);
 
   // Checks that all values are in the expected range. All limits are specified
   // in media::Limits.
   bool IsValid() const;
 
   // Returns a human-readable string describing |*this|.  For debugging & test
@@ skipping 16 matching lines @@
   // Comparison with other AudioParams.
   bool Equals(const AudioParameters& other) const;
 
   Format format() const { return format_; }
   ChannelLayout channel_layout() const { return channel_layout_; }
   int sample_rate() const { return sample_rate_; }
   int bits_per_sample() const { return bits_per_sample_; }
   int frames_per_buffer() const { return frames_per_buffer_; }
   int channels() const { return channels_; }
   int effects() const { return effects_; }
+  const std::string& mic_positions() const { return mic_positions_; }
 
  private:
   // These members are mutable to support entire struct assignment. They should
   // not be mutated individually.
   Format format_;                 // Format of the stream.
   ChannelLayout channel_layout_;  // Order of surround sound channels.
   int sample_rate_;               // Sampling frequency/rate.
   int bits_per_sample_;           // Number of bits per sample.
   int frames_per_buffer_;         // Number of frames in a buffer.
 
   int channels_;                  // Number of channels. Value set based on
                                   // |channel_layout|.
+
+  // Whitespace-separated microphone positions using Cartesian coordinates in
+  // meters with ordering x, y, z.
+  // x: the horizontal dimension, with positive to the right from the camera's
+  //    perspective.
+  // y: the depth dimension, with positive forward from the camera's
+  //    perspective.
+  // z: the vertical dimension, with positive upwards.
+  //
+  // Usually, the center of the microphone array will be treated as the origin
+  // (often the position of the camera). The string is formatted as:
+  // "x1 y1 z1 ... zn yn zn" for an n-microphone array.
+  // For example, a two-mic device with 4 cm of horizontal spacing would use:
+  // "-0.02 0 0 0.02 0 0"
+  //
+  // The empty string indicates unknown positions.
+  std::string mic_positions_;

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

I think we should have some other type for this. I understand it can be any
number of mics, what about use a vector of MicPosition (or such name), where
struct MicPosition contains x,y,z?

[ajm, 2015/08/28 07:36:13]

The reasons I want to use a string are:
1. It will be provided that way from CRAS.
2. The googArrayGeometry media constraint also uses a string; it's nice to have
uniformity when parsing them in media_stream_audio_processing.cc.
3. Avoid yet-another-Point-class. We have many floating around, notably
webrtc::Point which this is parsed to in MSAP.

The most significant counter-argument I can see is in the case that this field
is used outside of MSAP. Then we'll have to parse the string more than once.
I'll think about it some more tomorrow.

[Henrik Grunell, 2015/08/28 15:04:34]

I really hope there's only one in Chrome. :) Are there several?

What about using the (or "an" if several) existing Chrome point type, add a
common parser function if there is none, use that at any place we want to
convert? I assume you don't want to have that extra step between string and
webrtc::Point, but I think that conversion should be trivial.

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

I agree with Henrik, this also allows you to only surface devices which actually
have a valid geometry with number of mics greater than 1 and check this in
AudioManagerCras. 

+
   int effects_;                   // Bitmask using PlatformEffectsMask.
 };
 
 // Comparison is useful when AudioParameters is used with std structures.
 inline bool operator<(const AudioParameters& a, const AudioParameters& b) {
   if (a.format() != b.format())
     return a.format() < b.format();
   if (a.channels() != b.channels())
     return a.channels() < b.channels();
   if (a.sample_rate() != b.sample_rate())
     return a.sample_rate() < b.sample_rate();
   if (a.bits_per_sample() != b.bits_per_sample())
     return a.bits_per_sample() < b.bits_per_sample();
   return a.frames_per_buffer() < b.frames_per_buffer();
 }
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_PARAMETERS_H_