Enable platform echo cancellation through the AudioRecord path.

media/audio/android/audio_manager_android.cc

 // 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.
 
 #include "media/audio/android/audio_manager_android.h"
 
 #include "base/android/build_info.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "jni/AudioManagerAndroid_jni.h"
+#include "media/audio/android/audio_record_input.h"
 #include "media/audio/android/opensles_input.h"
 #include "media/audio/android/opensles_output.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/base/channel_layout.h"
 
 using base::android::AppendJavaStringArrayToStringVector;
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
@@ skipping 72 matching lines @@
 }
 
 void AudioManagerAndroid::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
   // TODO(henrika): enumerate using GetAudioInputDeviceNames().
   AddDefaultDevice(device_names);
 }
 
 AudioParameters AudioManagerAndroid::GetInputStreamParameters(
     const std::string& device_id) {
+  JNIEnv* env = AttachCurrentThread();
   // Use mono as preferred number of input channels on Android to save
   // resources. Using mono also avoids a driver issue seen on Samsung
   // Galaxy S3 and S4 devices. See http://crbug.com/256851 for details.
   ChannelLayout channel_layout = CHANNEL_LAYOUT_MONO;
   int buffer_size = Java_AudioManagerAndroid_getMinInputFrameSize(
-      base::android::AttachCurrentThread(), GetNativeOutputSampleRate(),
+      env, GetNativeOutputSampleRate(),
       ChannelLayoutToChannelCount(channel_layout));
-
-  return AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
+  int effects = AudioParameters::NO_EFFECTS;
+  effects |= Java_AudioManagerAndroid_shouldUseAcousticEchoCanceler(env) ?
+      AudioParameters::ECHO_CANCELLER : AudioParameters::NO_EFFECTS;
+  AudioParameters params(
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, 0,
       GetNativeOutputSampleRate(), 16,
-      buffer_size <= 0 ? kDefaultInputBufferSize : buffer_size);
+      buffer_size <= 0 ? kDefaultInputBufferSize : buffer_size, effects);
+  return params;
 }
 
 AudioOutputStream* AudioManagerAndroid::MakeAudioOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   AudioOutputStream* stream =
       AudioManagerBase::MakeAudioOutputStream(params, std::string(),
           std::string());
   if (stream && output_stream_count() == 1) {
@@ skipping 54 matching lines @@
 
 AudioInputStream* AudioManagerAndroid::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   DLOG_IF(ERROR, device_id.empty()) << "Invalid device ID!";
   // Utilize the device ID to select the correct input device.
   // Note that the input device is always associated with a certain output
   // device, i.e., this selection does also switch the output device.
   // All input and output streams will be affected by the device selection.
   SetAudioDevice(device_id);
+
+  if (params.effects() != AudioParameters::NO_EFFECTS) {
+    // Platform effects can only be enabled through the AudioRecord path.
+    // An effect should only have been requested here if recommended by
+    // AudioManagerAndroid.shouldUse<Effect>.
+    //
+    // Creating this class requires Jelly Bean, which is already guaranteed by
+    // shouldUse<Effect>. Only DCHECK on that condition to allow tests to use
+    // the effect settings as a way to select the input path.
+    DCHECK_GE(base::android::BuildInfo::GetInstance()->sdk_int(), 16);
+    DVLOG(1) << "Creating AudioRecordInputStream";
+    return new AudioRecordInputStream(this, params);
+  }
+  DVLOG(1) << "Creating OpenSLESInputStream";
   return new OpenSLESInputStream(this, params);
 }
 
 int AudioManagerAndroid::GetOptimalOutputFrameSize(int sample_rate,
                                                    int channels) {
   if (IsAudioLowLatencySupported()) {
     return GetAudioLowLatencyOutputFrameSize();
   } else {
     return std::max(kDefaultOutputBufferSize,
                     Java_AudioManagerAndroid_getMinOutputFrameSize(
@@ skipping 21 matching lines @@
     buffer_size = GetOptimalOutputFrameSize(
         sample_rate, ChannelLayoutToChannelCount(channel_layout));
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
-      sample_rate, bits_per_sample, buffer_size);
+      sample_rate, bits_per_sample, buffer_size, AudioParameters::NO_EFFECTS);
 }
 
 // static
 bool AudioManagerAndroid::RegisterAudioManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void AudioManagerAndroid::Init() {
   Java_AudioManagerAndroid_init(
       base::android::AttachCurrentThread(),
@@ skipping 55 matching lines @@
       j_audio_manager_.obj());
 }
 
 int AudioManagerAndroid::GetAudioLowLatencyOutputFrameSize() {
   return Java_AudioManagerAndroid_getAudioLowLatencyOutputFrameSize(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 }  // namespace media