Enable platform echo cancellation through the AudioRecord path.

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/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
@@ skipping 73 matching lines @@
   using namespace std;
   os << endl << "format: " << FormatToString(params.format()) << endl
      << "channel layout: " << LayoutToString(params.channel_layout()) << endl
      << "sample rate: " << params.sample_rate() << endl
      << "bits per sample: " << params.bits_per_sample() << endl
      << "frames per buffer: " << params.frames_per_buffer() << endl
      << "channels: " << params.channels() << endl
      << "bytes per buffer: " << params.GetBytesPerBuffer() << endl
      << "bytes per second: " << params.GetBytesPerSecond() << endl
      << "bytes per frame: " << params.GetBytesPerFrame() << endl
-     << "frame size in ms: " << ExpectedTimeBetweenCallbacks(params);
+     << "chunk size in ms: " << ExpectedTimeBetweenCallbacks(params) << endl
+     << "echo_canceller: " << params.effects().echo_canceller;
   return os;
 }
 
 // Gmock implementation of AudioInputStream::AudioInputCallback.
 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
  public:
   MOCK_METHOD5(OnData,
                void(AudioInputStream* stream,
                     const uint8* src,
                     uint32 size,
@@ skipping 267 matching lines @@
   AudioParameters params_;
   base::TimeTicks previous_time_;
   base::Lock lock_;
   scoped_ptr<media::SeekableBuffer> fifo_;
   scoped_ptr<uint8[]> buffer_;
   bool started_;
 
   DISALLOW_COPY_AND_ASSIGN(FullDuplexAudioSinkSource);
 };
 
-// Test fixture class.
-class AudioAndroidTest : public testing::Test {
+// Test fixture class for tests which only exercise the output path.
+class AudioAndroidOutputTest : public testing::Test {
  public:
-  AudioAndroidTest() {}
+  AudioAndroidOutputTest() {}
 
  protected:
   virtual void SetUp() {
     audio_manager_.reset(AudioManager::CreateForTesting());
     loop_.reset(new base::MessageLoopForUI());
   }
 
   virtual void TearDown() {}
 
   AudioManager* audio_manager() { return audio_manager_.get(); }
   base::MessageLoopForUI* loop() { return loop_.get(); }
 
-  AudioParameters GetDefaultInputStreamParameters() {
-    return audio_manager()->GetInputStreamParameters(
-        AudioManagerBase::kDefaultDeviceId);
-  }
-
   AudioParameters GetDefaultOutputStreamParameters() {
     return audio_manager()->GetDefaultOutputStreamParameters();
   }
 
   double AverageTimeBetweenCallbacks(int num_callbacks) const {
     return ((end_time_ - start_time_) / static_cast<double>(num_callbacks - 1))
         .InMillisecondsF();
   }
 
-  void StartInputStreamCallbacks(const AudioParameters& params) {
+  void StartOutputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
-    AudioInputStream* stream = audio_manager()->MakeAudioInputStream(
-        params, AudioManagerBase::kDefaultDeviceId);
+    AudioOutputStream* stream = audio_manager()->MakeAudioOutputStream(
+        params, std::string(), std::string());
     EXPECT_TRUE(stream);
 
     int count = 0;
-    MockAudioInputCallback sink;
+    MockAudioOutputCallback source;
 
-    EXPECT_CALL(sink,
-                OnData(stream, NotNull(), params.GetBytesPerBuffer(), _, _))
+    EXPECT_CALL(source, OnMoreData(NotNull(), _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
-             CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
-    EXPECT_CALL(sink, OnError(stream)).Times(0);
-    EXPECT_CALL(sink, OnClose(stream)).Times(1);
+             DoAll(CheckCountAndPostQuitTask(&count, num_callbacks, loop()),
+                   Invoke(&source, &MockAudioOutputCallback::RealOnMoreData)));
+    EXPECT_CALL(source, OnError(stream)).Times(0);
+    EXPECT_CALL(source, OnMoreIOData(_, _, _)).Times(0);
 
     EXPECT_TRUE(stream->Open());
-    stream->Start(&sink);
+    stream->Start(&source);
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
     stream->Stop();
     stream->Close();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
     VLOG(0) << "expected time between callbacks: "
             << expected_time_between_callbacks_ms << " ms";
     VLOG(0) << "average time between callbacks: "
             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.30 * expected_time_between_callbacks_ms);
   }
 
-  void StartOutputStreamCallbacks(const AudioParameters& params) {
+  scoped_ptr<base::MessageLoopForUI> loop_;
+  scoped_ptr<AudioManager> audio_manager_;
+  base::TimeTicks start_time_;
+  base::TimeTicks end_time_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AudioAndroidOutputTest);
+};
+
+// AudioRecordInputStream should only be created on Jelly Bean and higher. This
+// ensures we only test against the AudioRecord path when that is satisfied.
+std::vector<bool> RunAudioRecordInputPathTests() {
+  std::vector<bool> tests;
+  tests.push_back(false);
+  if (base::android::BuildInfo::GetInstance()->sdk_int() >= 16)
+    tests.push_back(true);
+  return tests;
+}
+
+// Test fixture class for tests which exercise the input path, or both input and
+// output paths. It is value-parameterized to test against both the Java
+// AudioRecord (when true) and native OpenSLES (when false) input paths.
+class AudioAndroidInputTest : public AudioAndroidOutputTest,
+                              public testing::WithParamInterface<bool> {
+ public:
+  AudioAndroidInputTest() {}
+
+ protected:
+  AudioParameters GetInputStreamParameters() {
+    AudioParameters input_params = audio_manager()->GetInputStreamParameters(
+        AudioManagerBase::kDefaultDeviceId);
+    // Override the platform effects setting to use the AudioRecord or OpenSLES
+    // path as requested.
+    AudioParameters::PlatformEffects effects;
+    effects.echo_canceller = GetParam();
+    AudioParameters params(input_params.format(),
+                           input_params.channel_layout(),
+                           input_params.sample_rate(),
+                           input_params.bits_per_sample(),
+                           input_params.frames_per_buffer(),
+                           effects);
+    return params;
+  }
+
+  void StartInputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
-    AudioOutputStream* stream = audio_manager()->MakeAudioOutputStream(
-        params, std::string(), std::string());
+    AudioInputStream* stream = audio_manager()->MakeAudioInputStream(
+        params, AudioManagerBase::kDefaultDeviceId);
     EXPECT_TRUE(stream);
 
     int count = 0;
-    MockAudioOutputCallback source;
+    MockAudioInputCallback sink;
 
-    EXPECT_CALL(source, OnMoreData(NotNull(), _))
+    EXPECT_CALL(sink,
+                OnData(stream, NotNull(), params.GetBytesPerBuffer(), _, _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
-             DoAll(CheckCountAndPostQuitTask(&count, num_callbacks, loop()),
-                   Invoke(&source, &MockAudioOutputCallback::RealOnMoreData)));
-    EXPECT_CALL(source, OnError(stream)).Times(0);
-    EXPECT_CALL(source, OnMoreIOData(_, _, _)).Times(0);
+             CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
+    EXPECT_CALL(sink, OnError(stream)).Times(0);
+    EXPECT_CALL(sink, OnClose(stream)).Times(1);
 
     EXPECT_TRUE(stream->Open());
-    stream->Start(&source);
+    stream->Start(&sink);
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
     stream->Stop();
     stream->Close();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
     VLOG(0) << "expected time between callbacks: "
             << expected_time_between_callbacks_ms << " ms";
     VLOG(0) << "average time between callbacks: "
             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.30 * expected_time_between_callbacks_ms);
   }
 
-  scoped_ptr<base::MessageLoopForUI> loop_;
-  scoped_ptr<AudioManager> audio_manager_;
-  base::TimeTicks start_time_;
-  base::TimeTicks end_time_;
 
-  DISALLOW_COPY_AND_ASSIGN(AudioAndroidTest);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AudioAndroidInputTest);
 };
 
 // Get the default audio input parameters and log the result.
-TEST_F(AudioAndroidTest, GetInputStreamParameters) {
-  AudioParameters params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, GetDefaultInputStreamParameters) {
+  // We don't go through AudioAndroidInputTest::GetInputStreamParameters() here
+  // so that we can log the real (non-overridden) values of the effects.
+  AudioParameters params = audio_manager()->GetInputStreamParameters(
+      AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(params.IsValid());
   VLOG(1) << params;
 }
 
 // Get the default audio output parameters and log the result.
-TEST_F(AudioAndroidTest, GetDefaultOutputStreamParameters) {
+TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   EXPECT_TRUE(params.IsValid());
   VLOG(1) << params;
 }
 
 // Check if low-latency output is supported and log the result as output.
-TEST_F(AudioAndroidTest, IsAudioLowLatencySupported) {
+TEST_F(AudioAndroidOutputTest, IsAudioLowLatencySupported) {
   AudioManagerAndroid* manager =
       static_cast<AudioManagerAndroid*>(audio_manager());
   bool low_latency = manager->IsAudioLowLatencySupported();
   low_latency ? VLOG(0) << "Low latency output is supported"
               : VLOG(0) << "Low latency output is *not* supported";
 }
 
 // Ensure that a default input stream can be created and closed.
-TEST_F(AudioAndroidTest, CreateAndCloseInputStream) {
-  AudioParameters params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
+  AudioParameters params = GetInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   ais->Close();
 }
 
 // Ensure that a default output stream can be created and closed.
 // TODO(henrika): should we also verify that this API changes the audio mode
 // to communication mode, and calls RegisterHeadsetReceiver, the first time
 // it is called?
-TEST_F(AudioAndroidTest, CreateAndCloseOutputStream) {
+TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
       params, std::string(), std::string());
   EXPECT_TRUE(aos);
   aos->Close();
 }
 
 // Ensure that a default input stream can be opened and closed.
-TEST_F(AudioAndroidTest, OpenAndCloseInputStream) {
-  AudioParameters params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, OpenAndCloseInputStream) {
+  AudioParameters params = GetInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   EXPECT_TRUE(ais->Open());
   ais->Close();
 }
 
 // Ensure that a default output stream can be opened and closed.
-TEST_F(AudioAndroidTest, OpenAndCloseOutputStream) {
+TEST_F(AudioAndroidOutputTest, OpenAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
       params, std::string(), std::string());
   EXPECT_TRUE(aos);
   EXPECT_TRUE(aos->Open());
   aos->Close();
 }
 
 // Start input streaming using default input parameters and ensure that the
 // callback sequence is sane.
-TEST_F(AudioAndroidTest, StartInputStreamCallbacks) {
-  AudioParameters params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, StartInputStreamCallbacks) {
+  AudioParameters params = GetInputStreamParameters();
   StartInputStreamCallbacks(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.
 // TODO(henrika): possibly add support for more variations.
-TEST_F(AudioAndroidTest, StartInputStreamCallbacksNonDefaultParameters) {
-  AudioParameters native_params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, StartInputStreamCallbacksNonDefaultParameters) {
+  AudioParameters native_params = GetInputStreamParameters();
   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.sample_rate() / 100,
+                         native_params.effects());
   StartInputStreamCallbacks(params);
 }
 
 // Start output streaming using default output parameters and ensure that the
 // callback sequence is sane.
-TEST_F(AudioAndroidTest, StartOutputStreamCallbacks) {
+TEST_F(AudioAndroidOutputTest, StartOutputStreamCallbacks) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   StartOutputStreamCallbacks(params);
 }
 
 // Start output streaming using non default output 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 and to open up the
 // device in mono.
 // TODO(henrika): possibly add support for more variations.
-TEST_F(AudioAndroidTest, StartOutputStreamCallbacksNonDefaultParameters) {
+TEST_F(AudioAndroidOutputTest, StartOutputStreamCallbacksNonDefaultParameters) {
   AudioParameters native_params = GetDefaultOutputStreamParameters();
   AudioParameters params(native_params.format(),
                          CHANNEL_LAYOUT_MONO,
                          native_params.sample_rate(),
                          native_params.bits_per_sample(),
                          native_params.sample_rate() / 100);
   StartOutputStreamCallbacks(params);
 }
 
 // Play out a PCM file segment in real time and allow the user to verify that
 // the rendered audio sounds OK.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
-TEST_F(AudioAndroidTest, DISABLED_RunOutputStreamWithFileAsSource) {
+TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   VLOG(1) << params;
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
       params, std::string(), std::string());
   EXPECT_TRUE(aos);
 
   std::string file_name;
   if (params.sample_rate() == 48000 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_48k;
   } else if (params.sample_rate() == 48000 && params.channels() == 1) {
@@ skipping 16 matching lines @@
   VLOG(0) << ">> Verify that the file is played out correctly...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   aos->Stop();
   aos->Close();
 }
 
 // Start input streaming and run it for ten seconds while recording to a
 // local audio file.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
-TEST_F(AudioAndroidTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
-  AudioParameters params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
+  AudioParameters params = GetInputStreamParameters();
   VLOG(1) << params;
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
 
   std::string file_name = base::StringPrintf("out_simplex_%d_%d_%d.pcm",
                                              params.sample_rate(),
                                              params.frames_per_buffer(),
                                              params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, params, file_name);
 
   EXPECT_TRUE(ais->Open());
   ais->Start(&sink);
   VLOG(0) << ">> Speak into the microphone to record audio...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   ais->Stop();
   ais->Close();
 }
 
 // Same test as RunSimplexInputStreamWithFileAsSink but this time output
 // streaming is active as well (reads zeros only).
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
-TEST_F(AudioAndroidTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
-  AudioParameters in_params = GetDefaultInputStreamParameters();
+TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
+  AudioParameters in_params = GetInputStreamParameters();
   AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
       in_params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
 
   AudioParameters out_params =
       audio_manager()->GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
       out_params, std::string(), std::string());
   EXPECT_TRUE(aos);
 
@@ skipping 22 matching lines @@
   aos->Close();
   ais->Close();
 }
 
 // Start audio in both directions while feeding captured data into a FIFO so
 // it can be read directly (in loopback) by the render side. A small extra
 // delay will be added by the FIFO and an estimate of this delay will be
 // printed out during the test.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
-TEST_F(AudioAndroidTest,
+TEST_P(AudioAndroidInputTest,
        DISABLED_RunSymmetricInputAndOutputStreamsInFullDuplex) {
   // Get native audio parameters for the input side.
-  AudioParameters default_input_params = GetDefaultInputStreamParameters();
+  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(),
                             default_input_params.sample_rate(),
                             default_input_params.bits_per_sample(),
                             default_input_params.sample_rate() / 100);
@@ skipping 22 matching lines @@
   VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   aos->Stop();
   ais->Stop();
   aos->Close();
   ais->Close();
 }
 
+INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
+    testing::ValuesIn(RunAudioRecordInputPathTests()));
+
 }  // namespace media