Enable platform echo cancellation through the AudioRecord path.

media/base/android/java/src/org/chromium/media/AudioRecordInput.java

 // 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.
 
 package org.chromium.media;
 
 import android.media.AudioFormat;
 import android.media.AudioRecord;
 import android.media.MediaRecorder.AudioSource;
+import android.media.audiofx.AcousticEchoCanceler;
+import android.media.audiofx.AudioEffect;
+import android.media.audiofx.AudioEffect.Descriptor;
 import android.os.Process;
 import android.util.Log;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 import java.nio.ByteBuffer;
 
 // Owned by its native counterpart declared in audio_record_input.h. Refer to
 // that class for general comments.
 @JNINamespace("media")
 class AudioRecordInput {
     private static final String TAG = "AudioRecordInput";
+    // Set to true to enable debug logs. Always check in as false.
+    private static final boolean DEBUG = false;
     // We are unable to obtain a precise measurement of the hardware delay on
     // Android. This is a conservative lower-bound based on measurments. It
     // could surely be tightened with further testing.
     private static final int HARDWARE_DELAY_MS = 100;
 
     private final long mNativeAudioRecordInputStream;
     private final int mSampleRate;
     private final int mChannels;
     private final int mBitsPerSample;
     private final int mHardwareDelayBytes;
+    private final boolean mUsePlatformAEC;
     private ByteBuffer mBuffer;
     private AudioRecord mAudioRecord;
     private AudioRecordThread mAudioRecordThread;
+    private AcousticEchoCanceler mAEC;
 
     private class AudioRecordThread extends Thread {
         // The "volatile" synchronization technique is discussed here:
         // http://stackoverflow.com/a/106787/299268
         // and more generally in this article:
         // https://www.ibm.com/developerworks/java/library/j-jtp06197/
         private volatile boolean mKeepAlive = true;
 
         @Override
         public void run() {
-            try {
-                Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
-            } catch (IllegalArgumentException e) {
-                Log.wtf(TAG, "setThreadPriority failed", e);
-            } catch (SecurityException e) {
-                Log.wtf(TAG, "setThreadPriority failed", e);
-            }
+            Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
             try {
                 mAudioRecord.startRecording();
             } catch (IllegalStateException e) {
                 Log.e(TAG, "startRecording failed", e);
                 return;
             }
 
             while (mKeepAlive) {
                 int bytesRead = mAudioRecord.read(mBuffer, mBuffer.capacity());
                 if (bytesRead > 0) {
                     nativeOnData(mNativeAudioRecordInputStream, bytesRead,
                                  mHardwareDelayBytes);
                 } else {
                     Log.e(TAG, "read failed: " + bytesRead);
+                    if (bytesRead == AudioRecord.ERROR_INVALID_OPERATION) {
+                        // This can happen if there is already an active
+                        // AudioRecord (e.g. in another tab).
+                        mKeepAlive = false;
+                    }
                 }
             }
 
             try {
                 mAudioRecord.stop();
             } catch (IllegalStateException e) {
                 Log.e(TAG, "stop failed", e);
             }
         }
 
         public void joinRecordThread() {
             mKeepAlive = false;
             while (isAlive()) {
                 try {
                     join();
                 } catch (InterruptedException e) {
                     // Ignore.
                 }
             }
         }
     }
 
     @CalledByNative
     private static AudioRecordInput createAudioRecordInput(long nativeAudioRecordInputStream,
-            int sampleRate, int channels, int bitsPerSample, int bytesPerBuffer) {
+            int sampleRate, int channels, int bitsPerSample, int bytesPerBuffer,
+            boolean usePlatformAEC) {
         return new AudioRecordInput(nativeAudioRecordInputStream, sampleRate, channels,
-                                    bitsPerSample, bytesPerBuffer);
+                                    bitsPerSample, bytesPerBuffer, usePlatformAEC);
     }
 
     private AudioRecordInput(long nativeAudioRecordInputStream, int sampleRate, int channels,
-                             int bitsPerSample, int bytesPerBuffer) {
+                             int bitsPerSample, int bytesPerBuffer, boolean usePlatformAEC) {
         mNativeAudioRecordInputStream = nativeAudioRecordInputStream;
         mSampleRate = sampleRate;
         mChannels = channels;
         mBitsPerSample = bitsPerSample;
         mHardwareDelayBytes = HARDWARE_DELAY_MS * sampleRate / 1000 * bitsPerSample / 8;
+        mUsePlatformAEC = usePlatformAEC;
 
         // We use a direct buffer so that the native class can have access to
         // the underlying memory address. This avoids the need to copy from a
         // jbyteArray to native memory. More discussion of this here:
         // http://developer.android.com/training/articles/perf-jni.html
-        try {
-            mBuffer = ByteBuffer.allocateDirect(bytesPerBuffer);
-        } catch (IllegalArgumentException e) {
-            Log.wtf(TAG, "allocateDirect failure", e);
-        }
+        mBuffer = ByteBuffer.allocateDirect(bytesPerBuffer);
         // Rather than passing the ByteBuffer with every OnData call (requiring
         // the potentially expensive GetDirectBufferAddress) we simply have the
         // the native class cache the address to the memory once.
         //
         // Unfortunately, profiling with traceview was unable to either confirm
         // or deny the advantage of this approach, as the values for
         // nativeOnData() were not stable across runs.
         nativeCacheDirectBufferAddress(mNativeAudioRecordInputStream, mBuffer);
     }
 
@@ skipping 40 matching lines @@
             mAudioRecord = new AudioRecord(AudioSource.VOICE_COMMUNICATION,
                                            mSampleRate,
                                            channelConfig,
                                            audioFormat,
                                            audioRecordBufferSizeInBytes);
         } catch (IllegalArgumentException e) {
             Log.e(TAG, "AudioRecord failed", e);
             return false;
         }
 
+        if (AcousticEchoCanceler.isAvailable()) {
+            mAEC = AcousticEchoCanceler.create(mAudioRecord.getAudioSessionId());
+            if (mAEC == null) {
+                Log.e(TAG, "AcousticEchoCanceler.create failed");
+                return false;
+            }
+            int ret = mAEC.setEnabled(mUsePlatformAEC);
+            if (ret != AudioEffect.SUCCESS) {
+                Log.e(TAG, "setEnabled error: " + ret);
+                return false;
+            }
+
+            if (DEBUG) {
+                Descriptor descriptor = mAEC.getDescriptor();
+                Log.d(TAG, "AcousticEchoCanceler " +
+                        "name: " + descriptor.name + ", " +
+                        "implementor: " + descriptor.implementor + ", " +
+                        "uuid: " + descriptor.uuid);
+            }
+        }
         return true;
     }
 
     @CalledByNative
     private void start() {
         if (mAudioRecord == null) {
             Log.e(TAG, "start() called before open().");
             return;
         }
         if (mAudioRecordThread != null) {
@@ skipping 17 matching lines @@
     @CalledByNative
     private void close() {
         if (mAudioRecordThread != null) {
             Log.e(TAG, "close() called before stop().");
             return;
         }
         if (mAudioRecord == null) {
             // open() was not called.
             return;
         }
+
+        if (mAEC != null) {
+            mAEC.release();
+            mAEC = null;
+        }
         mAudioRecord.release();
         mAudioRecord = null;
     }
 
     private native void nativeCacheDirectBufferAddress(long nativeAudioRecordInputStream,
                                                        ByteBuffer buffer);
     private native void nativeOnData(long nativeAudioRecordInputStream, int size,
                                      int hardwareDelayBytes);
 }