Add a virtual beamforming audio device on ChromeOS.

media/audio/android/audio_android_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 "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 573 matching lines @@
  protected:
   const AudioParameters& audio_input_parameters() {
     return audio_input_parameters_;
   }
 
   AudioParameters GetInputStreamParameters() {
     GetDefaultInputStreamParametersOnAudioThread();
 
     // Override the platform effects setting to use the AudioRecord or OpenSLES
     // path as requested.
-    int effects = GetParam() ? AudioParameters::ECHO_CANCELLER :
-                               AudioParameters::NO_EFFECTS;
+    AudioParameters::PlatformEffectsMask effects =
+        GetParam() ? AudioParameters::ECHO_CANCELLER
+                   : AudioParameters::NO_EFFECTS;
     AudioParameters params(audio_input_parameters().format(),
                            audio_input_parameters().channel_layout(),
                            audio_input_parameters().sample_rate(),
                            audio_input_parameters().bits_per_sample(),
                            audio_input_parameters().frames_per_buffer(),
-                           effects);
+                           std::vector<Point>(), effects);
     return params;
   }
 
   void GetDefaultInputStreamParametersOnAudioThread() {
      RunOnAudioThread(
         base::Bind(&AudioAndroidInputTest::GetDefaultInputStreamParameters,
                    base::Unretained(this)));
   }
 
   void MakeAudioInputStreamOnAudioThread(const AudioParameters& params) {
@@ skipping 178 matching lines @@
   AudioParameters native_params = GetInputStreamParameters();
   StartInputStreamCallbacks(native_params);
 }
 
 // Start input streaming using non default input parameters and ensure that the
 // callback sequence is sane. The only change we make in this test is to select
 // a 10ms buffer size instead of the default size.
 TEST_P(AudioAndroidInputTest,
        DISABLED_StartInputStreamCallbacksNonDefaultParameters) {
   AudioParameters native_params = GetInputStreamParameters();
-  AudioParameters params(native_params.format(),
-                         native_params.channel_layout(),
+  AudioParameters params(native_params.format(), native_params.channel_layout(),
                          native_params.sample_rate(),
                          native_params.bits_per_sample(),
                          native_params.sample_rate() / 100,
-                         native_params.effects());
+                         std::vector<Point>(), native_params.effects());
   StartInputStreamCallbacks(params);
 }
 
 // Start output streaming using default output parameters and ensure that the
 // callback sequence is sane.
 TEST_F(AudioAndroidOutputTest, StartOutputStreamCallbacks) {
   GetDefaultOutputStreamParametersOnAudioThread();
   StartOutputStreamCallbacks(audio_output_parameters());
 }
 
@@ skipping 110 matching lines @@
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest,
        DISABLED_RunSymmetricInputAndOutputStreamsInFullDuplex) {
   // Get native audio parameters for the input side.
   AudioParameters default_input_params = GetInputStreamParameters();
 
   // Modify the parameters so that both input and output can use the same
   // parameters by selecting 10ms as buffer size. This will also ensure that
   // the output stream will be a mono stream since mono is default for input
   // audio on Android.
-  AudioParameters io_params(default_input_params.format(),
-                            default_input_params.channel_layout(),
-                            ChannelLayoutToChannelCount(
-                                default_input_params.channel_layout()),
-                            default_input_params.sample_rate(),
-                            default_input_params.bits_per_sample(),
-                            default_input_params.sample_rate() / 100,
-                            default_input_params.effects());
+  AudioParameters io_params(
+      default_input_params.format(),
+      ChannelLayoutToChannelCount(default_input_params.channel_layout()),
+      default_input_params.channel_layout(), default_input_params.sample_rate(),
+      default_input_params.bits_per_sample(),
+      default_input_params.sample_rate() / 100, std::vector<Point>(),
+      default_input_params.effects());
   DVLOG(1) << io_params;
 
   // Create input and output streams using the common audio parameters.
   MakeAudioInputStreamOnAudioThread(io_params);
   MakeAudioOutputStreamOnAudioThread(io_params);
 
   FullDuplexAudioSinkSource full_duplex(io_params);
 
   // Start a full duplex audio session and print out estimates of the extra
   // delay we should expect from the FIFO. If real-time delay measurements are
   // performed, the result should be reduced by this extra delay since it is
   // something that has been added by the test.
   OpenAndStartAudioInputStreamOnAudioThread(&full_duplex);
   OpenAndStartAudioOutputStreamOnAudioThread(&full_duplex);
   DVLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
            << "once per second during this test.";
   DVLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media