Add a virtual beamforming audio device on ChromeOS.

content/renderer/media/media_stream_audio_processor_unittest.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 <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "base/path_service.h"
 #include "base/time/time.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/mock_media_constraint_factory.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Return;
 
+using media::AudioParameters;
+
+namespace webrtc {
+
+bool operator==(const webrtc::Point& lhs, const webrtc::Point& rhs) {
+  return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
+}
+
+}  // namespace webrtc
+
 namespace content {
 
 namespace {
 
 #if defined(ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 48000;
 #endif
 const int kAudioProcessingNumberOfChannel = 1;
@@ skipping 87 matching lines @@
 
       media::AudioBus* processed_data = nullptr;
       base::TimeDelta capture_delay;
       int new_volume = 0;
       while (audio_processor->ProcessAndConsumeData(
                  255, false, &processed_data, &capture_delay, &new_volume)) {
         EXPECT_TRUE(processed_data);
         EXPECT_NEAR(input_capture_delay.InMillisecondsF(),
                     capture_delay.InMillisecondsF(),
                     output_buffer_duration.InMillisecondsF());
-        EXPECT_EQ(audio_processor->OutputFormat().sample_rate(),
-                  expected_output_sample_rate);
-        EXPECT_EQ(audio_processor->OutputFormat().channels(),
-                  expected_output_channels);
-        EXPECT_EQ(audio_processor->OutputFormat().frames_per_buffer(),
-                  expected_output_buffer_size);
+        EXPECT_EQ(expected_output_sample_rate,
+                  audio_processor->OutputFormat().sample_rate());
+        EXPECT_EQ(expected_output_channels,
+                  audio_processor->OutputFormat().channels());
+        EXPECT_EQ(expected_output_buffer_size,
+                  audio_processor->OutputFormat().frames_per_buffer());
       }
 
       data_ptr += params.frames_per_buffer() * params.channels();
     }
   }
 
   void VerifyDefaultComponents(MediaStreamAudioProcessor* audio_processor) {
     webrtc::AudioProcessing* audio_processing =
         audio_processor->audio_processing_.get();
 #if defined(OS_ANDROID)
@@ skipping 22 matching lines @@
 #else
     EXPECT_TRUE(audio_processing->gain_control()->mode() ==
         webrtc::GainControl::kAdaptiveAnalog);
     EXPECT_TRUE(audio_processing->voice_detection()->is_enabled());
     EXPECT_TRUE(audio_processing->voice_detection()->likelihood() ==
         webrtc::VoiceDetection::kVeryLowLikelihood);
 #endif
   }
 
   media::AudioParameters params_;
+  MediaStreamDevice::AudioDeviceParameters input_device_params_;
 };
 
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_WithAudioProcessing DISABLED_WithAudioProcessing
 #else
 #define MAYBE_WithAudioProcessing WithAudioProcessing
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_WithAudioProcessing) {
   MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
   VerifyDefaultComponents(audio_processor.get());
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, VerifyTabCaptureWithoutAudioProcessing) {
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   // Create MediaStreamAudioProcessor instance for kMediaStreamSourceTab source.
   MockMediaConstraintFactory tab_constraint_factory;
   const std::string tab_string = kMediaStreamSourceTab;
   tab_constraint_factory.AddMandatory(kMediaStreamSource,
                                       tab_string);
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          tab_constraint_factory.CreateWebMediaConstraints(), 0,
-          webrtc_audio_device.get()));
+          tab_constraint_factory.CreateWebMediaConstraints(),
+          input_device_params_, webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
 
   // Create MediaStreamAudioProcessor instance for kMediaStreamSourceSystem
   // source.
   MockMediaConstraintFactory system_constraint_factory;
   const std::string system_string = kMediaStreamSourceSystem;
   system_constraint_factory.AddMandatory(kMediaStreamSource,
                                          system_string);
   audio_processor = new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-      system_constraint_factory.CreateWebMediaConstraints(), 0,
-      webrtc_audio_device.get());
+      system_constraint_factory.CreateWebMediaConstraints(),
+      input_device_params_, webrtc_audio_device.get());
   EXPECT_FALSE(audio_processor->has_audio_processing());
 
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TurnOffDefaultConstraints) {
   // Turn off the default constraints and pass it to MediaStreamAudioProcessor.
   MockMediaConstraintFactory constraint_factory;
   constraint_factory.DisableDefaultAudioConstraints();
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
@@ skipping 92 matching lines @@
 
 TEST_F(MediaStreamAudioProcessorTest, ValidateConstraints) {
   MockMediaConstraintFactory constraint_factory;
   const std::string dummy_constraint = "dummy";
   constraint_factory.AddMandatory(dummy_constraint, true);
   MediaAudioConstraints audio_constraints(
       constraint_factory.CreateWebMediaConstraints(), 0);
   EXPECT_FALSE(audio_constraints.IsValid());
 }
 
+MediaAudioConstraints MakeMediaAudioConstraints(
+    const MockMediaConstraintFactory& constraint_factory) {
+  return MediaAudioConstraints(constraint_factory.CreateWebMediaConstraints(),
+                               AudioParameters::NO_EFFECTS);
+}
+
+TEST_F(MediaStreamAudioProcessorTest, SelectsConstraintsArrayGeometryIfExists) {
+  std::vector<webrtc::Point> constraints_geometry(1,
+                                                  webrtc::Point(-0.02f, 0, 0));
+  constraints_geometry.push_back(webrtc::Point(0.02f, 0, 0));
+
+  std::vector<webrtc::Point> input_device_geometry(1, webrtc::Point(0, 0, 0));
+  input_device_geometry.push_back(webrtc::Point(0, 0.05f, 0));
+
+  {
+    // Both geometries empty.
+    MockMediaConstraintFactory constraint_factory;
+    MediaStreamDevice::AudioDeviceParameters input_params;
+
+    const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
+        MakeMediaAudioConstraints(constraint_factory), input_params);
+    EXPECT_EQ(std::vector<webrtc::Point>(), actual_geometry);
+  }
+  {
+    // Constraints geometry empty.
+    MockMediaConstraintFactory constraint_factory;
+    MediaStreamDevice::AudioDeviceParameters input_params;
+    input_params.mic_positions.push_back(media::Point(0, 0, 0));
+    input_params.mic_positions.push_back(media::Point(0, 0.05f, 0));
+
+    const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
+        MakeMediaAudioConstraints(constraint_factory), input_params);
+    EXPECT_EQ(input_device_geometry, actual_geometry);

[aluebs-chromium, 2015/09/10 02:41:39]

Can't you use input_params.mic_positions here instead of having to define
input_device_geometry above? Similar on all cases.

[ajm, 2015/09/10 21:56:57]

No, because input_params.mic_positions is a vector<media::Points> and
input_device_geometry is a vector<webrtc::Points>. I could write an equality
operator to compare them, but figured it was better to explicitly compare the
same types.

[aluebs-chromium, 2015/09/11 01:58:42]

Good point! But maybe you can use one to get the other with the appropriate
method? Or do you think being verbose here adds to the test simplicity?

[ajm, 2015/09/11 05:06:32]

I could, but that's part of the functionality I'm testing here:
https://codereview.chromium.org/1275783003/diff/510001/content/renderer/media...

in WebrtcPointsFromMediaPoints. Ideally we wouldn't repeat that here. I'd be
willing to add the aforementioned equality operator if you prefer though.

[aluebs-chromium, 2015/09/11 06:09:34]

Yes, you are right. You can leave it as is.

+  }
+  {
+    // Input device geometry empty.
+    MockMediaConstraintFactory constraint_factory;
+    constraint_factory.AddOptional(MediaAudioConstraints::kGoogArrayGeometry,
+                                   std::string("-0.02 0 0 0.02 0 0"));
+    MediaStreamDevice::AudioDeviceParameters input_params;
+
+    const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
+        MakeMediaAudioConstraints(constraint_factory), input_params);
+    EXPECT_EQ(constraints_geometry, actual_geometry);
+  }
+  {
+    // Both geometries existing.
+    MockMediaConstraintFactory constraint_factory;
+    constraint_factory.AddOptional(MediaAudioConstraints::kGoogArrayGeometry,
+                                   std::string("-0.02 0 0 0.02 0 0"));
+    MediaStreamDevice::AudioDeviceParameters input_params;
+    input_params.mic_positions.push_back(media::Point(0, 0, 0));
+    input_params.mic_positions.push_back(media::Point(0, 0.05f, 0));
+
+    // Constraints geometry is preferred.
+    const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
+        MakeMediaAudioConstraints(constraint_factory), input_params);
+    EXPECT_EQ(constraints_geometry, actual_geometry);
+  }
+}
+
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_TestAllSampleRates DISABLED_TestAllSampleRates
 #else
 #define MAYBE_TestAllSampleRates TestAllSampleRates
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestAllSampleRates) {
   MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   static const int kSupportedSampleRates[] =
       { 8000, 16000, 22050, 32000, 44100, 48000, 88200, 96000 };
   for (size_t i = 0; i < arraysize(kSupportedSampleRates); ++i) {
     int buffer_size = (kSupportedSampleRates[i] / 100)  < 128 ?
         kSupportedSampleRates[i] / 100 : 128;
     media::AudioParameters params(
         media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
@@ skipping 20 matching lines @@
   base::MessageLoopForUI message_loop;
   scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_(
       new AecDumpMessageFilter(message_loop.task_runner(),
                                message_loop.task_runner()));
 
   MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
 
   EXPECT_TRUE(audio_processor->aec_dump_message_filter_.get());
 
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TestStereoAudio) {
   // Set up the correct constraints to turn off the audio processing and turn
   // on the stereo channels mirroring.
   MockMediaConstraintFactory constraint_factory;
   constraint_factory.AddMandatory(MediaAudioConstraints::kEchoCancellation,
                                   false);
   constraint_factory.AddMandatory(MediaAudioConstraints::kGoogAudioMirroring,
                                   true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   const media::AudioParameters source_params(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_STEREO, 48000, 16, 480);
   audio_processor->OnCaptureFormatChanged(source_params);
   EXPECT_EQ(audio_processor->OutputFormat().channels(), 2);
 
   // Construct left and right channels, and assign different values to the
   // first data of the left channel and right channel.
@@ skipping 43 matching lines @@
 #endif
 
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestWithKeyboardMicChannel) {
   MockMediaConstraintFactory constraint_factory;
   constraint_factory.AddMandatory(
       MediaAudioConstraints::kGoogExperimentalNoiseSuppression, true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), 0,
+          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
                                 48000, 16, 512);
   audio_processor->OnCaptureFormatChanged(params);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
-using Point = webrtc::Point;
-using PointVector = std::vector<Point>;
-
-void ExpectPointVectorEqual(const PointVector& expected,
-                            const PointVector& actual) {
-  EXPECT_EQ(expected.size(), actual.size());
-  for (size_t i = 0; i < actual.size(); ++i) {
-    EXPECT_EQ(expected[i].x(), actual[i].x());
-    EXPECT_EQ(expected[i].y(), actual[i].y());
-    EXPECT_EQ(expected[i].z(), actual[i].z());
-  }
-}
-
-TEST(MediaStreamAudioProcessorOptionsTest, ParseArrayGeometry) {
-  const PointVector expected_empty;
-  ExpectPointVectorEqual(expected_empty, ParseArrayGeometry(""));
-  ExpectPointVectorEqual(expected_empty, ParseArrayGeometry("0 0 a"));
-  ExpectPointVectorEqual(expected_empty, ParseArrayGeometry("1 2"));
-  ExpectPointVectorEqual(expected_empty, ParseArrayGeometry("1 2 3 4"));
-
-  {
-    PointVector expected(1, Point(-0.02f, 0, 0));
-    expected.push_back(Point(0.02f, 0, 0));
-    ExpectPointVectorEqual(expected, ParseArrayGeometry("-0.02 0 0 0.02 0 0"));
-  }
-  {
-    PointVector expected(1, Point(1, 2, 3));
-    ExpectPointVectorEqual(expected, ParseArrayGeometry("1 2 3"));
-  }
-}
-
 }  // namespace content