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"
@@ skipping 115 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 109 matching lines @@
 #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,
@@ skipping 29 matching lines @@
     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